1

src/YSAI.DAQ/YSAI.Core/data/AddressDetails.cs

@@ -10,8 +10,6 @@ using YSAI.Core.@enum;
 
 namespace YSAI.Core.data
 {
-
-
     /// <summary>
     /// 单个地址的详细信息
     /// </summary>

src/YSAI.DAQ/YSAI.Core/data/packet/OperatePacket.cs

@@ -1,4 +1,6 @@
-using System;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -15,6 +17,7 @@ namespace YSAI.Core.data.packet
         /// <summary>
         /// 操作类型
         /// </summary>
+        [JsonConverter(typeof(StringEnumConverter))]
         public OperateType OType { get; set; }
         /// <summary>
         /// 操作传入的参数

src/YSAI.DAQ/YSAI.Core/interface/only/IModbus.cs

@@ -12,7 +12,7 @@ namespace YSAI.Core.@interface.only
     /// <summary>
     /// MODBUS 接口
     /// </summary>
-    public interface IModbusClient : IOn, IOff,IRead, IDisposable
+    public interface IModbusClient : IDaq, IDisposable
     {
         /// <summary>
         /// 读取从1到2000个连续线圈状态。
@@ -142,18 +142,5 @@ namespace YSAI.Core.@interface.only
         /// <param name="Values">地址数据</param>
         /// <returns>统一出参</returns>
         Task<OperateResult> WriteMultipleCoilsAsync(ConcurrentDictionary<ushort, bool[]> Values);
-
-        /// <summary>
-        /// 异步写入
-        /// </summary>
-        /// <param name="Values">写入的数据点，与数据类型</param>
-        /// <returns>统一泛型结果</returns>
-        Task<OperateResult> WriteAsync(ConcurrentDictionary<ushort, object> Values);
-        /// <summary>
-        /// 写入
-        /// </summary>
-        /// <param name="Values">写入的数据点，与数据类型</param>
-        /// <returns>统一泛型结果</returns>
-        OperateResult Write(ConcurrentDictionary<ushort, object> Values);
     }
 }

src/YSAI.DAQ/YSAI.Core/interface/only/IMqtt.cs

@@ -12,7 +12,7 @@ namespace YSAI.Core.@interface.only
     /// <summary>
     /// MQTT客户端接口
     /// </summary>
