MainWindow.xaml.ViewModel.cs

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

using Dreamine.Logging.Interfaces;
using Dreamine.MVVM.Attributes;
using Dreamine.MVVM.Core;
using Dreamine.MVVM.ViewModels;
using Dreamine.Threading.Interfaces;
using Dreamine.Threading.Models;
 
namespace SampleSmart.Pages
{
    public partial class MainWindowViewModel : ViewModelBase
    {
        [DreamineModel]
        private MainWindowModel _model;
        [DreamineEvent]
        private MainWindowEvent _event;
        public string Title => Model.Title;
        public string Message => Model.Message;
        [DreamineCommand("Event.Ok")]
        private partial void Ok();

        [DreamineCommand("Event.Cancel")]
        private partial void Cancel();

        [DreamineCommand("Event.Minimize")]
        private partial void Minimize();

        [DreamineCommand("Event.Maximize")]
        private partial void Maximize();

        [DreamineCommand("Event.Close")]
        private partial void Close();

        [DreamineCommand("Event.SubPage")]
        private partial void SubPage();

        [DreamineCommand("Event.SubPage2")]
        private partial void SubPage2();

        [DreamineCommand("Event.LogPage")]
        private partial void LogPage();

        [DreamineCommand("Event.ThreadPage")]
        private partial void ThreadPage();

        [DreamineCommand("Event.CommunicationPage")]
        private partial void CommunicationPage();

        [DreamineCommand("Event.PlcPage")]
        private partial void PlcPage();

        [DreamineCommand("Event.IoPage")]
        private partial void IoPage();

        [DreamineCommand("Event.DatabasePage")]
        private partial void DatabasePage();

        [DreamineCommand("Event.SubWindow")]
        private partial void SubWindow();

        [DreamineCommand("Event.NoticeWindow")]
        private partial void NoticeWindow();

        [DreamineCommand("Event.MonitorWindow")]
        private partial void MonitorWindow();

        [DreamineCommand("Event.SettingWindow")]
        private partial void SettingWindow();

        private const string SampleMonitoringJobName = "Sample-MonitoringJob";

        private readonly IDreamineLogger _logger;
        private readonly IDreamineThreadManager _threadManager;

        private bool _isInitialized;
        private bool _isSampleMonitoringJobRegistered;
        private int _sampleMonitoringTickCount;

        public MainWindowViewModel(IDreamineLogger logger, IDreamineThreadManager threadManager)
        {
            _model = null!;
            _event = null!;
            _ = _model;
            _ = _event;
 
            _logger = logger;
            _threadManager = threadManager;
 
            Initialize();
        }

        public void Initialize()
        {
            if (_isInitialized)
            {
                return;
            }
 
            _isInitialized = true;
 
            RegisterSampleMonitoringJob();
        }

        private void RegisterSampleMonitoringJob()
        {
            if (_isSampleMonitoringJobRegistered)
            {
                _logger.Warning($"{SampleMonitoringJobName} is already registered.");
                return;
            }
 
            _isSampleMonitoringJobRegistered = true;
 
            _threadManager.Register(
                new DreamineThreadOptions
                {
                    Name = SampleMonitoringJobName,
                    Priority = DreamineThreadPriority.Normal,
                    IntervalMs = 10,
                    CoreMode = DreamineThreadCoreMode.Auto,
                    AutoThreadsPerCore = 2,
                    OverflowPollingIntervalMs = 20,
                    AutoStart = true,
                    UseHighPrecisionTimer = true,
                    YieldWhenIntervalIsZero = true,
                    UseAdaptiveCpuDelay = true
                },
                ExecuteSampleMonitoringJobAsync);
 
            _logger.Info($"{SampleMonitoringJobName} registered from MainWindowViewModel.");
        }

        private ValueTask ExecuteSampleMonitoringJobAsync(CancellationToken token)
        {
            if (token.IsCancellationRequested)
            {
                return ValueTask.CompletedTask;
            }
 
            _sampleMonitoringTickCount++;
 
            if (_sampleMonitoringTickCount % 100 == 0)
            {
                _logger.Debug(
                    $"Sample monitoring thread tick. Count={_sampleMonitoringTickCount}");
            }
 
            return ValueTask.CompletedTask;
        }
    }
}