private readonly Func<bool> _canExecute;
    private readonly Action _executeAction;

    /// <summary>
    /// Occurs when changes occur that affect whether the command should execute.
    /// </summary>
    public event EventHandler CanExecuteChanged;

    /// <summary>
    /// Initializes a new instance of the <see cref="DelegateCommand"/> class.
    /// </summary>
    /// <param name="executeAction"></param>
    /// <param name="canExecute"></param>
    public DelegateCommand(Action executeAction, Func<bool> canExecute)
    {
        _executeAction = executeAction;
        _canExecute = canExecute;
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="DelegateCommand"/> class.
    /// </summary>
    /// <param name="executeAction"></param>
    public DelegateCommand(Action executeAction)
    {
        _executeAction = executeAction;
        _canExecute = () => true;
    }

    /// <summary>
    /// Raises the can execute changed.
    /// </summary>
    public void RaiseCanExecuteChanged()
    {
        EventHandler canExecuteChanged = CanExecuteChanged;
        if (canExecuteChanged == null)
            return;
        canExecuteChanged(this, EventArgs.Empty);
    }

    public bool CanExecute(object parameter) => _canExecute == null || _canExecute();

    public void Execute(object parameter) => _executeAction();
}

/// <summary>
/// A command whose sole purpose is to relay its functionality to other objects by invoking delegates.
/// </summary>
/// <typeparam name="T"></typeparam>
public class DelegateCommand<T> : ICommand
{
    private readonly Func<T, bool> _canExecute;
    private readonly Action<T> _executeAction;

    public event EventHandler CanExecuteChanged;

    /// <summary>
    /// Initializes a new instance of the <see cref="DelegateCommand{T}"/> class.
    /// </summary>
    /// <param name="executeAction"></param>
    /// <param name="canExecute"></param>
    public DelegateCommand(Action<T> executeAction, Func<T, bool> canExecute)
    {
        _executeAction = executeAction;
        _canExecute = canExecute;
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="DelegateCommand{T}"/> class.
    /// </summary>
    /// <param name="executeAction"></param>
    public DelegateCommand(Action<T> executeAction)
    {
        _executeAction = executeAction;
        _canExecute = x => true;
    }

    /// <summary>
    /// Raises the can execute changed.
    /// </summary>
    public void RaiseCanExecuteChanged()
    {
        EventHandler canExecuteChanged = CanExecuteChanged;
        if (canExecuteChanged == null)
            return;
        canExecuteChanged(this, EventArgs.Empty);
    }

    public bool CanExecute(object parameter)
    {
        if (parameter == null)
            return true;
        T obj = ConvertParameter(parameter);
        return _canExecute == null || _canExecute(obj);
    }

    public void Execute(object parameter) => _executeAction(ConvertParameter(parameter));

    /// <summary>
    /// Converts the parameter.
    /// </summary>
    /// <param name="parameter"></param>
    /// <returns></returns>
    /// <exception cref="InvalidCastException"></exception>
    private static T ConvertParameter(object parameter)
    {
        if (parameter == null)
            return default;
        string message = string.Format("Cannot convert {0} to {1}", parameter.GetType(), typeof(T));
        T obj1 = default;
        if (parameter is T obj2)
            return obj2;
        if (!(parameter is string))
            throw new InvalidCastException(message);
        MethodInfo methodInfo = (typeof(T).GetMethods(BindingFlags.Static | BindingFlags.Public)).Where(m => m.Name == "Parse" && m.GetParameters().Length == 1).FirstOrDefault();
        if (methodInfo == null)
            return obj1;
        try
        {
            return (T)methodInfo.Invoke(null, new object[1]
            {
      parameter
            });
        }
        catch (Exception ex)
        {
            if (ex.InnerException != null)
                throw ex.InnerException;
            throw new InvalidCastException(message);
        }
    }