Use Interfaces

Modbus.Net/src/Base.Common/BaseProtocal.cs

@@ -38,7 +38,8 @@ namespace Modbus.Net
     ///     基本协议
     /// </summary>
     public abstract class BaseProtocal<TParamIn, TParamOut, TProtocalUnit> :
-        IProtocal<TParamIn, TParamOut, TProtocalUnit> where TProtocalUnit : ProtocalUnit<TParamIn, TParamOut> where TParamOut : class
+        IProtocal<TParamIn, TParamOut, TProtocalUnit> where TProtocalUnit : ProtocalUnit<TParamIn, TParamOut>
+        where TParamOut : class
     {
         /// <summary>
         ///     构造器
@@ -67,9 +68,9 @@ namespace Modbus.Net
         public byte MasterAddress { get; set; }
 
         /// <summary>
-        ///     协议的连接器
+        ///     协议集合
         /// </summary>
-        public ProtocalLinker<TParamIn, TParamOut> ProtocalLinker { get; protected set; }
+        protected Dictionary<string, TProtocalUnit> Protocals { get; }
 
         /// <summary>
         ///     协议索引器，这是一个懒加载协议，当字典中不存在协议时自动加载协议，否则调用已经加载的协议
@@ -85,7 +86,9 @@ namespace Modbus.Net
                 lock (Protocals)
                 {
                     if (Protocals.ContainsKey(protocalName))
+                    {
                         protocalUnitReturn = Protocals[protocalName];
+                    }
                     else
                     {
                         //自动寻找存在的协议并将其加载
@@ -95,16 +98,39 @@ namespace Modbus.Net
                             throw new InvalidCastException($"No ProtocalUnit {nameof(TProtocalUnit)} implemented");
                         protocalUnit.Endian = Endian;
                         Register(protocalUnit);
-                    }                    
+                    }
                 }
                 return protocalUnitReturn ?? Protocals[protocalName];
             }
         }
 
         /// <summary>
-        ///     协议集合
+        ///     协议的连接器
         /// </summary>
-        protected Dictionary<string, TProtocalUnit> Protocals { get; }
+        public IProtocalLinker<TParamIn, TParamOut> ProtocalLinker { get; protected set; }
+
+        /// <summary>
+        ///     协议连接开始
+        /// </summary>
+        /// <returns></returns>
+        public abstract bool Connect();
+
+        /// <summary>
+        ///     协议连接开始（异步）
+        /// </summary>
+        /// <returns></returns>
+        public abstract Task<bool> ConnectAsync();
+
+        /// <summary>
+        ///     协议连接断开
+        /// </summary>
+        /// <returns></returns>
+        public virtual bool Disconnect()
+        {
+            if (ProtocalLinker != null)
+                return ProtocalLinker.Disconnect();
+            return false;
+        }
 
         /// <summary>
         ///     发送协议，通过传入需要使用的协议内容和输入结构
@@ -133,31 +159,21 @@ namespace Modbus.Net
         /// </summary>
         /// <param name="content">写入的内容，使用对象数组描述</param>
         /// <returns>从设备获取的字节流</returns>
-        public virtual byte[] SendReceive(params object[] content)
+        public virtual TParamOut SendReceive(params object[] content)
         {
             return AsyncHelper.RunSync(() => SendReceiveAsync(content));
         }
 
         /// <summary>
-        ///     发送协议内容并接收，一般方法
+        ///     发送协议内容并接收，一般方法（不能使用，如需使用请继承）
         /// </summary>
         /// <param name="content">写入的内容，使用对象数组描述</param>
         /// <returns>从设备获取的字节流</returns>
-        public virtual Task<byte[]> SendReceiveAsync(params object[] content)
+        public virtual Task<TParamOut> SendReceiveAsync(params object[] content)
         {
             throw new NotImplementedException();
         }
 
-        /// <summary>
-        ///     注册一个协议
-        /// </summary>
-        /// <param name="linkProtocal">需要注册的协议</param>
-        protected void Register(TProtocalUnit linkProtocal)
-        {
-            if (linkProtocal == null) return;
-            Protocals.Add(linkProtocal.GetType().FullName, linkProtocal);
-        }
-
         /// <summary>
         ///     发送协议，通过传入需要使用的协议内容和输入结构
         /// </summary>
@@ -197,26 +213,13 @@ namespace Modbus.Net
         }
 
         /// <summary>
-        ///     协议连接开始
+        ///     注册一个协议
         /// </summary>
