一款工业物联网高性能通讯中间件-服务端实现篇

在与远控操作台、自动化作业指令、人机交互、设备实时监控等工业物联网领域专家深入交流后，我了解到数据通讯方面的特殊要求。

请教了一些同事，我熟悉了工业标准协议。

经过三个版本的迭代，四个月的设计、编码、测试，上生产验证，一款由我独立研发的工业物联网高性能通讯中间件交付了。

本着交流合作，共同进步的精神，我决定把中间件的研发分享出来。由于内容较多，篇幅较长，将分三篇文章全面介绍这款中间件。

《一款工业物联网高性能通讯中间件-架构篇》：介绍中间件设计思想，技术方案，协议与标准，风险与应对

《一款工业物联网高性能通讯中间件-服务端实现篇》：介绍中间件服务端项目结构，开源组件，自封组件，PLC测点配置，数据采集，数据交互，OpcUa断线重连，常见问题及解决

《一款工业物联网高性能通讯中间件-客户端实现及封装篇》：内容待定

本次分享的是《一款工业物联网高性能通讯中间件-服务端实现篇》。服务端是中间件的核心，承担了底层数据采集，清洗，节点业务处理，IEC和Node接口交互，实时数据发送，历史数据发送的作用。

1 服务端项目结构

 类库说明如下：

DataCenter.Server：控制台启动程序，注册组件

DataCenter.Server.Service：服务层，解析OpuUa协议，提供IEC及Node接口，与客户端进行Socket通讯

DataCenter.Server.Model：实体层，包含请求实体，响应实体，配置实体等等

DataCenter.Server.Utility：公共调用层，包含了一些配置读取类，OpcUa数据清洗类等等

HPSocketCS：HPSocket开源源码

 类库之间关系如下：

HPSocketCS：供DataCenter.Server.Service调用

DataCenter.Server.Utility：供DataCenter.Server，DataCenter.Server.Service调用

DataCenter.Server.Model：供DataCenter.Server，DataCenter.Server.Service，DataCenter.Server.Utility调用

DataCenter.Server.Service：供DataCenter.Server调用

1.1 DataCenter.Server

1.1.1 windows服务

关键代码

        /// <summary>
        /// 入口程序
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            bool runAsService = ConfigUtil.GetBool("RunAsService", false);
            if (runAsService)
            {
                ServiceBase[] ServicesToRun;
                ServicesToRun = new ServiceBase[]
                {
                    new SanyEDPipeServer()
                };
                ServiceBase.Run(ServicesToRun);
            }
            else
            {
                Log.Info("数据同步服务启动...");
                SetConsoleCtrlHandler(cancelHandler, true);
                new EDPipeServerInit().Start();
            }
        }

用一个install.bat文件安装服务，内容如下

sc create "DataCenter.Server" binpath= "%~dp0DataCenter.Server.exe" start= auto
sc description DataCenter.Server "设备管道Socket服务及数据中心"
sc failure "DataCenter.Server" reset= 3600 actions= restart/500/restart/5000/restart/30000
sc start "DataCenter.Server"

用一个uninstall.bat文件卸载服务，内容如下

sc stop "DataCenter.Server"
sc delete "DataCenter.Server"

1.1.2 类图

 1.1.2.1 Program类-启动类

using DataCenter.Server.Service;
using DataCenter.Server.Service.Iec;
using Infrastructure.Log;
using DataCenter.Server.Service.Cache;
using DataCenter.Server.Utility;
using System;
using System.Runtime.InteropServices;
using System.ServiceProcess;

namespace DataCenter.Server
{
    public class Program
    {
        private static readonly string BasePath = AppDomain.CurrentDomain.BaseDirectory;

        /// <summary>
        /// 控制台关闭事件 
        /// </summary>
        /// <param name="ctrlType"></param>
        /// <returns></returns>
        public delegate bool ControlCtrlDelegate(int ctrlType);
        [DllImport("kernel32.dll")]
        private static extern bool SetConsoleCtrlHandler(ControlCtrlDelegate HandlerRoutine, bool Add);
        private static ControlCtrlDelegate cancelHandler = new ControlCtrlDelegate(HandlerRoutine);

        public static bool HandlerRoutine(int ctrlType)
        {
            switch (ctrlType)
            {
                //Ctrl+C关闭
                case 0:
                //按控制台关闭按钮关闭 
                case 2:
                    OnStop();
                    break;
            }
            return true;
        }

