2017-05-15 update 2 Add comments.

Modbus.Net/Modbus.Net.Modbus/Modbus.Net.Modbus.csproj

@@ -23,6 +23,10 @@
     <DocumentationFile>bin\Debug\net45\Modbus.Net.Modbus.xml</DocumentationFile>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Bcl.Build" Version="1.0.21" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\ModBus.Net\Modbus.Net.csproj" />
   </ItemGroup>

Modbus.Net/Modbus.Net.OPC/Modbus.Net.OPC.csproj

@@ -25,6 +25,7 @@
 
   <ItemGroup>
     <PackageReference Include="H.Opc" Version="0.9.0" />
+    <PackageReference Include="Microsoft.Bcl.Build" Version="1.0.21" />
   </ItemGroup>
 
   <ItemGroup>

Modbus.Net/Modbus.Net.Siemens/Modbus.Net.Siemens.csproj

@@ -22,6 +22,10 @@
     <DocumentationFile>bin\Debug\net45\Modbus.Net.Siemens.xml</DocumentationFile>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Bcl.Build" Version="1.0.21" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\ModBus.Net\Modbus.Net.csproj" />
   </ItemGroup>

Modbus.Net/Modbus.Net/ComConnector.cs

@@ -409,7 +409,7 @@ namespace Modbus.Net
                 Array.Copy(data, 0, returndata, 0, i);
                 return returndata;
             }
-            catch (Exception ex)
+            catch (Exception)
             {
                 Dispose();
                 return null;

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

@@ -55,6 +55,13 @@ namespace Modbus.Net
             return task.ContinueWith(t => t.GetAwaiter().GetResult(), token);
         }
 
+        /// <summary>
+        ///     Add a CancellationToken to async task
+        /// </summary>
+        /// <typeparam name="T">type of a task</typeparam>
+        /// <param name="task">Task</param>
+        /// <param name="token">Cancellation token</param>
+        /// <returns>Task with cancellation token</returns>
         public static Task<T> WithCancellation<T>(this Task<T> task,
             CancellationToken token)
         {

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

@@ -662,6 +662,10 @@ namespace Modbus.Net
             return BaseUtility.Disconnect();
         }
 
+        /// <summary>
+        ///     获取设备的Id，字符串格式
+        /// </summary>
+        /// <returns></returns>
         public string GetMachineIdString()
         {
             return Id.ToString();
@@ -821,12 +825,20 @@ namespace Modbus.Net
         /// </summary>
         public UnitExtend UnitExtend { get; set; }
 
+        /// <summary>
+        ///     两个地址是否一致
+        /// </summary>
+        /// <param name="other">另一个地址</param>
+        /// <returns>是否一致</returns>
         public bool Equals(AddressUnit<TKey> other)
         {
             return (Area.ToUpper() == other.Area.ToUpper() && Address == other.Address) || Id.Equals(other.Id);
         }
     }
 
+    /// <summary>
+    ///     没有Id的设备属性
+    /// </summary>
     public interface IMachinePropertyWithoutKey
     {
         /// <summary>
@@ -888,6 +900,10 @@ namespace Modbus.Net
         /// <returns>是否断开成功</returns>
         bool Disconnect();
 
+        /// <summary>
+        ///     获取设备的Id的字符串
+        /// </summary>
+        /// <returns></returns>
         string GetMachineIdString();
     }
 

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

@@ -44,7 +44,6 @@ namespace Modbus.Net
         /// </summary>
         /// <param name="message">发送或返回的命令，CRC码除外</param>
         /// <param name="Rcvbuf">存储CRC码的字节的数组</param>
