MainWindowViewModel.cs

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

using Dreamine.Hybrid.Interfaces;
using Dreamine.MVVM.Attributes;
using Dreamine.MVVM.ViewModels;
using Sample01.Messages;
using Sample01.States;
using System;
using System.Collections.ObjectModel;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
 
namespace Sample01.ViewModels
{
    public sealed partial class MainWindowViewModel : ViewModelBase, IDisposable
    {
        private readonly IHybridMessageBus _bus;
        private readonly IHybridStateStore<CounterState> _store;
        private readonly IDisposable? _dashboardSub;
        private readonly IDisposable? _counterSub;
        private bool _disposed;

        [DreamineProperty] private string _title = "🌇 저녁시간이 다가옵니다!";
        [DreamineProperty] private int _clickCount;
        [DreamineProperty] private string _statusMessage = "대기 중...";
        [DreamineProperty] private ObservableCollection<string> _logs = new();

        public MainWindowViewModel(
            IHybridMessageBus bus,
            IHybridStateStore<CounterState> store)
        {
            _bus = bus ?? throw new ArgumentNullException(nameof(bus));
            _store = store ?? throw new ArgumentNullException(nameof(store));
 
            ApplyState(_store.State);
 
            _dashboardSub = _bus.Subscribe<DashboardActionRequestedMessage>(OnDashboardActionRequestedAsync);
            _counterSub = _bus.Subscribe<CounterChangedMessage>(OnCounterChangedAsync);
        }

        [DreamineCommand("OnClick")]
        private partial void Click();

        [DreamineCommand("OnReset")]
        private partial void Reset();

        private Task OnDashboardActionRequestedAsync(
            DashboardActionRequestedMessage message,
            CancellationToken cancellationToken)
        {
            if (_disposed || cancellationToken.IsCancellationRequested)
            {
                return Task.CompletedTask;
            }
 
            return RunOnUiAsync(() =>
            {
                Logs.Add($"[{DateTime.Now:HH:mm:ss}] Dashboard Action: {message.Action}");
            });
        }

        private Task OnCounterChangedAsync(
            CounterChangedMessage message,
            CancellationToken cancellationToken)
        {
            if (_disposed || cancellationToken.IsCancellationRequested)
            {
                return Task.CompletedTask;
            }
 
            return RunOnUiAsync(() =>
            {
                ClickCount = message.Count;
                StatusMessage = $"현재 클릭 수: {ClickCount}";
                Logs.Add($"[{DateTime.Now:HH:mm:ss}] (Blazor) 카운트 변경: {ClickCount}");
 
                _store.SetState(new CounterState(
                    Count: ClickCount,
                    LastSource: "Blazor → WPF → StateStore",
                    LastUpdated: DateTime.Now));
            });
        }

        private void OnClick()
        {
            ThrowIfDisposed();
 
            ClickCount++;
            StatusMessage = $"현재 클릭 수: {ClickCount}";
            Logs.Add($"[{DateTime.Now:HH:mm:ss}] (WPF) 버튼 클릭 {ClickCount}회");
 
            _store.SetState(new CounterState(
                Count: ClickCount,
                LastSource: "WPF → StateStore",
                LastUpdated: DateTime.Now));
 
            _ = PublishCounterChangedAsync(ClickCount);
        }

        private void OnReset()
        {
            ThrowIfDisposed();
 
            ClickCount = 0;
            StatusMessage = "초기화 완료";
            Logs.Clear();
 
            _store.SetState(new CounterState(
                Count: 0,
                LastSource: "WPF → StateStore",
                LastUpdated: DateTime.Now));
 
            _ = PublishCounterChangedAsync(ClickCount);
        }

        private Task PublishCounterChangedAsync(int count)
        {
            return _bus.PublishAsync(new CounterChangedMessage(count));
        }

        private void ApplyState(CounterState state)
        {
            ClickCount = state.Count;
            StatusMessage = $"현재 클릭 수: {ClickCount}";
        }

        private static Task RunOnUiAsync(Action action)
        {
            if (action is null)
            {
                throw new ArgumentNullException(nameof(action));
            }
 
            Application? application = Application.Current;
 
            if (application?.Dispatcher is null)
            {
                action();
                return Task.CompletedTask;
            }
 
            if (application.Dispatcher.CheckAccess())
            {
                action();
                return Task.CompletedTask;
            }
 
            return application.Dispatcher.InvokeAsync(action).Task;
        }

        public void Dispose()
        {
            if (_disposed)
            {
                return;
            }
 
            _counterSub?.Dispose();
            _dashboardSub?.Dispose();
 
            _disposed = true;
            GC.SuppressFinalize(this);
        }

        private void ThrowIfDisposed()
        {
            if (_disposed)
            {
                throw new ObjectDisposedException(nameof(MainWindowViewModel));
            }
        }
    }
}