feat: async commands

changes:
- the `IAsyncRelayCommand` interface added
- the `IAsyncRelayCommand<T>` interface added
- the `AsyncRelayCommand` implementation added
- the `AsyncRelayCommand<T>` implementation added

closes #85

Author: BoBoBaSs84

src/BB84.Notifications/AsyncRelayCommand.cs

@@ -0,0 +1,117 @@
+using BB84.Notifications.Interfaces;
+
+namespace BB84.Notifications;
+
+/// <summary>
+/// The async relay command class.
+/// </summary>
+/// <param name="execute">The task to execute.</param>
+/// <param name="canExecute">The condition to execute.</param>
+public sealed class AsyncRelayCommand(Func<Task> execute, Func<bool>? canExecute) : IAsyncRelayCommand
+{
+  private bool _isExecuting;
+
+  /// <summary>
+  /// Initializes a new instance of the <see cref="AsyncRelayCommand"/> class that can always execute.
+  /// </summary>
+  /// <param name="execute">The task to execute.</param>
+  public AsyncRelayCommand(Func<Task> execute) : this(execute, null)
+  { }
+
+  /// <inheritdoc/>
+  public event EventHandler? CanExecuteChanged;
+
+  /// <inheritdoc/>
+  public bool CanExecute()
+    => !_isExecuting && (canExecute?.Invoke() ?? true);
+
+  /// <inheritdoc/>
+  public async Task ExecuteAsync()
+  {
+    if (CanExecute())
+    {
+      try
+      {
+        _isExecuting = true;
+        await execute();
+      }
+      finally
+      {
+        _isExecuting = false;
+      }
+    }
+
+    RaiseCanExecuteChanged();
+  }
+
+  /// <inheritdoc/>
+  public bool CanExecute(object? parameter)
+    => CanExecute();
+
+  /// <inheritdoc/>
+  public void Execute(object? parameter)
+    => ExecuteAsync().Wait();
+
+  /// <inheritdoc/>
+  public void RaiseCanExecuteChanged()
+    => CanExecuteChanged?.Invoke(this, EventArgs.Empty);
+}
+
+/// <summary>
+/// The async relay command class.
+/// </summary>
+/// <remarks>
+/// For all commands that need a parameter.
+/// </remarks>
+/// <typeparam name="T">The generic type to work with.</typeparam>
+/// <param name="execute">The task to execute.</param>
+/// <param name="canExecute">The condition to execute.</param>
+public sealed class AsyncRelayCommand<T>(Func<T, Task> execute, Func<T, bool>? canExecute) : IAsyncRelayCommand<T>
+{
+  private bool _isExecuting;
+
+  /// <summary>
+  /// Initializes a new instance of <see cref="AsyncRelayCommand{T}"/> class that can always execute.
+  /// </summary>
+  /// <param name="execute">The task to execute.</param>
+  public AsyncRelayCommand(Func<T, Task> execute) : this(execute, null)
+  { }
+
+  /// <inheritdoc/>
+  public event EventHandler? CanExecuteChanged;
+
+  /// <inheritdoc/>
+  public bool CanExecute(T parameter)
+    => !_isExecuting && (canExecute?.Invoke(parameter) ?? true);
+
+  /// <inheritdoc/>
+  public bool CanExecute(object? parameter)
+    => CanExecute((T)parameter!);
+
+  /// <inheritdoc/>
+  public void Execute(object? parameter)
+    => ExecuteAsync((T)parameter!).Wait();
+
+  /// <inheritdoc/>
+  public async Task ExecuteAsync(T parameter)
+  {
+    if (CanExecute(parameter))
+    {
+      try
+      {
+        _isExecuting = true;
+        await execute(parameter);
+      }
+      finally
+      {
+        _isExecuting = false;
+      }
+    }
+
+    RaiseCanExecuteChanged();
+  }
+
+  /// <inheritdoc/>
+  public void RaiseCanExecuteChanged()
+    => CanExecuteChanged?.Invoke(this, EventArgs.Empty);
+}

src/BB84.Notifications/Interfaces/IAsyncRelayCommand.cs

@@ -0,0 +1,52 @@
+using System.Windows.Input;
+
+namespace BB84.Notifications.Interfaces;
+
+/// <summary>
+/// The async relay command interface.
+/// </summary>
+public interface IAsyncRelayCommand : ICommand
+{
+  /// <summary>
+  /// Defines the method to be called when the command is invoked.
+  /// </summary>
+  /// <returns><see cref="Task"/></returns>
+  Task ExecuteAsync();
+
+  /// <summary>
+  /// Defines the method that determines whether the command can execute in its current state.
+  /// </summary>
+  /// <returns>True if this command can be executed, otherwise false.</returns>
+  bool CanExecute();
+
+  /// <summary>
+  /// Notifies that the <see cref="ICommand.CanExecuteChanged"/> property has changed.
+  /// </summary>
+  void RaiseCanExecuteChanged();
+}
+
+/// <summary>
+/// The async relay command interface.
+/// </summary>
+/// <typeparam name="T">The generic type to wor with.</typeparam>
+public interface IAsyncRelayCommand<T> : ICommand
+{
+  /// <summary>
+  /// Defines the method to be called when the command is invoked.
+  /// </summary>
+  /// <param name="parameter">The data used by the command.</param>
+  /// <returns><see cref="Task"/></returns>
+  Task ExecuteAsync(T parameter);
+
+  /// <summary>
+  /// Defines the method that determines whether the command can execute in its current state.
+  /// </summary>
+  /// <param name="parameter">The data used by the command.</param>
+  /// <returns>True if this command can be executed, otherwise false.</returns>
+  bool CanExecute(T parameter);
+
+  /// <summary>
+  /// Notifies that the <see cref="ICommand.CanExecuteChanged"/> property has changed.
+  /// </summary>
+  void RaiseCanExecuteChanged();
+}