1

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

@@ -17,9 +17,9 @@ using YSAI.Unility;
 namespace YSAI.Core.data
 {
     /// <summary>
-    /// 处理
+    /// 地址统一管理
     /// </summary>
-    public class Dispose
+    public class AddressHandler
     {
         /// <summary>
         /// 反射操作
@@ -37,7 +37,7 @@ namespace YSAI.Core.data
         public static AddressValue? Execute(AddressDetails addressDetails, string value)
         {
             //日志文件名称
-            string logName = "Dispose.txt";
+            string logName = "Handler.txt";
             try
             {
                 //原始值

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

@@ -24,5 +24,15 @@ namespace YSAI.Core.data
         /// 指定数采类型的实例参数
         /// </summary>
         public object? InstanceParam { get; set; }
+
+        /// <summary>
+        /// Modbus 读取类型
+        /// </summary>
+        public ModbusReadType MRType { get; set; } = ModbusReadType.NULL;
+
+        /// <summary>
+        /// Modbus 写入类型
+        /// </summary>
+        public ModbusWriteType MWType { get; set; } = ModbusWriteType.NULL;
     }
 }

src/YSAI.DAQ/YSAI.Core/enum/Enums.cs

@@ -228,4 +228,66 @@ namespace YSAI.Core.@enum
         [Description("转发库")]
         Relay
     }
+    /// <summary>
+    /// Modbus读取类型
+    /// </summary>
+    public enum ModbusReadType
+    {
+        /// <summary>
+        /// 读取从1到2000个连续线圈状态
+        /// </summary>
+        [Description("读取从1到2000个连续线圈状态")]
+        Coils,
+        /// <summary>
+        /// 读取从1到2000个连续离散输入状态
+        /// </summary>
+        [Description("读取从1到2000个连续离散输入状态")]
+        Inputs,
+        /// <summary>
+        /// 读取保持寄存器的连续块
+        /// </summary>
+        [Description("读取保持寄存器的连续块")]
+        HoldingRegisters,
+        /// <summary>
+        /// 读取输入寄存器的连续块
+        /// </summary>
+        [Description("读取输入寄存器的连续块")]
+        InputRegisters,
+        /// <summary>
+        /// 空
+        /// </summary>
+        [Description("空")]
+        NULL
+    }
+    /// <summary>
+    /// Modbus写入类型
+    /// </summary>
+    public enum ModbusWriteType
+    {
+        /// <summary>
+        /// 写入单线圈值
+        /// </summary>
+        [Description("写入单线圈值")]
+        SingleCoil,
+        /// <summary>
+        /// 写入单个保持寄存器
+        /// </summary>
+        [Description("写入单个保持寄存器")]
+        SingleRegister,
+        /// <summary>
+        /// 将1块写入123个连续寄存器
+        /// </summary>
+        [Description("将1块写入123个连续寄存器")]
+        MultipleRegisters,
+        /// <summary>
+        /// 写入线圈序列
+        /// </summary>
+        [Description("写入线圈序列")]
+        MultipleCoils,
+        /// <summary>
+        /// 空
+        /// </summary>
+        [Description("空")]
+        NULL
+    }
 }

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

@@ -72,7 +72,7 @@ namespace YSAI.Core.@interface.only
         Task<OperateResult> InitAsync();
 
         /// <summary>
-        /// 打开
+        /// 打开采集
         /// </summary>
         /// <param name="Name">库名称</param>
         /// <param name="SN">库实例SN</param>
@@ -80,7 +80,7 @@ namespace YSAI.Core.@interface.only
         OperateResult On(DaqType? Name, string SN);
 
         /// <summary>
-        /// 打开
+        /// 打开采集
         /// </summary>
         /// <param name="Name">库名称</param>
         /// <param name="SN">库实例SN</param>
@@ -88,7 +88,7 @@ namespace YSAI.Core.@interface.only
         Task<OperateResult> OnAsync(DaqType? Name, string SN);
 
         /// <summary>
-        /// 关闭
+        /// 关闭采集
         /// </summary>
         /// <param name="Name">库名称</param>
         /// <param name="SN">库实例SN</param>
@@ -96,7 +96,7 @@ namespace YSAI.Core.@interface.only
         OperateResult Off(DaqType? Name, string SN);
 
         /// <summary>
-        /// 关闭
+        /// 关闭采集
         /// </summary>
         /// <param name="Name">库名称</param>
         /// <param name="SN">库实例SN</param>

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

@@ -92,6 +92,43 @@ namespace YSAI.Core.@interface.only
         /// <returns>统一出参</returns>
         Task<OperateResult> ReadInputRegistersAsync(Address address, int DataType = 5);
 
+        /// <summary>
+        /// 读取保持寄存器的连续块。默认返回数据类型 5
+        /// </summary>
+        /// <param name="address">
+        /// 地址数据
+        /// modbus 读取特殊，如果读取单个地址就 直接在 Address 等于具体的地址，如果需要连续读取，就设置从第几位开始，往下读多少位Address=1,10，以逗号分隔
+        /// </param>
+        /// <returns>统一出参</returns>
+        OperateResult ReadHoldingRegisters(Address address);
+        /// <summary>
+        /// 读取保持寄存器的连续块。默认返回数据类型 5
+        /// </summary>
+        /// <param name="address">
+        /// 地址数据
+        /// modbus 读取特殊，如果读取单个地址就 直接在 Address 等于具体的地址，如果需要连续读取，就设置从第几位开始，往下读多少位Address=1,10，以逗号分隔
+        /// </param>
+        /// <returns>统一出参</returns>
+        Task<OperateResult> ReadHoldingRegistersAsync(Address address);
+        /// <summary>
+        /// 读取输入寄存器的连续块。默认返回数据类型 5
+        /// </summary>
+        /// <param name="address">
+        /// 地址数据
+        /// modbus 读取特殊，如果读取单个地址就 直接在 Address 等于具体的地址，如果需要连续读取，就设置从第几位开始，往下读多少位Address=1,10，以逗号分隔
+        /// </param>
+        /// <returns>统一出参</returns>
+        OperateResult ReadInputRegisters(Address address);
+        /// <summary>
+        /// 读取输入寄存器的连续块。默认返回数据类型 5
+        /// </summary>
+        /// <param name="address">
+        /// 地址数据
+        /// modbus 读取特殊，如果读取单个地址就 直接在 Address 等于具体的地址，如果需要连续读取，就设置从第几位开始，往下读多少位Address=1,10，以逗号分隔
+        /// </param>
+        /// <returns>统一出参</returns>
+        Task<OperateResult> ReadInputRegistersAsync(Address address);
+
         /// <summary>
         /// 写入单线圈值。
         /// </summary>

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