-    public interface IMqttClient : IInit, IOn, IOff, IDisposable
+    public interface IMqttClient : IOn, IOff, IDisposable
     {
         /// <summary>
         /// 发布订阅
@@ -95,7 +95,7 @@ namespace YSAI.Core.@interface.only
     /// <summary>
     /// MQTT服务端接口
     /// </summary>
-    public interface IMqttService : IInit, IOn, IOff, IDisposable { }
+    public interface IMqttService : IOn, IOff, IDisposable { }
 
     /// <summary>
     /// MQTTwebsocket 接口

src/YSAI.DAQ/YSAI.Core/interface/only/IOpc.cs

@@ -12,7 +12,7 @@ namespace YSAI.Core.@interface.only
     /// <summary>
     /// OPCDA 客户端接口
     /// </summary>
-    public interface IOpcDaClient : IOn, IOff, IRead, IWrite, IDisposable
+    public interface IOpcDaClient : IDaq, IDisposable
     {
         /// <summary>
         /// 添加组
@@ -96,7 +96,7 @@ namespace YSAI.Core.@interface.only
     /// <summary>
     /// OPCDAHTTP 接口
     /// </summary>
-    public interface IOpcDaHttp : IRead, IDisposable
+    public interface IOpcDaHttp : IDaq, IDisposable
     {
         /// <summary>
         /// 请求
@@ -118,32 +118,30 @@ namespace YSAI.Core.@interface.only
     /// <summary>
     /// OPCUA 客户端 接口
     /// </summary>
-    public interface IOpcUaClient : IInit, IOn, IOff, IRead, IWrite, IDisposable
+    public interface IOpcUaClient : IDaq, IDisposable
     {
         /// <summary>
         /// 批量添加订阅
         /// </summary>
-        /// <param name="Param">参数</param>
-        /// <param name="Priority">分配给订阅的优先级</param>
+        /// <param name="param">参数</param>
         /// <returns>只要有一个不成功则直接返回</returns>
-        Task<OperateResult> AddSubscribeAsync(ConcurrentDictionary<string, List<AddressDetails>> param, byte Priority = 100);
+        Task<OperateResult> AddSubscribeAsync(ConcurrentDictionary<string, Address> param);
         /// <summary>
         /// 批量添加订阅
         /// </summary>
-        /// <param name="Param">参数</param>
-        /// <param name="Priority">分配给订阅的优先级</param>
+        /// <param name="param">参数</param>
         /// <returns>只要有一个不成功则直接返回</returns>
-        OperateResult AddSubscribe(ConcurrentDictionary<string, List<AddressDetails>> param, byte Priority = 100);
+        OperateResult AddSubscribe(ConcurrentDictionary<string, Address> param);
         /// <summary>
         ///  移除订阅 通过节点来移除订阅，移除指定节点的订阅，没有也返回成功
         /// </summary>
         /// <returns>统一出参</returns>
-        Task<OperateResult> RemoveSubscribeAsync(List<AddressDetails> Nodes);
+        Task<OperateResult> RemoveSubscribeAsync(Address Nodes);
         /// <summary>
         ///  移除订阅 通过节点来移除订阅，移除指定节点的订阅，没有也返回成功
         /// </summary>
         /// <returns>统一出参</returns>
-        OperateResult RemoveSubscribe(List<AddressDetails> Nodes);
+        OperateResult RemoveSubscribe(Address Nodes);
 
         /// <summary>
         /// 删除一个节点的操作，除非服务器配置允许，否则引发异常

src/YSAI.DAQ/YSAI.Core/interface/only/IS7.cs

@@ -11,5 +11,5 @@ namespace YSAI.Core.@interface.only
     /// <summary>
     /// S7接口
     /// </summary>
-    public interface IS7Client : IOn, IOff, IRead, IWrite, IDisposable { }
+    public interface IS7Client : IDaq, IDisposable { }
 }

src/YSAI.DAQ/YSAI.Core/interface/only/ISubscribe.cs

@@ -16,30 +16,28 @@ namespace YSAI.Core.@interface.only
         /// <summary>
         /// 添加自定义订阅
         /// </summary>
-        /// <param name="addressesArray">节点数据</param>
+        /// <param name="address">节点数据</param>
         /// <returns>统一出参</returns>
-        OperateResult Subscribe(List<AddressDetails> addressesArray);
+        OperateResult Subscribe(Address address);
 
         /// <summary>
         /// 添加自定义订阅
         /// </summary>
-        /// <param name="addressesArray">节点数据</param>
+        /// <param name="address">节点数据</param>
         /// <returns>统一出参</returns>
-        Task<OperateResult> SubscribeAsync(List<AddressDetails> addressesArray);
-
-
+        Task<OperateResult> SubscribeAsync(Address address);
 
         /// <summary>
         /// 取消订阅
         /// </summary>
-        /// <param name="addressesArray">节点数据</param>
+        /// <param name="address">节点数据</param>
         /// <returns>统一出参</returns>
-        OperateResult UnSubscribe(List<AddressDetails> addressesArray);
+        OperateResult UnSubscribe(Address address);
         /// <summary>
         /// 取消订阅
         /// </summary>
-        /// <param name="addressesArray">节点数据</param>
+        /// <param name="address">节点数据</param>
         /// <returns>统一出参</returns>
-        Task<OperateResult> UnSubscribeAsync(List<AddressDetails> addressesArray);
+        Task<OperateResult> UnSubscribeAsync(Address address);
     }
 }

src/YSAI.DAQ/YSAI.Core/interface/unify/IDaq.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace YSAI.Core.@interface.unify
+{
+    /// <summary>
+    /// 数采接口
+    /// </summary>
+    public interface IDaq : IOn, IOff, IRead, IWrite, IDisposable
+    {
+
+    }
+}

src/YSAI.DAQ/YSAI.Core/interface/unify/IInit.cs

@@ -1,26 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using YSAI.Core.data;
-
-namespace YSAI.Core.@interface.unify
-{
-    /// <summary>
-    /// 初始化接口
-    /// </summary>
-    public interface IInit
-    {
-        /// <summary>
-        /// 异步初始化
-        /// </summary>
-        /// <returns>统一泛型结果</returns>
-        Task<OperateResult> InitAsync();
-        /// <summary>
-        /// 初始化
-        /// </summary>
-        /// <returns>统一泛型结果</returns>
-        OperateResult Init();
-    }
-}

src/YSAI.DAQ/YSAI.Core/subscribe/SubscribeOperate.cs

@@ -253,7 +253,7 @@ namespace YSAI.Core.subscription
             ThisObjList.Remove(this);
         }
 
-        public OperateResult Subscribe(List<AddressDetails> nodes)
+        public OperateResult Subscribe(Address address)
         {
             Depart("Subscribe");
             try
@@ -262,7 +262,7 @@ namespace YSAI.Core.subscription
                 lock (basics.Address)  //锁住不让其他操作
                 {
                     //添加新节点
-                    basics.Address.AddressArray.AddRange(nodes);
+                    basics.Address.AddressArray.AddRange(address.AddressArray);
                     //去重
                     basics.Address.AddressArray = basics.Address.AddressArray.Distinct().ToList();
                 }
@@ -275,12 +275,12 @@ namespace YSAI.Core.subscription
             }
         }
 
-        public Task<OperateResult> SubscribeAsync(List<AddressDetails> nodes)
+        public Task<OperateResult> SubscribeAsync(Address address)
         {
-            return Task.Run(() => Subscribe(nodes));
+            return Task.Run(() => Subscribe(address));
         }
 
