A more generic `DelegateCommand`
public override bool CanExecute(object parameter) =&gt; parameter is T ? CanExecute((T)parameter) : false;


Beware of a lesser known gotcha. This may not work as expected for parameter that's not "really" a T (it's not in Ts inheritance tree), only has an explicit cast operator defined allowing it to be casted to T. 

In that case while (T) parameter would return a T instance,  CanExecute won't even be called because your is check would prevent this from happening.

Other than that, I'd have some remarks related to naming and code style (rather subjective, so treat them as suggestions or food for thought more than claims your code is incorrect)

public interface IGenericCommand&lt;T&gt; : ICommand


There's no use in putting "generic" in the name. Any C# programmer knows that &lt;T&gt; indicates generics by itself. Case in point: in .NET we've got IEnumerable and IEnumerable&lt;T&gt; - not IGenericEnumerable&lt;T&gt;. (So "drop the the" ;) )

/// &lt;typeparam name="T"&gt;&lt;/typeparam&gt;

/// &lt;param name="parameter"&gt;&lt;/param&gt;
/// &lt;returns&gt;&lt;/returns&gt;


In my opinion such empty tags are of no use, all they do is clutter the codebase.

private readonly Func&lt;T, bool&gt; _canExecuteMethod;
private readonly Action&lt;T&gt; _executeMethod;


It's a matter of taste, but here I would ditch the "Method" suffix, as these aren't necessarily "methods". Note that you didn't name the class MethodCommand. Why not just _canExecute and _onExecute?

public bool CanExecute(T parameter) =&gt; _canExecuteMethod == null || _canExecuteMethod.Invoke(parameter);


Since you're using the null safety operator already, this could be simplified to _canExecuteMethod?.Invoke(parameter) ?? true.