@@ -30,7 +30,7 @@ namespace YSAI.Core.subscription
             /// Address：请求参数
             /// Task<OperateResult>：操作结果
             /// </summary>
-            public Func<Address, Task<OperateResult>>? Function { get; set; }
+            public Func<Address, OperateResult>? Function { get; set; }
             /// <summary>
             /// 数据变化抛出 false则为实时数据
             /// 只抛出变化项

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

@@ -155,7 +155,7 @@ namespace YSAI.Core.subscription
                     lock (basics.Address)  //锁住不让其他操作
                     {
                         //执行委托
-                        OperateResult values = basics.Function?.Invoke(basics.Address).Result;
+                        OperateResult values = basics.Function?.Invoke(basics.Address);
 
                         //完成后的数据复制
                         OperateResult value = values;

src/YSAI.DAQ/YSAI.DB/DBOperate.cs

@@ -444,7 +444,7 @@ namespace YSAI.DB
                 string value = VAM.Read(addressDetails);
 
                 //处理
-                AddressValue addressValue = YSAI.Core.data.Dispose.Execute(addressDetails, value);
+                AddressValue addressValue = YSAI.Core.data.AddressHandler.Execute(addressDetails, value);
 
                 //添加进字典 
                 retData.AddOrUpdate(addressDetails.AddressName, addressValue, (k, v) => addressValue);
@@ -466,7 +466,7 @@ namespace YSAI.DB
                         string value = Convert.ToString(item[column]);
 
                         //处理
-                        AddressValue addressValue = YSAI.Core.data.Dispose.Execute(addressDetails, value);
+                        AddressValue addressValue = YSAI.Core.data.AddressHandler.Execute(addressDetails, value);
 
                         //添加进字典   哪个表的哪个字段    值
                         retData.AddOrUpdate(column, addressValue, (k, v) => addressValue);

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

@@ -1,18 +1,23 @@
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
+using OpcDaComRcw.Dx;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Data.Entity.Core.Metadata.Edm;
 using System.Reflection.Emit;
+using System.Xml.Linq;
 using YSAI.Core.data;
 using YSAI.Core.@enum;
 using YSAI.Core.@interface.only;
 using YSAI.Core.@interface.unify;
+using YSAI.Core.subscription;
 using YSAI.DB;
 using YSAI.Modbus.client;
 using YSAI.Opc.da.client;
 using YSAI.Opc.da.http;
 using YSAI.Opc.ua.client;
 using YSAI.S7.client;
+using YSAI.Unility;
 
 namespace YSAI.Manage.Core.@base
 {
@@ -56,6 +61,34 @@ namespace YSAI.Manage.Core.@base
         private ConcurrentDictionary<string, S7ClientOperate> S7DaqObjArray = new ConcurrentDictionary<string, S7ClientOperate>();
 
 
+        /// <summary>
+        /// 休眠时间（毫秒）
+        /// </summary>
+        int SleepTime { get; set; } = 100;
+        /// <summary>
+        /// 执行方法的委托，读取方法，每个通信设备都应该存在
+        /// Address：请求参数
+        /// Task<OperateResult>：操作结果
+        /// </summary>
+        Func<Address, OperateResult>? Function { get; set; }
+        /// <summary>
+        /// 数据变化抛出 false则为实时数据
+        /// 只抛出变化项
+        /// 数据库查询，此项无效
+        /// </summary>
+        bool DataChangeOut { get; set; } = true;
+        /// <summary>
+        /// 当节点数据变化，有一项数据未变化，也把这未变项与变化项一同抛出，在特殊用途中，确保此批点位数据都存在
+        /// 当 DataChangeOut 为 true 此项生效
+        /// 数据库查询，此项无效
+        /// </summary>
+        bool SameDataOut { get; set; } = false;
+
+        /// <summary>
+        /// 自定义订阅操作对象集合
+        /// </summary>
+        private ConcurrentDictionary<string, SubscribeOperate> SubscribeObjArray = new ConcurrentDictionary<string, SubscribeOperate>();
+
         /// <summary>
         /// 单例模式
         /// </summary>
@@ -95,10 +128,21 @@ namespace YSAI.Manage.Core.@base
         /// </summary>
         private ManageBaseData.Basics basics { get; set; }
 
+        /// <summary>
+        /// 操作结果
+        /// </summary>
+        private OperateResult operateResult { get; set; }
+
 
-        public OperateResult Init()
+
+        #region 私有函数
+        /// <summary>
+        /// 初始化管理
+        /// </summary>
+        /// <returns></returns>
+        private List<string> InHandler()
         {
-            Depart("Init");
+            List<string> FaliMessage = new List<string>();
             try
             {
                 foreach (AddressManage manage in basics.AManages)
@@ -110,37 +154,377 @@ namespace YSAI.Manage.Core.@base
                             DBData.Basics? dBData = manage.InstanceParam as DBData.Basics;
                             if (dBData != null)
                             {
-                                //获取一个实例
-                                DBOperate dBOperate = DBOperate.Instance(dBData);
-                                //把这个实例添加到集合中
-                                DBDaqObjArray.AddOrUpdate(dBData.SN, dBOperate, (k, v) => dBOperate);
+                                if (DBDaqObjArray.ContainsKey(dBData.SN))
+                                {
+                                    FaliMessage.Add($"[ {manage.DType.ToString()} ] [ {dBData.SN} ] 已存在实例对象");
+                                }
+                                else
+                                {
+                                    //获取一个实例
+                                    DBOperate dBOperate = DBOperate.Instance(dBData);
+
+                                    //创建一个自定义订阅
+                                    SubscribeOperate subscribeOperate = SubscribeOperate.Instance(new SubscribeData.Basics()
+                                    {
+                                        Address = manage,
+                                        SN = dBData.SN,
+                                        DataChangeOut = DataChangeOut,
+                                        SameDataOut = SameDataOut,
+                                        SleepTime = SleepTime,
+                                        Function = dBOperate.Read
+                                    });
+                                    //事件注册(永远保持一个事件注册)
+                                    subscribeOperate.OnEvent -= delegate (object? sender, SubscribeData.EventParam e) { SubscribeOperate_OnEvent(sender, e, manage.DType, dBData.SN); };
+                                    subscribeOperate.OnEvent += delegate (object? sender, SubscribeData.EventParam e) { SubscribeOperate_OnEvent(sender, e, manage.DType, dBData.SN); };
+
+                                    //把订阅添加到集合
+                                    SubscribeObjArray.AddOrUpdate(dBData.SN, subscribeOperate, (k, v) => subscribeOperate);
+
+                                    //把这个实例添加到集合中
+                                    DBDaqObjArray.AddOrUpdate(dBData.SN, dBOperate, (k, v) => dBOperate);
+                                }
                             }
                             else
                             {
-                                return Break("Init",false,"数据库采集实例参数为空");   
+                                FaliMessage.Add($"[ {manage.DType.ToString()} ] 采集实例参数为空");
                             }
 
                             break;
                         case DaqType.Modbus:
 
+                            ModbusClientData.Basics modbusClientData = manage.InstanceParam as ModbusClientData.Basics;
+                            if (modbusClientData != null)
+                            {
+                                if (ModbusDaqObjArray.ContainsKey(modbusClientData.SN))
+                                {
+                                    FaliMessage.Add($"[ {manage.DType.ToString()} ] [ {modbusClientData.SN} ] 已存在实例对象");
+                                }
+                                else
+                                {
+                                    //获取一个实例
+                                    ModbusClientOperate modbusClientOperate = ModbusClientOperate.Instance(modbusClientData);
+
+                                    //打开连接
+                                    operateResult = modbusClientOperate.On();
+                                    if (operateResult.State)
+                                    {
+                                        Func<Address, OperateResult>? Function = null;
+                                        switch (manage.MRType)
+                                        {
+                                            case ModbusReadType.Coils:
+                                                Function = modbusClientOperate.ReadCoils;
+                                                break;
+                                            case ModbusReadType.Inputs:
+                                                Function = modbusClientOperate.ReadInputs;
+                                                break;
+                                            case ModbusReadType.HoldingRegisters:
+                                                Function = modbusClientOperate.ReadHoldingRegisters;
+                                                break;
+                                            case ModbusReadType.InputRegisters:
+                                                Function = modbusClientOperate.ReadInputRegisters;
+                                                break;
+                                        }
+                                        //创建一个自定义订阅
+                                        SubscribeOperate subscribeOperate = SubscribeOperate.Instance(new SubscribeData.Basics()
+                                        {
+                                            Address = manage,
+                                            SN = modbusClientData.SN,
+                                            DataChangeOut = DataChangeOut,
+                                            SameDataOut = SameDataOut,
+                                            SleepTime = SleepTime,
+                                            Function = Function
+                                        });
+
+                                        //事件注册(永远保持一个事件注册)
+                                        subscribeOperate.OnEvent -= delegate (object? sender, SubscribeData.EventParam e) { SubscribeOperate_OnEvent(sender, e, manage.DType, modbusClientData.SN); };
+                                        subscribeOperate.OnEvent += delegate (object? sender, SubscribeData.EventParam e) { SubscribeOperate_OnEvent(sender, e, manage.DType, modbusClientData.SN); };
+
+                                        //把订阅添加到集合
+                                        SubscribeObjArray.AddOrUpdate(modbusClientData.SN, subscribeOperate, (k, v) => subscribeOperate);
+
+                                        //把这个实例添加到集合中
+                                        ModbusDaqObjArray.AddOrUpdate(modbusClientData.SN, modbusClientOperate, (k, v) => modbusClientOperate);
+                                    }
+                                    else
+                                    {
+                                        FaliMessage.Add($"[ {manage.DType.ToString()} ] [ {modbusClientData.SN} ] {operateResult.Message}");
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                FaliMessage.Add($"[ {manage.DType.ToString()} ] 采集实例参数为空");
+                            }
 
                             break;
                         case DaqType.OpcUa:
+
+                            OpcUaClientData.Basics opcUaClientData = manage.InstanceParam as OpcUaClientData.Basics;
+                            if (opcUaClientData != null)
+                            {
+                                if (OpcUaDaqObjArray.ContainsKey(opcUaClientData.SN))
+                                {
+                                    FaliMessage.Add($"[ {manage.DType.ToString()} ] [ {opcUaClientData.SN} ] 已存在实例对象");
+                                }
+                                else
+                                {
+                                    //获取一个实例
+                                    OpcUaClientOperate opcUaClientOperate = OpcUaClientOperate.Instance(opcUaClientData);
+
+                                    //初始化
+                                    operateResult = opcUaClientOperate.Init();
+                                    if (!operateResult.State)
+                                    {
+                                        FaliMessage.Add($"[ {manage.DType.ToString()} ] [ {opcUaClientData.SN} ] {operateResult.Message}");
+                                    }
+                                    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.ToString()} ] [ {opcUaClientData.SN} ] {operateResult.Message}");
+                                        }
+
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                FaliMessage.Add($"[ {manage.DType.ToString()} ] 采集实例参数为空");
+                            }
+
                             break;
                         case DaqType.OpcDa:
+
+                            OpcDaClientData.Basics opcDaClientData = manage.InstanceParam as OpcDaClientData.Basics;
+                            if (opcDaClientData != null)
+                            {
+                                if (OpcDaDaqObjArray.ContainsKey(opcDaClientData.SN))
+                                {
+                                    FaliMessage.Add($"[ {manage.DType.ToString()} ] [ {opcDaClientData.SN} ] 已存在实例对象");
+                                }
+                                else
+                                {
+                                    //获取一个实例
+                                    OpcDaClientOperate opcDaClientOperate = OpcDaClientOperate.Instance(opcDaClientData);
+
+                                    //打开连接
+                                    operateResult = opcDaClientOperate.On();
+                                    if (operateResult.State)
+                                    {
+
+                                        //事件注册(永远保持一个事件注册)
+                                        opcDaClientOperate.OnEvent -= delegate (object? sender, OpcDaClientData.EventParam e) { OpcDaClientOperate_OnEvent(sender, e, opcDaClientData.SN); };
+                                        opcDaClientOperate.OnEvent += delegate (object? sender, OpcDaClientData.EventParam e) { OpcDaClientOperate_OnEvent(sender, e, opcDaClientData.SN); };
+
+
+                                        ConcurrentDictionary<string, List<AddressDetails>> sub = new ConcurrentDictionary<string, List<AddressDetails>>();
+                                        sub.TryAdd(opcDaClientData.SN, manage.AddressArray);
+                                        operateResult = opcDaClientOperate.AddNode(manage, opcDaClientData.SN, true);
+                                        if (!operateResult.State)
+                                        {
+                                            FaliMessage.Add($"[ {manage.DType.ToString()} ] [ {opcDaClientData.SN} ] {operateResult.Message}");
+                                        }
+                                        else
+                                        {
+                                            //把这个实例添加到集合中
+                                            OpcDaDaqObjArray.AddOrUpdate(opcDaClientData.SN, opcDaClientOperate, (k, v) => opcDaClientOperate);
+                                        }
+                                    }
+                                    else
+                                    {
+                                        FaliMessage.Add($"[ {manage.DType.ToString()} ] [ {opcDaClientData.SN} ] {operateResult.Message}");
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                FaliMessage.Add($"[ {manage.DType.ToString()} ] 采集实例参数为空");
+                            }
+
                             break;
                         case DaqType.OpcDaHttp:
+
+                            OpcDaHttpData.Basics opcDaHttpData = manage.InstanceParam as OpcDaHttpData.Basics;
+                            if (opcDaHttpData != null)
+                            {
+                                if (OpcDaHttpDaqObjArray.ContainsKey(opcDaHttpData.SN))
+                                {
+                                    FaliMessage.Add($"[ {manage.DType.ToString()} ] [ {opcDaHttpData.SN} ] 已存在实例对象");
+                                }
+                                else
+                                {
+                                    //获取一个实例
+                                    OpcDaHttpOperate opcDaHttpOperate = OpcDaHttpOperate.Instance(opcDaHttpData);
+
+                                    //创建一个自定义订阅
+                                    SubscribeOperate subscribeOperate = SubscribeOperate.Instance(new SubscribeData.Basics()
+                                    {
+                                        Address = manage,
+                                        SN = opcDaHttpData.SN,
+                                        DataChangeOut = DataChangeOut,
+                                        SameDataOut = SameDataOut,
+                                        SleepTime = SleepTime,
+                                        Function = opcDaHttpOperate.Read
+                                    });
+                                    //事件注册(永远保持一个事件注册)
+                                    subscribeOperate.OnEvent -= delegate (object? sender, SubscribeData.EventParam e) { SubscribeOperate_OnEvent(sender, e, manage.DType, opcDaHttpData.SN); };
+                                    subscribeOperate.OnEvent += delegate (object? sender, SubscribeData.EventParam e) { SubscribeOperate_OnEvent(sender, e, manage.DType, opcDaHttpData.SN); };
+
+                                    //把订阅添加到集合
+                                    SubscribeObjArray.AddOrUpdate(opcDaHttpData.SN, subscribeOperate, (k, v) => subscribeOperate);
+
+                                    //把这个实例添加到集合中
+                                    OpcDaHttpDaqObjArray.AddOrUpdate(opcDaHttpData.SN, opcDaHttpOperate, (k, v) => opcDaHttpOperate);
+                                }
+                            }
+                            else
+                            {
+                                FaliMessage.Add($"[ {manage.DType.ToString()} ] 采集实例参数为空");
+                            }
+
                             break;
                         case DaqType.S7:
+
+                            S7ClientData.Basics s7ClientData = manage.InstanceParam as S7ClientData.Basics;
+                            if (s7ClientData != null)
+                            {
+                                if (S7DaqObjArray.ContainsKey(s7ClientData.SN))
+                                {
+                                    FaliMessage.Add($"[ {manage.DType.ToString()} ] [ {s7ClientData.SN} ] 已存在实例对象");
+                                }
+                                else
+                                {
+                                    //获取一个实例
+                                    S7ClientOperate s7ClientOperate = S7ClientOperate.Instance(s7ClientData);
+
+                                    //打开连接
+                                    operateResult = s7ClientOperate.On();
+                                    if (operateResult.State)
+                                    {
+                                        //创建一个自定义订阅
+                                        SubscribeOperate subscribeOperate = SubscribeOperate.Instance(new SubscribeData.Basics()
+                                        {
+                                            Address = manage,
+                                            SN = s7ClientData.SN,
+                                            DataChangeOut = DataChangeOut,
+                                            SameDataOut = SameDataOut,
+                                            SleepTime = SleepTime,
+                                            Function = s7ClientOperate.Read
+                                        });
+                                        //事件注册(永远保持一个事件注册)
+                                        subscribeOperate.OnEvent -= delegate (object? sender, SubscribeData.EventParam e) { SubscribeOperate_OnEvent(sender, e, manage.DType, s7ClientData.SN); };
+                                        subscribeOperate.OnEvent += delegate (object? sender, SubscribeData.EventParam e) { SubscribeOperate_OnEvent(sender, e, manage.DType, s7ClientData.SN); };
+
+                                        //把订阅添加到集合
+                                        SubscribeObjArray.AddOrUpdate(s7ClientData.SN, subscribeOperate, (k, v) => subscribeOperate);
+
+                                        //把这个实例添加到集合中
+                                        S7DaqObjArray.AddOrUpdate(s7ClientData.SN, s7ClientOperate, (k, v) => s7ClientOperate);
+                                    }
+                                    else
+                                    {
+                                        FaliMessage.Add($"[ {manage.DType.ToString()} ] [ {s7ClientData.SN} ] {operateResult.Message}");
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                FaliMessage.Add($"[ {manage.DType.ToString()} ] 采集实例参数为空");
+                            }
+
                             break;
                     }
                 }
             }
             catch (Exception ex)
+            {
+                FaliMessage.Add("初始化异常：" + ex.Message);
+            }
+            return FaliMessage;
+        }
+
+        #endregion
+        #region 事件管理
+        /// <summary>
+        /// OPCUA客户端的全局事件
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e">参数</param>
+        /// <param name="SN">哪个SN的实例对象抛出来的数据</param>
+        /// <exception cref="NotImplementedException"></exception>
+        private void OpcUaClientOperate_OnEvent(object? sender, OpcUaClientData.Event e, string SN)
+        {
+            throw new NotImplementedException();
+        }
+        /// <summary>
+        /// OPCUA客户端的订阅事件
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e">参数</param>
+        /// <param name="SN">哪个SN的实例对象抛出来的数据</param>
+        /// <exception cref="NotImplementedException"></exception>
+        private void OpcUaClientOperate_OnEventParam(object? sender, OpcUaClientData.EventParam e, string SN)
+        {
+            throw new NotImplementedException();
+        }
+        /// <summary>
+        /// OPCDA客户端的订阅事件
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        /// <param name="SN">哪个SN的实例对象抛出来的数据</param>
+        /// <exception cref="NotImplementedException"></exception>
+        private void OpcDaClientOperate_OnEvent(object? sender, OpcDaClientData.EventParam e, string SN)
+        {
+            throw new NotImplementedException();
+        }
+        /// <summary>
+        /// 自定义订阅的事件
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e">参数</param>
+        /// <param name="DType">数采类型</param>
+        /// <param name="SN">哪个SN的实例对象抛出来的数据</param>
+        /// <exception cref="NotImplementedException"></exception>
+        private void SubscribeOperate_OnEvent(object? sender, SubscribeData.EventParam e,DaqType? DType, string SN)
+        {
+            throw new NotImplementedException();
+        }
+        #endregion
+
+        public OperateResult Init()
+        {
+            Depart("Init");
+            try
+            {
+                List<string> strings = InHandler();
+                if (strings.Count > 0)
+                {
+                    return Break("Init", false, "存在一个或多个初始化错误", RData: strings.ToJson(), RType: ResultType.Json);
+                }
+                else
+                {
+                    return Break("Init", true);
+                }
+            }
+            catch (Exception ex)
             {
                 return Break("Init", false, ex.Message);
             }
-            return Break("xx", false);
         }
 
         public Task<OperateResult> InitAsync()
@@ -153,13 +537,150 @@ namespace YSAI.Manage.Core.@base
             Depart("On");
             try
             {
+                AddressManage? addressManage = basics.AManages.FirstOrDefault(c => c.DType.Equals(Name) && c.SN.Equals(SN));
+
+                if (addressManage == null)
+                {
+                    return Break("On", false, $"[ {Name.ToString()} ] 地址管理数据为空");
+                }
 
+                switch (Name)
+                {
+                    case DaqType.DB:
+                        //判断是否有此实例
+                        if (DBDaqObjArray.ContainsKey(SN))
+                        {
+                            //判断是否有此自定义订阅
+                            if (SubscribeObjArray.ContainsKey(SN))
+                            {
+                               operateResult = SubscribeObjArray[SN].On();
+                                if (!operateResult.State)
+                                {
+                                    return Break("On", false, $"[ {Name.ToString} ] [ {SN} ] {operateResult.Message}");
+                                }
+                            }
+                            else
+                            {
+                                return Break("On", false, $"[ {Name.ToString} ] [ {SN} ] 订阅不存在");
+                            }
+                        }
+                        else
+                        {
+                            return Break("On", false, $"[ {Name.ToString} ] [ {SN} ] 实例不存在");
+                        }
+                        break;
+                    case DaqType.Modbus:
+
+                        //判断是否有此实例
+                        if (DBDaqObjArray.ContainsKey(SN))
+                        {
+                            //判断是否有此自定义订阅
+                            if (SubscribeObjArray.ContainsKey(SN))
+                            {
+                                operateResult = SubscribeObjArray[SN].On();
+                                if (!operateResult.State)
+                                {
+                                    return Break("On", false, $"[ {Name.ToString} ] [ {SN} ] {operateResult.Message}");
+                                }
+                            }
+                            else
+                            {
+                                return Break("On", false, $"[ {Name.ToString} ] [ {SN} ] 订阅不存在");
+                            }
+                        }
+                        else
+                        {
+                            return Break("On", false, $"[ {Name.ToString} ] [ {SN} ] 实例不存在");
+                        }
+
+                        break;
+                    case DaqType.OpcUa:
+                        //判断是否有此实例
+                        if (OpcUaDaqObjArray.ContainsKey(SN))
+                        {
+                            //OPCUA 自带订阅功能
+                            ConcurrentDictionary<string, List<AddressDetails>> sub = new ConcurrentDictionary<string, List<AddressDetails>>();
+                            sub.TryAdd(addressManage.SN, addressManage.AddressArray);
+                            operateResult = OpcUaDaqObjArray[SN].AddSubscribe(sub);
+                            if (!operateResult.State)
+                            {
+                                return Break("On", operateResult.State, operateResult.Message);
+                            }
+                        }
+                        else
+                        {
+                            return Break("On", false, $"[ {Name.ToString} ] [ {SN} ] 实例不存在");
+                        }
+                        break;
+                    case DaqType.OpcDa:
+                        //判断是否有此实例
+                        if (OpcDaDaqObjArray.ContainsKey(SN))
+                        {
+                            operateResult = OpcDaDaqObjArray[SN].UpdateGroupSubscribedState(SN, true);
+                            if (!operateResult.State)
+                            {
+                                return Break("On", false, $"[ {Name.ToString} ] [ {SN} ] {operateResult.Message}");
+                            }
+                        }
+                        else
+                        {
+                            return Break("On", false, $"[ {Name.ToString} ] [ {SN} ] 实例不存在");
+                        }
+                        break;
+                    case DaqType.OpcDaHttp:
+                        //判断是否有此实例
+                        if (DBDaqObjArray.ContainsKey(SN))
+                        {
+                            //判断是否有此自定义订阅
+                            if (SubscribeObjArray.ContainsKey(SN))
+                            {
+                                operateResult = SubscribeObjArray[SN].On();
+                                if (!operateResult.State)
+                                {
+                                    return Break("On", false, $"[ {Name.ToString} ] [ {SN} ] {operateResult.Message}");
+                                }
+                            }
+                            else
+                            {
+                                return Break("On", false, $"[ {Name.ToString} ] [ {SN} ] 订阅不存在");
+                            }
+                        }
+                        else
+                        {
+                            return Break("On", false, $"[ {Name.ToString} ] [ {SN} ] 实例不存在");
+                        }
+                        break;
+                    case DaqType.S7:
+                        //判断是否有此实例
+                        if (DBDaqObjArray.ContainsKey(SN))
+                        {
+                            //判断是否有此自定义订阅
+                            if (SubscribeObjArray.ContainsKey(SN))
+                            {
+                                operateResult = SubscribeObjArray[SN].On();
+                                if (!operateResult.State)
+                                {
+                                    return Break("On", false, $"[ {Name.ToString} ] [ {SN} ] {operateResult.Message}");
+                                }
+                            }
+                            else
+                            {
+                                return Break("On", false, $"[ {Name.ToString} ] [ {SN} ] 订阅不存在");
+                            }
+                        }
+                        else
+                        {
+                            return Break("On", false, $"[ {Name.ToString} ] [ {SN} ] 实例不存在");
+                        }
+                        break;
+                }
+
+                return Break("On", true);
             }
             catch (Exception ex)
             {
                 return Break("On", false, ex.Message);
             }
-            return Break("xx", false);
         }
 
         public Task<OperateResult> OnAsync(DaqType? Name, string SN)
@@ -172,13 +693,69 @@ namespace YSAI.Manage.Core.@base
             Depart("Off");
             try
             {
-
+                switch (Name)
+                {
+                    case DaqType.DB:
+
+                        operateResult = SubscribeObjArray[SN].Off();
+                        if (!operateResult.State)
+                        {
+                            return Break("Off", false, operateResult.Message);
+                        }
+
+                        break;
+                    case DaqType.Modbus:
+
+                        operateResult = SubscribeObjArray[SN].Off();
+                        if (!operateResult.State)
+                        {
+                            return Break("Off", false, operateResult.Message);
+                        }
+
+                        break;
+                    case DaqType.OpcUa:
+
+                        operateResult = OpcUaDaqObjArray[SN].RemoveSubscribe(basics.AManages.FirstOrDefault(c => c.DType.Equals(Name) && c.SN.Equals(SN)).AddressArray);
+                        if (!operateResult.State)
+                        {
+                            return Break("Off", false, operateResult.Message);
+                        }
+
+                        break;
+                    case DaqType.OpcDa:
+
+                        operateResult = OpcDaDaqObjArray[SN].UpdateGroupSubscribedState(SN, false);
+                        if (!operateResult.State)
+                        {
+                            return Break("Off", false, operateResult.Message);
+                        }
+
+                        break;
+                    case DaqType.OpcDaHttp:
+
+                        operateResult = SubscribeObjArray[SN].Off();
+                        if (!operateResult.State)
+                        {
+                            return Break("Off", false, operateResult.Message);
+                        }
+
+                        break;
+                    case DaqType.S7:
+
+                        operateResult = SubscribeObjArray[SN].Off();
+                        if (!operateResult.State)
+                        {
+                            return Break("Off", false, operateResult.Message);
+                        }
+
+                        break;
+                }
+                return Break("Off", true);
             }
             catch (Exception ex)
             {
                 return Break("Off", false, ex.Message);
             }
-            return Break("xx", false);
         }
 
         public Task<OperateResult> OffAsync(DaqType? Name, string SN)
@@ -191,13 +768,94 @@ namespace YSAI.Manage.Core.@base
             Depart("Read");
             try
             {
+                AddressManage? addressManage = basics.AManages.FirstOrDefault(c => c.DType.Equals(Name) && c.SN.Equals(SN));
+                if (addressManage == null)
+                {
+                    return Break("Read", false, $"[ {Name.ToString()} ] 地址管理数据为空");
+                }
+                AddressDetails? details = addressManage.AddressArray.FirstOrDefault(c => c.AddressName.Equals(AddressName));
+                if (details == null)
+                {
+                    return Break("Read", false, $"[ {Name.ToString()} ] 未查询到（{AddressName}）地址配置数据");
+                }
 
+                switch (Name)
+                {
+                    case DaqType.DB:
+                        operateResult = DBDaqObjArray[SN].Read(addressManage);
+                        if (operateResult.State)
+                        {
+                            return Break("Read", true, RData: operateResult.RData, RType: operateResult.RType);
+                        }
+                        break;
+                    case DaqType.Modbus:
+                        switch (addressManage.MRType)
+                        {
+                            case ModbusReadType.Coils:
+                                operateResult = ModbusDaqObjArray[SN].ReadCoils(addressManage);
+                                if (operateResult.State)
+                                {
+                                    return Break("Read", true, RData: operateResult.RData, RType: operateResult.RType);
+                                }
+                                break;
+                            case ModbusReadType.Inputs:
+                                operateResult = ModbusDaqObjArray[SN].ReadInputs(addressManage);
+                                if (operateResult.State)
+                                {
+                                    return Break("Read", true, RData: operateResult.RData, RType: operateResult.RType);
+                                }
+                                break;
+                            case ModbusReadType.HoldingRegisters:
+                                operateResult = ModbusDaqObjArray[SN].ReadHoldingRegisters(addressManage);
+                                if (operateResult.State)
+                                {
+                                    return Break("Read", true, RData: operateResult.RData, RType: operateResult.RType);
+                                }
+                                break;
+                            case ModbusReadType.InputRegisters:
+                                operateResult = ModbusDaqObjArray[SN].ReadInputRegisters(addressManage);
+                                if (operateResult.State)
+                                {
+                                    return Break("Read", true, RData: operateResult.RData, RType: operateResult.RType);
+                                }
+                                break;
+                        }
+                        break;
+                    case DaqType.OpcUa:
+                        operateResult = OpcUaDaqObjArray[SN].Read(addressManage);
+                        if (operateResult.State)
+                        {
+                            return Break("Read", true, RData: operateResult.RData, RType: operateResult.RType);
+                        }
+                        break;
+                    case DaqType.OpcDa:
+                        operateResult = OpcDaDaqObjArray[SN].Read(addressManage);
+                        if (operateResult.State)
+                        {
+                            return Break("Read", true, RData: operateResult.RData, RType: operateResult.RType);
+                        }
+                        break;
+                    case DaqType.OpcDaHttp:
+                        operateResult = OpcDaHttpDaqObjArray[SN].Read(addressManage);
+                        if (operateResult.State)
+                        {
+                            return Break("Read", true, RData: operateResult.RData, RType: operateResult.RType);
+                        }
+                        break;
+                    case DaqType.S7:
+                        operateResult = S7DaqObjArray[SN].Read(addressManage);
+                        if (operateResult.State)
+                        {
+                            return Break("Read", true, RData: operateResult.RData, RType: operateResult.RType);
+                        }
+                        break;
+                }
+                return Break("Read", false, $"[ {Name.ToString()} ] [ {AddressName} ] {operateResult.Message}");
             }
             catch (Exception ex)
             {
                 return Break("Read", false, ex.Message);
             }
-            return Break("xx", false);
         }
 
         public Task<OperateResult> ReadAsync(DaqType? Name, string SN, string AddressName)
@@ -210,13 +868,39 @@ namespace YSAI.Manage.Core.@base
             Depart("Write");
             try
             {
+                AddressManage? addressManage = basics.AManages.FirstOrDefault(c => c.DType.Equals(Name) && c.SN.Equals(SN));
+                if (addressManage == null)
+                {
+                    return Break("Write", false, $"[ {Name.ToString()} ] 地址管理数据为空");
+                }
+                AddressDetails? details = addressManage.AddressArray.FirstOrDefault(c => c.AddressName.Equals(AddressName));
+                if (details == null)
+                {
+                    return Break("Write", false, $"[ {Name.ToString()} ] 未查询到（{AddressName}）地址配置数据");
+                }
 
+                switch (Name)
+                {
+                    case DaqType.DB:
+                        return Break("Write",false,$"[ {Name.ToString()} ] 目前不支持写入功能");
+                    case DaqType.Modbus:
+
+                        break;
+                    case DaqType.OpcUa:
+                        break;
+                    case DaqType.OpcDa:
+                        break;
+                    case DaqType.OpcDaHttp:
+                        break;
+                    case DaqType.S7:
+                        break;
+                }
+                return Break("Write", true);
             }
             catch (Exception ex)
             {
                 return Break("Write", false, ex.Message);
             }
-            return Break("xx", false);
         }
 
         public Task<OperateResult> WriteAsync(DaqType? Name, string SN, string AddressName, string Value, DataType DType)
