jdescopingtool/Deprecated/JdeScoping.SecureStoreManager/ViewModels/RelayCommand.cs

using System.Windows.Input;

namespace JdeScoping.SecureStoreManager.ViewModels;

/// <summary>
/// A command implementation that delegates to action methods.
/// </summary>
public class RelayCommand : ICommand
{
    private readonly Action<object?> _execute;
    private readonly Predicate<object?>? _canExecute;
    private EventHandler? _canExecuteChanged;

    /// <summary>
    /// Raised when the command's ability to execute may have changed.
    /// </summary>
    public event EventHandler? CanExecuteChanged
    {
        add => _canExecuteChanged += value;
        remove => _canExecuteChanged -= value;
    }

    /// <summary>
    /// Creates a new RelayCommand that can always execute.
    /// </summary>
    /// <param name="execute">The action to execute.</param>
    public RelayCommand(Action<object?> execute)
        : this(execute, null)
    {
    }

    /// <summary>
    /// Creates a new RelayCommand with a CanExecute predicate.
    /// </summary>
    /// <param name="execute">The action to execute.</param>
    /// <param name="canExecute">The predicate to determine if the command can execute.</param>
    public RelayCommand(Action<object?> execute, Predicate<object?>? canExecute)
    {
        _execute = execute ?? throw new ArgumentNullException(nameof(execute));
        _canExecute = canExecute;
    }

    /// <summary>
    /// Creates a new RelayCommand from a parameterless action.
    /// </summary>
    /// <param name="execute">The action to execute.</param>
    public RelayCommand(Action execute)
        : this(_ => execute(), null)
    {
    }

    /// <summary>
    /// Creates a new RelayCommand from a parameterless action with a CanExecute predicate.
    /// </summary>
    /// <param name="execute">The action to execute.</param>
    /// <param name="canExecute">The predicate to determine if the command can execute.</param>
    public RelayCommand(Action execute, Func<bool>? canExecute)
        : this(_ => execute(), canExecute != null ? _ => canExecute() : null)
    {
    }

    /// <summary>
    /// Determines whether the command can execute.
    /// </summary>
    /// <param name="parameter">An optional command parameter.</param>
    /// <returns>True if the command can execute, false otherwise.</returns>
    public bool CanExecute(object? parameter)
    {
        return _canExecute == null || _canExecute(parameter);
    }

    /// <summary>
    /// Executes the command with the specified parameter.
    /// </summary>
    /// <param name="parameter">An optional command parameter.</param>
    public void Execute(object? parameter)
    {
        _execute(parameter);
    }

    /// <summary>
    /// Raises the CanExecuteChanged event.
    /// </summary>
    public void RaiseCanExecuteChanged()
    {
        _canExecuteChanged?.Invoke(this, EventArgs.Empty);
    }
}