2017-04-01 update 1 IInputStrcut IOutputStruct Template System.

Modbus.Net/Modbus.Net.Modbus/ModbusUtility.cs

@@ -137,8 +137,7 @@ namespace Modbus.Net.Modbus
                 var inputStruct = new ReadDataModbusInputStruct(SlaveAddress, startAddress,
                     (ushort) getByteCount, AddressTranslator);
                 var outputStruct = await
-                    Wrapper.SendReceiveAsync(Wrapper[typeof (ReadDataModbusProtocal)], inputStruct) as
+					Wrapper.SendReceiveAsync<ReadDataModbusOutputStruct>(Wrapper[typeof (ReadDataModbusProtocal)], inputStruct);
-                    ReadDataModbusOutputStruct;
                 return outputStruct?.DataValue;
             }
             catch
@@ -160,8 +159,7 @@ namespace Modbus.Net.Modbus
                 var inputStruct = new WriteDataModbusInputStruct(SlaveAddress, startAddress, setContents,
                     AddressTranslator, Endian);
                 var outputStruct = await
-                    Wrapper.SendReceiveAsync(Wrapper[typeof (WriteDataModbusProtocal)], inputStruct) as
+					Wrapper.SendReceiveAsync<WriteDataModbusOutputStruct>(Wrapper[typeof (WriteDataModbusProtocal)], inputStruct);
-                    WriteDataModbusOutputStruct;
                 return outputStruct?.WriteCount == setContents.Length;
             }
             catch
@@ -181,8 +179,7 @@ namespace Modbus.Net.Modbus
             {
                 var inputStruct = new GetSystemTimeModbusInputStruct(SlaveAddress);
                 var outputStruct =
-                    Wrapper.SendReceive(Wrapper[typeof(GetSystemTimeModbusProtocal)], inputStruct) as
+					Wrapper.SendReceive<GetSystemTimeModbusOutputStruct>(Wrapper[typeof(GetSystemTimeModbusProtocal)], inputStruct);
-                        GetSystemTimeModbusOutputStruct;
                 return outputStruct?.Time;
             }
             catch (Exception)
@@ -202,8 +199,7 @@ namespace Modbus.Net.Modbus
             {
                 var inputStruct = new SetSystemTimeModbusInputStruct(SlaveAddress, setTime);
                 var outputStruct =
-                    Wrapper.SendReceive(Wrapper[typeof(SetSystemTimeModbusProtocal)], inputStruct) as
+                    Wrapper.SendReceive<SetSystemTimeModbusOutputStruct>(Wrapper[typeof(SetSystemTimeModbusProtocal)], inputStruct);
-                        SetSystemTimeModbusOutputStruct;
                 return outputStruct?.WriteCount > 0;
             }
             catch (Exception)

Modbus.Net/Modbus.Net.OPC/OpcUtility.cs

@@ -33,8 +33,7 @@ namespace Modbus.Net.OPC
                 var readRequestOpcInputStruct = new ReadRequestOpcInputStruct(startAddress, split.ToString());
                 var readRequestOpcOutputStruct =
                     await
-                        Wrapper.SendReceiveAsync(Wrapper[typeof(ReadRequestOpcProtocal)], readRequestOpcInputStruct) as
+						Wrapper.SendReceiveAsync<ReadRequestOpcOutputStruct>(Wrapper[typeof(ReadRequestOpcProtocal)], readRequestOpcInputStruct);
-                        ReadRequestOpcOutputStruct;
                 return readRequestOpcOutputStruct?.GetValue;
             }
             catch (Exception)
@@ -51,8 +50,7 @@ namespace Modbus.Net.OPC
                 var writeRequestOpcInputStruct = new WriteRequestOpcInputStruct(startAddress, split.ToString(), setContents[0]);
                 var writeRequestOpcOutputStruct =
                     await
-                        Wrapper.SendReceiveAsync(Wrapper[typeof(WriteRequestOpcProtocal)], writeRequestOpcInputStruct)
+						Wrapper.SendReceiveAsync<WriteRequestOpcOutputStruct>(Wrapper[typeof(WriteRequestOpcProtocal)], writeRequestOpcInputStruct);
-                        as WriteRequestOpcOutputStruct;
                 return writeRequestOpcOutputStruct?.WriteResult == true;
             }
             catch (Exception e)

Modbus.Net/Modbus.Net.Siemens/SiemensUtility.cs

@@ -183,8 +183,8 @@ namespace Modbus.Net.Siemens
                     0xd3c7, SiemensTypeCode.Byte, startAddress, (ushort) getByteCount, AddressTranslator);
                 var readRequestSiemensOutputStruct =
                     await
-                        Wrapper.SendReceiveAsync(Wrapper[typeof (ReadRequestSiemensProtocal)],
+						Wrapper.SendReceiveAsync<ReadRequestSiemensOutputStruct>(Wrapper[typeof (ReadRequestSiemensProtocal)],
-                            readRequestSiemensInputStruct) as ReadRequestSiemensOutputStruct;
+                            readRequestSiemensInputStruct);
                 return readRequestSiemensOutputStruct?.GetValue;
             }
             catch (Exception)
@@ -207,8 +207,8 @@ namespace Modbus.Net.Siemens
                     0xd3c8, startAddress, setContents, AddressTranslator);
                 var writeRequestSiemensOutputStruct =
                     await
-                        Wrapper.SendReceiveAsync(Wrapper[typeof (WriteRequestSiemensProtocal)],
+						Wrapper.SendReceiveAsync<WriteRequestSiemensOutputStruct>(Wrapper[typeof (WriteRequestSiemensProtocal)],
-                            writeRequestSiemensInputStruct) as WriteRequestSiemensOutputStruct;
+                            writeRequestSiemensInputStruct);
                 return writeRequestSiemensOutputStruct?.AccessResult == SiemensAccessResult.NoError;
             }
             catch (Exception)

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