@@ -240,6 +924,8 @@ namespace YSAI.Manage.Core.@base
 
             foreach (var item in S7DaqObjArray) { item.Value.Dispose(); }
 
+            foreach (var item in SubscribeObjArray) { item.Value.Dispose(); }
+            
             GC.Collect();
             GC.SuppressFinalize(this);
             ThisObjList.Remove(this);

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

@@ -180,8 +180,6 @@ namespace YSAI.Modbus.client
         }
         #endregion
 
-
-
         protected override string LogHead => "[ ModbusClientOperate 操作 ]";
         protected override string ClassName => "ModbusClientOperate";
 
@@ -368,7 +366,7 @@ namespace YSAI.Modbus.client
                     }
 
                     //数据处理
-                    AddressValue addressValue = Core.data.Dispose.Execute(add, value);
+                    AddressValue addressValue = Core.data.AddressHandler.Execute(add, value);
 
                     //数据添加
                     param.AddOrUpdate(add.AddressName, addressValue, (k, v) => addressValue);
@@ -425,7 +423,7 @@ namespace YSAI.Modbus.client
                         value = retvalue[0].ToString();
                     }
                     //数据处理
-                    AddressValue addressValue = Core.data.Dispose.Execute(add, value);
+                    AddressValue addressValue = Core.data.AddressHandler.Execute(add, value);
 
                     //数据添加
                     param.AddOrUpdate(add.AddressName, addressValue, (k, v) => addressValue);