-        /// <param name="CRC">生成的CRC码</param>
         public short GetCRC(byte[] message, ref byte[] Rcvbuf)
         {
             int IX, IY, CRC;
@@ -83,7 +82,7 @@ namespace Modbus.Net
         /// <summary>
         ///     CRC校验
         /// </summary>
-        /// <param name="src">ST开头，&&结尾</param>
+        /// <param name="byteframe">需要校验的字节数组</param>
         /// <returns>十六进制数</returns>
         public bool CrcEfficacy(byte[] byteframe)
         {
@@ -149,15 +148,13 @@ namespace Modbus.Net
             decByteTotal = 255 - decByteTotal + 1;
             decByteTotal = decByteTotal & 255;
 
-            int a, b = 0;
-
             string hexByte = "", hexTotal = "";
             double i;
 
             for (i = 0; decByteTotal > 0; i++)
             {
                 //b = Convert.ToInt32(System.Math.Pow(16.0, i));
-                a = decByteTotal%16;
+                var a = decByteTotal%16;
                 decByteTotal /= 16;
                 if (a <= 9)
                     hexByte = a.ToString();

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

@@ -25,10 +25,19 @@ namespace Modbus.Net
     /// </summary>
     public class DataReturnDef<TMachineKey> where TMachineKey : IEquatable<TMachineKey>
     {
+        /// <summary>
+        ///     设备的Id
+        /// </summary>
         public TMachineKey MachineId { get; set; }
+        /// <summary>
+        ///     返回的数据值
+        /// </summary>
         public Dictionary<string, ReturnUnit> ReturnValues { get; set; }
     }
 
+    /// <summary>
+    ///     Limited concurrency level task scheduler
+    /// </summary>
     public class LimitedConcurrencyLevelTaskScheduler : TaskScheduler
     {
         /// <summary>
@@ -192,20 +201,45 @@ namespace Modbus.Net
         }
     }
 
+    /// <summary>
+    ///     具有任务管理的设备
+    /// </summary>
+    /// <typeparam name="TMachineKey">设备的Id类型</typeparam>
     public class TaskMachine<TMachineKey> where TMachineKey : IEquatable<TMachineKey>
     {
-        private TaskFactory _tasks { get; }
+        /// <summary>
+        ///     任务工厂
+        /// </summary>
+        private readonly TaskFactory _tasks;
 
+        /// <summary>
+        /// 构造函数
+        /// </summary>
+        /// <param name="machine">设备</param>
+        /// <param name="taskFactory">任务工厂</param>
         public TaskMachine(IMachineProperty<TMachineKey> machine, TaskFactory taskFactory)
         {
             Machine = machine;
             _tasks = taskFactory;
+            TasksWithTimer = new List<ITaskItem>();
         }
 
+        /// <summary>
+        ///     设备
+        /// </summary>
         public IMachineProperty<TMachineKey> Machine { get; }
 
-        public List<ITaskItem> TasksWithTimer { get; set; }
+        /// <summary>
+        ///     任务调度器
+        /// </summary>
+        public List<ITaskItem> TasksWithTimer { get; }
 
+        /// <summary>
+        ///     定时方式启动任务
+        /// </summary>
+        /// <typeparam name="TInterType">任务返回值的类型</typeparam>
+        /// <param name="task">任务</param>
+        /// <returns>任务是否执行成功</returns>
         public bool InvokeTimer<TInterType>(TaskItem<TInterType> task)
         {
             task.DetectConnected = () => Machine.IsConnected;
@@ -221,6 +255,11 @@ namespace Modbus.Net
             return false;
         }
 
+        /// <summary>
+        ///     停止任务
+        /// </summary>
+        /// <param name="taskItemName">任务的名称</param>
+        /// <returns>是否停止成功</returns>
         public bool StopTimer(string taskItemName)
         {
             if (TasksWithTimer.Exists(taskCon => taskCon.Name == taskItemName))
@@ -233,6 +272,10 @@ namespace Modbus.Net
             return false;
         }
 
+        /// <summary>
+        ///     停止所有任务
+        /// </summary>
+        /// <returns>是否停止成功</returns>
         public bool StopAllTimers()
         {
             bool ans = true;
@@ -243,6 +286,11 @@ namespace Modbus.Net
             return ans;
         }
 
+        /// <summary>
+        ///     暂时任务
+        /// </summary>
+        /// <param name="taskItemName">任务的名称</param>
+        /// <returns>是否暂停成功</returns>
         public bool PauseTimer(string taskItemName)
         {
             if (TasksWithTimer.Exists(taskCon => taskCon.Name == taskItemName))
@@ -254,6 +302,10 @@ namespace Modbus.Net
             return false;
         }
 
+        /// <summary>
+        ///     暂停所有任务
+        /// </summary>
+        /// <returns>是否暂停成功</returns>
         public bool PauseAllTimers()
         {
             bool ans = true;
@@ -264,6 +316,11 @@ namespace Modbus.Net
             return ans;
         }
 
+        /// <summary>
+        ///     恢复任务
+        /// </summary>
+        /// <param name="taskItemName">任务的名称</param>
+        /// <returns>是否恢复任务</returns>
         public bool ContinueTimer(string taskItemName)
         {
             if (TasksWithTimer.Exists(taskCon => taskCon.Name == taskItemName))
@@ -275,6 +332,10 @@ namespace Modbus.Net
             return false;
         }
 
+        /// <summary>
+        ///     恢复所有任务
+        /// </summary>
+        /// <returns>是否恢复成功</returns>
         public bool ContinueAllTimers()
         {
             bool ans = true;
@@ -285,12 +346,18 @@ namespace Modbus.Net
             return ans;
         }
 
+        /// <summary>
+        ///     执行任务一次
+        /// </summary>
+        /// <typeparam name="TInterType">任务返回值的类型</typeparam>
+        /// <param name="task">任务</param>
+        /// <returns>任务是否执行成功</returns>
         public async Task<bool> InvokeOnce<TInterType>(TaskItem<TInterType> task)
         {
             if (Machine.IsConnected)
             {
                 var ans = await task.Invoke(Machine, _tasks, task.Params);
-                task.Return(ans);
+                task.Return?.Invoke(ans);
                 return true;
             }
             return false;
@@ -311,17 +378,40 @@ namespace Modbus.Net
         }
     }
 
+    /// <summary>
+    ///     任务的接口
+    /// </summary>
     public interface ITaskItem
     {
+        /// <summary>
+        ///     任务的名称
+        /// </summary>
         string Name { get; set; }
 
+        /// <summary>
+        ///     启动计时器
+        /// </summary>
+        /// <returns></returns>
         bool StartTimer();
 
+        /// <summary>
+        ///     停止计时器
+        /// </summary>
+        /// <returns></returns>
         bool StopTimer();
     }
 
+    /// <summary>
+    ///     获取数据的预定义任务
+    /// </summary>
     public class TaskItemGetData : TaskItem<DataReturnDef>
     {
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="returnFunc">返回值的处理函数</param>
+        /// <param name="getCycle">循环间隔(毫秒)</param>
+        /// <param name="sleepCycle">设备离线时的循环间隔(毫秒)</param>
         public TaskItemGetData(Action<DataReturnDef> returnFunc, int getCycle, int sleepCycle)
         {
             Name = "GetDatas";
@@ -347,9 +437,17 @@ namespace Modbus.Net
         }
     }
     
+    /// <summary>
+    ///     写入数据的预定义任务
+    /// </summary>
     public class TaskItemSetData : TaskItem<bool>
     {
-        public TaskItemSetData(Dictionary<string, double> values)
+        /// <summary>
+        ///     构造函数
+        /// </summary>
+        /// <param name="values">写入的值</param>
+        /// <param name="returnFunc">返回值的处理函数</param>
+        public TaskItemSetData(Dictionary<string, double> values, Action<bool> returnFunc = null)
         {
             Name = "SetDatas";
             Invoke = Invoke = async (machine, tasks, parameters) =>
@@ -364,50 +462,106 @@ namespace Modbus.Net
                 return ans;
             };
             Params = new object[]{values};
+            Return = returnFunc;
         }
     }
 
+    /// <summary>
+    ///     任务
+    /// </summary>
+    /// <typeparam name="TInterType">任务返回值的类型</typeparam>
     public class TaskItem<TInterType> : ITaskItem, IEquatable<TaskItem<TInterType>>
     {
+        /// <summary>
+        ///     名称
+        /// </summary>
         public string Name { get; set; }
+        /// <summary>
+        ///     定时器
+        /// </summary>
         private Timer Timer { get; set; }
+        /// <summary>
+        ///     定时器的时间
+        /// </summary>
         public int TimerTime { get; set; }
+        /// <summary>
+        ///     离线定时器
+        /// </summary>
         private Timer TimerDisconnected { get; set; }
+        /// <summary>
+        ///     离线定时器的时间
+        /// </summary>
         public int TimerDisconnectedTime { get; set; }
+        /// <summary>
+        ///     执行的任务
+        /// </summary>
         public Func<IMachinePropertyWithoutKey, TaskFactory, object[], Task<TInterType>> Invoke { get; set; }
+        /// <summary>
+        ///     检测设备的在线状态
+        /// </summary>
         internal Func<bool> DetectConnected { get; set; } 
+        /// <summary>
+        ///     任务执行的参数
+        /// </summary>
         public object[] Params { get; set; }
+        /// <summary>
+        ///     返回值的处理函数
+        /// </summary>
         public Action<TInterType> Return { get; set; }
+        /// <summary>
+        ///     获取设备
+        /// </summary>
         internal Func<IMachinePropertyWithoutKey> GetMachine { get; set; }
+        /// <summary>
+        ///     获取任务工厂
+        /// </summary>
         internal Func<TaskFactory> GetTaskFactory { get; set; }
 
+        /// <summary>
+        ///     是否相等
+        /// </summary>
+        /// <param name="other">另一个实例</param>
+        /// <returns>是否相等</returns>
         public bool Equals(TaskItem<TInterType> other)
         {
             return Name == other?.Name;
         }
 
+        /// <summary>
+        ///     启动定时器
+        /// </summary>
+        /// <returns>是否成功</returns>
         public bool StartTimer()
         {
             ActivateTimerDisconnected();
             return true;
         }
 
+        /// <summary>
+        ///     激活定时器
+        /// </summary>
         private void ActivateTimer()
         {
             Timer = new Timer(async state =>
             {
                 if (!DetectConnected()) TimerChangeToDisconnect();
                 var ans = await Invoke(GetMachine(),GetTaskFactory(),Params);
-                Return(ans);
+                Return?.Invoke(ans);
             }, null, 0, TimerTime);
         }
 
+        /// <summary>
+        ///     反激活定时器
+        /// </summary>
         private void DeactivateTimer()
         {
             Timer.Dispose();
             Timer = null;
         }
 
+        /// <summary>
+        ///     激活离线定时器
+        /// </summary>
         private void ActivateTimerDisconnected()
         {
             TimerDisconnected = new Timer(async state =>
@@ -417,12 +571,19 @@ namespace Modbus.Net
             }, null, 0, TimerDisconnectedTime);
         }
 
+        /// <summary>
+        ///     反激活离线定时器
+        /// </summary>
         private void DeactivateTimerDisconnected()
         {
             TimerDisconnected.Dispose();
             TimerDisconnected = null;
         }
 
+        /// <summary>
+        ///     将定时器切换至在线
+        /// </summary>
+        /// <returns></returns>
         private bool TimerChangeToConnect()
         {
             DeactivateTimerDisconnected();
@@ -430,6 +591,10 @@ namespace Modbus.Net
             return true;
         }
 
+        /// <summary>
+        ///     将定时器切换至离线
+        /// </summary>
+        /// <returns></returns>
         private bool TimerChangeToDisconnect()
         {
             DeactivateTimer();
@@ -437,6 +602,10 @@ namespace Modbus.Net
             return true;
         }
 
+        /// <summary>
+        ///     停止定时器
+        /// </summary>
+        /// <returns></returns>
         public bool StopTimer()
         {
             DeactivateTimer();
@@ -450,27 +619,51 @@ namespace Modbus.Net
     /// </summary>
     public class TaskManager : TaskManager<string>
     {
+        /// <summary>
+        ///     构造一个TaskManager
+        /// </summary>
+        /// <param name="maxRunningTask">同时可以运行的任务数</param>
+        /// <param name="keepConnect">读取数据后是否保持连接</param>
+        /// <param name="dataType">获取与设置数据的方式</param>
         public TaskManager(int maxRunningTask, bool keepConnect,
             MachineDataType dataType = MachineDataType.CommunicationTag)
             : base(maxRunningTask, keepConnect, dataType)
         {
         }
 
+        /// <summary>
+        ///     添加一台设备
+        /// </summary>
+        /// <param name="machine">设备</param>
         public void AddMachine(BaseMachine machine)
         {
             base.AddMachine(machine);
         }
 
+        /// <summary>
+        ///     添加多台设备
+        /// </summary>
+        /// <param name="machines">多台设备</param>
         public void AddMachines(IEnumerable<BaseMachine> machines)
         {
             base.AddMachines(machines);
         }
 
+        /// <summary>
+        ///     通过Id获取设备
+        /// </summary>
+        /// <param name="id">设备Id</param>
+        /// <returns>获取的设备</returns>
         public BaseMachine GetMachineById(string id)
         {
             return base.GetMachineById<string>(id) as BaseMachine;
         }
 
+        /// <summary>
+        ///     通过通讯标志获取设备
+        /// </summary>
+        /// <param name="connectionToken">通讯标志</param>
+        /// <returns>获取的设备</returns>
         public BaseMachine GetMachineByConnectionToken(string connectionToken)
         {
             return base.GetMachineByConnectionToken<string>(connectionToken) as BaseMachine;
@@ -480,7 +673,7 @@ namespace Modbus.Net
     /// <summary>
     ///     任务调度器
     /// </summary>
-    /// <typeparam name="TMachineKey"></typeparam>
+    /// <typeparam name="TMachineKey">设备Id的类型</typeparam>
     public class TaskManager<TMachineKey> where TMachineKey : IEquatable<TMachineKey>
     {
         /// <summary>
@@ -488,6 +681,9 @@ namespace Modbus.Net
         /// </summary>
         private readonly HashSet<TaskMachine<TMachineKey>> _machines;
 
+        /// <summary>
+        ///     全局任务取消标志
+        /// </summary>
         private CancellationTokenSource _cts;
 
         /// <summary>
@@ -554,6 +750,9 @@ namespace Modbus.Net
             }
         }
 
+        /// <summary>
+        ///     设备读写设备的关键字
+        /// </summary>
         public MachineDataType MachineDataType
         {
             set
@@ -588,7 +787,13 @@ namespace Modbus.Net
             }
         }
 
+        /// <summary>
+        ///     设备读数据的关键字
+        /// </summary>
         public MachineGetDataType GetDataType { get; set; }
+        /// <summary>
+        ///     设备写数据的关键字
+        /// </summary>
         public MachineSetDataType SetDataType { get; set; }
 
         /// <summary>
@@ -615,7 +820,7 @@ namespace Modbus.Net
             machine.KeepConnect = KeepConnect;
             lock (_machines)
             {
-                _machines.Add(new TaskMachine<TMachineKey>(machine, _tasks) {TasksWithTimer = new List<ITaskItem>()});
+                _machines.Add(new TaskMachine<TMachineKey>(machine, _tasks));
             }
         }
 
@@ -635,6 +840,12 @@ namespace Modbus.Net
             }
         }
 