-        /// <returns></returns>
+        /// <param name="linkProtocal">需要注册的协议</param>
-        public abstract bool Connect();
+        protected void Register(TProtocalUnit linkProtocal)
-
-        /// <summary>
-        ///     协议连接开始（异步）
-        /// </summary>
-        /// <returns></returns>
-        public abstract Task<bool> ConnectAsync();
-
-        /// <summary>
-        ///     协议连接断开
-        /// </summary>
-        /// <returns></returns>
-        public virtual bool Disconnect()
         {
-            if (ProtocalLinker != null)
+            if (linkProtocal == null) return;
-                return ProtocalLinker.Disconnect();
+            Protocals.Add(linkProtocal.GetType().FullName, linkProtocal);
-            return false;
         }
     }
 }

Modbus.Net/src/Base.Common/BaseUtility.cs

@@ -49,7 +49,7 @@ namespace Modbus.Net
         /// <summary>
         ///     协议收发主体
         /// </summary>
-        protected BaseProtocal<TParamIn, TParamOut, TProtocalUnit> Wrapper;
+        protected IProtocal<TParamIn, TParamOut, TProtocalUnit> Wrapper;
 
         /// <summary>
         ///     构造器

Modbus.Net/src/Base.Common/IProtocal.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System;
+using System.Threading.Tasks;
 
 namespace Modbus.Net
 {
@@ -8,22 +9,52 @@ namespace Modbus.Net
     /// <typeparam name="TParamIn">向Connector传入的类型</typeparam>
     /// <typeparam name="TParamOut">从Connector返回的类型</typeparam>
     /// <typeparam name="TProtocalUnit">协议单元的类型</typeparam>
-    public interface IProtocal<TParamIn, TParamOut, in TProtocalUnit>
+    public interface IProtocal<TParamIn, TParamOut, TProtocalUnit>
         where TProtocalUnit : IProtocalFormatting<TParamIn, TParamOut>
     {
         /// <summary>
-        ///     发送协议内容并接收，一般方法
+        ///     协议的连接器
         /// </summary>
-        /// <param name="content">写入的内容，使用对象数组描述</param>
+        IProtocalLinker<TParamIn, TParamOut> ProtocalLinker { get; }
-        /// <returns>从设备获取的字节流</returns>
+
-        byte[] SendReceive(params object[] content);
+        /// <summary>
+        ///     协议索引器，这是一个懒加载协议，当字典中不存在协议时自动加载协议，否则调用已经加载的协议
+        /// </summary>
+        /// <param name="type">协议的类的GetType</param>
+        /// <returns>协议的实例</returns>
+        TProtocalUnit this[Type type] { get; }
+
+        /// <summary>
+        ///     协议连接开始
+        /// </summary>
+        /// <returns></returns>
+        bool Connect();
+
+        /// <summary>
+        ///     协议连接开始（异步）
+        /// </summary>
+        /// <returns></returns>
+        Task<bool> ConnectAsync();
+
+        /// <summary>
+        ///     协议连接断开
+        /// </summary>
+        /// <returns></returns>
+        bool Disconnect();
 
         /// <summary>
         ///     发送协议内容并接收，一般方法
         /// </summary>
         /// <param name="content">写入的内容，使用对象数组描述</param>
         /// <returns>从设备获取的字节流</returns>
-        Task<byte[]> SendReceiveAsync(params object[] content);
+        TParamOut SendReceive(params object[] content);
+
+        /// <summary>
+        ///     发送协议内容并接收，一般方法
+        /// </summary>
+        /// <param name="content">写入的内容，使用对象数组描述</param>
+        /// <returns>从设备获取的字节流</returns>
+        Task<TParamOut> SendReceiveAsync(params object[] content);
 
         /// <summary>
         ///     发送协议，通过传入需要使用的协议内容和输入结构
@@ -40,5 +71,23 @@ namespace Modbus.Net
         /// <param name="content">输入信息的结构化描述</param>
         /// <returns>输出信息的结构化描述</returns>
         Task<IOutputStruct> SendReceiveAsync(TProtocalUnit unit, IInputStruct content);
+
+        /// <summary>
+        ///     发送协议，通过传入需要使用的协议内容和输入结构
+        /// </summary>
+        /// <param name="unit">协议的实例</param>
+        /// <param name="content">输入信息的结构化描述</param>
+        /// <returns>输出信息的结构化描述</returns>
+        /// <typeparam name="T">IOutputStruct的具体类型</typeparam>
+        T SendReceive<T>(TProtocalUnit unit, IInputStruct content) where T : class, IOutputStruct;
+
+        /// <summary>
+        ///     发送协议，通过传入需要使用的协议内容和输入结构
+        /// </summary>
+        /// <param name="unit">协议的实例</param>
+        /// <param name="content">输入信息的结构化描述</param>
+        /// <returns>输出信息的结构化描述</returns>
+        /// <typeparam name="T">IOutputStruct的具体类型</typeparam>
+        Task<T> SendReceiveAsync<T>(TProtocalUnit unit, IInputStruct content) where T : class, IOutputStruct;
     }
 }