@@ -482,7 +480,7 @@ namespace YSAI.Modbus.client
                         value = DataConvert(retvalue[0], (DataType)DataType);
                     }
                     //数据处理
-                    AddressValue addressValue = Core.data.Dispose.Execute(add, value);
+                    AddressValue addressValue = Core.data.AddressHandler.Execute(add, value);
 
                     //数据添加
                     param.AddOrUpdate(add.AddressName, addressValue, (k, v) => addressValue);
@@ -539,7 +537,7 @@ namespace YSAI.Modbus.client
                     }
 
                     //数据处理
-                    AddressValue addressValue = Core.data.Dispose.Execute(add, value);
+                    AddressValue addressValue = Core.data.AddressHandler.Execute(add, value);
 
                     //数据添加
                     param.AddOrUpdate(add.AddressName, addressValue, (k, v) => addressValue);
@@ -562,6 +560,26 @@ namespace YSAI.Modbus.client
             return Task.Run(() => ReadInputRegisters(address, DataType));
         }
 
+        public OperateResult ReadHoldingRegisters(Address address)
+        {
+            return ReadInputRegisters(address,5);
+        }
+
+        public Task<OperateResult> ReadHoldingRegistersAsync(Address address)
+        {
+            return Task.Run(() => ReadHoldingRegisters(address));
+        }
+
+        public OperateResult ReadInputRegisters(Address address)
+        {
+            return ReadInputRegisters(address, 5);
+        }
+
+        public Task<OperateResult> ReadInputRegistersAsync(Address address)
+        {
+            return Task.Run(() => ReadInputRegisters(address));
+        }
+
         public OperateResult WriteSingleCoil(ConcurrentDictionary<ushort, bool> Values)
         {
             //开始记录运行时间

src/YSAI.DAQ/YSAI.Opc/da/client/OpcDaClientOperate.cs

@@ -114,7 +114,7 @@ namespace YSAI.Opc.da.client
                         ConcurrentDictionary<string, AddressValue> param = new ConcurrentDictionary<string, AddressValue>();
 
                         //处理数据
-                        AddressValue addressValue = YSAI.Core.data.Dispose.Execute(addressDetails, item.Value.ToString());  //数据 
+                        AddressValue addressValue = YSAI.Core.data.AddressHandler.Execute(addressDetails, item.Value.ToString());  //数据 
 
                         //添加至集合
                         param.AddOrUpdate(addressDetails.AddressName, addressValue, (k, v) => addressValue);
@@ -640,7 +640,7 @@ namespace YSAI.Opc.da.client
                             string? Value = VAM.Read(item);
 
                             //数据处理
-                            AddressValue addressValue = YSAI.Core.data.Dispose.Execute(item, Value);
+                            AddressValue addressValue = YSAI.Core.data.AddressHandler.Execute(item, Value);
 
                             //数据添加
                             param.AddOrUpdate(item.AddressName, addressValue, (k, v) => addressValue);
@@ -663,7 +663,7 @@ namespace YSAI.Opc.da.client
                             string? Value = itemValue[i].Value.ToString();
 
                             //数据处理
-                            AddressValue addressValue = YSAI.Core.data.Dispose.Execute(address.AddressArray[i], Value);
+                            AddressValue addressValue = YSAI.Core.data.AddressHandler.Execute(address.AddressArray[i], Value);
 
                             //数据添加
                             param.AddOrUpdate(itemValue[i].ItemName, addressValue, (k, v) => addressValue);

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

@@ -275,7 +275,7 @@ namespace YSAI.Opc.da.http
                     {
                         string? Value = VAM.Read(addressDetails.AddressName);
 
-                        nodes.TryAdd(addressDetails.AddressName, YSAI.Core.data.Dispose.Execute(addressDetails, Value));
+                        nodes.TryAdd(addressDetails.AddressName, YSAI.Core.data.AddressHandler.Execute(addressDetails, Value));
                     }
                     else
                     {
@@ -304,13 +304,13 @@ namespace YSAI.Opc.da.http
                                 if (read.ReadGroup)  //直接读取组下面的数据
                                 {
                                     //处理
-                                    nodes.TryAdd(itemvalues.itemname, YSAI.Core.data.Dispose.Execute(addressDetails, Value));
+                                    nodes.TryAdd(itemvalues.itemname, YSAI.Core.data.AddressHandler.Execute(addressDetails, Value));
                                 }
                                 else  //读取单个节点数据
                                 {
                                     if (addressDetails.AddressName.Equals(itemvalues.itemname))
                                     {
-                                        nodes.TryAdd(itemvalues.itemname, YSAI.Core.data.Dispose.Execute(addressDetails, Value));
+                                        nodes.TryAdd(itemvalues.itemname, YSAI.Core.data.AddressHandler.Execute(addressDetails, Value));
                                     }
                                 }
                             }

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

@@ -202,7 +202,7 @@ namespace YSAI.Opc.ua.client
                 //设置参数
                 ConcurrentDictionary<string, AddressValue> param = new ConcurrentDictionary<string, AddressValue>();
                 //处理数据
-                AddressValue addressValue = YSAI.Core.data.Dispose.Execute(addressDetails, notification.Value.ToString());  //数据 
+                AddressValue addressValue = YSAI.Core.data.AddressHandler.Execute(addressDetails, notification.Value.ToString());  //数据 
 
                 param.AddOrUpdate(addressDetails.AddressName, addressValue, (k, v) => addressValue);
 
@@ -1146,7 +1146,7 @@ namespace YSAI.Opc.ua.client
                         string? Value = VAM.Read(item);
 
                         //数据处理
-                        AddressValue addressValue = YSAI.Core.data.Dispose.Execute(item, Value);
+                        AddressValue addressValue = YSAI.Core.data.AddressHandler.Execute(item, Value);
 
                         //数据添加
                         param.AddOrUpdate(item.AddressName, addressValue, (k, v) => addressValue);
@@ -1171,7 +1171,7 @@ namespace YSAI.Opc.ua.client
                         string? Value = read.Results[i].ToString();
 
                         //数据处理
-                        AddressValue addressValue = YSAI.Core.data.Dispose.Execute(addressDetails, Value);
+                        AddressValue addressValue = YSAI.Core.data.AddressHandler.Execute(addressDetails, Value);
 
                         //数据添加
                         param.AddOrUpdate(addressDetails.AddressName, addressValue, (k, v) => addressValue);

src/YSAI.DAQ/YSAI.S7/client/S7ClientOperate.cs

@@ -67,6 +67,7 @@ namespace YSAI.S7.client
         /// S7PLC
         /// </summary>
         private Plc PlcS7;
+
         public void Dispose()
         {
             Off();
@@ -180,7 +181,7 @@ namespace YSAI.S7.client
                         }
 
                         //数据处理
-                        AddressValue addressValue = Core.data.Dispose.Execute(item, Value);
+                        AddressValue addressValue = Core.data.AddressHandler.Execute(item, Value);
 
                         //数据添加
                         param.AddOrUpdate(item.AddressName, addressValue, (k, v) => addressValue);