+        /// <summary>
+        ///     通过Id获取设备
+        /// </summary>
+        /// <typeparam name="TUnitKey">设备地址Id的类型</typeparam>
+        /// <param name="id">设备的Id</param>
+        /// <returns>获取设备</returns>
         public BaseMachine<TMachineKey, TUnitKey> GetMachineById<TUnitKey>(TMachineKey id)
             where TUnitKey : IEquatable<TUnitKey>
         {
@@ -654,6 +865,12 @@ namespace Modbus.Net
             }
         }
 
+        /// <summary>
+        ///     通过通讯标志获取设备
+        /// </summary>
+        /// <typeparam name="TUnitKey">设备地址Id的类型</typeparam>
+        /// <param name="connectionToken">通讯标志</param>
+        /// <returns>获取的数据</returns>
         public BaseMachine<TMachineKey, TUnitKey> GetMachineByConnectionToken<TUnitKey>(string connectionToken)
             where TUnitKey : IEquatable<TUnitKey>
         {
@@ -709,78 +926,117 @@ namespace Modbus.Net
             }
         }
 
+        /// <summary>
+        ///     所有设备执行定时任务
+        /// </summary>
+        /// <typeparam name="TInterType">任务返回值的类型</typeparam>
+        /// <param name="item">任务</param>
+        /// <returns>所有任务是否执行成功</returns>
         public bool InvokeTimerAll<TInterType>(TaskItem<TInterType> item)
         {
+            var ans = true;
             lock (_machines)
             {
                 foreach (var machine in _machines)
                 {
-                    machine.InvokeTimer(item);
+                    ans &= machine.InvokeTimer(item);
                 }
             }
-            return true;
+            return ans;
         }
 