        /// <summary>
        /// 入口程序
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            bool runAsService = ConfigUtil.GetBool("RunAsService", false);
            if (runAsService)
            {
                ServiceBase[] ServicesToRun;
                ServicesToRun = new ServiceBase[]
                {
                    new EDPipeServer()
                };
                ServiceBase.Run(ServicesToRun);
            }
            else
            {
                Log.Info("数据同步服务启动...");
                SetConsoleCtrlHandler(cancelHandler, true);
                new EDPipeServerInit().Start();
            }
        }

        /// <summary>
        /// 关闭执行事件
        /// </summary>
        private static void OnStop()
        {
            Log.Info("设备管道服务停止开始...");
            try
            {
                Log.Info("关闭OpcUa连接功能 - 开始...");
                DataCollectionService.DisConnectOpcUa();
                Log.Info("关闭OpcUa连接功能 - 结束...");
                Log.Info("关闭IEC最新值的记录功能 - 开始...");
                RealtimeMemoryService.Stop();
                Log.Info("关闭IEC最新值的记录功能 - 成功");
                Log.Info("持久化客户端节点订阅 - 开始...");
                NodeSubscribeClientCache.Persist();
                Log.Info("持久化客户端节点订阅 - 成功");
            }
            catch (Exception ex)
            {
                Log.Error("设备管道服务停止报错，错误原因：" + ex.Message, ex);
            }
            Log.Info("设备管道服务停止成功");
        }
    }
}

 1.1.2.2 EDPipeServer类-服务自动生成类

namespace DataCenter.Server
{
    partial class EDPipeServer
    {
        /// <summary> 
        /// 必需的设计器变量。
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// 清理所有正在使用的资源。
        /// </summary>
        /// <param name="disposing">如果应释放托管资源，为 true；否则为 false。</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region 组件设计器生成的代码

        /// <summary> 
        /// 设计器支持所需的方法 - 不要修改
        /// 使用代码编辑器修改此方法的内容。
        /// </summary>
        private void InitializeComponent()
        {
            components = new System.ComponentModel.Container();
            this.ServiceName = "DataCenter.Service";
        }

        #endregion
    }
}

 1.1.2.3 EDPipeServerInit类-数据采集，Socket注册类

using DataCenter.Server.Service;
using System;

namespace DataCenter.Server
{
    public class EDPipeServerInit
    {
        public void Start()
        {

            //数据采集注册
            new DataCollectionService().DataCollectionServiceRegister();

            //Socket注册
            new HPSocketServerService().HPSocketServerServiceRegister();
 
            //阻塞线程，防止退出，控制台消失
            Console.ReadLine();
        }
    }
}

1.2 DataCenter.Server.Model

可供中间件的客户端共用

1.2.1 文档分类

 

 Enum：枚举文件，存放指令类型

    /// <summary>
    /// 指令类型
    /// </summary>
    public enum CmdTypeEnum
    {
        心跳检测 = 1,
        握手 = 2,
        客户端测试消息 = 3,
        浏览数据 = 4, //Cmd:4
        查询点 = 5, //Cmd:5,NodeId:ns=1;i=73
        修改点 =6,
        订阅点 = 7,
        推送点 = 8,
        退订点 = 9
    }

Iec：Iec标准实体类

Mq：Mq实体类

Persistence：持久化实体类

Plc：PLC实体类

Receive：中间件-服务端接受应用客户端消息实体类

Send：中间件-服务端发送到应用客户端消息实体类

Ua：Opu Ua自定义实体类

 1.2.2 类图

 

 

 

 

1.3 DataCenter.Server.Service

数据采集，清洗，协议解析，HpSocket通讯，MQ转发业务

1.3.1 文档分类

Cache：11个并发缓存类。包含浏览节点目录缓存，应用客户端标识与长连接标识关系缓存，应用客户端需订阅节点缓存，设备与IEC点关系缓存，节点Id与全路径缓存，节点Id与Iec点关系缓存，节点Id与浏览名称缓存，节点Id与值缓存，服务端连接客户端点持久化缓存，服务端订阅点缓存，OpcUaClient实例化缓存

Cmd：指令服务类。包含Socket心跳服务，Socket握手服务，Socket消息测试服务，节点目录浏览服务，点推送服务，点查询服务，点订阅服务，点退订服务，点修改服务

Consumers：MQ消息消费类。包含推送时发布的历史数据的消息消费服务

Iec：包含Iec格式组装及解析

Proxy：协议代理服务。包含基于OpcUa协议的解析

DataCollectionSevice：数据采集服务类

HPSoceketServerService：HpSocket服务端实现类

OpcUaServer：应用客户端请求数据交互的服务端基于OpuUa协议的服务类

