关于OPC UA Helper 命名空间中的OpcUaClient 类中的订阅函数的更改

原函数是opcUaClient.MonitorValue("ns=4;s=MAIN.d", new Action<double, Action>(MonitorTestValueFloat));

由于订阅函的的回调函的类型是

public void MonitorValue<T>(string tag, Action<T, Action> callback);
所以返回的函数参数中只有数值，所以在实际应用中是不够的，另外多个订阅就要加多个回调函数处理。为此需要更改为
 private void MonitorTestValueFloat(object clientHandle, DataValue value)
操作步骤如下：
先继承OpcUaHelper.OpcUaClient 后添加订阅方法 具体代码如下

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Opc.Ua;
using Opc.Ua.Client;
namespace 组态
{
/// <summary>
/// 值变化委托函数
/// </summary>
/// <param name="clientHandle">客户处理事件</param>
/// <param name="value">变化的值</param>
public delegate void valueChanged(object clientHandle, DataValue value);
class MyOpcUa:OpcUaHelper.OpcUaClient
{
/// <summary>
/// OPCUA服务器订阅
/// </summary>
private Subscription m_Subscription;

/// <summary>
/// 添加处理函数
/// </summary>
public void addNotificationHandle(int publishingInterval)
{
try
{
Opc.Ua.Client.Subscription innerSubscription = new Opc.Ua.Client.Subscription(this.Session.DefaultSubscription);

innerSubscription.DisplayName = "My Subscription Name";
innerSubscription.PublishingEnabled = true;
innerSubscription.PublishingInterval = publishingInterval; // in milliseconds.
innerSubscription.KeepAliveCount = 10; // 10*UaRefreshRate = 5s if UaRefreshRate = 500
innerSubscription.LifetimeCount = 100; // UaRefreshRate*100 = 50s if UaRefreshRate = 500;
innerSubscription.MaxNotificationsPerPublish = 100;

//将订阅与会话关联起来
this.Session.AddSubscription(innerSubscription);

// Call the server and create the subscription.
//调用服务器并创建订阅。
innerSubscription.Create();

// At this point the subscription is sending publish requests at the keep alive rate.
// Use the Notification event the session to receive updates when a publish completes.
//此时，订阅将以保持活跃的速率发送发布请求。
//使用通知事件会话在发布完成时接收更新。
this.Session.Notification += new NotificationEventHandler(Session_Notification);

m_Subscription = innerSubscription;
//m_Subscription.Session = m_Session;
//newSubscription.innerSubscription = innerSubscription;
}
catch (Exception e)
{
throw e;
}
this.Session.Notification += Session_Notification;
}
/// <summary>
/// 添加订阅函数
/// </summary>
/// <param name="variableNodeId">节点ID</param>
/// <param name="clientHandle">客户端对象</param>
/// <param name="callback">回调函数</param>
/// <param name="samplingRate">采样时间.</param>
/// <param name="serverHandle">服务处理</param>
public void AddDataMonitoredItem(NodeId variableNodeId, object clientHandle, valueChanged callback, uint samplingRate, out object serverHandle)
{
serverHandle = null;

try
{
if (m_Subscription==null)
{
m_Subscription = new Subscription();
//m_Subscription.Session = m_Session;
}
MonitoredItem monitoredItem = (m_Subscription.DefaultItem);
ClientMonitoredItemData clientData = new ClientMonitoredItemData();
clientData.callback = callback;
clientData.clientHandle = clientHandle;

// Monitored item settings:
monitoredItem.StartNodeId = variableNodeId;
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.MonitoringMode = MonitoringMode.Reporting;
monitoredItem.SamplingInterval = (int)samplingRate; // Affects the read cycle between UA Server and data source
monitoredItem.QueueSize = 1;
monitoredItem.DiscardOldest = false;
monitoredItem.Handle = clientData;

// Add item to subscription.
m_Subscription.AddItem(monitoredItem);

// Call the server and apply any changes to the state of the subscription or monitored items.
m_Subscription.ApplyChanges();

// Check result of add.
if (monitoredItem.Status.Error != null && StatusCode.IsBad(monitoredItem.Status.Error.StatusCode))
{
throw ServiceResultException.Create(
monitoredItem.Status.Error.StatusCode.Code,
"Creation of data monitored item failed");
}

serverHandle = monitoredItem;
}
catch (Exception e)
{
throw e;
}
}

/// <summary>
/// 当服务器发布数据时，响应从到达时，就会执行函数。
/// </summary>
/// <param name="session">The target of the event.</param>
/// <param name="e">The <see cref="Opc.Ua.Client.NotifacationEventArgs"/>Instance containing the event data.</param>
private void Session_Notification(Session session, NotificationEventArgs e)
{
NotificationMessage message = e.NotificationMessage;

// Check for keep alive.
if (message.NotificationData.Count == 0)
{
return;
}

// Get the data changes (oldest to newest).
foreach (MonitoredItemNotification datachange in message.GetDataChanges(false))
{
// Lookup the monitored item.
MonitoredItem monitoredItem = e.Subscription.FindItemByClientHandle(datachange.ClientHandle);

if (monitoredItem == null)
{
continue;
}

ClientMonitoredItemData clientData = monitoredItem.Handle as ClientMonitoredItemData;

clientData.callback(clientData.clientHandle, datachange.Value);
}
}
}
/// <summary>
/// 客户端监控项数据
/// </summary>
public class ClientMonitoredItemData
{
/// <summary>
/// 客户端处理对象
/// </summary>
public object clientHandle = null;
/// <summary>
/// 变化值
/// </summary>
public valueChanged callback = null;
}
}

调用方法

MyOpcUa opcUaClient = new MyOpcUa();
opcUaClient.ConnectServer("opc.tcp://localhost:4840");
opcUaClient.addNotificationHandle(1000);
object sobj = null;
//opcUaClient.MonitorValue("ns=4;s=MAIN.d", new Action<double, Action>(MonitorTestValueFloat));
opcUaClient.AddDataMonitoredItem("ns=4;s=MAIN.d", null, MonitorTestValueFloat, 1000, out sobj);

//回调处理函数

//clientHandle:用户对象，

//value:数据值

private void MonitorTestValueFloat(object clientHandle, DataValue value)
{
object objv = value.Value;
}