+        /// <summary>
+        ///     所有设备停止执行所有任务
+        /// </summary>
+        /// <returns>所有任务是否停止成功</returns>
         public bool StopTimerAll()
         {
+            var ans = true;
             lock (_machines)
             {
                 foreach (var machine in _machines)
                 {
-                    machine.StopAllTimers();
+                    ans &= machine.StopAllTimers();
                 }
             }
-            return true;
+            return ans;
         }
 
+        /// <summary>
+        ///     所有设备停止执行某一个任务
+        /// </summary>
+        /// <param name="taskItemName">任务名称</param>
+        /// <returns>任务是否停止成功</returns>
         public bool StopTimerAll(string taskItemName)
         {
+            var ans = true;
             lock (_machines)
             {
                 foreach (var machine in _machines)
                 {
-                    machine.StopTimer(taskItemName);
+                    ans &= machine.StopTimer(taskItemName);
                 }
             }
-            return true;
+            return ans;
         }
 
+        /// <summary>
+        ///     所有设备暂停执行所有任务
+        /// </summary>
+        /// <returns>任务是否暂停成功</returns>
         public bool PauseTimerAll()
         {
+            var ans = true;
             lock (_machines)
             {
                 foreach (var machine in _machines)
                 {
-                    machine.PauseAllTimers();
+                    ans &= machine.PauseAllTimers();
                 }
             }
-            return true;
+            return ans;
         }
 