1.3.2 类图

 

1.4 DataCenter.Server.Utility

 帮助类，文档结构如下

1.5 HPSocketCS

HPSocket源码，文档结构如下

 

2 开源组件

2.1 Opc Ua 基金会源码

开源地址：https://github.com/camais/UA-.NETStandard

版本：1.4.365.23

2.2 OpcUaHelper源码

开源地址：https://github.com/dathlin/OpcUaHelper

版本：1.4.365.0

2.3 HpSocket源码

开源地址：https://github.com/ldcsaa/HP-Socket

版本：5.4.2.4

3 自封组件

自封组件包含日志组件，MQ组件，UA组件，可独立成篇介绍

日志组件实现分级分类的日志功能

MQ组件实现fanout,direct消息发布与订阅功能

UA实现PLC服务器连接，节点目录浏览，节点查询，节点修改，节点订阅及节点退订功能

4 PLC测点配置

 通过配置工具读取数据库的测点信息、Plc信息，设备信息，IEC版本信息，生成PLC测点配置的json文件，文件格式如下

{
    "Head": "port",
    "Collection": "change",
    "PlcList": [{
        "Index": 1,
        "DeviceId": 10001001,
        "Name": "P1",
        "OpcUaServerAddress": "opc.tcp://192.168.1.11:4840",
        "BrowseDisplayNamespace": false,
        "RootNodeId": "i=85",
        "RootNodeName": "Root",
        "IecPathList": [{
            "DeviceId": 10001001,
            "IecPath": "SPRD.Pos.YC.F32.X",
            "DataPath": "ns=3;s=\"publicInfoSet\".\"spreaderInfo\".\"X\"",
            "Type": "2",
            "IsArray": false
        }, {
            "DeviceId": 10001001,
            "IecPath": "SPRD.Pos.YC.F32.Z",
            "DataPath": "ns=3;s=\"publicInfoSet\".\"spreaderInfo\".\"Z\"",
            "Type": "2",
            "IsArray": false
        }]
    }]
}

读取配置文件的代码如下

        /// <summary>
        /// 获取Json文件
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public static OpcUaConfigInfo ReadJsonFile(string filePath)
        {
            if (string.IsNullOrWhiteSpace(filePath))
            {
                return null;
            }
            var fullPath = GetPath(filePath);
            var opcUaInfoList = new List<OpcUaInfo>();
            var opcUaConfigInfo = new OpcUaConfigInfo() { OpcUaInfoList = opcUaInfoList };
            using (StreamReader file = File.OpenText(fullPath))
            {
                using (JsonTextReader reader = new JsonTextReader(file))
                {
                    JObject jsonObject = (JObject)JToken.ReadFrom(reader);
                    var head = (string)jsonObject["Head"];
                    var collection = (string)jsonObject["Collection"];
                    opcUaConfigInfo.Head = head;
                    opcUaConfigInfo.Collection = collection;
                    var plcList = jsonObject["PlcList"];
                    foreach (JObject jobjectPlc in plcList)
                    {
                        var opcUaInfo = new OpcUaInfo();
                        opcUaInfo.Index = (int)jobjectPlc["Index"];
                        opcUaInfo.Name = (string)jobjectPlc["Name"];
                        opcUaInfo.OpcUaServerAddress = (string)jobjectPlc["OpcUaServerAddress"];
                        opcUaInfo.Head = head;
                        opcUaInfo.Collection = collection;
                        var iecPathObject = jobjectPlc["IecPathList"];
                        var iecPathList = new List<IecPathInfo>();
                        foreach (JObject iecJobject in iecPathObject)
                        {
                            var iecPathInfo = new IecPathInfo();
                            iecPathInfo.DeviceId = (int)iecJobject["DeviceId"];
                            iecPathInfo.IecPath = (string)iecJobject["IecPath"];
                            iecPathInfo.DataPath = (string)iecJobject["DataPath"];
                            iecPathInfo.IsArray = (bool)iecJobject["IsArray"];
                            //IEC配置，类型默认是0，最大值、最小值、系数、小数位、单位默认无, zyj 2021-08-31
                            iecPathInfo.Type = string.IsNullOrEmpty(iecJobject["Type"]?.ToString()) ? 0 : Convert.ToInt32(iecJobject["Type"]);
                            if (!string.IsNullOrEmpty(iecJobject["MaxValue"]?.ToString()))
                            {
                                iecPathInfo.MaxValue = Convert.ToDouble(iecJobject["MaxValue"]);
                            }
                            if (!string.IsNullOrEmpty(iecJobject["MinValue"]?.ToString()))
                            {
                                iecPathInfo.MinValue = Convert.ToDouble(iecJobject["MinValue"]);
                            }
                            if (!string.IsNullOrEmpty(iecJobject["Coefficient"]?.ToString()))
                            {
                                iecPathInfo.Coefficient = Convert.ToDouble(iecJobject["Coefficient"]);
                            }
                            if (!string.IsNullOrEmpty(iecJobject["DecimalDigit"]?.ToString()))
                            {
                                iecPathInfo.DecimalDigit = Convert.ToInt32(iecJobject["DecimalDigit"]);
                            }
                            if (!string.IsNullOrEmpty(iecJobject["IecUnit"]?.ToString()))
                            {
                                iecPathInfo.IecUnit = Convert.ToString(iecJobject["IecUnit"]);
                            }
                            iecPathList.Add(iecPathInfo);
                        }
                        opcUaInfo.IecPathList = iecPathList;

                        opcUaInfoList.Add(opcUaInfo);
                    }
                }
            }
            return opcUaConfigInfo;
        }