Modbus.Net/src/Base.Common/IProtocalLinker.cs

@@ -9,6 +9,34 @@ namespace Modbus.Net
     /// <typeparam name="TParamOut">从Connector返回的数据类型</typeparam>
     public interface IProtocalLinker<TParamIn, TParamOut>
     {
+        /// <summary>
+        ///     通讯字符串
+        /// </summary>
+        string ConnectionToken { get; }
+
+        /// <summary>
+        ///     设备是否连接
+        /// </summary>
+        bool IsConnected { get; }
+
+        /// <summary>
+        ///     连接设备
+        /// </summary>
+        /// <returns>设备是否连接成功</returns>
+        bool Connect();
+
+        /// <summary>
+        ///     连接设备
+        /// </summary>
+        /// <returns>设备是否连接成功</returns>
+        Task<bool> ConnectAsync();
+
+        /// <summary>
+        ///     断开设备
+        /// </summary>
+        /// <returns>设备是否断开成功</returns>
+        bool Disconnect();
+
         /// <summary>
         ///     发送并接收数据
         /// </summary>

Modbus.Net/src/Base.Common/ProtocalLinker.cs

@@ -70,13 +70,41 @@ namespace Modbus.Net
     /// <summary>
     ///     基本的协议连接器
     /// </summary>
-    public abstract class ProtocalLinker<TParamIn, TParamOut> : IProtocalLinker<TParamIn, TParamOut> where TParamOut : class
+    public abstract class ProtocalLinker<TParamIn, TParamOut> : IProtocalLinker<TParamIn, TParamOut>
+        where TParamOut : class
     {
         /// <summary>
         ///     传输连接器
         /// </summary>
         protected BaseConnector<TParamIn, TParamOut> BaseConnector;
 
+        /// <summary>
+        ///     连接设备
+        /// </summary>
+        /// <returns>设备是否连接成功</returns>
+        public bool Connect()
+        {
+            return BaseConnector.Connect();
+        }
+
+        /// <summary>
+        ///     连接设备
+        /// </summary>
+        /// <returns>设备是否连接成功</returns>
+        public async Task<bool> ConnectAsync()
+        {
+            return await BaseConnector.ConnectAsync();
+        }
+
+        /// <summary>
+        ///     断开设备
+        /// </summary>
+        /// <returns>设备是否断开成功</returns>
+        public bool Disconnect()
+        {
+            return BaseConnector.Disconnect();
+        }
+
         /// <summary>
         ///     通讯字符串
         /// </summary>
@@ -151,40 +179,19 @@ namespace Modbus.Net
         /// </summary>
         /// <param name="content">扩展前的基本协议内容</param>
         /// <returns>扩展后的协议内容</returns>
-        public abstract TParamIn BytesExtend(TParamIn content);
+        public virtual TParamIn BytesExtend(TParamIn content)
+        {
+            throw new NotImplementedException();
+        }
 
         /// <summary>
         ///     协议内容缩减，接收时根据需要缩减
         /// </summary>
         /// <param name="content">缩减前的完整协议内容</param>
         /// <returns>缩减后的协议内容</returns>
-        public abstract TParamOut BytesDecact(TParamOut content);
+        public virtual TParamOut BytesDecact(TParamOut content)
-
-        /// <summary>
-        ///     连接设备
-        /// </summary>
-        /// <returns>设备是否连接成功</returns>
-        public bool Connect()
         {
-            return BaseConnector.Connect();
+            throw new NotImplementedException();
-        }
-
-        /// <summary>
-        ///     连接设备
-        /// </summary>
-        /// <returns>设备是否连接成功</returns>
-        public async Task<bool> ConnectAsync()
-        {
-            return await BaseConnector.ConnectAsync();
-        }
-
-        /// <summary>
-        ///     断开设备
-        /// </summary>
-        /// <returns>设备是否断开成功</returns>
-        public bool Disconnect()
-        {
-            return BaseConnector.Disconnect();
         }
     }
 }