ThreadInfoRow.cs

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

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using Dreamine.Threading.Models;
 
namespace Dreamine.Threading.Wpf.ViewModels
{
    public sealed class ThreadInfoRow : INotifyPropertyChanged
    {
        private DreamineThreadStatus _status;
        private DreamineThreadPriority _priority;
        private int _intervalMs;
        private int? _coreIndex;
        private bool _useAffinity;
        private int _jobCount;
        private long _cycleCount;
        private DateTimeOffset? _startedAt;
        private DateTimeOffset? _stoppedAt;
        private string? _lastErrorMessage;

        public event PropertyChangedEventHandler? PropertyChanged;

        public string Name { get; }

        public DreamineThreadStatus Status
        {
            get => _status;
            private set => SetField(ref _status, value);
        }

        public DreamineThreadPriority Priority
        {
            get => _priority;
            private set => SetField(ref _priority, value);
        }

        public int IntervalMs
        {
            get => _intervalMs;
            private set => SetField(ref _intervalMs, value);
        }

        public int? CoreIndex
        {
            get => _coreIndex;
            private set => SetField(ref _coreIndex, value);
        }

        public bool UseAffinity
        {
            get => _useAffinity;
            private set => SetField(ref _useAffinity, value);
        }

        public int JobCount
        {
            get => _jobCount;
            private set => SetField(ref _jobCount, value);
        }

        public long CycleCount
        {
            get => _cycleCount;
            private set => SetField(ref _cycleCount, value);
        }

        public DateTimeOffset? StartedAt
        {
            get => _startedAt;
            private set => SetField(ref _startedAt, value);
        }

        public DateTimeOffset? StoppedAt
        {
            get => _stoppedAt;
            private set => SetField(ref _stoppedAt, value);
        }

        public string? LastErrorMessage
        {
            get => _lastErrorMessage;
            private set => SetField(ref _lastErrorMessage, value);
        }

        public bool IsRunning => Status == DreamineThreadStatus.Running;

        public bool IsPaused => Status == DreamineThreadStatus.Paused;

        public bool IsFaulted => Status == DreamineThreadStatus.Faulted;

        public ThreadInfoRow(DreamineThreadInfo info)
        {
            ArgumentNullException.ThrowIfNull(info);
 
            Name = info.Name;
            _status = info.Status;
            _priority = info.Priority;
            _intervalMs = info.IntervalMs;
            _coreIndex = info.CoreIndex;
            _useAffinity = info.UseAffinity;
            _jobCount = info.JobCount;
            _cycleCount = info.CycleCount;
            _startedAt = info.StartedAt;
            _stoppedAt = info.StoppedAt;
            _lastErrorMessage = info.LastErrorMessage;
        }

        public bool UpdateFrom(DreamineThreadInfo info)
        {
            ArgumentNullException.ThrowIfNull(info);
 
            var statusChanged = _status != info.Status;
            var anyChanged = false;
 
            anyChanged |= SetField(ref _status, info.Status, nameof(Status));
            anyChanged |= SetField(ref _priority, info.Priority, nameof(Priority));
            anyChanged |= SetField(ref _intervalMs, info.IntervalMs, nameof(IntervalMs));
            anyChanged |= SetField(ref _coreIndex, info.CoreIndex, nameof(CoreIndex));
            anyChanged |= SetField(ref _useAffinity, info.UseAffinity, nameof(UseAffinity));
            anyChanged |= SetField(ref _jobCount, info.JobCount, nameof(JobCount));
            anyChanged |= SetField(ref _cycleCount, info.CycleCount, nameof(CycleCount));
            anyChanged |= SetField(ref _startedAt, info.StartedAt, nameof(StartedAt));
            anyChanged |= SetField(ref _stoppedAt, info.StoppedAt, nameof(StoppedAt));
            anyChanged |= SetField(ref _lastErrorMessage, info.LastErrorMessage, nameof(LastErrorMessage));
 
            if (statusChanged)
            {
                OnPropertyChanged(nameof(IsRunning));
                OnPropertyChanged(nameof(IsPaused));
                OnPropertyChanged(nameof(IsFaulted));
            }
 
            return anyChanged;
        }

        private bool SetField<T>(ref T field, T value, [CallerMemberName] string? propertyName = null)
        {
            if (EqualityComparer<T>.Default.Equals(field, value))
            {
                return false;
            }
 
            field = value;
            OnPropertyChanged(propertyName);
            return true;
        }

        private void OnPropertyChanged(string? propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}