-        public OperateResult UnSubscribe(List<AddressDetails> nodes)
+        public OperateResult UnSubscribe(Address address)
         {
             //开始记录运行时间
             Depart("UnSubscribe");
@@ -291,7 +291,7 @@ namespace YSAI.Core.subscription
                 List<string> FillMessage = new List<string>();
                 lock (basics.Address)  //锁住不让其他操作
                 {
-                    foreach (var item in nodes)
+                    foreach (var item in address.AddressArray)
                     {
                         //移除不需要的节点订阅
                         if (basics.Address.AddressArray.RemoveAll(e => e.Equals(item)).Equals(0))
@@ -313,9 +313,9 @@ namespace YSAI.Core.subscription
             }
         }
 
-        public Task<OperateResult> UnSubscribeAsync(List<AddressDetails> nodes)
+        public Task<OperateResult> UnSubscribeAsync(Address address)
         {
-            return Task.Run(() => UnSubscribe(nodes));
+            return Task.Run(() => UnSubscribe(address));
         }
 
         public Task<OperateResult> OnAsync()

src/YSAI.DAQ/YSAI.Manage.Core/base/ManageBaseOperate.cs

@@ -268,33 +268,23 @@ namespace YSAI.Manage.Core.@base
                                         //获取一个实例
                                         OpcUaClientOperate opcUaClientOperate = OpcUaClientOperate.Instance(opcUaClientData);
 
-                                        //初始化
-                                        operateResult = opcUaClientOperate.Init();
-                                        if (!operateResult.State)
+                                        //打开连接
+                                        operateResult = opcUaClientOperate.On();
+                                        if (operateResult.State)
                                         {
-                                            FaliMessage.Add($"[ {manage.DType} ] [ {opcUaClientData.SN} ] {operateResult.Message}");
+                                            //事件注册(永远保持一个事件注册)
+                                            opcUaClientOperate.OnEvent -= delegate (object? sender, OpcUaClientData.Event e) { OpcUaClientOperate_OnEvent(sender, e, opcUaClientData.SN); };
+                                            opcUaClientOperate.OnEventParam -= delegate (object? sender, OpcUaClientData.EventParam e) { OpcUaClientOperate_OnEventParam(sender, e, opcUaClientData.SN); };
+
+                                            opcUaClientOperate.OnEvent += delegate (object? sender, OpcUaClientData.Event e) { OpcUaClientOperate_OnEvent(sender, e, opcUaClientData.SN); };
+                                            opcUaClientOperate.OnEventParam += delegate (object? sender, OpcUaClientData.EventParam e) { OpcUaClientOperate_OnEventParam(sender, e, opcUaClientData.SN); };
+
+                                            //把这个实例添加到集合中
+                                            OpcUaDaqObjArray.AddOrUpdate(opcUaClientData.SN, opcUaClientOperate, (k, v) => opcUaClientOperate);
                                         }
                                         else
                                         {
-                                            //打开连接
-                                            operateResult = opcUaClientOperate.On();
-                                            if (operateResult.State)
-                                            {
-                                                //事件注册(永远保持一个事件注册)
-                                                opcUaClientOperate.OnEvent -= delegate (object? sender, OpcUaClientData.Event e) { OpcUaClientOperate_OnEvent(sender, e, opcUaClientData.SN); };
-                                                opcUaClientOperate.OnEventParam -= delegate (object? sender, OpcUaClientData.EventParam e) { OpcUaClientOperate_OnEventParam(sender, e, opcUaClientData.SN); };
-
-                                                opcUaClientOperate.OnEvent += delegate (object? sender, OpcUaClientData.Event e) { OpcUaClientOperate_OnEvent(sender, e, opcUaClientData.SN); };
-                                                opcUaClientOperate.OnEventParam += delegate (object? sender, OpcUaClientData.EventParam e) { OpcUaClientOperate_OnEventParam(sender, e, opcUaClientData.SN); };
-
-                                                //把这个实例添加到集合中
-                                                OpcUaDaqObjArray.AddOrUpdate(opcUaClientData.SN, opcUaClientOperate, (k, v) => opcUaClientOperate);
-                                            }
-                                            else
-                                            {
-                                                FaliMessage.Add($"[ {manage.DType} ] [ {opcUaClientData.SN} ] {operateResult.Message}");
-                                            }
-
+                                            FaliMessage.Add($"[ {manage.DType} ] [ {opcUaClientData.SN} ] {operateResult.Message}");
                                         }
                                     }
                                 }
@@ -1057,22 +1047,22 @@ namespace YSAI.Manage.Core.@base
                             case DaqType.DB:
                                 return Break("Write", false, $"[ {DType} ] 目前不支持写入功能");
                             case DaqType.Modbus:
