OPCFoundation.NetStandard.Opc.Ua是OPC基金会发布的开源OPC UA包，提供Client读写库方便读写OPC 服务器数据。
OPCFoundation.NetStandard.Opc.Ua开源项目地址：https://github.com/OPCFoundation/UA-.NETStandard
使用时有几点需要注意。
1、订阅分组
OPC UA的数据订阅分组，和OPC DA的有所不同，每个组数据项有限，这个值具体是多少与服务器的配置有关，一般几百到上千。每个组的订阅名称也不能相同，需要考虑订阅名称分类。服务器对与订阅资源是有限的，有的服务器必须显式的释放订阅资源，不然会造成订阅资源耗尽而订阅失败，必须重启服务端软件才能解决。
2、连接断开
OPC Client与服务器连接断开有两种情况：主动断开和被动断开
客户端主动断开时，必须先注销订阅的数据分组项，再进行断开。目前这个库不能在连接关闭时自动释放所有服务器的连接资源，这个也是这个库不太友好的地方。
如果是服务端主动断开，很可能是服务器关闭了，这时直接关闭即可。
3、数据读取
数据读取有订阅、同步和异步几种方法。订阅较为复杂但性能高、占用的网络带宽也最少。同步与异步仅调用语法有差异，其他类似。
同步或异步都数据时，读多少数据点，就传入多少，然后到返回值中拿数据，C#可以作比较好的类型转换。
4、数据写入
OPC UA在数据写入时，对数据类型有严格要求，数据类型不会自动转换，会写入失败。如果仅在C#系统内部写入数据，且仅少数点写入这时读有次数据，记录返回的数据类型，固定编码写入。
在数据量较多，且有数据订阅的情况下，也可以记录每个点的数据类型，在写入数据时索引数据类型，然后自动转换。
在把数据接口封装为API的情况下，同一个数据可以解析为很多数据类型，比如数据123，可以是Byte，I2、U2、I4、U4、R4等很多类型，反序列化时一般会解析为Single，直接调用写入会因数据类型不正确而失败。这时除了使用索引，自己处理数据兼容性问题，也可以多写几个wrapper来处理数据类型转换问题。
示例的Controller类代码如下：
[ApiController]
[Route("[controller]/[action]")]
public class OpcUaControlServiceController : ControllerBase
{
private readonly ILogger<OpcUaControlServiceController> _logger;
public OpcUaControlServiceController(ILogger<OpcUaControlServiceController> logger)
{
_logger = logger;
}
/// <summary>
/// 获取服务运行信息
/// </summary>
/// <returns>运行信息概览JSON</returns>
[HttpPost,HttpGet]
public string info()
{
return ApiContentResultMsg.Success(OpcUaControlService.Instance.Info());
}
/// <summary>
/// 启动OpcUa 控制服务
/// </summary>
/// <returns>执行信息JSON</returns>
[HttpPost]
public string Start()
{
OpcUaControlService.Instance.Start();
return ApiContentResultMsg.Success();
}
/// <summary>
/// 停止OpcUa 控制服务
/// </summary>
/// <returns>执行信息JSON</returns>
[HttpPost]
public string ShutDown()
{
OpcUaControlService.Instance.ShutDown();
return ApiContentResultMsg.Success();
}
/// <summary>
/// 写入Int32 类型 OpcUa NodeId数据
/// </summary>
/// <returns>执行信息JSON</returns>
[HttpPost]
public string SyncWriteOpcUaInt32(String nodeId, Int32 value)
{
bool b = OpcUaControlService.Instance.SyncWriteOpcUaInt32(nodeId, value);
return b?ApiContentResultMsg.Success(): ApiContentResultMsg.Error("write fail!");
}
/// <summary>
/// 写入float 类型 OpcUa NodeId数据
/// </summary>
/// <returns>执行信息JSON</returns>
[HttpPost]
public string SyncWriteOpcUaFloat(String nodeId, float value)
{
bool b = OpcUaControlService.Instance.SyncWriteOpcUaFloat(nodeId, value);
return b ? ApiContentResultMsg.Success() : ApiContentResultMsg.Error("write fail!");
}
/// <summary>
/// 写入bool 类型 OpcUa NodeId数据
/// </summary>
/// <returns>执行信息JSON</returns>
[HttpPost]
public string SyncWriteOpcUaBool(String nodeId, bool value)
{
bool b = OpcUaControlService.Instance.SyncWriteOpcUaBool(nodeId, value);
return b ? ApiContentResultMsg.Success() : ApiContentResultMsg.Error("write fail!");
}
/// <summary>
/// 写入String 类型 OpcUa NodeId数据
/// </summary>
/// <returns>执行信息JSON</returns>
[HttpPost]
public string SyncWriteOpcUaString(String nodeId, String value)
{
bool b = OpcUaControlService.Instance.SyncWriteOpcUaString(nodeId, value);
return b ? ApiContentResultMsg.Success() : ApiContentResultMsg.Error("write fail!");
}
}5、参考资料
日本DeviceXPlorer OPC Server软件，在日系PLC和数控支持上比较友好，适用于1万点以内的采集服务，其自带了有个客户端的Demo，参考如下：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Opc.Ua.Client;
using Opc.Ua.Configuration;
using Opc.Ua;
using System.Security.Cryptography.X509Certificates;
namespace DxpUaSimpleAPI
{
public class DxpUaSimpleClass
{
public struct ReadItemResults
{
public object m_readResultValue;
public StatusCode m_resultCodes;
public DateTime m_sourceTimeStamp;
public DateTime m_serverTimeStamp;
}
public struct WriteItemResults
{
public StatusCode m_resultCodes;
}
public delegate void onAsyncReadCompleteDelegate(List<string> asyncReadNodeName, List<ReadItemResults> AsyncReadItemResults);
public delegate void onAsyncWriteCompleteDelegate(List<string> asyncWriteNodeName, List<WriteItemResults> asyncResultStatus);
public delegate void monitoredItemNotification(List<string> monitoredItems, List<object> monitoredItemValue);
private Session m_clientSession = null;
private Dictionary<string, Subscription> m_subscriptionMap = new Dictionary<string, Subscription>();
private ApplicationInstance m_application = new ApplicationInstance();
private List<Subscription> m_subscriptions = new List<Subscription>();
public onAsyncReadCompleteDelegate m_ReadEventHandler = null;
public onAsyncWriteCompleteDelegate m_WriteEventHandler = null;
public monitoredItemNotification m_MonitoredEventHandler = null;
public struct CertificateStore
{
public string m_applicationCertificateFileName;
public string m_applicationCertificateStore;
public string m_trustedIssuerCertificatesStore;
public string m_TrustedPeerCertificatesStore;
public string m_RejectedCertificateStore;
}
public struct BrowseNodeResults
{
public QualifiedName m_browseName;
public ExpandedNodeId m_nodeIdList;
public LocalizedText m_displayName;
public StatusCode m_statusCodes;
}
public void Initialize()
{
m_application.ApplicationType = ApplicationType.Client;
m_application.ConfigSectionName = "Opc.Ua.SampleClient";
try
{
m_application.LoadApplicationConfiguration(false);
m_application.CheckApplicationInstanceCertificate(false, 0);
}
catch (Exception ex)
{
Console.WriteLine(" Initialize Exception" + ex.Message);
}
}
public bool Initialize(string sApplicationName, string sApplicationUri, string sProductUri, CertificateStore newCertificateStore, string sStoreType)
{
try
{
m_application.ApplicationConfiguration = new ApplicationConfiguration();
if (sApplicationName == "")
{
m_application.ApplicationConfiguration.ApplicationName = "OPC UA User Client";
}
if (sApplicationUri == "")
{
m_application.ApplicationConfiguration.ApplicationUri = "urn:localhost:TAKEBISHI:UserClient";
}
if (sProductUri == "")
{
m_application.ApplicationConfiguration.ProductUri = "http://opcfoundation.org/UA/SampleClient";
}
m_application.ApplicationConfiguration.ApplicationType = ApplicationType.Client;
m_application.ApplicationConfiguration.SecurityConfiguration.ApplicationCertificate = new CertificateIdentifier(new X509Certificate2(newCertificateStore.m_applicationCertificateFileName));
m_application.ApplicationConfiguration.SecurityConfiguration.ApplicationCertificate.StoreType = CertificateStoreType.Directory;
m_application.ApplicationConfiguration.SecurityConfiguration.ApplicationCertificate.StorePath = newCertificateStore.m_applicationCertificateStore;
m_application.ApplicationConfiguration.SecurityConfiguration.ApplicationCertificate.OpenStore();
m_application.ApplicationConfiguration.SecurityConfiguration.TrustedIssuerCertificates.StoreType = sStoreType;
m_application.ApplicationConfiguration.SecurityConfiguration.TrustedIssuerCertificates.StorePath = newCertificateStore.m_trustedIssuerCertificatesStore;
m_application.ApplicationConfiguration.SecurityConfiguration.TrustedIssuerCertificates.OpenStore();
m_application.ApplicationConfiguration.SecurityConfiguration.TrustedPeerCertificates.StoreType = sStoreType;
m_application.ApplicationConfiguration.SecurityConfiguration.TrustedPeerCertificates.StorePath = newCertificateStore.m_TrustedPeerCertificatesStore;
m_application.ApplicationConfiguration.SecurityConfiguration.TrustedPeerCertificates.OpenStore();
m_application.ApplicationConfiguration.SecurityConfiguration.RejectedCertificateStore = new CertificateStoreIdentifier();
m_application.ApplicationConfiguration.SecurityConfiguration.RejectedCertificateStore.StoreType = sStoreType;
m_application.ApplicationConfiguration.SecurityConfiguration.RejectedCertificateStore.StorePath = newCertificateStore.m_RejectedCertificateStore;
m_application.ApplicationConfiguration.SecurityConfiguration.RejectedCertificateStore.OpenStore();
m_application.ApplicationConfiguration.SecurityConfiguration.AutoAcceptUntrustedCertificates = false;
m_application.ApplicationConfiguration.CertificateValidator = new CertificateValidator();
StringCollection wellKnownDiscoveryUrls = new StringCollection();
wellKnownDiscoveryUrls.Add("http://{0}:52601/UADiscovery");
wellKnownDiscoveryUrls.Add("opc.tcp://{0}:4840");
wellKnownDiscoveryUrls.Add("http://{0}/UADiscovery/Default.svc");
m_application.ApplicationConfiguration.ClientConfiguration = new ClientConfiguration();
m_application.ApplicationConfiguration.ClientConfiguration.WellKnownDiscoveryUrls = wellKnownDiscoveryUrls;
m_application.CheckApplicationInstanceCertificate(false, 0);
}
catch (Exception ex)
{
Console.WriteLine(" Initialize Exception" + ex.Message);
return false;
}
return true;
}
public ConfiguredEndpoint GetEndPoint(string sUrl, MessageSecurityMode securityMode, string sSecurityPoricies)
{
try
{
ApplicationConfiguration configuration = m_application.ApplicationConfiguration;
EndpointConfiguration endpointConfiguration = EndpointConfiguration.Create(configuration);
EndpointDescription endpointDescription = null;
endpointDescription = new EndpointDescription();
endpointDescription.EndpointUrl = sUrl;
endpointDescription.SecurityLevel = 0;
endpointDescription.SecurityMode = securityMode;
endpointDescription.SecurityPolicyUri = sSecurityPoricies;
endpointDescription.Server.ApplicationName = endpointDescription.EndpointUrl;
endpointDescription.Server.ApplicationType = ApplicationType.Server;
endpointDescription.Server.ApplicationUri = endpointDescription.EndpointUrl;
ConfiguredEndpoint endpoint = new ConfiguredEndpoint(null, endpointDescription, endpointConfiguration);
return endpoint;
}
catch (Exception ex)
{
Console.WriteLine(" GetEndPoint Exception" + ex.Message);
return null;
}
}
public bool Connect(string sUrl, MessageSecurityMode securityMode, string sSecurityPoricies)
{
ApplicationConfiguration configuration = m_application.ApplicationConfiguration;
bool UpdateBeforeConnect = true;
string sSessionName = "session1";
uint nSessionTimeout = 3000;
UserIdentity userIdentity = null;
IList<string> PreferredLocales = null;
ConfiguredEndpoint endpoint = GetEndPoint(sUrl, securityMode, sSecurityPoricies);
try
{
m_clientSession = Session.Create(configuration, endpoint, UpdateBeforeConnect, sSessionName, nSessionTimeout, userIdentity, PreferredLocales);
if (m_clientSession == null)
{
return false;
}
return true;
}
catch (Exception ex)
{
Console.WriteLine(" Session Create Exception" + ex.Message);
return false;
}
}
public bool DisConnect()
{
if (m_subscriptions.Count() > 0)
{
for (int i = 0; i < m_subscriptions.Count(); i++)
{
Subscription subscription = m_subscriptions[i];
if (m_subscriptionMap.ContainsKey(subscription.DisplayName))
{
subscription = m_subscriptionMap[subscription.DisplayName];
if (!RemoveAllMonitoredItems(subscription.DisplayName))
{
return false;
}
}
}
if (!m_clientSession.RemoveSubscriptions(m_subscriptions))
{
return false;
}
}
try
{
if (m_clientSession != null)
{
m_clientSession.Close();
m_clientSession.Dispose();
m_clientSession = null;
}
}
catch (Exception ex)
{
Console.WriteLine(" Session close Exception" + ex.Message);
return false;
}
return true;
}
public bool BrowseNode(NodeId targetNodeId, NodeId ReferenceType, out List<BrowseNodeResults> results)
{
BrowseDescription nodeToBrowse = new BrowseDescription();
BrowseDescriptionCollection nodesToBrowse = new BrowseDescriptionCollection();
RequestHeader BrowseRequestHeader = new RequestHeader();
ViewDescription BrowseView = new ViewDescription();
BrowseResultCollection BrowseResults = new BrowseResultCollection();
uint requestMaxReferencesPerNode = 0;
DiagnosticInfoCollection BrowseDiagnosticsInfos = new DiagnosticInfoCollection();
nodeToBrowse.ReferenceTypeId = ReferenceType;
nodeToBrowse.NodeId = targetNodeId;
nodeToBrowse.IncludeSubtypes = true;
nodeToBrowse.NodeClassMask = (uint)(NodeClass.Object | NodeClass.Variable);
nodeToBrowse.ResultMask = (uint)BrowseResultMask.All;
nodeToBrowse.BrowseDirection = BrowseDirection.Forward;
nodesToBrowse.Add(nodeToBrowse);
results = new List<BrowseNodeResults>();
BrowseNodeResults browseNodeResults = new BrowseNodeResults();
browseNodeResults.m_browseName = null;
browseNodeResults.m_nodeIdList = null;
browseNodeResults.m_displayName = null;
browseNodeResults.m_statusCodes = new StatusCode();
try
{
m_clientSession.Browse(BrowseRequestHeader, BrowseView, requestMaxReferencesPerNode, nodesToBrowse, out BrowseResults, out BrowseDiagnosticsInfos);
browseNodeResults.m_statusCodes = BrowseResults[0].StatusCode;
for (int i = 0; i < BrowseResults[0].References.Count(); i++)
{
browseNodeResults.m_browseName = BrowseResults[0].References[i].BrowseName;
browseNodeResults.m_nodeIdList = BrowseResults[0].References[i].NodeId;
browseNodeResults.m_displayName = BrowseResults[0].References[i].DisplayName;
results.Add(browseNodeResults);
}
}
catch (Exception ex)
{
Console.WriteLine(" BrowseNode Exception" + ex.Message);
return false;
}
return true;
}
public bool SyncRead(List<NodeId> readItemList, out List<ReadItemResults> results)
{
RequestHeader ReadRequestHeader = new RequestHeader();
ReadRequestHeader.ReturnDiagnostics = 5000;
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
DataValueCollection ReadResults = new DataValueCollection();
DiagnosticInfoCollection ReadDiagnosticsInfos = null;
results = new List<ReadItemResults>();
ReadItemResults readItemResults = new ReadItemResults();
readItemResults.m_readResultValue = 0;
readItemResults.m_resultCodes = new StatusCode();
readItemResults.m_serverTimeStamp = new DateTime();
readItemResults.m_sourceTimeStamp = new DateTime();
try
{
foreach (NodeId nodeId in readItemList)
{
ReadValueId readId = new ReadValueId();
readId.NodeId = nodeId;
readId.AttributeId = (uint)Attributes.Value;
nodesToRead.Add(readId);
}
m_clientSession.Read(ReadRequestHeader, 0, TimestampsToReturn.Both, nodesToRead, out ReadResults, out ReadDiagnosticsInfos);
for (int i = 0; i < ReadResults.Count(); i++)
{
readItemResults.m_resultCodes = ReadResults[i].StatusCode;
if (!StatusCode.IsBad(ReadResults[i].StatusCode))
{
readItemResults.m_readResultValue = ReadResults[i].Value;
readItemResults.m_sourceTimeStamp = ReadResults[i].SourceTimestamp;
readItemResults.m_serverTimeStamp = ReadResults[i].ServerTimestamp;
}
else
{
readItemResults.m_readResultValue = null;
readItemResults.m_sourceTimeStamp = DateTime.MinValue;
readItemResults.m_serverTimeStamp = DateTime.MinValue;
}
results.Add(readItemResults);
}
}
catch (Exception ex)
{
Console.WriteLine(" SyncRead Exception" + ex.Message);
return false;
}
return true;
}
public bool SyncWrite(List<NodeId> writeNodeIdList, List<object> writeValueList, out List<WriteItemResults> Results)
{
RequestHeader WriteRequestHeader = null;
Results = new List<WriteItemResults>();
WriteItemResults writeItemResults = new WriteItemResults();
writeItemResults.m_resultCodes = new StatusCode();
WriteValueCollection writeValueCollection = new WriteValueCollection();
StatusCodeCollection WriteResults = null;
DiagnosticInfoCollection WriteDiagnosticsInfos = null;
try
{
for (int i = 0; i < writeNodeIdList.Count(); i++)
{
WriteValue valueToWrite = new WriteValue();
valueToWrite.NodeId = writeNodeIdList[i];
valueToWrite.AttributeId = (uint)Attributes.Value;
valueToWrite.Value.Value = writeValueList[i];
valueToWrite.Value.StatusCode = StatusCodes.Good;
valueToWrite.Value.ServerTimestamp = DateTime.MinValue;
writeValueCollection.Add(valueToWrite);
}
m_clientSession.Write(WriteRequestHeader, writeValueCollection, out WriteResults, out WriteDiagnosticsInfos);
if (WriteResults.Count() > 0)
{
for (int m = 0; m < WriteResults.Count(); m++)
{
writeItemResults.m_resultCodes = WriteResults[0];
Results.Add(writeItemResults);
}
}
else
{
return false;
}
}
catch (Exception ex)
{
Console.WriteLine(" SyncWrite Exception" + ex.Message);
return false;
}
return true;
}
public void ASyncRead(List<NodeId> readItemList)
{
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
try
{
foreach (NodeId nodeId in readItemList)
{
ReadValueId readId = new ReadValueId();
readId.NodeId = nodeId;
readId.AttributeId = (uint)Attributes.Value;
nodesToRead.Add(readId);
}
m_clientSession.BeginRead(null, 0, TimestampsToReturn.Both, nodesToRead, new AsyncCallback(AsyncReadCompleted), nodesToRead);
}
catch (Exception ex)
{
Console.WriteLine(" ASyncRead Exception" + ex.Message);
}
}
public void AsyncReadCompleted(IAsyncResult result)
{
try
{
if (!result.IsCompleted)
{
return;
}
EndRead(result);
}
catch (Exception ex)
{
Console.WriteLine(" ASyncRead Exception" + ex.Message);
}
}
public ResponseHeader EndRead(IAsyncResult result)
{
ReadResponse response = null;
DataValueCollection results = new DataValueCollection();
DiagnosticInfoCollection diagnosticInfos = new DiagnosticInfoCollection();
ReadValueIdCollection nodesToRead = (ReadValueIdCollection)result.AsyncState;
List<ReadItemResults> readResults = new List<ReadItemResults>();
IServiceResponse genericResponse = m_clientSession.TransportChannel.EndSendRequest(result);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (ReadResponse)genericResponse;
results = response.Results;
diagnosticInfos = response.DiagnosticInfos;
ClientBase.ValidateResponse(results, nodesToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
ReadItemResults readItemResults = new ReadItemResults();
readItemResults.m_readResultValue = 0;
readItemResults.m_resultCodes = new StatusCode();
readItemResults.m_serverTimeStamp = new DateTime();
readItemResults.m_sourceTimeStamp = new DateTime();
List<string> asyncReadNodeName = new List<string>();
for (int i = 0; i < results.Count; i++)
{
asyncReadNodeName.Add(nodesToRead[i].NodeId.ToString());
readItemResults.m_resultCodes = results[i].StatusCode;
if (!StatusCode.IsBad(results[i].StatusCode))
{
readItemResults.m_readResultValue = results[i].Value;
readItemResults.m_sourceTimeStamp = results[i].SourceTimestamp;
readItemResults.m_serverTimeStamp = results[i].ServerTimestamp;
}
else
{
readItemResults.m_readResultValue = null;
readItemResults.m_sourceTimeStamp = DateTime.MinValue;
readItemResults.m_serverTimeStamp = DateTime.MinValue;
}
readResults.Add(readItemResults);
}
m_ReadEventHandler(asyncReadNodeName, readResults);
return response.ResponseHeader;
}
public static void ValidateResponse(ResponseHeader header)
{
if (header == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse, "Deficiencies in the response.");
}
if (StatusCode.IsBad(header.ServiceResult))
{
throw new ServiceResultException(new ServiceResult(header.ServiceResult, header.ServiceDiagnostics, header.StringTable));
}
}
public void RegisterReadEventHandler(onAsyncReadCompleteDelegate eventHandler)
{
m_ReadEventHandler = eventHandler;
}
public void UnRegisterReadEventHandler(onAsyncReadCompleteDelegate eventHandler)
{
m_ReadEventHandler -= eventHandler;
}
public bool ASyncWrite(List<NodeId> writeNodeIdList, List<object> writeValueList)
{
RequestHeader AsyncWriteRequestHeader = null;
WriteValueCollection nodesToAsyncWrite = new WriteValueCollection();
try
{
for (int i = 0; i < writeNodeIdList.Count(); i++)
{
WriteValue valueToAsyncWrite = new WriteValue();
valueToAsyncWrite.NodeId = writeNodeIdList[i];
TypeInfo typeInfo = TypeInfo.Construct(writeValueList[i]);
valueToAsyncWrite.Value.Value = writeValueList[i];
valueToAsyncWrite.AttributeId = (uint)Attributes.Value;
valueToAsyncWrite.Value.StatusCode = StatusCodes.Good;
valueToAsyncWrite.Value.ServerTimestamp = DateTime.MinValue;
valueToAsyncWrite.Value.SourceTimestamp = DateTime.MinValue;
nodesToAsyncWrite.Add(valueToAsyncWrite);
}
m_clientSession.BeginWrite(AsyncWriteRequestHeader, nodesToAsyncWrite, new AsyncCallback(AsyncWriteCompleted), nodesToAsyncWrite);
}
catch (Exception ex)
{
Console.WriteLine(" ASyncWrite Exception" + ex.Message);
return false;
}
return true;
}
public void AsyncWriteCompleted(IAsyncResult result)
{
try
{
if (!result.IsCompleted)
{
return;
}
EndWrite(result);
}
catch (Exception ex)
{
Console.WriteLine(" ASyncWrite Exception" + ex.Message);
}
}
public ResponseHeader EndWrite(IAsyncResult result)
{
WriteResponse response = null;
StatusCodeCollection results = new StatusCodeCollection();
DiagnosticInfoCollection diagnosticInfos = new DiagnosticInfoCollection();
WriteValueCollection nodesToWrite = (WriteValueCollection)result.AsyncState;
List<WriteItemResults> writeResults = new List<WriteItemResults>();
IServiceResponse genericResponse = m_clientSession.TransportChannel.EndSendRequest(result);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (WriteResponse)genericResponse;
results = response.Results;
diagnosticInfos = response.DiagnosticInfos;
List<string> asyncWriteNodeName = new List<string>();
WriteItemResults writeItemResults = new WriteItemResults();
writeItemResults.m_resultCodes = new StatusCode();
for (int ii = 0; ii < results.Count; ii++)
{
asyncWriteNodeName.Add(nodesToWrite[ii].NodeId.ToString());
writeItemResults.m_resultCodes = results[ii];
writeResults.Add(writeItemResults);
}
m_WriteEventHandler(asyncWriteNodeName, writeResults);
return response.ResponseHeader;
}
public void RegisterWriteEventHandler(onAsyncWriteCompleteDelegate eventHandler)
{
m_WriteEventHandler = eventHandler;
}
public void UnRegisterWriteEventHandler(onAsyncReadCompleteDelegate eventHandler)
{
m_ReadEventHandler = null;
}
public bool CreateSubscription(string sSubscriptionName, int nPublishInterval)
{
Subscription subscription = new Subscription(m_clientSession.DefaultSubscription);
subscription.DisplayName = sSubscriptionName;
subscription.PublishingInterval = nPublishInterval;
subscription.LifetimeCount = 100;
subscription.KeepAliveCount = 10;
subscription.MaxNotificationsPerPublish = 1000;
subscription.Priority = 1;
subscription.PublishingEnabled = true;
subscription.TimestampsToReturn = TimestampsToReturn.Both;
if (m_clientSession.AddSubscription(subscription))
{
subscription.Create();
m_subscriptions.Add(subscription);
m_subscriptionMap.Add(sSubscriptionName, subscription);
return true;
}
else
{
return false;
}
}
public bool DestroySubscription(string sSubscriptionName)
{
Subscription subscription = null;
if (m_subscriptionMap.ContainsKey(sSubscriptionName))
{
subscription = m_subscriptionMap[sSubscriptionName];
if (RemoveAllMonitoredItems(sSubscriptionName))
{
if (m_clientSession.RemoveSubscription(subscription))
{
m_subscriptionMap.Remove(sSubscriptionName);
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
else
{
return false;
}
}
public bool AddMonitoredItem(string sSubscriptionName, List<NodeId> NodeIdList)
{
Subscription subscription = null;
if (m_subscriptionMap.ContainsKey(sSubscriptionName))
subscription = m_subscriptionMap[sSubscriptionName];
try
{
for (int count = 0; count < NodeIdList.Count(); count++)
{
MonitoredItem monitoredItem = new MonitoredItem(subscription.DefaultItem);
monitoredItem.StartNodeId = NodeIdList[count];
string monitoredItemName = "MonitoredItem_" + count.ToString();
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.DisplayName = monitoredItemName;
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.SamplingInterval = subscription.PublishingInterval;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
if (Contains(subscription, monitoredItem))
{
Console.WriteLine("The item is already added.");
}
subscription.AddItem(monitoredItem);
monitoredItem.Handle = this;
subscription.ApplyChanges();
if (ServiceResult.IsBad(monitoredItem.Status.Error))
{
throw new ServiceResultException(monitoredItem.Status.Error);
}
monitoredItem.Notification += monitoredItem_Notification;
}
}
catch (Exception ex)
{
Console.WriteLine(" AddMonitoredItem Exception" + ex.Message);
return false;
}
return true;
}
public void RegisterMontioredItemEventHandler(monitoredItemNotification eventHandler)
{
m_MonitoredEventHandler = eventHandler;
}
public void UnRegisterMontioredItemEventHandler(monitoredItemNotification eventHandler)
{
m_MonitoredEventHandler = null;
}
public void monitoredItem_Notification(MonitoredItem monitoredItem, MonitoredItemNotificationEventArgs e)
{
List<string> monitoredItems = new List<string>();
List<object> monitoredValues = new List<object>();
MonitoredItemNotification notification = e.NotificationValue as MonitoredItemNotification;
IList<DataValue> list = monitoredItem.DequeueValues();
DataValue data = list[0];
monitoredItems.Add(monitoredItem.DisplayName.ToString());
monitoredValues.Add(data.Value);
m_MonitoredEventHandler(monitoredItems, monitoredValues);
}
public bool RemoveMonitoredItems(string sSubscriptionName, List<NodeId> NodeIdList)
{
Subscription subscription = null;
if (m_subscriptionMap.ContainsKey(sSubscriptionName))
subscription = m_subscriptionMap[sSubscriptionName];
for (int count = 0; count < NodeIdList.Count(); count++)
{
foreach (MonitoredItem item in subscription.MonitoredItems)
{
if (NodeIdList[count] == item.StartNodeId)
{
Subscription removeSubscription = item.Subscription;
item.Subscription.RemoveItem(item);
removeSubscription.ApplyChanges();
}
}
}
return true;
}
public bool RemoveAllMonitoredItems(string sSubscriptionName)
{
Subscription subscription = null;
if (m_subscriptionMap.ContainsKey(sSubscriptionName))
subscription = m_subscriptionMap[sSubscriptionName];
foreach (MonitoredItem item in subscription.MonitoredItems)
{
MonitoredItem monitoredItem = item as MonitoredItem;
if (monitoredItem != null)
{
Subscription removeSubscription = monitoredItem.Subscription;
monitoredItem.Subscription.RemoveItem(monitoredItem);
removeSubscription.ApplyChanges();
}
}
return true;
}
public static bool Contains(Subscription subscription, MonitoredItem monitoredItem)
{
foreach (MonitoredItem item in subscription.MonitoredItems)
{
if (item.StartNodeId == monitoredItem.StartNodeId)
{
return true;
}
}
return false;
}
}
}
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
