2017-05-17 Update 3 Implement log system and add comments

Modbus.Net/Modbus.Net.Modbus/AddressFormaterModbus.cs

@@ -5,11 +5,24 @@
     /// </summary>
     public class AddressFormaterNA200H : AddressFormater
     {
+        /// <summary>
+        ///     格式化地址
+        /// </summary>
+        /// <param name="area">地址区域</param>
+        /// <param name="address">地址</param>
+        /// <returns>格式化的地址字符串</returns>
         public override string FormatAddress(string area, int address)
         {
             return area + " " + address;
         }
 
+        /// <summary>
+        ///     格式化地址
+        /// </summary>
+        /// <param name="area">地址区域</param>
+        /// <param name="address">地址</param>
+        /// <param name="subAddress">比特位地址</param>
+        /// <returns>格式化的地址字符串</returns>
         public override string FormatAddress(string area, int address, int subAddress)
         {
             return area + " " + address + "." + subAddress;
@@ -21,11 +34,24 @@
     /// </summary>
     public class AddressFormaterModbus : AddressFormater
     {
+        /// <summary>
+        ///     格式化地址
+        /// </summary>
+        /// <param name="area">地址区域</param>
+        /// <param name="address">地址</param>
+        /// <returns>格式化的地址字符串</returns>
         public override string FormatAddress(string area, int address)
         {
             return area + " " + address;
         }
 
+        /// <summary>
+        ///     格式化地址
+        /// </summary>
+        /// <param name="area">地址区域</param>
+        /// <param name="address">地址</param>
+        /// <param name="subAddress">比特位地址</param>
+        /// <returns>格式化的地址字符串</returns>
         public override string FormatAddress(string area, int address, int subAddress)
         {
             return area + " " + address + "." + subAddress;

Modbus.Net/Modbus.Net.Modbus/AddressTranslatorModbus.cs

@@ -23,6 +23,9 @@ namespace Modbus.Net.Modbus
         /// </summary>
         protected Dictionary<string, AreaOutputDef> WriteFunctionCodeDictionary;
 
+        /// <summary>
+        ///     构造器
+        /// </summary>
         public AddressTranslatorNA200H()
         {
             TransDictionary = new Dictionary<string, int>
@@ -154,6 +157,12 @@ namespace Modbus.Net.Modbus
             };
         }
 
+        /// <summary>
+        ///     地址转换
+        /// </summary>
+        /// <param name="address">格式化的地址</param>
+        /// <param name="isRead">是否为读取，是为读取，否为写入</param>
+        /// <returns>翻译后的地址</returns>
         public override AddressDef AddressTranslate(string address, bool isRead)
         {
             address = address.ToUpper();
@@ -188,6 +197,11 @@ namespace Modbus.Net.Modbus
                 };
         }
 
+        /// <summary>
+        ///     获取区域中的单个地址占用的字节长度
+        /// </summary>
+        /// <param name="area">区域名称</param>
+        /// <returns>字节长度</returns>
         public override double GetAreaByteLength(string area)
         {
             return ReadFunctionCodeDictionary[area].AreaWidth;
@@ -209,6 +223,9 @@ namespace Modbus.Net.Modbus
         /// </summary>
         protected Dictionary<string, AreaOutputDef> WriteFunctionCodeDictionary;
 
+        /// <summary>
+        ///     构造器
+        /// </summary>
         public AddressTranslatorModbus()
         {
             ReadFunctionCodeDictionary = new Dictionary<string, AreaOutputDef>
@@ -259,6 +276,12 @@ namespace Modbus.Net.Modbus
             };
         }
 
+        /// <summary>
+        ///     地址转换
+        /// </summary>
+        /// <param name="address">格式化的地址</param>
+        /// <param name="isRead">是否为读取，是为读取，否为写入</param>
+        /// <returns>翻译后的地址</returns>
         public override AddressDef AddressTranslate(string address, bool isRead)
         {
             address = address.ToUpper();
@@ -293,6 +316,11 @@ namespace Modbus.Net.Modbus
                 };
         }
 
+        /// <summary>
+        ///     获取区域中的单个地址占用的字节长度
+        /// </summary>
+        /// <param name="area">区域名称</param>
+        /// <returns>字节长度</returns>
         public override double GetAreaByteLength(string area)
         {
             return ReadFunctionCodeDictionary[area].AreaWidth;

Modbus.Net/Modbus.Net.Modbus/ModbusAsciiProtocal.cs

@@ -7,11 +7,24 @@ namespace Modbus.Net.Modbus
     /// </summary>
     public class ModbusAsciiProtocal : ModbusProtocal
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
+        /// <param name="endian">端格式</param>
         public ModbusAsciiProtocal(byte slaveAddress, byte masterAddress, Endian endian)
             : this(ConfigurationManager.AppSettings["COM"], slaveAddress, masterAddress, endian)
         {
         }
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="com">串口地址</param>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
+        /// <param name="endian">端格式</param>
         public ModbusAsciiProtocal(string com, byte slaveAddress, byte masterAddress, Endian endian)
             : base(slaveAddress, masterAddress, endian)
         {

Modbus.Net/Modbus.Net.Modbus/ModbusAsciiProtocalLinker.cs

@@ -8,13 +8,24 @@ namespace Modbus.Net.Modbus
     /// </summary>
     public class ModbusAsciiProtocalLinker : ComProtocalLinker
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="com">串口地址</param>
+        /// <param name="slaveAddress">从站号</param>
         public ModbusAsciiProtocalLinker(string com, int slaveAddress)
             : base(com, 9600, Parity.None, StopBits.One, 8, slaveAddress)
         {
         }
 
+        /// <summary>
+        ///     校验返回数据是否正确
+        /// </summary>
+        /// <param name="content">返回的数据</param>
+        /// <returns>校验是否正确</returns>
         public override bool? CheckRight(byte[] content)
         {
+            //ProtocalLinker不会返回null
             if (!base.CheckRight(content).Value) return false;
             //CRC校验失败
             var contentString = Encoding.ASCII.GetString(content);

Modbus.Net/Modbus.Net.Modbus/ModbusMachine.cs

@@ -9,6 +9,16 @@ namespace Modbus.Net.Modbus
     public class ModbusMachine<TKey, TUnitKey> : BaseMachine<TKey, TUnitKey> where TKey : IEquatable<TKey>
         where TUnitKey : IEquatable<TUnitKey>
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="connectionType">连接类型</param>
+        /// <param name="connectionString">连接地址</param>
+        /// <param name="getAddresses">读写的地址</param>
+        /// <param name="keepConnect">是否保持连接</param>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
+        /// <param name="endian">端格式</param>
         public ModbusMachine(ModbusType connectionType, string connectionString,
             IEnumerable<AddressUnit<TUnitKey>> getAddresses, bool keepConnect, byte slaveAddress, byte masterAddress,
             Endian endian = Endian.BigEndianLsb)
@@ -20,6 +30,15 @@ namespace Modbus.Net.Modbus
             AddressCombinerSet = new AddressCombinerContinus<TUnitKey>(AddressTranslator, 100);
         }
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="connectionType">连接类型</param>
+        /// <param name="connectionString">连接地址</param>
+        /// <param name="getAddresses">读写的地址</param>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
+        /// <param name="endian">端格式</param>
         public ModbusMachine(ModbusType connectionType, string connectionString,
             IEnumerable<AddressUnit<TUnitKey>> getAddresses, byte slaveAddress, byte masterAddress,
             Endian endian = Endian.BigEndianLsb)
@@ -33,6 +52,16 @@ namespace Modbus.Net.Modbus
     /// </summary>
     public class ModbusMachine : BaseMachine
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="connectionType">连接类型</param>
+        /// <param name="connectionString">连接地址</param>
+        /// <param name="getAddresses">读写的地址</param>
+        /// <param name="keepConnect">是否保持连接</param>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
+        /// <param name="endian">端格式</param>
         public ModbusMachine(ModbusType connectionType, string connectionString,
             IEnumerable<AddressUnit> getAddresses, bool keepConnect, byte slaveAddress, byte masterAddress,
             Endian endian = Endian.BigEndianLsb)
@@ -44,6 +73,15 @@ namespace Modbus.Net.Modbus
             AddressCombinerSet = new AddressCombinerContinus(AddressTranslator, 100);
         }
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="connectionType">连接类型</param>
+        /// <param name="connectionString">连接地址</param>
+        /// <param name="getAddresses">读写的地址</param>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
+        /// <param name="endian">端格式</param>
         public ModbusMachine(ModbusType connectionType, string connectionString,
             IEnumerable<AddressUnit> getAddresses, byte slaveAddress, byte masterAddress,
             Endian endian = Endian.BigEndianLsb)

Modbus.Net/Modbus.Net.Modbus/ModbusProtocal.cs

@@ -9,7 +9,14 @@ namespace Modbus.Net.Modbus
     /// </summary>
     internal enum ModbusProtocalVariableFunctionCode : byte
     {
+        /// <summary>
+        ///     读变量
+        /// </summary>
         ReadVariable = 20,
+
+        /// <summary>
+        ///     写变量
+        /// </summary>
         WriteVariable = 21
     }
 
@@ -18,7 +25,14 @@ namespace Modbus.Net.Modbus
     /// </summary>
     public enum ModbusProtocalTimeFunctionCode : byte
     {
+        /// <summary>
+        ///     读时间
+        /// </summary>
         GetSystemTime = 3,
+
+        /// <summary>
+        ///     写时间
+        /// </summary>
         SetSystemTime = 16
     }
 
@@ -27,9 +41,24 @@ namespace Modbus.Net.Modbus
     /// </summary>
     public enum ModbusProtocalReadDataFunctionCode : byte
     {
+        /// <summary>
+        ///     读线圈
+        /// </summary>
         ReadCoilStatus = 1,
+
+        /// <summary>
+        ///     读输入线圈
+        /// </summary>
         ReadInputStatus = 2,
+
+        /// <summary>
+        ///     读保持寄存器
+        /// </summary>
         ReadHoldRegister = 3,
+
+        /// <summary>
+        ///     读输入寄存器
+        /// </summary>
         ReadInputRegister = 4
     }
 
@@ -38,7 +67,24 @@ namespace Modbus.Net.Modbus
     /// </summary>
     internal enum ModbusProtocalWriteDataFunctionCode : byte
     {
+        /// <summary>
+        ///     写单个线圈
+        /// </summary>
+        WriteSingleCoil = 5,
+
+        /// <summary>
+        ///     写单个寄存器
+        /// </summary>
+        WriteSingleRegister = 6,
+
+        /// <summary>
+        ///     写多个线圈
+        /// </summary>
         WriteMultiCoil = 15,
+
+        /// <summary>
+        ///     写多个寄存器
+        /// </summary>
         WriteMultiRegister = 16
     }
 
@@ -47,16 +93,30 @@ namespace Modbus.Net.Modbus
     /// </summary>
     public abstract class ModbusProtocal : BaseProtocal
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="slaveAddress">从站地址</param>
+        /// <param name="masterAddress">主站地址</param>
+        /// <param name="endian">端格式</param>
         protected ModbusProtocal(byte slaveAddress, byte masterAddress, Endian endian)
             : base(slaveAddress, masterAddress, endian)
         {
         }
 
+        /// <summary>
+        ///     连接
+        /// </summary>
+        /// <returns>是否连接成功</returns>
         public override bool Connect()
         {
             return ProtocalLinker.Connect();
         }
 
+        /// <summary>
+        ///     连接
+        /// </summary>
+        /// <returns>是否连接成功</returns>
         public override async Task<bool> ConnectAsync()
         {
             return await ProtocalLinker.ConnectAsync();
@@ -65,8 +125,18 @@ namespace Modbus.Net.Modbus
 
     #region 读PLC数据
 
+    /// <summary>
+    ///     读数据输入
+    /// </summary>
     public class ReadDataModbusInputStruct : IInputStruct
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="slaveAddress">从站地址</param>
+        /// <param name="startAddress">开始地址</param>
+        /// <param name="getCount">读取个数</param>
+        /// <param name="addressTranslator">地址翻译器</param>
         public ReadDataModbusInputStruct(byte slaveAddress, string startAddress, ushort getCount,
             AddressTranslator addressTranslator)
         {
@@ -78,17 +148,39 @@ namespace Modbus.Net.Modbus
                 (ushort) Math.Ceiling(getCount / addressTranslator.GetAreaByteLength(translateAddress.AreaString));
         }
 
+        /// <summary>
+        ///     从站地址
+        /// </summary>
         public byte SlaveAddress { get; }
 
+        /// <summary>
+        ///     功能码
+        /// </summary>
         public byte FunctionCode { get; }
 
+        /// <summary>
+        ///     开始地址
+        /// </summary>
         public ushort StartAddress { get; }
 
+        /// <summary>
+        ///     获取个数
+        /// </summary>
         public ushort GetCount { get; }
     }
 
+    /// <summary>
+    ///     读数据输出
+    /// </summary>
     public class ReadDataModbusOutputStruct : IOutputStruct
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="functionCode">功能码</param>
+        /// <param name="dataCount">数据个数</param>
+        /// <param name="dataValue">读取的数据值</param>
         public ReadDataModbusOutputStruct(byte slaveAddress, byte functionCode,
             int dataCount, byte[] dataValue)
         {
@@ -98,17 +190,37 @@ namespace Modbus.Net.Modbus
             DataValue = dataValue.Clone() as byte[];
         }
 
+        /// <summary>
+        ///     从站号
+        /// </summary>
         public byte SlaveAddress { get; private set; }
 
+        /// <summary>
+        ///     功能码
+        /// </summary>
         public byte FunctionCode { get; private set; }
 
+        /// <summary>
+        ///     数据个数
+        /// </summary>
         public int DataCount { get; private set; }
 
+        /// <summary>
+        ///     数据值
+        /// </summary>
         public byte[] DataValue { get; private set; }
     }
 
+    /// <summary>
+    ///     读数据协议
+    /// </summary>
     public class ReadDataModbusProtocal : ProtocalUnit
     {
+        /// <summary>
+        ///     格式化
+        /// </summary>
+        /// <param name="message">读取参数</param>
+        /// <returns>读取数据的协议核心</returns>
         public override byte[] Format(IInputStruct message)
         {
             var r_message = (ReadDataModbusInputStruct) message;
@@ -116,6 +228,12 @@ namespace Modbus.Net.Modbus
                 r_message.StartAddress, r_message.GetCount);
         }
 
+        /// <summary>
+        ///     反格式化
+        /// </summary>
+        /// <param name="messageBytes">设备返回的信息</param>
+        /// <param name="pos">当前反格式化的位置</param>
+        /// <returns>反格式化的信息</returns>
         public override IOutputStruct Unformat(byte[] messageBytes, ref int pos)
         {
             var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref pos);
@@ -131,8 +249,19 @@ namespace Modbus.Net.Modbus
 
     #region 写PLC数据
 
+    /// <summary>
+    ///     写数据输入
+    /// </summary>
     public class WriteDataModbusInputStruct : IInputStruct
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="startAddress">开始地址</param>
+        /// <param name="writeValue">写入的数据</param>
+        /// <param name="addressTranslator">地址翻译器</param>
+        /// <param name="endian">端格式</param>
         public WriteDataModbusInputStruct(byte slaveAddress, string startAddress, object[] writeValue,
             AddressTranslator addressTranslator, Endian endian)
         {
@@ -147,21 +276,49 @@ namespace Modbus.Net.Modbus
             WriteValue = writeByteValue;
         }
 
+        /// <summary>
+        ///     从站号
+        /// </summary>
         public byte SlaveAddress { get; }
 
+        /// <summary>
+        ///     功能码
+        /// </summary>
         public byte FunctionCode { get; }
 
+        /// <summary>
+        ///     开始地址
+        /// </summary>
         public ushort StartAddress { get; }
 
+        /// <summary>
+        ///     写入个数
+        /// </summary>
         public ushort WriteCount { get; }
 
+        /// <summary>
+        ///     写入字节个数
+        /// </summary>
         public byte WriteByteCount { get; }
 
+        /// <summary>
+        ///     写入的数据
+        /// </summary>
         public byte[] WriteValue { get; }
     }
 