+        /// <summary>
+        ///     所有设备暂停执行某一个任务
+        /// </summary>
+        /// <param name="taskItemName">任务的名称</param>
+        /// <returns>任务是否暂停成功</returns>
         public bool PauseTimerAll(string taskItemName)
         {
+            var ans = true;
             lock (_machines)
             {
                 foreach (var machine in _machines)
                 {
-                    machine.PauseTimer(taskItemName);
+                    ans &= machine.PauseTimer(taskItemName);
                 }
             }
-            return true;
+            return ans;
         }
 
+        /// <summary>
+        ///     所有设备继续执行所有任务
+        /// </summary>
+        /// <returns>所有任务是否继续执行成功</returns>
         public bool ContinueTimerAll()
         {
+            var ans = true;
             lock (_machines)
             {
                 foreach (var machine in _machines)
                 {
-                    machine.ContinueAllTimers();
+                    ans &= machine.ContinueAllTimers();
                 }
             }
-            return true;
+            return ans;
         }
 
+        /// <summary>
+        ///     所有设备继续执行某一个任务
+        /// </summary>
+        /// <param name="taskItemName">任务的名称</param>
+        /// <returns>任务是否继续执行成功</returns>
         public bool ConinueTimerAll(string taskItemName)
         {
             lock (_machines)
@@ -793,6 +1049,12 @@ namespace Modbus.Net
             return true;
         }
 