-                                ConcurrentDictionary<ushort, object> pairs = new ConcurrentDictionary<ushort, object>();
+                                ConcurrentDictionary<string, object> pairs = new ConcurrentDictionary<string, object>();
                                 try
                                 {
                                     switch (DaType)
                                     {
                                         case DataType.String:
-                                            pairs.TryAdd(int.Parse(AddressName).ToUshort(), Value);
+                                            pairs.TryAdd(AddressName, Value);
                                             break;
                                         case DataType.Bool:
-                                            pairs.TryAdd(int.Parse(AddressName).ToUshort(), bool.Parse(Value));
+                                            pairs.TryAdd(AddressName, bool.Parse(Value));
                                             break;
                                         case DataType.Float:
-                                            pairs.TryAdd(int.Parse(AddressName).ToUshort(), float.Parse(Value));
+                                            pairs.TryAdd(AddressName, float.Parse(Value));
                                             break;
                                         case DataType.Int:
-                                            pairs.TryAdd(int.Parse(AddressName).ToUshort(), int.Parse(Value));
+                                            pairs.TryAdd(AddressName, int.Parse(Value));
                                             break;
                                         default:
                                             return Break("Write", false, "值类型错误");

src/YSAI.DAQ/YSAI.Modbus/client/ModbusClientOperate.cs

@@ -833,12 +833,12 @@ namespace YSAI.Modbus.client
             }
         }
 
-        public Task<OperateResult> WriteAsync(ConcurrentDictionary<ushort, object> Values)
+        public Task<OperateResult> WriteAsync<V>(ConcurrentDictionary<string, V> Values)
         {
             return Task.Run(()=>Write(Values));
         }
 
-        public OperateResult Write(ConcurrentDictionary<ushort, object> Values)
+        public OperateResult Write<V>(ConcurrentDictionary<string, V> Values)
         {
             Depart("Write");
             try
@@ -847,20 +847,15 @@ namespace YSAI.Modbus.client
                 {
                     case ModbusWriteType.SingleCoil:
                         ConcurrentDictionary<ushort, bool> wsc = new ConcurrentDictionary<ushort, bool>();
-                        foreach (var item in Values) { wsc.TryAdd(item.Key, (bool)item.Value); }
+                        foreach (var item in Values) { wsc.TryAdd(item.Key.ToInt().ToUshort(), item.Value.ToBool()); }
                         return WriteSingleCoil(wsc);
                     case ModbusWriteType.SingleRegister:
                         ConcurrentDictionary<ushort, ushort> wsr = new ConcurrentDictionary<ushort, ushort>();
-                        foreach (var item in Values) { wsr.TryAdd(item.Key, (ushort)item.Value); }
+                        foreach (var item in Values) { wsr.TryAdd(item.Key.ToInt().ToUshort(), item.Value.ToInt().ToUshort()); }
                         return WriteSingleRegister(wsr);
                     case ModbusWriteType.MultipleRegisters:
-                        ConcurrentDictionary<ushort, ushort[]> wmr = new ConcurrentDictionary<ushort, ushort[]>();
-                        foreach (var item in Values) { wmr.TryAdd(item.Key, (ushort[])item.Value); }
-                        return WriteMultipleRegisters(wmr);
                     case ModbusWriteType.MultipleCoils:
-                        ConcurrentDictionary<ushort, bool[]> wmc = new ConcurrentDictionary<ushort, bool[]>();
-                        foreach (var item in Values) { wmc.TryAdd(item.Key, (bool[])item.Value); }
-                        return WriteMultipleCoils(wmc);
+                        return Break("Write", false, "不支持连续写入");
                     default:
                         return Break("Write", false, "写入类型错误");
                 }

src/YSAI.DAQ/YSAI.Mqtt/client/MqttClientData.cs

@@ -140,10 +140,6 @@ namespace YSAI.Mqtt.client
             /// </summary>
             Off,
             /// <summary>
-            /// 已初始化
-            /// </summary>
-            Init,
-            /// <summary>
             /// 啥也没干
             /// </summary>
             Null

src/YSAI.DAQ/YSAI.Mqtt/client/MqttClientOperate.cs

@@ -56,6 +56,16 @@ namespace YSAI.Mqtt.client
         public MqttClientOperate(MqttClientData.Basics param)
         {
             this.mqttClientData = param;
+
+
+            //工厂模式获取连接客户端对象
+            mqttClient = new MqttFactory().CreateMqttClient() as MQTTnet.Client.MqttClient;
+
+            //客户端支持 Connected、Disconnected 和 ApplicationMessageReceived 事件，
+            //用来处理客户端与服务端连接、客户端从服务端断开以及客户端收到消息的事情。
+
+            //消息（异步）
+            mqttClient.ApplicationMessageReceivedAsync += MqttClient_ApplicationMessageReceivedAsync;
         }
 
         #region 属性
@@ -188,37 +198,6 @@ namespace YSAI.Mqtt.client
             }
         }
 