+    /// <summary>
+    ///     写数据输出
+    /// </summary>
     public class WriteDataModbusOutputStruct : IOutputStruct
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="functionCode">功能码</param>
+        /// <param name="startAddress">开始地址</param>
+        /// <param name="writeCount">写入个数</param>
         public WriteDataModbusOutputStruct(byte slaveAddress, byte functionCode,
             ushort startAddress, ushort writeCount)
         {
@@ -171,20 +328,37 @@ namespace Modbus.Net.Modbus
             WriteCount = writeCount;
         }
 
+        /// <summary>
+        ///     从站号
+        /// </summary>
         public byte SlaveAddress { get; private set; }
 
+        /// <summary>
+        ///     功能码
+        /// </summary>
         public byte FunctionCode { get; private set; }
 
+        /// <summary>
+        ///     开始地址
+        /// </summary>
         public ushort StartAddress { get; private set; }
 
+        /// <summary>
+        ///     写入个数
+        /// </summary>
         public ushort WriteCount { get; private set; }
     }
 
     /// <summary>
-    ///     写多个寄存器状态
+    ///     写多个寄存器协议
     /// </summary>
     public class WriteDataModbusProtocal : ProtocalUnit
     {
+        /// <summary>
+        ///     格式化
+        /// </summary>
+        /// <param name="message">写寄存器参数</param>
+        /// <returns>写寄存器协议核心</returns>
         public override byte[] Format(IInputStruct message)
         {
             var r_message = (WriteDataModbusInputStruct) message;
@@ -194,6 +368,12 @@ namespace Modbus.Net.Modbus
             return formattingBytes;
         }
 
+        /// <summary>
+        ///     反格式化
+        /// </summary>
+        /// <param name="messageBytes">设备返回的信息</param>
+        /// <param name="flag">当前反格式化的位置</param>
+        /// <returns>反格式化的信息</returns>
         public override IOutputStruct Unformat(byte[] messageBytes, ref int flag)
         {
             var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag);
@@ -209,8 +389,15 @@ namespace Modbus.Net.Modbus
 
     #region 读PLC时间
 
+    /// <summary>
+    ///     读时间输入
+    /// </summary>
     public class GetSystemTimeModbusInputStruct : IInputStruct
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="slaveAddress">从站号</param>
         public GetSystemTimeModbusInputStruct(byte slaveAddress)
         {
             SlaveAddress = slaveAddress;
@@ -219,17 +406,45 @@ namespace Modbus.Net.Modbus
             GetCount = 5;
         }
 
+        /// <summary>
+        ///     从站号
+        /// </summary>
         public byte SlaveAddress { get; }
 
+        /// <summary>
+        ///     功能码
+        /// </summary>
         public byte FunctionCode { get; }
 
+        /// <summary>
+        ///     开始地址
+        /// </summary>
         public ushort StartAddress { get; }
 
+        /// <summary>
+        ///     获取个数
+        /// </summary>
         public ushort GetCount { get; }
     }
 
+    /// <summary>
+    ///     读时间输出
+    /// </summary>
     public class GetSystemTimeModbusOutputStruct : IOutputStruct
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="functionCode">功能码</param>
+        /// <param name="writeByteCount">写入个数</param>
+        /// <param name="year">年</param>
+        /// <param name="day">日</param>
+        /// <param name="month">月</param>
+        /// <param name="hour">时</param>
+        /// <param name="second">秒</param>
+        /// <param name="minute">分</param>
+        /// <param name="millisecond">毫秒</param>
         public GetSystemTimeModbusOutputStruct(byte slaveAddress, byte functionCode,
             byte writeByteCount, ushort year, byte day, byte month, ushort hour, byte second, byte minute,
             ushort millisecond)
