Minics/Tools/PLCIOPointTool/ViewModels/WorkAreaViewModel.cs

using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using PLCIOPointTool.Services;
using ValueType = PLCIOPointTool.Services.ValueType;

namespace PLCIOPointTool.ViewModels;

public partial class WorkAreaViewModel : ObservableObject, IDisposable
{
    private readonly ICommunicator _communicator;

    private bool disposedValue;

    [ObservableProperty]
    [NotifyCanExecuteChangedFor(nameof(SendCommand))]
    [NotifyCanExecuteChangedFor(nameof(ReadCommand))]
    private bool _isConnected;

    [ObservableProperty]
    private string _sentSymbolName;

    [ObservableProperty]
    private string _sentValue;

    [ObservableProperty]
    private int _sentValueTypeIndex;

    [ObservableProperty]
    private string _readSymbolName;

    [ObservableProperty]
    private string _readValue;

    [ObservableProperty]
    private int _readValueTypeIndex;

    [ObservableProperty]
    private ValueType[] _valueTypes;



    public WorkAreaViewModel(ICommunicator communicator)
    {
        _isConnected = false;
        _sentSymbolName = string.Empty;
        _sentValue = string.Empty;
        _sentValueTypeIndex = -1;
        _readSymbolName = string.Empty;
        _readValue = string.Empty;
        _readValueTypeIndex = -1;
        _valueTypes = Enum.GetValues<ValueType>();

        _communicator = communicator;
        _communicator.ConnectionStatusChanged += OnConnectionStatusChanged;
    }

    [RelayCommand(CanExecute = nameof(IsConnected))]
    private void Send()
    {
        if (string.IsNullOrWhiteSpace(SentSymbolName) || string.IsNullOrWhiteSpace(SentValue) || SentValueTypeIndex < 0)
        {
            return;
        }

        Task.Run(() =>
        {
            _communicator.SetValue(SentSymbolName, SentValue, (ValueType)SentValueTypeIndex);
        });
    }

    [RelayCommand(CanExecute = nameof(IsConnected))]
    private void Read()
    {
        if (string.IsNullOrWhiteSpace(ReadSymbolName) || ReadValueTypeIndex < 0)
        {
            return;
        }
        Task.Run(() =>
        {
            _communicator.GetValue(ReadSymbolName, (ValueType)ReadValueTypeIndex);
        });
    }

    private void OnConnectionStatusChanged(object? sender, bool e)
    {
        App.Current.Dispatcher.Invoke(() =>
        {
            IsConnected = e;
        });
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!disposedValue)
        {
            if (disposing)
            {
                // TODO: dispose managed state (managed objects)
                _communicator.ConnectionStatusChanged -= OnConnectionStatusChanged;
            }

            // TODO: free unmanaged resources (unmanaged objects) and override finalizer
            // TODO: set large fields to null
            disposedValue = true;
        }
    }

    // // TODO: override finalizer only if 'Dispose(bool disposing)' has code to free unmanaged resources
    // ~WorkAreaViewModel()
    // {
    //     // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
    //     Dispose(disposing: false);
    // }

    public void Dispose()
    {
        // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
        Dispose(disposing: true);
        GC.SuppressFinalize(this);
    }
}