@@ -109,6 +109,18 @@ namespace Modbus.Net
             return AsyncHelper.RunSync(() => SendReceiveAsync(unit, content));
         }
 
+		/// <summary>
+		///     发送协议，通过传入需要使用的协议内容和输入结构
+		/// </summary>
+		/// <param name="unit">协议的实例</param>
+		/// <param name="content">输入信息的结构化描述</param>
+		/// <returns>输出信息的结构化描述</returns>
+		/// <typeparam name="T">IOutputStruct的具体类型</typeparam>
+		public virtual T SendReceive<T>(ProtocalUnit unit, IInputStruct content) where T : class, IOutputStruct
+		{
+			return AsyncHelper.RunSync(() => SendReceiveAsync<T>(unit, content));
+		}
+
         /// <summary>
         ///     发送协议，通过传入需要使用的协议内容和输入结构
         /// </summary>
@@ -117,28 +129,40 @@ namespace Modbus.Net
         /// <returns>输出信息的结构化描述</returns>
         public virtual async Task<IOutputStruct> SendReceiveAsync(ProtocalUnit unit, IInputStruct content)
         {
-            var t = 0;
+			return await SendReceiveAsync<IOutputStruct>(unit, content);
-            var formatContent = unit.Format(content);
-            if (formatContent != null)
-            {
-                byte[] receiveContent;
-                //如果为特别处理协议的话，跳过协议扩展收缩
-                if (unit is ISpecialProtocalUnit)
-                {
-                    receiveContent = await ProtocalLinker.SendReceiveWithoutExtAndDecAsync(formatContent);
-                }
-                else
-                {
-                    receiveContent = await ProtocalLinker.SendReceiveAsync(formatContent);
-                }
-                if (receiveContent != null)
-                {
-                    return unit.Unformat(receiveContent, ref t);
-                }
-            }
-            return null;
         }
 
+		/// <summary>
+		///     发送协议，通过传入需要使用的协议内容和输入结构
+		/// </summary>
+		/// <param name="unit">协议的实例</param>
+		/// <param name="content">输入信息的结构化描述</param>
+		/// <returns>输出信息的结构化描述</returns>
+		/// <typeparam name="T">IOutputStruct的具体类型</typeparam>
+		public virtual async Task<T> SendReceiveAsync<T>(ProtocalUnit unit, IInputStruct content) where T : class, IOutputStruct
+		{
+			var t = 0;
+			var formatContent = unit.Format(content);
+			if (formatContent != null)
+			{
+				byte[] receiveContent;
+				//如果为特别处理协议的话，跳过协议扩展收缩
+				if (unit is ISpecialProtocalUnit)
+				{
+					receiveContent = await ProtocalLinker.SendReceiveWithoutExtAndDecAsync(formatContent);
+				}
+				else
+				{
+					receiveContent = await ProtocalLinker.SendReceiveAsync(formatContent);
+				}
+				if (receiveContent != null)
+				{
+					return unit.Unformat<T>(receiveContent, ref t);
+				}
+			}
+			return null;
+		}
+
         /// <summary>
         ///     协议连接开始
         /// </summary>

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

@@ -12,12 +12,23 @@ namespace Modbus.Net
         /// </summary>
         public Endian Endian { get; set; } = Endian.BigEndianLsb;
 
-        /// <summary>
+		/// <summary>
-        ///     从输入结构格式化
+		///     从输入结构格式化
-        /// </summary>s
+		/// </summary>s
-        /// <param name="message">结构化的输入数据</param>
+		/// <param name="message">结构化的输入数据</param>
-        /// <returns>格式化后的字节流</returns>
+		/// <returns>格式化后的字节流</returns>
-        public abstract byte[] Format(IInputStruct message);
+		public abstract byte[] Format(IInputStruct message);
+
+		/// <summary>
+		///     从输入结构格式化
+		/// </summary>
+		/// <param name="message">结构化的输入数据</param>
+		/// <typeparam name="T">IInputStruct的具体类型</typeparam>
+		/// <returns>格式化后的字节流</returns>
+		public byte[] Format<T>(T message) where T : IInputStruct
+		{
+			return Format(message);
+		}
 
         /// <summary>
         ///     从对象的参数数组格式化
@@ -29,13 +40,25 @@ namespace Modbus.Net
             return TranslateContent(Endian, message);
         }
 
-        /// <summary>
+		/// <summary>
-        ///     把仪器返回的内容填充到输出结构中
+		///     把仪器返回的内容填充到输出结构中
-        /// </summary>
+		/// </summary>
-        /// <param name="messageBytes">返回数据的字节流</param>
+		/// <param name="messageBytes">返回数据的字节流</param>
-        /// <param name="pos">转换标记位</param>
+		/// <param name="pos">转换标记位</param>
-        /// <returns>结构化的输出数据</returns>
+		/// <returns>结构化的输出数据</returns>
-        public abstract IOutputStruct Unformat(byte[] messageBytes, ref int pos);
+		public abstract IOutputStruct Unformat(byte[] messageBytes, ref int pos);
+
+		/// <summary>
+		/// 	把仪器返回的内容填充到输出结构中
+		/// </summary>
+		/// <param name="messageBytes">返回数据的字节流</param>
+		/// <param name="pos">转换标记位</param>
+		/// <typeparam name="T">IOutputStruct的具体类型</typeparam>
+		/// <returns>结构化的输出数据</returns>
+		public T Unformat<T>(byte[] messageBytes, ref int pos) where T : class, IOutputStruct
+		{
+			return Unformat(messageBytes, ref pos) as T;
+		}
 
         /// <summary>
         ///     转换静态方法，把对象数组转换为字节数组。