@@ -240,20 +455,37 @@ namespace Modbus.Net.Modbus
             Time = new DateTime(year, month, day, hour, minute, second, millisecond);
         }
 
+        /// <summary>
+        ///     从站号
+        /// </summary>
         public byte SlaveAddress { get; private set; }
 
+        /// <summary>
+        ///     功能码
+        /// </summary>
         public byte FunctionCode { get; private set; }
 
+        /// <summary>
+        ///     写入个数
+        /// </summary>
         public byte WriteByteCount { get; private set; }
 
+        /// <summary>
+        ///     时间
+        /// </summary>
         public DateTime Time { get; private set; }
     }
 
     /// <summary>
-    ///     读系统时间
+    ///     读系统时间协议
     /// </summary>
     public class GetSystemTimeModbusProtocal : ProtocalUnit
     {
+        /// <summary>
+        ///     格式化
+        /// </summary>
+        /// <param name="message">写系统时间参数</param>
+        /// <returns>写系统时间的核心</returns>
         public override byte[] Format(IInputStruct message)
         {
             var r_message = (GetSystemTimeModbusInputStruct) message;
@@ -261,6 +493,12 @@ namespace Modbus.Net.Modbus
                 r_message.StartAddress, r_message.GetCount);
         }
 
+        /// <summary>
+        ///     反格式化
+        /// </summary>
+        /// <param name="messageBytes">获取的信息</param>
+        /// <param name="flag">当前反格式化的位置</param>
+        /// <returns>反格式化的信息</returns>
         public override IOutputStruct Unformat(byte[] messageBytes, ref int flag)
         {
             var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag);
@@ -282,8 +520,16 @@ namespace Modbus.Net.Modbus
 
     #region 写PLC时间
 
+    /// <summary>
+    ///     写时间输入
+    /// </summary>
     public class SetSystemTimeModbusInputStruct : IInputStruct
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="time">时间</param>
         public SetSystemTimeModbusInputStruct(byte slaveAddress, DateTime time)
         {
             SlaveAddress = slaveAddress;
@@ -300,33 +546,79 @@ namespace Modbus.Net.Modbus
             Millisecond = (ushort) time.Millisecond;
         }
 
+        /// <summary>
+        ///     从站号
+        /// </summary>
         public byte SlaveAddress { get; }
 
+        /// <summary>
+        ///     功能码
+        /// </summary>
         public byte FunctionCode { get; }
 
+        /// <summary>
+        ///     开始地址
+        /// </summary>
         public ushort StartAddress { get; }
 
+        /// <summary>
+        ///     写入个数
+        /// </summary>
         public ushort WriteCount { get; }
 
+        /// <summary>
+        ///     写入字节个数
+        /// </summary>
         public byte WriteByteCount { get; }
 
+        /// <summary>
+        ///     年
+        /// </summary>
         public ushort Year { get; }
 
+        /// <summary>
+        ///     日
+        /// </summary>
         public byte Day { get; }
 
+        /// <summary>
+        ///     月
+        /// </summary>
         public byte Month { get; }
 
+        /// <summary>
+        ///     时
+        /// </summary>
         public ushort Hour { get; }
 
+        /// <summary>
+        ///     秒
+        /// </summary>
         public byte Second { get; }
 
+        /// <summary>
+        ///     分
+        /// </summary>
         public byte Minute { get; }
 
+        /// <summary>
+        ///     毫秒
+        /// </summary>
         public ushort Millisecond { get; }
     }
 
+    /// <summary>
+    ///     写时间输出
+    /// </summary>
     public class SetSystemTimeModbusOutputStruct : IOutputStruct
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="functionCode">功能码</param>
+        /// <param name="startAddress">开始地址</param>
+        /// <param name="writeCount">写入个数</param>
         public SetSystemTimeModbusOutputStruct(byte slaveAddress, byte functionCode,
             ushort startAddress, ushort writeCount)
         {
@@ -336,20 +628,37 @@ namespace Modbus.Net.Modbus
             WriteCount = writeCount;
         }
 
+        /// <summary>
+        ///     从站号
+        /// </summary>
         public byte SlaveAddress { get; private set; }
 
+        /// <summary>
+        ///     功能码
+        /// </summary>
         public byte FunctionCode { get; private set; }
 
+        /// <summary>
+        ///     开始地址
+        /// </summary>
         public ushort StartAddress { get; private set; }
 
+        /// <summary>
+        ///     写入个数
+        /// </summary>
         public ushort WriteCount { get; private set; }
     }
 
     /// <summary>
-    ///     写系统时间
+    ///     写系统时间协议
     /// </summary>
     public class SetSystemTimeModbusProtocal : ProtocalUnit
     {
+        /// <summary>
+        ///     格式化
+        /// </summary>
+        /// <param name="message">写系统时间的参数</param>
+        /// <returns>写系统时间的核心</returns>
         public override byte[] Format(IInputStruct message)
         {
             var r_message = (SetSystemTimeModbusInputStruct) message;
@@ -359,6 +668,12 @@ namespace Modbus.Net.Modbus
                 r_message.Month, r_message.Hour, r_message.Second, r_message.Minute, r_message.Millisecond);
         }
 
+        /// <summary>
+        ///     反格式化
+        /// </summary>
+        /// <param name="messageBytes">获取的信息</param>
+        /// <param name="flag">当前反格式化的位置</param>
+        /// <returns>反格式化的信息</returns>
         public override IOutputStruct Unformat(byte[] messageBytes, ref int flag)
         {
             var slaveAddress = ValueHelper.GetInstance(Endian).GetByte(messageBytes, ref flag);
@@ -388,12 +703,19 @@ namespace Modbus.Net.Modbus
             {501, "RTU_ILLEGAL_CRC"}
         };
 
+        /// <summary>
+        ///     Modbus错误
+        /// </summary>
+        /// <param name="messageNumber">Modbus错误号</param>
         public ModbusProtocalErrorException(int messageNumber)
             : base(ProtocalErrorDictionary[messageNumber])
         {
             ErrorMessageNumber = messageNumber;
         }
 
+        /// <summary>
+        ///     Modbus错误号
+        /// </summary>
         public int ErrorMessageNumber { get; private set; }
     }
 }

Modbus.Net/Modbus.Net.Modbus/ModbusProtocalLinkerBytesExtend.cs

@@ -10,6 +10,11 @@ namespace Modbus.Net.Modbus
     /// </summary>
     public class ModbusTcpProtocalLinkerBytesExtend : IProtocalLinkerBytesExtend
     {
+        /// <summary>
+        ///     协议扩展，协议内容发送前调用
+        /// </summary>
+        /// <param name="content">扩展前的原始协议内容</param>
+        /// <returns>扩展后的协议内容</returns>
         public byte[] BytesExtend(byte[] content)
         {
             //Modbus/Tcp协议扩张，前面加6个字节，前面4个为0，后面两个为协议整体内容的长度
@@ -22,6 +27,11 @@ namespace Modbus.Net.Modbus
             return newFormat;
         }
 
+        /// <summary>
+        ///     协议收缩，协议内容接收后调用
+        /// </summary>
+        /// <param name="content">收缩前的完整协议内容</param>
+        /// <returns>收缩后的协议内容</returns>
         public byte[] BytesDecact(byte[] content)
         {
             //Modbus/Tcp协议收缩，抛弃前面6个字节的内容
@@ -31,8 +41,16 @@ namespace Modbus.Net.Modbus
         }
     }
 
+    /// <summary>
+    ///     Rtu协议字节伸缩
+    /// </summary>
     public class ModbusRtuProtocalLinkerBytesExtend : IProtocalLinkerBytesExtend
     {
+        /// <summary>
+        ///     协议扩展，协议内容发送前调用
+        /// </summary>
+        /// <param name="content">扩展前的原始协议内容</param>
+        /// <returns>扩展后的协议内容</returns>
         public byte[] BytesExtend(byte[] content)
         {
             var crc = new byte[2];
@@ -44,6 +62,11 @@ namespace Modbus.Net.Modbus
             return newFormat;
         }
 
+        /// <summary>
+        ///     协议收缩，协议内容接收后调用
+        /// </summary>
+        /// <param name="content">收缩前的完整协议内容</param>
+        /// <returns>收缩后的协议内容</returns>
         public byte[] BytesDecact(byte[] content)
         {
             //Modbus/Rtu协议收缩，抛弃后面2个字节的内容
@@ -53,8 +76,16 @@ namespace Modbus.Net.Modbus
         }
     }
 