-        public Task<OperateResult> InitAsync()
-        {
-            return Task.Run(() => Init());
-        }
-
-        public OperateResult Init()
-        {
-            //开始记录运行时间
-            Depart("Init");
-            try
-            {
-                //工厂模式获取连接客户端对象
-                mqttClient = new MqttFactory().CreateMqttClient() as MQTTnet.Client.MqttClient;
-
-                //客户端支持 Connected、Disconnected 和 ApplicationMessageReceived 事件，
-                //用来处理客户端与服务端连接、客户端从服务端断开以及客户端收到消息的事情。
-
-                //消息（异步）
-                mqttClient.ApplicationMessageReceivedAsync += MqttClient_ApplicationMessageReceivedAsync;
-
-                //设置状态
-                states = States.Init;
-
-                return Break("Init", true);
-            }
-            catch (Exception ex)
-            {
-                return Break("Init", false, ex.Message);
-            }
-        }
-
         public Task<OperateResult> OnAsync()
         {
             return Task.Run(() => On());

src/YSAI.DAQ/YSAI.Mqtt/service/MqttServiceData.cs

@@ -142,10 +142,6 @@ namespace YSAI.Mqtt.service
             /// </summary>
             Off,
             /// <summary>
-            /// 已初始化
-            /// </summary>
-            Init,
-            /// <summary>
             /// 啥也没干
             /// </summary>
             Null

src/YSAI.DAQ/YSAI.Mqtt/service/MqttServiceOperate.cs

@@ -185,15 +185,16 @@ namespace YSAI.Mqtt.service
 
         protected override string ClassName => "MqttService";
 
-        public Task<OperateResult> InitAsync()
+
+        public Task<OperateResult> OnAsync()
         {
-            return Task.Run(() => Init());
+            return Task.Run(()=> On());
         }
 
-        public OperateResult Init()
+        public OperateResult On()
         {
             //开始记录运行时间
-            Depart("Init");
+            Depart("On");
             try
             {
                 //实例化对象
@@ -222,27 +223,6 @@ namespace YSAI.Mqtt.service
                 mqttServer.StartedAsync += MqttServer_StartedAsync;
                 //停止后事件（异步）
                 mqttServer.StoppedAsync += MqttServer_StoppedAsync;
-                //设置状态
-                states = States.Init;
-                return Break("Init", true);
-            }
-            catch (Exception ex)
-            {
-                return Break("Init", false, ex.Message);
-            }
-        }
-
-        public Task<OperateResult> OnAsync()
-        {
-            return Task.Run(()=> On());
-        }
-
-        public OperateResult On()
-        {
-            //开始记录运行时间
-            Depart("On");
-            try
-            {
                 //启动服务（异步）等待执行完成
                 mqttServer.StartAsync().Wait();
                 //设置状态

src/YSAI.DAQ/YSAI.Opc/da/http/OpcDaHttpOperate.cs

@@ -328,5 +328,35 @@ namespace YSAI.Opc.da.http
                 return Break("Read", false, ex.Message);
             }
         }
+
+        public Task<OperateResult> OnAsync()
+        {
+            return Task.Run(() => On());
+        }
+
+        public OperateResult On()
+        {
+            return Break(Depart("On"),true);
+        }
+
+        public Task<OperateResult> OffAsync()
+        {
+            return Task.Run(() => Off());
+        }
+
+        public OperateResult Off()
+        {
+            return Break(Depart("Off"), true);
+        }
+
+        public Task<OperateResult> WriteAsync<V>(ConcurrentDictionary<string, V> Values)
+        {
+            return Task.Run(() => Write(Values));
+        }
+
+        public OperateResult Write<V>(ConcurrentDictionary<string, V> Values)
+        {
+            return Break(Depart("Write"), false, "不支持写入功能");
+        }
     }
 }

src/YSAI.DAQ/YSAI.Opc/ua/client/OpcUaClientData.cs

@@ -70,6 +70,10 @@ namespace YSAI.Opc.ua.client
             [Description("取样时间间隔")]
             public int SamplingInterval { get; set; }
 
+            /// <summary>
+            /// 分配给订阅的优先级
+            /// </summary>
+            public byte Priority { get; set; } = 100;
 
             /// <summary>
             /// 重写基类中的Equals方法

src/YSAI.DAQ/YSAI.Opc/ua/client/OpcUaClientOperate.cs

@@ -32,20 +32,20 @@ namespace YSAI.Opc.ua.client
         /// </summary>
         /// <param name="OpcUaData.Basics">基础数据</param>
         /// <returns></returns>