5 数据采集

通过OpcUaHelper开源框架实现数据采集，实现了连接，关闭OpcUaServer端，节点目录浏览，节点查询，节日修改，节点订阅，节点退订功能，开放了OpcUa断线重连接口。在OpcUaHelper的基础上再次封装了Infrastructure.UA组件。

5.1 文档格式

5.2 类图

6 数据交互

数据交互提供了应用客户端调用接口，提供了节点查询，修改，订阅，退订，推送功能，代码如下

using Newtonsoft.Json;
using DataCenter.Server.Service.Cache;
using DataCenter.Server.Service.Proxy;
using Infrastructure.Log;
using DataCenter.Server.Model.Ua;
using DataCenter.Server.Utility;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace DataCenter.Server.Service
{
    public class OpcUaServer
    {
        /// <summary>
        /// 是否打印日志
        /// </summary>
        private static bool PrintLog { get { return ConfigUtil.GetBool("PrintLog", false); } }

        #region 浏览
        /// <summary>
        /// 缓存查询
        /// </summary>
        /// <param name="clientNodeIdStrList"></param>
        /// <returns></returns>
        public static List<BrowseResultTree> QueryBrowseListFromCacheByNodeId(List<NodeIdStr> clientNodeIdStrList)
        {
            var result = new List<BrowseResultTree>();
            var clientNodeIdList = ConvertToNodeIdRequest(clientNodeIdStrList);
            if (clientNodeIdList == null || !clientNodeIdList.Any() || clientNodeIdList.Any(o => o == null || o.PlcKey <= 0))
            {
                Log.Info("节点Id为空或Plc键非法，已从缓存中查询");
                var opcUaProxyCache = OpcUaProxyCache.GetDic();
                if (opcUaProxyCache == null || opcUaProxyCache.Keys == null || !opcUaProxyCache.Keys.Any())
                {
                    return null;
                }
                foreach (var keyValue in opcUaProxyCache)
                {
                    var opcUaProxy = OpcUaProxyCache.Get(keyValue.Key);
                    var tree = opcUaProxy.QueryBrowseFromCache(null);
                    result.Add(tree);
                }
                return result;
            }
            foreach(var clientNodeId in clientNodeIdList)
            {
                var tree = QueryBrowseFromCacheByNodeId(clientNodeId);
                if (tree != null)
                {
                    result.Add(tree);
                }
            }
            return result;
        }

        #endregion

        #region 节点查询
        /// <summary>
        /// 查点值集合
        /// </summary>
        /// <param name="nodeIdStrList"></param>
        /// <param name="needSort">是否需要排序</param>
        /// <returns></returns>
        public static List<NodeInfo> QueryNodeList(List<NodeIdStr> nodeIdStrList, bool needSort = true)
        {
            var nodeInfoList = new List<NodeInfo>();
            if (nodeIdStrList == null || !nodeIdStrList.Any())
            {
                return null;
            }
            var plcKeyValidate = nodeIdStrList.Any(o => o.Id == null || OpcUaConfigHelper.NodeIdRequestFromStr(o.Id)?.PlcKey <= 0);
            if (plcKeyValidate)
            {
                return nodeInfoList;
            }
            var dicReadNode = NodeToClass(nodeIdStrList);
            if (dicReadNode == null || dicReadNode.Keys == null || dicReadNode.Keys.Count == 0)
            {
                return nodeInfoList;
            }
            double cacheCost = 0;
            foreach (var keyValue in dicReadNode)
            {
                var opcUaProxy = OpcUaProxyCache.Get(Convert.ToInt32(keyValue.Key));
                if (opcUaProxy == null)
                {
                    continue;
                }
                var nodeIdRequestList = ConvertToNodeIdRequest(keyValue.Value);
                var nodeIdList = nodeIdRequestList.Select(o => o.NodeId).ToList();
                var stopwatch = new Stopwatch();
                stopwatch.Start();
                var query = opcUaProxy.QueryNodeList(nodeIdList);
                nodeInfoList.AddRange(query);
                stopwatch.Stop();
                cacheCost += stopwatch.ElapsedMilliseconds;
            }
            if (!needSort)
            {
                Log.Warn($"【查询】数据中心<-->opc耗时总：{cacheCost}");
                return nodeInfoList;
            }
            var result = ReSort(nodeIdStrList, nodeInfoList);
            Log.Warn($"【查询】数据中心<-->opc耗时总：{cacheCost}");
            return result;
        }
        #endregion

        #region 节点写入

        /// <summary>
        /// 写值
        /// </summary>
        /// <param name="nodes">节点修改集合(节点Id包含了OpcUa的Name)</param>
        /// <param name="statusCodeList">状态码集合</param>
        /// <returns></returns>
        public static bool WriteNode(List<NodeUpdateBase> nodes, out List<string> statusCodeList)
        {
            statusCodeList = new List<string>();
            var errorMsg = string.Empty;
            if (nodes == null || !nodes.Any())
            {
                errorMsg = "值为空";
                Log.Info(errorMsg, "WriteNode");
                return false;
            }
            var plcKeyValidate = nodes.Any(o => o.Id == null || OpcUaConfigHelper.NodeIdRequestFromStr(o.Id)?.PlcKey <= 0);
            if (plcKeyValidate)
            {
                errorMsg = "PlcKey Invalid";
                foreach (var nodeUpdateBase in nodes)
                {
                    statusCodeList.Add(errorMsg);
                }
                Log.Info(errorMsg, "WriteNode");
                return false;
            }

            var dicWriteNode = NodeToClass(nodes);
            if (dicWriteNode == null || dicWriteNode.Keys == null || dicWriteNode.Keys.Count == 0)
            {
                errorMsg = "Data Null";
                foreach (var nodeUpdateBase in nodes)
                {
                    statusCodeList.Add(errorMsg);
                }
                Log.Info(errorMsg, "WriteNode");
                return false;
            }
            var nodeUpdateResultList = new List<NodeUpdateResult>();
            var result = true;
            foreach (var keyValue in dicWriteNode)
            {
                var opcUaProxy = OpcUaProxyCache.Get(Convert.ToInt32(keyValue.Key));
                if (opcUaProxy == null)
                {
                    errorMsg = "Plc Example Null";
                    foreach (var node in keyValue.Value)
                    {
                        var nodeUpdateResult = new NodeUpdateResult() { Id = node.Id, StatusCode = errorMsg };
                        nodeUpdateResultList.Add(nodeUpdateResult);
                        result = false;
                    }
                    continue;
                }
                var writeResult = opcUaProxy.WriteNode(keyValue.Value, ref nodeUpdateResultList);
                if (!writeResult)
                {
                    result=false;
                }
            }
            #region 重排
            var needResort = result == false || dicWriteNode.Count > 1;
            statusCodeList = ReSort(nodes, nodeUpdateResultList, needResort);
            #endregion
            return result;
        }

        #endregion

        #region 客户端点订阅、退订

        /// <summary>
        /// 客户端订阅点
        /// </summary>
        /// <param name="clientId">客户端Id</param>
        /// <param name="nodeIdStrList">订阅节点列表</param>
        /// <param name="nodeQueryList">节点列表查询信息</param>
        /// <param name="successSubNodeList">成功订阅的节点列表(乱序，只包含成功订阅的节点)</param>
        /// <returns></returns>
        public static bool ClientNodeSubscribe(string clientId, List<NodeIdStr> nodeIdStrList, ref List<NodeInfo> nodeQueryList,ref List<NodeOperateResult> successSubNodeList)
        {
            if(successSubNodeList == null)
            {
                successSubNodeList = new List<NodeOperateResult>();
            }
            //非空校验
            if (nodeIdStrList == null || !nodeIdStrList.Any())
            {
                Log.Warn("无订阅点");
                return false;
            }
            //加入到待订阅的客户端缓存，防止断线重连未订阅到客户端订阅的点
            ClientNeedSubscribeNodeCache.Set(clientId, nodeIdStrList);
            //订阅点信息
            nodeQueryList = QueryNodeList(nodeIdStrList);
            if (nodeQueryList == null || !nodeQueryList.Any())
            {
                Log.Warn("点信息查询失败");
                return false;
            }
            var nodeIds = new List<NodeInfo>();
            for(int i = 0; i < nodeQueryList.Count; i++)
            {
                if (nodeQueryList[i] == null || string.IsNullOrWhiteSpace(nodeQueryList[i].Id))
                {
                    if (PrintLog)
                    {
                        Log.Warn($"第{i + 1}项节点Id为空，已忽略此节点订阅");
                    }
                    continue;
                }
                var idRequest = OpcUaConfigHelper.NodeIdRequestFromStr(nodeQueryList[i].Id);
                if (idRequest == null || idRequest.PlcKey<=0 || idRequest.NodeId==null|| string.IsNullOrWhiteSpace(idRequest.NodeId.ToString()))
                {
                    Log.Warn($"第{i + 1}项节点PlcKey非法，已忽略此节点订阅，{JsonConvert.SerializeObject(nodeQueryList[i])}");
                    continue;
                }
                nodeIds.Add(nodeQueryList[i]);

            }
            if (!nodeIds.Any())
            {
                Log.Warn("无合法订阅点");
                return false;
            }
            //节点分类
            var dicWriteNode = NodeToClass(nodeIds);
            if (dicWriteNode == null || dicWriteNode.Keys == null || dicWriteNode.Keys.Count == 0)
            {
                 Log.Warn("节点分类数据为空");
                return false;
            }
            //根据各自Opc实例订阅
            var readyNumber = 0; //待订阅个数
            var successNodeList = new List<NodeIdStr>();
            foreach (var keyValue in dicWriteNode)
            {
                readyNumber += keyValue.Value.Count;
                var opcUaProxy = OpcUaProxyCache.Get(Convert.ToInt32(keyValue.Key));
                if (opcUaProxy == null)
                {
                    Log.Warn($"订阅点-获取不到OpcUa实例,PlcKey:{keyValue.Key}");
                    continue;
                }
                List<NodeOperateResult> subResult = null;
                var success = opcUaProxy.SubscribeNode(keyValue.Value, ref subResult);
                if (success)
                {
                    if (subResult != null && subResult.Any())
                    {
                        successSubNodeList.AddRange(subResult);
                        subResult.ForEach(o =>
                        {
                            if (o.Success)
                            {
                                successNodeList.Add(new NodeIdStr { Id = o.Id });
                            }
                        });
                    }
                }
                else
                {
                    Log.Warn($"订阅点失败：点{JsonConvert.SerializeObject(keyValue.Value)},subResult{JsonConvert.SerializeObject(subResult)}");
                }
            }
            if(successNodeList.Count != readyNumber)
            {
                Log.Warn($"订阅个数不一致：共计{readyNumber}个点订阅，实际订阅{successNodeList.Count}个");
            }
            var addResult = NodeSubscribeClientCache.Set(clientId, successNodeList);
            //客户端待订阅缓存清除订阅成功的点
            if (addResult)
            {
                ClientNeedSubscribeNodeCache.Remove(clientId, successNodeList);
            }
            var result = successNodeList.Any();
            return result;
        }

        /// <summary>
        /// 客户端退订点
        /// </summary>
        /// <param name="clientId"></param>
        /// <param name="nodeIdStrList"></param>
        /// <param name="unSubResult">退订结果(只有退订有结果的的节点)</param>
        /// <returns></returns>
        public static bool ClientNodeUnSubscribe(string clientId, List<NodeIdStr> nodeIdStrList, ref List<NodeOperateResult> unSubResult)
        {
            if(unSubResult == null)
            {
                unSubResult = new List<NodeOperateResult>();
            }
            //非空校验
            if (nodeIdStrList == null || !nodeIdStrList.Any())
            {
                Log.Warn("无退订点");
                return false;
            }
            //节点分类
            var dicWriteNode = NodeToClass(nodeIdStrList);
            if (dicWriteNode == null || dicWriteNode.Keys == null || dicWriteNode.Keys.Count == 0)
            {
                Log.Warn("节点分类数据为空");
                return false;
            }
            //根据各自Opc实例退订
            var readyNumber = 0; //待退订个数
            var successNumber = 0;//退订成功个数
            var stopwatch = new Stopwatch();
            stopwatch.Start();
            foreach (var keyValue in dicWriteNode)
            {
                readyNumber += keyValue.Value.Count;
                var opcUaProxy = OpcUaProxyCache.Get(Convert.ToInt32(keyValue.Key));
                if (opcUaProxy == null)
                {
                    Log.Warn($"退订点-获取不到OpcUa实例,PlcKey:{keyValue.Key}");
                    continue;
                }
                var success = opcUaProxy.UnSubscribeNode(keyValue.Value.Select(o=>o.Id)?.ToList());
                if (success)
                {
                    successNumber += keyValue.Value.Count;
                    unSubResult.AddRange(keyValue.Value.Select(o => new NodeOperateResult { Id = o.Id, Success = true }));
                }
                else
                {
                    Log.Warn($"退订点失败：点{JsonConvert.SerializeObject(keyValue.Value)}");
                }
            }
            stopwatch.Stop();
            Log.Warn($"【退订】数据中心<-->opc耗时(ms)缓存：{stopwatch.ElapsedMilliseconds}");
            if (successNumber != readyNumber)
            {
                Log.Warn($"退阅个数不一致：共计{readyNumber}个点退订，实际退订{successNumber}个");
            }
            if (!unSubResult.Any())
            {
                return false;
            }
            var successNodes = unSubResult.Select(o => new NodeIdStr { Id = o.Id }).ToList();
            var result = NodeSubscribeClientCache.Remove(clientId, successNodes);
            //客户端待订阅缓存清除订阅成功的点
            if (result)
            {
                ClientNeedSubscribeNodeCache.Remove(clientId, successNodes);
            }
            return result;
        }
        #endregion

        #region 私有方法


        /// <summary>
        /// 重排
        /// </summary>
        /// <param name="nodeIdStrList">传入的值</param>
        /// <param name="nodeIdList">结果集</param>
        /// <returns></returns>
        private static List<NodeInfo> ReSort(List<NodeIdStr> nodeIdStrList, List<NodeInfo> nodeIdList)
        {
            var result = new List<NodeInfo>();
            if (nodeIdList == null || !nodeIdList.Any())
            {
                return result;
            }
            nodeIdStrList.ForEach(o =>
            {
                var nodeInfo = nodeIdList.Find(p => p.Id == o.Id);
                result.Add(nodeInfo);
            });
            return result;
        }

        /// <summary>
        /// 重排序
        /// </summary>
        /// <param name="nodes">原始节点列表</param>
        /// <param name="nodeUpdateResultList">修改后节点结果列表</param>
        /// <param name="needResort">是否需要重排序</param>
        /// <returns></returns>
        private static List<string> ReSort(List<NodeUpdateBase> nodes, List<NodeUpdateResult> nodeUpdateResultList, bool needResort)
        {
            if (!needResort)
            {
                var result = nodeUpdateResultList.Select(o => o.StatusCode).ToList();
                return result;
            }
            var statusCodeList = new List<string>();
            foreach (var node in nodes)
            {
                var nodeUpdateResult = nodeUpdateResultList.Find(o => o.Id == node.Id);
                var statusCode = nodeUpdateResult == null ? "未获取到写入信息" : nodeUpdateResult.StatusCode;
                statusCodeList.Add(statusCode);
            }
            return statusCodeList;
        }

        /// <summary>
        /// 节点分类
        /// </summary>
        /// <param name="nodes"></param>
        /// <returns></returns>
        private static ConcurrentDictionary<int, List<T>> NodeToClass<T>(List<T> nodes) where T : NodeIdStr
        {
            if (nodes == null || !nodes.Any())
            {
                return null;
            }
            var result = new ConcurrentDictionary<int, List<T>>();
            for (int i = 0; i < nodes.Count; i++)
            {
                if (nodes[i] == null || string.IsNullOrWhiteSpace(nodes[i].Id))
                {
                    Log.Warn($"写入点第{i + 1}项节点Id为空，已忽略此节点,写入集合{JsonConvert.SerializeObject(nodes)}", "NodeToClass");
                    continue;
                }
                var nodeIdRequest = OpcUaConfigHelper.NodeIdRequestFromStr(nodes[i].Id);
                var key = nodeIdRequest.PlcKey;
                if (result.ContainsKey(key))
                {
                    var value = result[key];
                    value.Add(nodes[i]);
                    result.AddOrUpdate(key, value, (tKey, existingVal) => { return value; });
                }
                else
                {
                    var value = new List<T> { nodes[i] };
                    result.AddOrUpdate(key, value, (tKey, existingVal) => { return value; });
                }
            }
            return result;
        }

        /// <summary>
        /// 缓存查询
        /// </summary>
        /// <param name="clientNodeId"></param>
        /// <returns></returns>
        private static BrowseResultTree QueryBrowseFromCacheByNodeId(NodeIdRequest clientNodeId)
        {
            if (clientNodeId == null && clientNodeId.NodeId == null || string.IsNullOrWhiteSpace(clientNodeId.NodeId.ToString()))
            {
                Log.Warn("客户端点为空");
                return null;
            }
            if (clientNodeId.PlcKey <= 0)
            {
                Log.Warn("plc标识错误");
                return null;
            }
            var opcUaProxy = OpcUaProxyCache.Get(clientNodeId.PlcKey);
            if(opcUaProxy == null)
            {
                Log.Warn($"没有获取到Plc实例：Plc：{clientNodeId.PlcKey}");
                return null;
            }
            var cacheNodeId = OpcUaConfigHelper.KeyToCache(clientNodeId.NodeId.ToString(), clientNodeId.PlcKey);
            var result = opcUaProxy.QueryBrowseFromCache(cacheNodeId);
            return result;
        }

        /// <summary>
        /// 转为NodeIdRequest集合
        /// </summary>
        /// <param name="clientNodeIdList"></param>
        /// <returns></returns>
        private static List<NodeIdRequest> ConvertToNodeIdRequest(List<NodeIdStr> clientNodeIdList)
        {
            if (clientNodeIdList == null || !clientNodeIdList.Any())
            {
                return null;
            }
            var result = new List<NodeIdRequest>();
            clientNodeIdList.ForEach(o =>
            {
                var request = OpcUaConfigHelper.NodeIdRequestFromStr(o.Id);
                result.Add(request);
            });
            return result;
        }

        #endregion
    }
}