+    /// <summary>
+    ///     Ascii协议字节伸缩
+    /// </summary>
     public class ModbusAsciiProtocalLinkerBytesExtend : IProtocalLinkerBytesExtend
     {
+        /// <summary>
+        ///     协议扩展，协议内容发送前调用
+        /// </summary>
+        /// <param name="content">扩展前的原始协议内容</param>
+        /// <returns>扩展后的协议内容</returns>
         public byte[] BytesExtend(byte[] content)
         {
             //Modbus/Ascii协议扩张，前面增加:，后面增加LRC校验和尾字符
@@ -68,6 +99,11 @@ namespace Modbus.Net.Modbus
             return newContent.ToArray();
         }
 
+        /// <summary>
+        ///     协议收缩，协议内容接收后调用
+        /// </summary>
+        /// <param name="content">收缩前的完整协议内容</param>
+        /// <returns>收缩后的协议内容</returns>
         public byte[] BytesDecact(byte[] content)
         {
             //Modbus/Ascii协议收缩，抛弃头尾。

Modbus.Net/Modbus.Net.Modbus/ModbusRtuProtocal.cs

@@ -7,11 +7,24 @@ namespace Modbus.Net.Modbus
     /// </summary>
     public class ModbusRtuProtocal : ModbusProtocal
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
+        /// <param name="endian">端格式</param>
         public ModbusRtuProtocal(byte slaveAddress, byte masterAddress, Endian endian)
             : this(ConfigurationManager.AppSettings["COM"], slaveAddress, masterAddress, endian)
         {
         }
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="com">串口</param>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
+        /// <param name="endian">端格式</param>
         public ModbusRtuProtocal(string com, byte slaveAddress, byte masterAddress, Endian endian)
             : base(slaveAddress, masterAddress, endian)
         {

Modbus.Net/Modbus.Net.Modbus/ModbusRtuProtocalLinker.cs

@@ -7,13 +7,24 @@ namespace Modbus.Net.Modbus
     /// </summary>
     public class ModbusRtuProtocalLinker : ComProtocalLinker
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="com">串口地址</param>
+        /// <param name="slaveAddress">从站号</param>
         public ModbusRtuProtocalLinker(string com, int slaveAddress)
             : base(com, 9600, Parity.None, StopBits.One, 8, slaveAddress)
         {
         }
 
+        /// <summary>
+        ///     校验返回数据
+        /// </summary>
+        /// <param name="content">设备返回的数据</param>
+        /// <returns>数据是否正确</returns>
         public override bool? CheckRight(byte[] content)
         {
+            //ProtocalLinker的CheckRight不会返回null
             if (!base.CheckRight(content).Value) return false;
             //CRC校验失败
             if (!Crc16.GetInstance().CrcEfficacy(content))

Modbus.Net/Modbus.Net.Modbus/ModbusTcpProtocal.cs

@@ -7,17 +7,38 @@ namespace Modbus.Net.Modbus
     /// </summary>
     public class ModbusTcpProtocal : ModbusProtocal
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
+        /// <param name="endian">端格式</param>
         public ModbusTcpProtocal(byte slaveAddress, byte masterAddress, Endian endian)
             : this(ConfigurationManager.AppSettings["IP"], slaveAddress, masterAddress, endian)
         {
         }
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="ip">ip地址</param>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
+        /// <param name="endian">端格式</param>
         public ModbusTcpProtocal(string ip, byte slaveAddress, byte masterAddress, Endian endian)
             : base(slaveAddress, masterAddress, endian)
         {
             ProtocalLinker = new ModbusTcpProtocalLinker(ip);
         }
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="ip">ip地址</param>
+        /// <param name="port">端口</param>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
+        /// <param name="endian">端格式</param>
         public ModbusTcpProtocal(string ip, int port, byte slaveAddress, byte masterAddress, Endian endian)
             : base(slaveAddress, masterAddress, endian)
         {

Modbus.Net/Modbus.Net.Modbus/ModbusTcpProtocalLinker.cs

@@ -7,17 +7,32 @@ namespace Modbus.Net.Modbus
     /// </summary>
     public class ModbusTcpProtocalLinker : TcpProtocalLinker
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="ip">IP地址</param>
         public ModbusTcpProtocalLinker(string ip)
             : base(ip, int.Parse(ConfigurationManager.AppSettings["ModbusPort"] ?? "502"))
         {
         }
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="ip">IP地址</param>
+        /// <param name="port">端口</param>
         public ModbusTcpProtocalLinker(string ip, int port) : base(ip, port)
         {
         }
 
+        /// <summary>
+        ///     校验返回数据
+        /// </summary>
+        /// <param name="content">设备返回的数据</param>
+        /// <returns>数据是否正确</returns>
         public override bool? CheckRight(byte[] content)
         {
+            //ProtocalLinker的CheckRight不会返回null
             if (!base.CheckRight(content).Value) return false;
             //长度校验失败
             if (content[5] != content.Length - 6)

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

@@ -1,5 +1,6 @@
 using System;
 using System.Threading.Tasks;
+using Serilog;
 
 namespace Modbus.Net.Modbus
 {
@@ -34,6 +35,13 @@ namespace Modbus.Net.Modbus
         /// </summary>
         private ModbusType _modbusType;
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="connectionType">协议类型</param>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
+        /// <param name="endian">端格式</param>
         public ModbusUtility(int connectionType, byte slaveAddress, byte masterAddress,
             Endian endian = Endian.BigEndianLsb)
             : base(slaveAddress, masterAddress)
@@ -44,6 +52,14 @@ namespace Modbus.Net.Modbus
             AddressTranslator = new AddressTranslatorModbus();
         }
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="connectionType">协议类型</param>
+        /// <param name="connectionString">连接地址</param>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
+        /// <param name="endian">端格式</param>
         public ModbusUtility(ModbusType connectionType, string connectionString, byte slaveAddress, byte masterAddress,
             Endian endian = Endian.BigEndianLsb)
             : base(slaveAddress, masterAddress)
@@ -54,8 +70,14 @@ namespace Modbus.Net.Modbus
             AddressTranslator = new AddressTranslatorModbus();
         }
 
+        /// <summary>
+        ///     端格式
+        /// </summary>
         public override Endian Endian { get; }
 
+        /// <summary>
+        ///     Ip地址
+        /// </summary>
         protected string ConnectionStringIp
         {
             get
@@ -65,6 +87,9 @@ namespace Modbus.Net.Modbus
             }
         }
 
+        /// <summary>
+        ///     端口
+        /// </summary>
         protected int? ConnectionStringPort
         {
             get
@@ -76,13 +101,17 @@ namespace Modbus.Net.Modbus
                 {
                     return connectionStringSplit.Length < 2 ? (int?) null : int.Parse(connectionStringSplit[1]);
                 }
-                catch
+                catch (Exception e)
                 {
+                    Log.Error(e, $"ModbusUtility: {ConnectionString} format error");
                     return null;
                 }
             }
         }
 
+        /// <summary>
+        ///     协议类型
+        /// </summary>
         public ModbusType ModbusType
         {
             get { return _modbusType; }
@@ -136,8 +165,9 @@ namespace Modbus.Net.Modbus
                         Wrapper[typeof(GetSystemTimeModbusProtocal)], inputStruct);
                 return outputStruct?.Time ?? DateTime.MinValue;
             }
-            catch (Exception)
+            catch (Exception e)
             {
+                Log.Error(e, $"ModbusUtility -> GetTime: {ConnectionString} error");
                 return DateTime.MinValue;
             }
         }
@@ -157,12 +187,17 @@ namespace Modbus.Net.Modbus
                         Wrapper[typeof(SetSystemTimeModbusProtocal)], inputStruct);
                 return outputStruct?.WriteCount > 0;
             }
-            catch (Exception)
+            catch (Exception e)
             {
+                Log.Error(e, $"ModbusUtility -> SetTime: {ConnectionString} error");
                 return false;
             }
         }
 
+        /// <summary>
+        ///     设置协议类型
+        /// </summary>
+        /// <param name="connectionType">协议类型</param>
         public override void SetConnectionType(int connectionType)
         {
             ModbusType = (ModbusType) connectionType;
@@ -185,8 +220,9 @@ namespace Modbus.Net.Modbus
                         inputStruct);
                 return outputStruct?.DataValue;
             }
-            catch
+            catch (Exception e)
             {
+                Log.Error(e, $"ModbusUtility -> GetDatas: {ConnectionString} error");
                 return null;
             }
         }
@@ -208,8 +244,9 @@ namespace Modbus.Net.Modbus
                         inputStruct);
                 return outputStruct?.WriteCount == setContents.Length;
             }
-            catch
+            catch (Exception e)
             {
+                Log.Error(e, $"ModbusUtility -> SetDatas: {ConnectionString} error");
                 return false;
             }
         }

Modbus.Net/Modbus.Net.OPC/OpcConnector.cs

@@ -5,6 +5,7 @@ using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using Hylasoft.Opc.Common;
+using Serilog;
 
 namespace Modbus.Net.OPC
 {
@@ -28,12 +29,12 @@ namespace Modbus.Net.OPC
                 Client?.Dispose();
                 Client = null;
                 _connect = false;
-                AddInfo("client disconnected successfully.");
+                Log.Information("opc client {ConnectionToken} disconnected success", ConnectionToken);
                 return true;
             }
             catch (Exception ex)
             {
-                AddInfo("client disconnected exception: " + ex.Message);
+                Log.Error(ex, "opc client {ConnectionToken} disconnected error", ConnectionToken);
                 _connect = false;
                 return false;
             }
@@ -125,7 +126,7 @@ namespace Modbus.Net.OPC
                         }
                         catch (Exception e)
                         {
-                            AddInfo("opc write exception:" + e.Message);
+                            Log.Error(e, "opc client {ConnectionToken} write exception", ConnectionToken);
                             return new OpcParamOut
                             {
                                 Success = false
@@ -144,7 +145,7 @@ namespace Modbus.Net.OPC
             }
             catch (Exception e)
             {
-                AddInfo("opc client exception:" + e.Message);
+                Log.Error(e, "opc client {ConnectionToken} read exception", ConnectionToken);
                 return new OpcParamOut
                 {
                     Success = false,
@@ -180,13 +181,12 @@ namespace Modbus.Net.OPC
             {
                 Client.Connect();
                 _connect = true;
-                AddInfo("client connected.");
+                Log.Information("opc client {ConnectionToken} connect success", ConnectionToken);
                 return true;
             }
             catch (Exception ex)
             {
-                AddInfo("client connected exception: " + ex.Message);
+                Log.Error(ex, "opc client {ConnectionToken} connected failed", ConnectionToken);
-                AddInfo("connect failed.");
                 _connect = false;
                 return false;
             }

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

@@ -1,5 +1,6 @@
 using System;
 using System.Threading.Tasks;
+using Serilog;
 
 namespace Modbus.Net.OPC
 {
@@ -34,8 +35,9 @@ namespace Modbus.Net.OPC
                             readRequestOpcInputStruct);
                 return readRequestOpcOutputStruct?.GetValue;
             }
-            catch (Exception)
+            catch (Exception e)
             {
+                Log.Error(e, $"OpcUtility -> GetDatas: {ConnectionString} error");
                 return null;
             }
         }
@@ -54,6 +56,7 @@ namespace Modbus.Net.OPC
             }
             catch (Exception e)
             {
+                Log.Error(e, $"OpcUtility -> SetDatas: {ConnectionString} error");
                 return false;
             }
         }