-        public static OpcUaClientOperate Instance(Basics opcUaData)
+        public static OpcUaClientOperate Instance(Basics basics)
         {
-            OpcUaClientOperate? exp = ThisObjList.FirstOrDefault(c => c.opcUaData.Equals(opcUaData));
+            OpcUaClientOperate? exp = ThisObjList.FirstOrDefault(c => c.basics.Equals(basics));
             if (exp == null)
             {
                 lock (Lock)
                 {
-                    if (ThisObjList.Count(c => c.opcUaData.Equals(opcUaData)) > 0)
+                    if (ThisObjList.Count(c => c.basics.Equals(basics)) > 0)
                     {
-                        return ThisObjList.First(c => c.opcUaData.Equals(opcUaData));
+                        return ThisObjList.First(c => c.basics.Equals(basics));
                     }
                     else
                     {
-                        OpcUaClientOperate exp2 = new OpcUaClientOperate(opcUaData);
+                        OpcUaClientOperate exp2 = new OpcUaClientOperate(basics);
                         ThisObjList.Add(exp2);
                         return exp2;
                     }
@@ -58,10 +58,10 @@ namespace YSAI.Opc.ua.client
         /// 构造函数
         /// </summary>
         /// <param name="OpcUaData.Basics">基础数据</param>
-        public OpcUaClientOperate(Basics opcUaData)
+        public OpcUaClientOperate(Basics basics)
         {
             //设置参数
-            this.opcUaData = opcUaData;
+            this.basics = basics;
         }
 
         #region 公共属性
@@ -76,7 +76,7 @@ namespace YSAI.Opc.ua.client
         /// <summary>
         /// 基础数据
         /// </summary>
-        private Basics opcUaData { get; set; }
+        private Basics basics { get; set; }
         /// <summary>
         /// OPCUA 安装、配置、运行
         /// </summary>
@@ -695,12 +695,12 @@ namespace YSAI.Opc.ua.client
         protected override string LogHead => "[ OpcUaClientOperate 操作 ]";
         protected override string ClassName => "OpcUaClientOperate";
 
-        public Task<OperateResult> AddSubscribeAsync(ConcurrentDictionary<string, List<AddressDetails>> param, byte Priority = 100)
+        public Task<OperateResult> AddSubscribeAsync(ConcurrentDictionary<string, Address> param)
         {
-            return Task.Run(()=> AddSubscribe(param,Priority));
+            return Task.Run(()=> AddSubscribe(param));
         }
 
-        public OperateResult AddSubscribe(ConcurrentDictionary<string, List<AddressDetails>> param, byte Priority = 100)
+        public OperateResult AddSubscribe(ConcurrentDictionary<string, Address> param)
         {
             //开始记录运行时间
             Depart("AddSubscribe");
@@ -721,7 +721,7 @@ namespace YSAI.Opc.ua.client
                 {
                     string Tag = p.Key;
 
-                    List<AddressDetails> Nodes = p.Value;
+                    List<AddressDetails> Nodes = p.Value.AddressArray;
 
                     try
                     {
@@ -772,7 +772,7 @@ namespace YSAI.Opc.ua.client
                                 intMonitoredItem.StartNodeId = new NodeId(item.AddressName);  //标识要监视的节点的浏览路径的开始节点
                                 intMonitoredItem.AttributeId = Attributes.Value;  //要监视的属性
                                 intMonitoredItem.DisplayName = item.AddressName;  //被监控项的显示名称
-                                intMonitoredItem.SamplingInterval = opcUaData.SamplingInterval;  //采样间隔
+                                intMonitoredItem.SamplingInterval = basics.SamplingInterval;  //采样间隔
                                 intMonitoredItem.Notification += async delegate (MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { OnMonitoredItemNotification(monitoredItem, e, item); };  //重写事件添加一个参数
 
                                 allSubscriptions[Tag].AddItem(intMonitoredItem);  //添加订阅
@@ -802,7 +802,7 @@ namespace YSAI.Opc.ua.client
                             subscription.KeepAliveCount = uint.MaxValue;  //存活数量
                             subscription.LifetimeCount = uint.MaxValue;  //生命周期
                             subscription.MaxNotificationsPerPublish = uint.MaxValue;  //每个发布请求的最大通知数
-                            subscription.Priority = Priority;  //分配给订阅的优先级
+                            subscription.Priority = basics.Priority;  //分配给订阅的优先级
                             subscription.DisplayName = Tag;  //订阅的显示名称
 
                             //循环添加
@@ -814,7 +814,7 @@ namespace YSAI.Opc.ua.client
                                 intMonitoredItem.StartNodeId = new NodeId(item.AddressName);  //标识要监视的节点的浏览路径的开始节点
                                 intMonitoredItem.AttributeId = Attributes.Value;  //要监视的属性
                                 intMonitoredItem.DisplayName = item.AddressName;  //被监控项的显示名称
-                                intMonitoredItem.SamplingInterval = opcUaData.SamplingInterval;  //采样间隔
+                                intMonitoredItem.SamplingInterval = basics.SamplingInterval;  //采样间隔
                                 intMonitoredItem.Notification += async delegate (MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e) { OnMonitoredItemNotification(monitoredItem, e, item); };  //重写事件添加一个参数
                                 subscription.AddItem(intMonitoredItem);   //添加订阅通知项
                             }
@@ -847,12 +847,12 @@ namespace YSAI.Opc.ua.client
             }
         }
 
-        public Task<OperateResult> RemoveSubscribeAsync(List<AddressDetails> Nodes)
+        public Task<OperateResult> RemoveSubscribeAsync(Address Nodes)
         {
             return Task.Run(() => RemoveSubscribe(Nodes));
         }
 
-        public OperateResult RemoveSubscribe(List<AddressDetails> Nodes)
+        public OperateResult RemoveSubscribe(Address Nodes)
         {
             //开始记录运行时间
             Depart("RemoveSubscribe");
@@ -862,7 +862,7 @@ namespace YSAI.Opc.ua.client
                 {
                     return Break("RemoveSubscribe", false, "未连接");
                 }
-                foreach (var node in Nodes)
+                foreach (var node in Nodes.AddressArray)
                 {
                     foreach (var alls in allSubscriptions)
                     {
@@ -950,72 +950,6 @@ namespace YSAI.Opc.ua.client
             }
         }
 
-        public Task<OperateResult> InitAsync()
-        {
-            return Task.Run(()=> Init());
-        }
-
-        public OperateResult Init()
-        {
-            //开始记录运行时间
-            Depart("Init");
-            try
-            {
-                //实例化对象
-                allSubscriptions = new ConcurrentDictionary<string, Subscription>();
-                //OPCUA证书验证
-                CertificateValidator certificateValidator = new CertificateValidator();
-                //当发生证书验证错误时引发
-                certificateValidator.CertificateValidation += (sender, eventArgs) =>
-                {
-                    if (ServiceResult.IsGood(eventArgs.Error)) //验证状态码是否正常
-                    {
-                        eventArgs.Accept = true;
-                    }
-                    else if (eventArgs.Error.StatusCode.Code == StatusCodes.BadCertificateUntrusted)  //验证证书状态
-                    {
-                        eventArgs.Accept = true;
-                    }
-                    else
-                    {
-                        throw new Exception(string.Format("证书验证错误：{0}，{1}", eventArgs.Error.Code, eventArgs.Error.AdditionalInfo));
-                    }
-                };
-
-
-                //用配置的当前状态更新验证器。
-                certificateValidator.Update(new SecurityConfiguration
-                {
-                    //获取或设置一个值，该值指示是否应自动接受不受信任的证书
-                    AutoAcceptUntrustedCertificates = true,
-                    //获取或设置一个值，该值指示是否接受SHA-1签名的证书
-                    RejectSHA1SignedCertificates = false,
-                    //获取或设置一个值，该值指示接受的最小证书密钥强度
-                    MinimumCertificateKeySize = 1024
-                }).Wait();
-                //实例化
-                if (AI == null)
-                {
-                    AI = new ApplicationInstance();
-                }
-                //初始化配置
-                AI.ApplicationType = ApplicationType.Client;
-                //配置文件的名称
-                AI.ConfigSectionName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Opc.Ua.Client");   
-                //加载应用程序配置
-                AC = AI.LoadApplicationConfiguration(false).Result;
-                AC.ApplicationName = opcUaData.Name;
-                AC.ApplicationType = ApplicationType.Client;
-                AC.CertificateValidator = certificateValidator;
-
-                return Break("Init", true);
-            }
-            catch (Exception ex)
-            {
-                return Break("Init", false, ex.Message);
-            }
-        }
-
         public Task<OperateResult> OnAsync()
         {
             return Task.Run(() => On());
@@ -1033,22 +967,69 @@ namespace YSAI.Opc.ua.client
                     {
                         return Break("On", false, "已连接");
                     }
+                    //实例化对象
+                    allSubscriptions = new ConcurrentDictionary<string, Subscription>();
+                    //OPCUA证书验证
+                    CertificateValidator certificateValidator = new CertificateValidator();
+                    //当发生证书验证错误时引发
+                    certificateValidator.CertificateValidation += (sender, eventArgs) =>
+                    {
+                        if (ServiceResult.IsGood(eventArgs.Error)) //验证状态码是否正常
+                        {
+                            eventArgs.Accept = true;
+                        }
+                        else if (eventArgs.Error.StatusCode.Code == StatusCodes.BadCertificateUntrusted)  //验证证书状态
+                        {
+                            eventArgs.Accept = true;
+                        }
+                        else
+                        {
+                            throw new Exception(string.Format("证书验证错误：{0}，{1}", eventArgs.Error.Code, eventArgs.Error.AdditionalInfo));
+                        }
+                    };
+
+
+                    //用配置的当前状态更新验证器。
+                    certificateValidator.Update(new SecurityConfiguration
+                    {
+                        //获取或设置一个值，该值指示是否应自动接受不受信任的证书
+                        AutoAcceptUntrustedCertificates = true,
+                        //获取或设置一个值，该值指示是否接受SHA-1签名的证书
+                        RejectSHA1SignedCertificates = false,
+                        //获取或设置一个值，该值指示接受的最小证书密钥强度
+                        MinimumCertificateKeySize = 1024
+                    }).Wait();
+                    //实例化
+                    if (AI == null)
+                    {
+                        AI = new ApplicationInstance();
+                    }
+                    //初始化配置
+                    AI.ApplicationType = ApplicationType.Client;
+                    //配置文件的名称
+                    AI.ConfigSectionName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Opc.Ua.Client");
+                    //加载应用程序配置
+                    AC = AI.LoadApplicationConfiguration(false).Result;
+                    AC.ApplicationName = basics.Name;
+                    AC.ApplicationType = ApplicationType.Client;
+                    AC.CertificateValidator = certificateValidator;
+
                     //查找与当前设置最匹配的端点
-                    EndpointDescription endpointDescription = CoreClientUtils.SelectEndpoint(opcUaData.ServerUrl, false);
+                    EndpointDescription endpointDescription = CoreClientUtils.SelectEndpoint(basics.ServerUrl, false);
                     //使用合理的默认值创建配置的实例
                     EndpointConfiguration endpointConfiguration = EndpointConfiguration.Create(AC);
                     //配置终端
                     ConfiguredEndpoint endpoint = new ConfiguredEndpoint(null, endpointDescription, endpointConfiguration);
 
                     //证书跟密钥的设置，首选证书设置，如两个都为空则是匿名访问
-                    if (!opcUaData.Cer.IsEmpty() && !opcUaData.SecreKey.IsEmpty())//设置证书
+                    if (!basics.Cer.IsEmpty() && !basics.SecreKey.IsEmpty())//设置证书
                     {
-                        X509Certificate2 certificate = new X509Certificate2(opcUaData.Cer, opcUaData.SecreKey, X509KeyStorageFlags.MachineKeySet | X509KeyStorageFlags.Exportable);
+                        X509Certificate2 certificate = new X509Certificate2(basics.Cer, basics.SecreKey, X509KeyStorageFlags.MachineKeySet | X509KeyStorageFlags.Exportable);
                         UserIdentity = new UserIdentity(certificate);
                     }
-                    else if (!opcUaData.UserName.IsEmpty() && !opcUaData.Password.IsEmpty())//设置账户密码
+                    else if (!basics.UserName.IsEmpty() && !basics.Password.IsEmpty())//设置账户密码
                     {
-                        UserIdentity = new UserIdentity(opcUaData.UserName, opcUaData.Password);
+                        UserIdentity = new UserIdentity(basics.UserName, basics.Password);
                     }
                     //通过调用CreateSession服务创建与服务器的新通信会话
                     clientSession = Session.Create(AC, endpoint, false, false, AC.ApplicationName, 60000, UserIdentity, null).Result;

src/YSAI.DAQ/YSAI.Test/TestAll.cs

@@ -350,10 +350,6 @@ namespace YSAI.Test
                     opcUaClientOperate.OnEvent += OpcUaClientOperate_OnEvent;
                     opcUaClientOperate.OnEventParam += OpcUaClientOperate_OnEventParam;
 
-
-                    operateResult = opcUaClientOperate.Init();
-                    Console.WriteLine(operateResult.Message);
-
                     operateResult = opcUaClientOperate.On();
                     Console.WriteLine(operateResult.Message);
 

src/YSAI.DAQ/YSAI.WindowMessage/WindowController.cs

@@ -24,37 +24,40 @@ namespace YSAI.WindowMessage
             OkOrYes_HorizontalAlignment = HorizontalAlignment.Center;  //默认居中
             OkOrYes_GridColumnSpan = 1;
             OkOrYes_GridColumn = 0;
-
-            Task.Run(() => ShowKeyState());
+            ShowKeyState();
         }
         /// <summary>
         /// 获取键盘按键
         /// </summary>
-        public async Task ShowKeyState()
+        public Task ShowKeyState()
         {
-            while (true)
+            return Task.Run(() =>
             {
-                
-                try
+                while (true)
                 {
-                    if (KeyBoardTool.IsKeyDown(System.Windows.Forms.Keys.Escape))  //取消
+
+                    try
                     {
-                        System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
+                        if (KeyBoardTool.IsKeyDown(System.Windows.Forms.Keys.Escape))  //取消
                         {
-                            OnCancelOrNo();
-                        }));
-                    }
-                    else if (KeyBoardTool.IsKeyDown(System.Windows.Forms.Keys.Enter)) //确认
-                    {
-                        System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
+                            System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
+                            {
+                                OnCancelOrNo();
+                            }));
+                        }
+                        else if (KeyBoardTool.IsKeyDown(System.Windows.Forms.Keys.Enter)) //确认
                         {
-                            OnOkOrYes();
-                        }));
+                            System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
+                            {
+                                OnOkOrYes();
+                            }));
+                        }
                     }
-                }catch { }
-                Thread.Sleep(100);
-            }
-        } 
+                    catch { }
+                    Thread.Sleep(100);
+                }
+            });
+        }
         /// <summary>
         /// 当前窗口
         /// </summary>