+        /// <summary>
+        ///     所有设备执行一个一次性任务
+        /// </summary>
+        /// <typeparam name="TInterType">任务的返回值类型</typeparam>
+        /// <param name="item">任务</param>
+        /// <returns>任务是否执行成功</returns>
         public async Task<bool> InvokeOnceAll<TInterType>(TaskItem<TInterType> item)
         {
             var tasks = new List<Task<bool>>();
@@ -807,57 +1069,84 @@ namespace Modbus.Net
             return ans.All(p=>p);
         }
 
+        /// <summary>
+        ///     某个设备执行一个一次性任务
+        /// </summary>
+        /// <typeparam name="TInterType">任务的返回值类型</typeparam>
+        /// <param name="machineId">设备的Id</param>
+        /// <param name="item">任务</param>
+        /// <returns>任务是否执行成功</returns>
         public async Task<bool> InvokeOnceForMachine<TInterType>(TMachineKey machineId, TaskItem<TInterType> item)
         {
             var machine = _machines.FirstOrDefault(p => p.Machine.Id.Equals(machineId));
             if (machine != null)
             {
-                await machine.InvokeOnce(item);
+                return await machine.InvokeOnce(item);
-                return true;
             }
             return false;
         }
 
+        /// <summary>
+        ///     某个设备执行一个定时任务
+        /// </summary>
+        /// <typeparam name="TInterType">任务的返回值类型</typeparam>
+        /// <param name="machineId">设备的Id</param>
+        /// <param name="item">任务</param>
+        /// <returns>任务是否执行成功</returns>
         public bool InvokeTimerForMachine<TInterType>(TMachineKey machineId, TaskItem<TInterType> item)
         {
             var machine = _machines.FirstOrDefault(p => p.Machine.Id.Equals(machineId));
             if (machine != null)
             {
-                machine.InvokeTimer(item);
+                return machine.InvokeTimer(item);
-                return true;
             }
             return false;
         }
 