Modbus.Net/Modbus.Net.Siemens/AddressFormaterSiemens.cs

@@ -5,11 +5,24 @@
     /// </summary>
     public class AddressFormaterSiemens : AddressFormater
     {
+        /// <summary>
+        ///     编码地址
+        /// </summary>
+        /// <param name="area">地址所在的数据区域</param>
+        /// <param name="address">地址</param>
+        /// <returns>编码后的地址</returns>
         public override string FormatAddress(string area, int address)
         {
             return area + " " + address;
         }
 
+        /// <summary>
+        ///     编码地址
+        /// </summary>
+        /// <param name="area">地址所在的数据区域</param>
+        /// <param name="address">地址</param>
+        /// <param name="subAddress">子地址</param>
+        /// <returns>编码后的地址</returns>
         public override string FormatAddress(string area, int address, int subAddress)
         {
             return area + " " + address + "." + subAddress;
@@ -21,6 +34,12 @@
     /// </summary>
     public class AddressFormaterSimenseStandard : AddressFormater
     {
+        /// <summary>
+        ///     编码地址
+        /// </summary>
+        /// <param name="area">地址所在的数据区域</param>
+        /// <param name="address">地址</param>
+        /// <returns>编码后的地址</returns>
         public override string FormatAddress(string area, int address)
         {
             if (area.Length > 1 &&
@@ -29,6 +48,13 @@
             return area.ToUpper() + address;
         }
 
+        /// <summary>
+        ///     编码地址
+        /// </summary>
+        /// <param name="area">地址所在的数据区域</param>
+        /// <param name="address">地址</param>
+        /// <param name="subAddress">子地址</param>
+        /// <returns>编码后的地址</returns>
         public override string FormatAddress(string area, int address, int subAddress)
         {
             if (area.Length > 1 &&

Modbus.Net/Modbus.Net.Siemens/AddressTranslatorSiemens.cs

@@ -9,8 +9,14 @@ namespace Modbus.Net.Siemens
     /// </summary>
     public class AddressTranslatorSiemens : AddressTranslator
     {
+        /// <summary>
+        ///     区域的翻译字典
+        /// </summary>
         protected Dictionary<string, int> AreaCodeDictionary;
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
         public AddressTranslatorSiemens()
         {
             AreaCodeDictionary = new Dictionary<string, int>
@@ -30,6 +36,12 @@ namespace Modbus.Net.Siemens
             };
         }
 
+        /// <summary>
+        ///     地址转换
+        /// </summary>
+        /// <param name="address">格式化的地址</param>
+        /// <param name="isRead">是否为读取，是为读取，否为写入</param>
+        /// <returns>翻译后的地址</returns>
         public override AddressDef AddressTranslate(string address, bool isRead)
         {
             address = address.ToUpper();
@@ -68,6 +80,11 @@ namespace Modbus.Net.Siemens
                 };
         }
 
+        /// <summary>
+        ///     获取区域中的单个地址占用的字节长度
+        /// </summary>
+        /// <param name="area">区域名称</param>
+        /// <returns>字节长度</returns>
         public override double GetAreaByteLength(string area)
         {
             return 1;
@@ -79,8 +96,14 @@ namespace Modbus.Net.Siemens
     /// </summary>
     public class AddressTranslatorSimenseStandard : AddressTranslator
     {
+        /// <summary>
+        ///     区域的翻译字典
+        /// </summary>
         protected Dictionary<string, int> AreaCodeDictionary;
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
         public AddressTranslatorSimenseStandard()
         {
             AreaCodeDictionary = new Dictionary<string, int>
@@ -100,6 +123,12 @@ namespace Modbus.Net.Siemens
             };
         }
 
+        /// <summary>
+        ///     地址转换
+        /// </summary>
+        /// <param name="address">格式化的地址</param>
+        /// <param name="isRead">是否为读取，是为读取，否为写入</param>
+        /// <returns>翻译后的地址</returns>
         public override AddressDef AddressTranslate(string address, bool isRead)
         {
             address = address.ToUpper();
@@ -134,6 +163,11 @@ namespace Modbus.Net.Siemens
             };
         }
 
+        /// <summary>
+        ///     获取区域中的单个地址占用的字节长度
+        /// </summary>
+        /// <param name="area">区域名称</param>
+        /// <returns>字节长度</returns>
         public override double GetAreaByteLength(string area)
         {
             return 1;

Modbus.Net/Modbus.Net.Siemens/SiemensMachine.cs

@@ -9,6 +9,16 @@ namespace Modbus.Net.Siemens
     public class SiemensMachine<TKey, TUnitKey> : BaseMachine<TKey, TUnitKey> where TKey : IEquatable<TKey>
         where TUnitKey : IEquatable<TUnitKey>
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="connectionType">连接类型</param>
+        /// <param name="connectionString">连接地址</param>
+        /// <param name="model">设备类型</param>
+        /// <param name="getAddresses">读写的地址</param>
+        /// <param name="keepConnect">是否保持连接</param>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
         public SiemensMachine(SiemensType connectionType, string connectionString, SiemensMachineModel model,
             IEnumerable<AddressUnit<TUnitKey>> getAddresses, bool keepConnect, byte slaveAddress, byte masterAddress)
             : base(getAddresses, keepConnect, slaveAddress, masterAddress)
@@ -19,6 +29,15 @@ namespace Modbus.Net.Siemens
             AddressCombinerSet = new AddressCombinerContinus<TUnitKey>(AddressTranslator, 100);
         }
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="connectionType">连接类型</param>
+        /// <param name="connectionString">连接地址</param>
+        /// <param name="model">设备类型</param>
+        /// <param name="getAddresses">读写的地址</param>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
         public SiemensMachine(SiemensType connectionType, string connectionString, SiemensMachineModel model,
             IEnumerable<AddressUnit<TUnitKey>> getAddresses, byte slaveAddress, byte masterAddress)
             : this(connectionType, connectionString, model, getAddresses, false, slaveAddress, masterAddress)
@@ -31,6 +50,16 @@ namespace Modbus.Net.Siemens
     /// </summary>
     public class SiemensMachine : BaseMachine
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="connectionType">连接类型</param>
+        /// <param name="connectionString">连接地址</param>
+        /// <param name="model">设备类型</param>
+        /// <param name="getAddresses">读写的地址</param>
+        /// <param name="keepConnect">是否保持连接</param>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
         public SiemensMachine(SiemensType connectionType, string connectionString, SiemensMachineModel model,
             IEnumerable<AddressUnit> getAddresses, bool keepConnect, byte slaveAddress, byte masterAddress)
             : base(getAddresses, keepConnect, slaveAddress, masterAddress)
@@ -41,6 +70,15 @@ namespace Modbus.Net.Siemens
             AddressCombinerSet = new AddressCombinerContinus(AddressTranslator, 100);
         }
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="connectionType">连接类型</param>
+        /// <param name="connectionString">连接地址</param>
+        /// <param name="model">设备类型</param>
+        /// <param name="getAddresses">读写的地址</param>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
         public SiemensMachine(SiemensType connectionType, string connectionString, SiemensMachineModel model,
             IEnumerable<AddressUnit> getAddresses, byte slaveAddress, byte masterAddress)
             : this(connectionType, connectionString, model, getAddresses, false, slaveAddress, masterAddress)

Modbus.Net/Modbus.Net.Siemens/SiemensPpiProtocal.cs

@@ -10,22 +10,43 @@ namespace Modbus.Net.Siemens
     {
         private readonly string _com;
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
         public SiemensPpiProtocal(byte slaveAddress, byte masterAddress)
             : this(ConfigurationManager.AppSettings["COM"], slaveAddress, masterAddress)
         {
         }
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="com">串口地址</param>
+        /// <param name="slaveAddress">从站号</param>
+        /// <param name="masterAddress">主站号</param>
         public SiemensPpiProtocal(string com, byte slaveAddress, byte masterAddress)
             : base(slaveAddress, masterAddress)
         {
             _com = com;
         }
 
+        /// <summary>
+        ///     发送协议内容并接收，一般方法
+        /// </summary>
+        /// <param name="content">写入的内容，使用对象数组描述</param>
+        /// <returns>从设备获取的字节流</returns>
         public override byte[] SendReceive(params object[] content)
         {
             return AsyncHelper.RunSync(() => SendReceiveAsync(Endian, content));
         }
 
+        /// <summary>
+        ///     发送协议内容并接收，一般方法
+        /// </summary>
+        /// <param name="content">写入的内容，使用对象数组描述</param>
+        /// <returns>从设备获取的字节流</returns>
         public override async Task<byte[]> SendReceiveAsync(params object[] content)
         {
             if (ProtocalLinker == null || !ProtocalLinker.IsConnected)
@@ -33,16 +54,30 @@ namespace Modbus.Net.Siemens
             return await base.SendReceiveAsync(Endian, content);
         }
 
+        /// <summary>
+        ///     强行发送，不检测连接状态
+        /// </summary>
+        /// <param name="unit">协议核心</param>
+        /// <param name="content">协议的参数</param>
+        /// <returns>设备返回的信息</returns>
         private async Task<IOutputStruct> ForceSendReceiveAsync(ProtocalUnit unit, IInputStruct content)
         {
             return await base.SendReceiveAsync(unit, content);
         }
 
+        /// <summary>
+        ///     连接设备
+        /// </summary>
+        /// <returns>是否连接成功</returns>
         public override bool Connect()
         {
-            return AsyncHelper.RunSync(() => ConnectAsync());
+            return AsyncHelper.RunSync(ConnectAsync);
         }
 
+        /// <summary>
+        ///     连接设备
+        /// </summary>
+        /// <returns>是否连接成功</returns>
         public override async Task<bool> ConnectAsync()
         {
             ProtocalLinker = new SiemensPpiProtocalLinker(_com, SlaveAddress);

Modbus.Net/Modbus.Net.Siemens/SiemensPpiProtocalLinker.cs

@@ -9,11 +9,21 @@ namespace Modbus.Net.Siemens
     /// </summary>
     public class SiemensPpiProtocalLinker : ComProtocalLinker
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="com">串口地址</param>
+        /// <param name="slaveAddress">从站号</param>
         public SiemensPpiProtocalLinker(string com, int slaveAddress)
             : base(com, 9600, Parity.Even, StopBits.One, 8, slaveAddress)
         {
         }
 
+        /// <summary>
+        ///     发送协议内容并接收返回
+        /// </summary>
+        /// <param name="content">发送的报文</param>
+        /// <returns>接收的报文</returns>
         public override async Task<byte[]> SendReceiveAsync(byte[] content)
         {
             var extBytes = BytesExtend(content);
@@ -36,6 +46,11 @@ namespace Modbus.Net.Siemens
             return BytesDecact(receiveBytes);
         }
 
+        /// <summary>
+        ///     发送协议内容并接收返回，不进行协议扩展和收缩
+        /// </summary>
+        /// <param name="content">发送的报文</param>
+        /// <returns>接收的报文</returns>
         public override async Task<byte[]> SendReceiveWithoutExtAndDecAsync(byte[] content)
         {
             var ans = await base.SendReceiveWithoutExtAndDecAsync(content);
@@ -60,6 +75,11 @@ namespace Modbus.Net.Siemens
             return ans;
         }
 
+        /// <summary>
+        ///     校验报文
+        /// </summary>
+        /// <param name="content">设备返回的信息</param>
+        /// <returns>报文是否正确</returns>
         public override bool? CheckRight(byte[] content)
         {
             if (!base.CheckRight(content).Value) return false;

Modbus.Net/Modbus.Net.Siemens/SiemensProtocalLinkerBytesExtend.cs

@@ -7,6 +7,11 @@ namespace Modbus.Net.Siemens
     /// </summary>
     public class SiemensTcpProtocalLinkerBytesExtend : IProtocalLinkerBytesExtend
     {
+        /// <summary>
+        ///     协议扩展，协议内容发送前调用
+        /// </summary>
+        /// <param name="content">扩展前的原始协议内容</param>
+        /// <returns>扩展后的协议内容</returns>
         public byte[] BytesExtend(byte[] content)
         {
             Array.Copy(new byte[] {0x03, 0x00, 0x00, 0x00, 0x02, 0xf0, 0x80}, 0, content, 0, 7);
@@ -14,6 +19,11 @@ namespace Modbus.Net.Siemens
             return content;
         }
 
+        /// <summary>
+        ///     协议收缩，协议内容接收后调用
+        /// </summary>
+        /// <param name="content">收缩前的完整协议内容</param>
+        /// <returns>收缩后的协议内容</returns>
         public byte[] BytesDecact(byte[] content)
         {
             var newContent = new byte[content.Length - 7];
@@ -27,6 +37,11 @@ namespace Modbus.Net.Siemens
     /// </summary>
     public class SiemensPpiProtocalLinkerBytesExtend : IProtocalLinkerBytesExtend
     {
+        /// <summary>
+        ///     协议扩展，协议内容发送前调用
+        /// </summary>
+        /// <param name="content">扩展前的原始协议内容</param>
+        /// <returns>扩展后的协议内容</returns>
         public byte[] BytesExtend(byte[] content)
         {
             var newContent = new byte[content.Length + 2];
@@ -42,6 +57,11 @@ namespace Modbus.Net.Siemens
             return newContent;
         }
 
+        /// <summary>
+        ///     协议收缩，协议内容接收后调用
+        /// </summary>
+        /// <param name="content">收缩前的完整协议内容</param>
+        /// <returns>收缩后的协议内容</returns>
         public byte[] BytesDecact(byte[] content)
         {
             var newContent = new byte[content.Length - 9];

Modbus.Net/Modbus.Net.Siemens/SiemensTcpProtocal.cs

@@ -18,12 +18,31 @@ namespace Modbus.Net.Siemens
         private readonly ushort _tsapDst;
         private int _connectTryCount;
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="tdpuSize"></param>
+        /// <param name="tsapSrc"></param>
+        /// <param name="tsapDst"></param>
+        /// <param name="maxCalling"></param>
+        /// <param name="maxCalled"></param>
+        /// <param name="maxPdu"></param>
         public SiemensTcpProtocal(byte tdpuSize, ushort tsapSrc, ushort tsapDst, ushort maxCalling, ushort maxCalled,
             ushort maxPdu)
             : this(tdpuSize, tsapSrc, tsapDst, maxCalling, maxCalled, maxPdu, ConfigurationManager.AppSettings["IP"])
         {
         }
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="tdpuSize"></param>
+        /// <param name="tsapSrc"></param>
+        /// <param name="tsapDst"></param>
+        /// <param name="maxCalling"></param>
+        /// <param name="maxCalled"></param>
+        /// <param name="maxPdu"></param>
+        /// <param name="ip">IP地址</param>
         public SiemensTcpProtocal(byte tdpuSize, ushort tsapSrc, ushort tsapDst, ushort maxCalling, ushort maxCalled,
             ushort maxPdu, string ip)
             : this(
@@ -32,6 +51,17 @@ namespace Modbus.Net.Siemens
         {
         }
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="tdpuSize"></param>
+        /// <param name="tsapSrc"></param>
+        /// <param name="tsapDst"></param>
+        /// <param name="maxCalling"></param>
+        /// <param name="maxCalled"></param>
+        /// <param name="maxPdu"></param>
+        /// <param name="ip">IP地址</param>
+        /// <param name="port">端口</param>
         public SiemensTcpProtocal(byte tdpuSize, ushort tsapSrc, ushort tsapDst, ushort maxCalling, ushort maxCalled,
             ushort maxPdu, string ip, int port) : base(0, 0)
         {
@@ -46,11 +76,21 @@ namespace Modbus.Net.Siemens
             _connectTryCount = 0;
         }
 
+        /// <summary>
+        ///     发送数据并接收
+        /// </summary>
+        /// <param name="content">发送的数据</param>
+        /// <returns>返回的数据</returns>
         public override byte[] SendReceive(params object[] content)
         {
             return AsyncHelper.RunSync(() => SendReceiveAsync(Endian, content));
         }
 
+        /// <summary>
+        ///     发送数据并接收
+        /// </summary>
+        /// <param name="content">发送的数据</param>
+        /// <returns>返回的数据</returns>
         public override async Task<byte[]> SendReceiveAsync(params object[] content)
         {
             if (ProtocalLinker == null || !ProtocalLinker.IsConnected)
@@ -58,11 +98,23 @@ namespace Modbus.Net.Siemens
             return await base.SendReceiveAsync(Endian, content);
         }
 
+        /// <summary>
+        ///     发送数据并接收
+        /// </summary>
+        /// <param name="unit">协议的核心</param>
+        /// <param name="content">协议的参数</param>
+        /// <returns>返回的数据</returns>
         public override IOutputStruct SendReceive(ProtocalUnit unit, IInputStruct content)
         {
             return AsyncHelper.RunSync(() => SendReceiveAsync(unit, content));
         }
 
+        /// <summary>
+        ///     发送数据并接收
+        /// </summary>
+        /// <param name="unit">发送的数据</param>
+        /// <param name="content">协议的参数</param>
+        /// <returns>返回的数据</returns>
         public override async Task<IOutputStruct> SendReceiveAsync(ProtocalUnit unit, IInputStruct content)
         {
             if (ProtocalLinker != null && ProtocalLinker.IsConnected) return await base.SendReceiveAsync(unit, content);
@@ -74,16 +126,30 @@ namespace Modbus.Net.Siemens
                             .ContinueWith(answer => answer.Result ? base.SendReceiveAsync(unit, content) : null);
         }
 
+        /// <summary>
+        ///     强制发送数据并接收
+        /// </summary>
+        /// <param name="unit">发送的数据</param>
+        /// <param name="content">协议的参数</param>
+        /// <returns>返回的数据</returns>
         private async Task<IOutputStruct> ForceSendReceiveAsync(ProtocalUnit unit, IInputStruct content)
         {
             return await base.SendReceiveAsync(unit, content);
         }
 
+        /// <summary>
+        ///     连接设备
+        /// </summary>
+        /// <returns>设备是否连接成功</returns>
         public override bool Connect()
         {
             return AsyncHelper.RunSync(ConnectAsync);
         }
 
+        /// <summary>
+        ///     连接设备
+        /// </summary>
+        /// <returns>设备是否连接成功</returns>
         public override async Task<bool> ConnectAsync()
         {
             _connectTryCount++;

Modbus.Net/Modbus.Net.Siemens/SiemensTcpProtocalLinker.cs

@@ -8,16 +8,30 @@ namespace Modbus.Net.Siemens
     /// </summary>
     public class SiemensTcpProtocalLinker : TcpProtocalLinker
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="ip">IP地址</param>
         public SiemensTcpProtocalLinker(string ip)
             : this(ip, int.Parse(ConfigurationManager.AppSettings["SiemensPort"] ?? "102"))
         {
         }
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="ip">IP地址</param>
+        /// <param name="port">端口</param>
         public SiemensTcpProtocalLinker(string ip, int port)
             : base(ip, port)
         {
         }
 
+        /// <summary>
+        ///     校验报文
+        /// </summary>
+        /// <param name="content">设备返回的信息</param>
+        /// <returns>报文是否正确</returns>
         public override bool? CheckRight(byte[] content)
         {
             if (!base.CheckRight(content).Value) return false;

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

@@ -1,22 +1,56 @@
 using System;
 using System.Threading.Tasks;
+using Serilog;
 
 namespace Modbus.Net.Siemens
 {
+    /// <summary>
+    ///     西门子协议类型
+    /// </summary>
     public enum SiemensType
     {
+        /// <summary>
+        /// PPI
+        /// </summary>
         Ppi = 0,
+        /// <summary>
+        /// MPI
+        /// </summary>
         Mpi = 1,
+        /// <summary>
+        /// 以太网
+        /// </summary>
         Tcp = 2
     }
 
+    /// <summary>
+    ///     西门子设备类型
+    /// </summary>
     public enum SiemensMachineModel
     {
+        /// <summary>
+        /// S7-200
+        /// </summary>
         S7_200 = 0,
+        /// <summary>
+        /// S7-200 Smart
+        /// </summary>
         S7_200_Smart = 1,
+        /// <summary>
+        /// S7-300
+        /// </summary>
         S7_300 = 2,
+        /// <summary>
+        /// S7-400
+        /// </summary>
         S7_400 = 3,
+        /// <summary>
+        /// S7-1200
+        /// </summary>
         S7_1200 = 4,
+        /// <summary>
+        /// S7-1500
+        /// </summary>
         S7_1500 = 5
     }
 
@@ -34,6 +68,14 @@ namespace Modbus.Net.Siemens
 
         private SiemensType _siemensType;
 
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="connectionType">连接类型</param>
+        /// <param name="connectionString">连接字符串</param>
+        /// <param name="model">设备类型</param>
+        /// <param name="slaveAddress">从站地址</param>
+        /// <param name="masterAddress">主站地址</param>
         public SiemensUtility(SiemensType connectionType, string connectionString, SiemensMachineModel model,
             byte slaveAddress, byte masterAddress) : base(slaveAddress, masterAddress)
         {
@@ -84,15 +126,21 @@ namespace Modbus.Net.Siemens
                 }
                 default:
                 {
-                    throw new NotImplementedException("没有相应的西门子类型");
+                    throw new NotImplementedException("Siemens PLC Model not Supported");
                 }
             }
             ConnectionType = connectionType;
             AddressTranslator = new AddressTranslatorSiemens();
         }
 
+        /// <summary>
+        ///     端格式
+        /// </summary>
         public override Endian Endian => Endian.BigEndianLsb;
 
+        /// <summary>
+        ///     IP地址
+        /// </summary>
         protected string ConnectionStringIp
         {
             get
@@ -102,6 +150,9 @@ namespace Modbus.Net.Siemens
             }
         }
 
+        /// <summary>
+        ///     端口
+        /// </summary>
         protected int? ConnectionStringPort
         {
             get
@@ -113,8 +164,9 @@ namespace Modbus.Net.Siemens
                 {
                     return connectionStringSplit.Length < 2 ? (int?) null : int.Parse(connectionStringSplit[1]);
                 }
-                catch
+                catch (Exception e)
                 {
+                    Log.Error(e, $"SiemensUtility: {ConnectionString} format error");
                     return null;
                 }
             }
@@ -188,8 +240,9 @@ namespace Modbus.Net.Siemens
                             readRequestSiemensInputStruct);
                 return readRequestSiemensOutputStruct?.GetValue;
             }
-            catch (Exception)
+            catch (Exception e)
             {
+                Log.Error(e, $"SiemensUtility -> GetDatas: {ConnectionString} error");
                 return null;
             }
         }
@@ -213,8 +266,9 @@ namespace Modbus.Net.Siemens
                             writeRequestSiemensInputStruct);
                 return writeRequestSiemensOutputStruct?.AccessResult == SiemensAccessResult.NoError;
             }
-            catch (Exception)
+            catch (Exception e)
             {
+                Log.Error(e, $"ModbusUtility -> SetDatas: {ConnectionString} error");
                 return false;
             }
         }

Modbus.Net/Modbus.Net/ComConnector.cs

@@ -61,15 +61,16 @@ namespace Modbus.Net
         /// </summary>
         private readonly int _timeoutTime;
 
+        private int _errorCount;
+        private int _receiveCount;
+
+        private int _sendCount;
+
         /// <summary>
         ///     Dispose是否执行
         /// </summary>
         private bool m_disposed;
 
-        private int _sendCount;
-        private int _receiveCount;
-        private int _errorCount;
-
         /// <summary>
         ///     构造器
         /// </summary>
@@ -144,7 +145,7 @@ namespace Modbus.Net
         /// <param name="byteTime">字节间隔最大时间 </param>
         /// <returns>串口实际读入数据个数 </returns>
         public int ReadComm(out byte[] readBuf, int bufRoom, int howTime, int byteTime)
-        { 
+        {
             readBuf = new byte[1023];
             Array.Clear(readBuf, 0, readBuf.Length);
 
@@ -283,7 +284,7 @@ namespace Modbus.Net
                         {
                             SerialPort.Close();
                         }
-                        catch (Exception)
+                        catch
                         {
                             //ignore
                         }
@@ -308,6 +309,24 @@ namespace Modbus.Net
             Dispose(false);
         }
 
+        private void RefreshSendCount()
+        {
+            _sendCount++;
+            Log.Verbose("Tcp client {ConnectionToken} send count: {SendCount}", ConnectionToken, _sendCount);
+        }
+
+        private void RefreshReceiveCount()
+        {
+            _receiveCount++;
+            Log.Verbose("Tcp client {ConnectionToken} receive count: {SendCount}", ConnectionToken, _receiveCount);
+        }
+
+        private void RefreshErrorCount()
+        {
+            _errorCount++;
+            Log.Verbose("Tcp client {ConnectionToken} error count: {ErrorCount}", ConnectionToken, _errorCount);
+        }
+
         #region 发送接收数据
 
         /// <summary>
@@ -381,7 +400,8 @@ namespace Modbus.Net
                     Log.Error(e, "Com client {ConnectionToken} disconnect error", ConnectionToken);
                     return false;
                 }
-            Log.Error(new Exception("Linkers or Connectors Dictionary not found"), "Com client {ConnectionToken} disconnect error", ConnectionToken);
+            Log.Error(new Exception("Linkers or Connectors Dictionary not found"),
+                "Com client {ConnectionToken} disconnect error", ConnectionToken);
             return false;
         }
 
@@ -436,7 +456,8 @@ namespace Modbus.Net
                 {
                     try
                     {
-                        Log.Verbose("Com client {ConnectionToken} send msg length: {Length}", ConnectionToken, sendbytes.Length);
+                        Log.Verbose("Com client {ConnectionToken} send msg length: {Length}", ConnectionToken,
+                            sendbytes.Length);
                         Log.Verbose("Com client {ConnectionToken} send msg: {SendBytes}", ConnectionToken, sendbytes);
                         SerialPort.Write(sendbytes, 0, sendbytes.Length);
                     }
@@ -450,8 +471,10 @@ namespace Modbus.Net
                     try
                     {
                         returnBytes = ReadMsg();
-                        Log.Verbose("Com client {ConnectionToken} receive msg length: {Length}", ConnectionToken, returnBytes.Length);
+                        Log.Verbose("Com client {ConnectionToken} receive msg length: {Length}", ConnectionToken,
-                        Log.Verbose("Com client {ConnectionToken} receive msg: {SendBytes}", ConnectionToken, returnBytes);
+                            returnBytes.Length);
+                        Log.Verbose("Com client {ConnectionToken} receive msg: {SendBytes}", ConnectionToken,
+                            returnBytes);
                     }
                     catch (Exception e)
                     {
@@ -504,7 +527,8 @@ namespace Modbus.Net
                 {
                     try
                     {
-                        Log.Verbose("Com client {ConnectionToken} send msg length: {Length}", ConnectionToken, sendbytes.Length);
+                        Log.Verbose("Com client {ConnectionToken} send msg length: {Length}", ConnectionToken,
+                            sendbytes.Length);
                         Log.Verbose("Com client {ConnectionToken} send msg: {SendBytes}", ConnectionToken, sendbytes);
                         SerialPort.Write(sendbytes, 0, sendbytes.Length);
                     }
@@ -513,7 +537,7 @@ namespace Modbus.Net
                         Log.Error(err, "Com client {ConnectionToken} send msg error", ConnectionToken);
                         Dispose();
                         return false;
-                    } 
+                    }
                     RefreshSendCount();
                 }
                 return true;
@@ -549,23 +573,5 @@ namespace Modbus.Net
         }
 
         #endregion
-
-        private void RefreshSendCount()
-        {
-            _sendCount++;
-            Log.Verbose("Tcp client {ConnectionToken} send count: {SendCount}", ConnectionToken, _sendCount);
-        }
-
-        private void RefreshReceiveCount()
-        {
-            _receiveCount++;
-            Log.Verbose("Tcp client {ConnectionToken} receive count: {SendCount}", ConnectionToken, _receiveCount);
-        }
-
-        private void RefreshErrorCount()
-        {
-            _errorCount++;
-            Log.Verbose("Tcp client {ConnectionToken} error count: {ErrorCount}", ConnectionToken, _errorCount);
-        }
     }
 }

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

@@ -52,9 +52,9 @@ namespace Modbus.Net
         /// <summary>
         ///     地址转换
         /// </summary>
-        /// <param name="address">地址前地址</param>
+        /// <param name="address">格式化的地址</param>
         /// <param name="isRead">是否为读取，是为读取，否为写入</param>
-        /// <returns>Key为转换后的地址，Value为辅助码</returns>
+        /// <returns>翻译后的地址</returns>
         public abstract AddressDef AddressTranslate(string address, bool isRead);
 
         /// <summary>

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

@@ -7,7 +7,6 @@ namespace Modbus.Net
     /// </summary>
     public abstract class BaseConnector : BaseConnector<byte[], byte[]>
     {
-        
     }
 
     /// <summary>

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

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
+using Serilog;
 
 namespace Modbus.Net
 {
@@ -333,8 +334,9 @@ namespace Modbus.Net
             }
             catch (Exception e)
             {
-                Console.WriteLine(ConnectionToken + " " + e.Message);
                 ErrorCount++;
+                Log.Error(e, $"BaseMachine -> GetDatas, Id:{Id} Connection:{ConnectionToken} error. ErrorCount {ErrorCount}.");
+                
                 if (ErrorCount >= _maxErrorCount)
                     Disconnect();
                 return null;
@@ -532,7 +534,11 @@ namespace Modbus.Net
             }
             catch (Exception e)
             {
-                Console.WriteLine(ConnectionToken + " " + e.Message);
+                ErrorCount++;
+                Log.Error(e, $"BaseMachine -> SetDatas, Id:{Id} Connection:{ConnectionToken} error. ErrorCount {ErrorCount}.");
+
+                if (ErrorCount >= _maxErrorCount)
+                    Disconnect();
                 return false;
             }
             return true;
@@ -591,7 +597,7 @@ namespace Modbus.Net
                     .Invoke(this, parameters);
                 return (TReturnType) returnValue;
             }
-            throw new InvalidCastException($"Machine未实现{typeof(TMachineMethod).Name}的接口");
+            throw new InvalidCastException($"Machine interface {nameof(TMachineMethod)} not implemented");
         }
 
         /// <summary>
