ModBusClient.cs

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using TAG.Simulator.ObjectModel.Actors;
using Waher.Content.Xml;
using Waher.Networking.Modbus;
using Waher.Networking.Sniffers;
 
namespace TAG.Simulator.ModBus.Actors
{
    public class ModBusClient : ModBusActor
    {
        private readonly SemaphoreSlim synchObj = new SemaphoreSlim(1);
        private ModbusTcpClient client;
        private ISniffer sniffer;
        private string host;
        private int port;
 
        public ModBusClient(ISimulationNode Parent, Model Model)
            : base(Parent, Model)
        {
        }
 
        public ModBusClient(ISimulationNode Parent, Model Model, int InstanceIndex, string InstanceId)
            : base(Parent, Model, InstanceIndex, InstanceId)
        {
        }
 
        public override string LocalName => nameof(ModBusClient);
 
        public override Task FromXml(XmlElement Definition)
        {
            this.host = XML.Attribute(Definition, "host", "localhost");
            this.port = XML.Attribute(Definition, "port", ModbusTcpClient.DefaultPort);
 
            return base.FromXml(Definition);
        }
 
        public override ISimulationNode Create(ISimulationNode Parent, Model Model)
        {
            return new ModBusClient(Parent, Model);
        }
 
        public override Task<Actor> CreateInstanceAsync(int InstanceIndex, string InstanceId)
        {
            return Task.FromResult<Actor>(new ModBusClient(this, this.Model, InstanceIndex, InstanceId)
            {
                host = this.host,
                port = this.port
            });
        }
 
        public override Task InitializeInstance()
        {
            this.client = null;
            return Task.CompletedTask;
        }
 
        public override async Task StartInstance()
        {
            this.sniffer = this.Model.GetSniffer(this.InstanceId, BinaryPresentationMethod.Hexadecimal);
            this.client = await ModbusTcpClient.Connect(this.host, this.port, this.sniffer);
        }
 
        public override async Task FinalizeInstance()
        {
            await this.Lock();
            try
            {
                this.client?.Dispose();
                this.client = null;
 
                if (!(this.sniffer is null))
                {
                    if (this.sniffer is IDisposable Disposable)
                        Disposable.Dispose();
 
                    this.sniffer = null;
                }
            }
            finally
            {
                this.Unlock();
            }
        }
 
        public ModbusTcpClient Client => this.client;
 
        public async Task Lock()
        {
            await this.synchObj.WaitAsync();
        }
 
        public void Unlock()
        {
            this.synchObj.Release();
        }
    }
}