+        /// <summary>
+        ///     某个设备停止一个定时任务
+        /// </summary>
+        /// <param name="machineId">任务的Id</param>
+        /// <param name="taskItemName">任务的名称</param>
+        /// <returns>任务是否停止成功</returns>
         public bool StopTimerForMachine(TMachineKey machineId, string taskItemName)
         {
             var machine = _machines.FirstOrDefault(p => p.Machine.Id.Equals(machineId));
             if (machine != null)
             {
-                machine.StopTimer(taskItemName);
+                return machine.StopTimer(taskItemName);
-                return true;
             }
             return false;
         }
 
+        /// <summary>
+        ///     某个设备暂停一个定时任务
+        /// </summary>
+        /// <param name="machineId">任务的Id</param>
+        /// <param name="taskItemName">任务的名称</param>
+        /// <returns>任务是否暂停成功</returns>
         public bool PauseTimerForMachine(TMachineKey machineId, string taskItemName)
         {
             var machine = _machines.FirstOrDefault(p => p.Machine.Id.Equals(machineId));
             if (machine != null)
             {
-                machine.PauseTimer(taskItemName);
+                return machine.PauseTimer(taskItemName);
-                return true;
             }
             return false;
         }
 
+        /// <summary>
+        ///     某个设备继续进行一个定时任务
+        /// </summary>
+        /// <param name="machineId">任务的Id</param>
+        /// <param name="taskItemName">任务的名称</param>
+        /// <returns>任务是否继续运行成功</returns>
         public bool ContinueTimerForMachine(TMachineKey machineId, string taskItemName)
         {
             var machine = _machines.FirstOrDefault(p => p.Machine.Id.Equals(machineId));
             if (machine != null)
             {
-                machine.ContinueTimer(taskItemName);
+                return machine.ContinueTimer(taskItemName);
-                return true;
             }
             return false;
         }

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

@@ -8,6 +8,9 @@ using System.Threading.Tasks;
 
 namespace Modbus.Net
 {
+    /// <summary>
+    ///     Extensions of Reflection
+    /// </summary>
     public static class TypeExtensions
     {
         #region Public Methods
@@ -22,6 +25,9 @@ namespace Modbus.Net
         /// <param name="args">
         /// The types of the method's arguments to match.
         /// </param>
+        /// <param name="isGenericMethod">
+        /// Is method Generic Method.
+        /// </param>
         /// <returns></returns>
         /// <exception cref="ArgumentNullException">
         /// Thrown if:

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

@@ -1244,7 +1244,8 @@ namespace Modbus.Net
         ///     设置对应数字中相应位置的bit的值
         /// </summary>
         /// <param name="number">byte数子</param>
-        /// <param name="subPos">设置位置</param>
+        /// <param name="pos">设置的位置</param>
+        /// <param name="subPos">设置的子位置</param>
         /// <param name="setBit">设置bit大小，true为1，false为0</param>
         /// <returns>设置是否成功</returns>
         public override bool SetBit(byte[] number, int pos, int subPos, bool setBit)