@@ -641,9 +647,9 @@ namespace Modbus.Net
             {
                 return GetAddresses.SingleOrDefault(p => p.Id.Equals(addressUnitId));
             }
-            catch (Exception)
+            catch (Exception e)
             {
-                Console.WriteLine("Id重复，请检查");
+                Log.Error(e, $"BaseMachine -> GetAddressUnitById Id:{Id} ConnectionToken:{ConnectionToken} addressUnitId:{addressUnitId} Repeated");
                 return null;
             }
         }

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

@@ -85,7 +85,8 @@ namespace Modbus.Net
                 //自动寻找存在的协议并将其加载
                 var protocalUnit =
                     Activator.CreateInstance(type.GetTypeInfo().Assembly.GetType(protocalName)) as TProtocalUnit;
-                if (protocalUnit == null) throw new InvalidCastException("没有相应的协议内容");
+                if (protocalUnit == null)
+                    throw new InvalidCastException($"No ProtocalUnit {nameof(TProtocalUnit)} implemented");
                 protocalUnit.Endian = Endian;
                 Register(protocalUnit);
                 return Protocals[protocalName];

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

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using Serilog;
 
 /// <summary>
 ///     端格式
@@ -124,8 +125,9 @@ namespace Modbus.Net
                 var getBytes = getReturnValue;
                 return ValueHelper.GetInstance(Endian).ByteArrayToObjectArray(getBytes, getTypeAndCount);
             }