7 OpcUa断线重连

Opc Ua Server更新，网络断开会触发Infrastructure.UA组件断线重连，重连成功后会通知OpcUa实体，然后重新建立连接，重新订阅点。实现如下

        /// <summary>
        /// 断线重连成功通知注册
        /// </summary>
        /// <returns></returns>
        public bool ReconnectSuccessNoticeRegister()
        {
            OpcUaClient.reconnectSuccessNoticeEvent.OnNotice += OnNotice;
            return true;
        }

        /// <summary>
        /// 订阅断线重连
        /// </summary>
        /// <returns></returns>
        public bool OnNotice()
        {
            try
            {
                Log.Warn("Opc Ua触发了断线重连通知!");
                DisConnect();
                Thread.Sleep(500);
                Connect();
                if (OpcUaClient.IsConnected)
                {
                    Log.Warn("Opc Ua断线重连成功了!");
                    //停止订阅推初值
                    OpcUaClient.Sub_Stop();
                    //注册订阅
                    NodeSubscribeRegister();
                    //订阅
                    var cacheNodeInfoList = NodeSubscribeServerCache.GetAll();
                    //服务端订阅所有缓存
                    if (cacheNodeInfoList != null && cacheNodeInfoList.Any())
                    {
                        List<NodeOperateResult> subResult = null;
                        Subscribe(cacheNodeInfoList, ref subResult, false);
                        Log.Warn($"Opc Ua断线重连：服务端点订阅缓存为{JsonConvert.SerializeObject(cacheNodeInfoList.Select(o => o.Id).ToList())}!");
                    }
                    else
                    {
                        Log.Warn("Opc Ua断线重连：服务端点订阅缓存为空，无需订阅!");
                    }
                    //客户端订阅
                    ClientSubscribe();
                }
                return true;
            }
            catch(Exception ex)
            {
                Log.Error($"断线重连结果异常:{ex.Message}", ex);
                return false;
            }
        }

8 常见问题及解决

8.1 批量操作（查询，订阅，修改）出现ToManyOperation错误

问题原因：PLC硬件性能不一致，比如西门子PLC-1500系列，订阅批次数不能超过20，每批次不能超过1000个节点

问题解决：批量操作时分批处理，通过Infrastructure.UA组件查询，修改节点每批次数设置成500。订阅时通过key来关联批次，每个key是一个批次，一个批次1000个节点，保存key与节点的缓存关系，超过20个批次的节点共计2万个点时，超过部分丢弃，写异常日志。

8.2 启动服务时报错，报InvalidSession错误

问题原因：上一次关闭时OPC UA基金会有缓存，还未到2分钟的过期时间，Session还保存了订阅点信息，订阅时出错

问题解决：每次程序关闭时主动关闭OpcUa的连接

 8.3 OpcUA短线重连20次后重连不起作用

问题原因：OpcUaServer端默认对每个Session有重连次数的限制且不可更改

问题解决：每次重连时关闭原来的连接，重新启动新的连接