AsyncRelayCommand.cs

이 파일의 문서화 페이지로 가기

using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Input;
 
namespace Dreamine.MVVM.ViewModels
{
    public sealed class AsyncRelayCommand : ICommand
    {
        private readonly Func<Task> _execute;
        private readonly Func<bool>? _canExecute;
        // Interlocked: 0 = idle, 1 = executing. Prevents concurrent entry without lock.
        private int _isExecuting;
        private volatile Exception? _lastException;

        public AsyncRelayCommand(Func<Task> execute, Func<bool>? canExecute = null)
        {
            _execute = execute ?? throw new ArgumentNullException(nameof(execute));
            _canExecute = canExecute;
        }

        public event EventHandler? CanExecuteChanged;

        public event EventHandler<Exception>? ExecutionFailed;

        public Exception? LastException => _lastException;

        public bool CanExecute(object? parameter)
        {
            return Volatile.Read(ref _isExecuting) == 0 && (_canExecute?.Invoke() ?? true);
        }

        public async void Execute(object? parameter)
        {
            // Atomically claim execution slot; bail if already executing.
            if (Interlocked.CompareExchange(ref _isExecuting, 1, 0) != 0)
            {
                return;
            }
 
            RaiseCanExecuteChanged();
            try
            {
                await _execute().ConfigureAwait(true);
            }
            catch (Exception ex)
            {
                _lastException = ex;
 
                var handler = ExecutionFailed;
                if (handler is not null)
                {
                    handler.Invoke(this, ex);
                }
                else
                {
                    // No subscriber — emit a diagnostic trace so the exception is visible
                    // in the Output window rather than silently disappearing.
                    Debug.WriteLine(
                        $"[AsyncRelayCommand] Unhandled exception (subscribe to ExecutionFailed to suppress this): {ex}");
                }
            }
            finally
            {
                Interlocked.Exchange(ref _isExecuting, 0);
                RaiseCanExecuteChanged();
            }
        }

        public void RaiseCanExecuteChanged()
        {
            CanExecuteChanged?.Invoke(this, EventArgs.Empty);
        }
    }
}