-            catch (Exception)
+            catch (Exception e)
             {
+                Log.Error(e, $"ModbusUtility -> GetDatas: {ConnectionString} error");
                 return null;
             }
         }
@@ -159,8 +161,9 @@ namespace Modbus.Net
                     new KeyValuePair<Type, int>(typeof(T), getByteCount));
                 return ValueHelper.GetInstance(Endian).ObjectArrayToDestinationArray<T>(getBytes);
             }
-            catch (Exception)
+            catch (Exception e)
             {
+                Log.Error(e, $"ModbusUtility -> GetDatas Generic: {ConnectionString} error");
                 return null;
             }
         }
@@ -199,8 +202,9 @@ namespace Modbus.Net
                 var getBytes = getReturnValue;
                 return ValueHelper.GetInstance(Endian).ByteArrayToObjectArray(getBytes, translateTypeAndCount);
             }
-            catch (Exception)
+            catch (Exception e)
             {
+                Log.Error(e, $"ModbusUtility -> GetDatas pair: {ConnectionString} error");
                 return null;
             }
         }
@@ -290,7 +294,7 @@ namespace Modbus.Net
                     .Invoke(this, parameters);
                 return (TReturnType) returnValue;
             }
-            throw new InvalidCastException($"Utility未实现{typeof(TUtilityMethod).Name}的接口");
+            throw new InvalidCastException($"Utility interface {nameof(TUtilityMethod)} not implemented");
         }
 
         /// <summary>

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

@@ -9,6 +9,7 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Nito.AsyncEx;
+using Serilog;
 
 namespace Modbus.Net
 {
@@ -864,7 +865,7 @@ namespace Modbus.Net
             }
             catch (Exception e)
             {
-                Console.WriteLine($"设备返回错误 {e.Message}");
+                Log.Error(e, $"Device {id} return error");
                 return null;
             }
         }
@@ -889,7 +890,7 @@ namespace Modbus.Net
             }
             catch (Exception e)
             {
-                Console.WriteLine($"设备返回错误 {e.Message}");
+                Log.Error(e, $"Device {connectionToken} return error");
                 return null;
             }
         }

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

@@ -40,9 +40,10 @@ namespace Modbus.Net
         /// </summary>
         private readonly byte[] _receiveBuffer = new byte[1024];
 
-        private int _sendCount;
-        private int _receiveCount;
         private int _errorCount;
+        private int _receiveCount;
+
+        private int _sendCount;
 
         private TcpClient _socketClient;
 
@@ -73,7 +74,8 @@ namespace Modbus.Net
         /// </summary>
         public int TimeoutTime
         {
-            get => _timeoutTime;
+            get  =>
+            _timeoutTime;
             set
             {
                 _timeoutTime = value;
@@ -122,7 +124,7 @@ namespace Modbus.Net
 #endif
                     Log.Debug("Tcp client {ConnectionToken} Disposed", ConnectionToken);
                 }
-                m_disposed = true;               
+                m_disposed = true;
             }
         }
 
@@ -242,7 +244,7 @@ namespace Modbus.Net
                 await stream.WriteAsync(datagram, 0, datagram.Length);
 
                 RefreshSendCount();
-                
+
                 return true;
             }
             catch (Exception err)
@@ -282,11 +284,12 @@ namespace Modbus.Net
                 Log.Verbose("Tcp client {ConnectionToken} send text len = {Length}", ConnectionToken, datagram.Length);
                 Log.Verbose("Tcp client {ConnectionToken} send: {Datagram}", ConnectionToken, datagram);
                 await stream.WriteAsync(datagram, 0, datagram.Length);
-                                       
+
                 RefreshSendCount();
 
                 var receiveBytes = await ReceiveAsync(stream);
-                Log.Verbose("Tcp client {ConnectionToken} receive text len = {Length}", ConnectionToken, receiveBytes.Length);
+                Log.Verbose("Tcp client {ConnectionToken} receive text len = {Length}", ConnectionToken,
+                    receiveBytes.Length);
                 Log.Verbose("Tcp client {ConnectionToken} receive: {Datagram}", ConnectionToken, receiveBytes);
 
                 return receiveBytes;
@@ -332,7 +335,7 @@ namespace Modbus.Net
             var replyMessage = new byte[len];
             Array.Copy(_receiveBuffer, replyMessage, len);
 
-            Log.Verbose("Tcp client {ConnectionToken} reply: {replyMessage}",ConnectionToken, replyMessage);
+            Log.Verbose("Tcp client {ConnectionToken} reply: {replyMessage}", ConnectionToken, replyMessage);
             RefreshReceiveCount();
 
             if (len <= 0)

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

@@ -1,6 +1,6 @@
-
+#if NET40||NET45||NET451||NET452||NET46||NET461||NET462||NET47
-#if NET40||NET45||NET451||NET452||NET46||NET461||NET462||NET47
 using System.Configuration;
+
 #endif
 
 namespace Modbus.Net

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

@@ -36,7 +36,7 @@ namespace Modbus.Net
                 throw new NullReferenceException("The type has not been specified.");
 
             if (string.IsNullOrEmpty(methodName))
-                throw new ArgumentNullException("methodName", "The name of the method has not been specified.");
+                throw new ArgumentNullException(nameof(methodName), "The name of the method has not been specified.");
 
 
             var methods =

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

@@ -3,6 +3,7 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using Serilog;
 
 namespace Modbus.Net
 {
@@ -707,12 +708,13 @@ namespace Modbus.Net
                             }
                             default:
                             {
-                                throw new NotImplementedException("没有实现除整数以外的其它转换方式");
+                                throw new NotImplementedException("Number casting not implemented");
                             }
                         }
                     }
-                    catch (Exception)
+                    catch (Exception e)
                     {
+                        Log.Error(e, "ValueHelper -> ByteArrayToObjectArray error");
                         count = contents.Length;
                     }
                 }
@@ -798,7 +800,7 @@ namespace Modbus.Net
                 }
                 default:
                 {
-                    throw new NotImplementedException("没有实现除整数以外的其它转换方式");
+                    throw new NotImplementedException("Number casting not implemented");
                 }
             }
         }
@@ -818,8 +820,9 @@ namespace Modbus.Net
                 Array.Copy(datas, 0, contents, pos, datas.Length);
                 return true;
             }
-            catch (Exception)
+            catch (Exception e)
             {
+                Log.Error(e, "ValueHelper -> SetValue set value failed");
                 return false;
             }
         }
@@ -866,8 +869,9 @@ namespace Modbus.Net
                 contents[pos] = SetBit(contents[pos], subPos, setValue);
                 return true;
             }
-            catch (Exception)
+            catch (Exception e)
             {
+                Log.Error(e, "ValueHelper -> SetBit set bit failed");
                 return false;
             }
         }