h-opc-net 1.0.0.105

h-opc-net

An Opc Library and a command line to perform OPC operations with ease and transparency among different protocols. Currently supports synchronous operation over UA and DA protocols. This fork targets modern .NET (net8.0/net9.0/net10.0) and is actively maintained.

Table of Contents

• Use
• Documentation
  • Exploring the nodes
  • Read a node
  • Writing to a node
  • Monitoring a tag
  • Go Asynchronous!
• Command line
• What's new in 1.0.0.105
• Disclaimer
• Roadmap

Use

To install h-opc-net, run the following command in the Package Manager Console:

PM> Install-Package h-opc-net

To install the command line interface, head to the nuget gallery.

Documentation

to use the UA Client simply...

using (var client = new UaClient(new Uri("opc.tcp://host-url")))
{
  client.Connect();
  // Use `client` here
}

or with options...

var options = new UaClientOptions {
  UserIdentity = new Opc.Ua.UserIdentity("<your-username>", "<your-password>")
};
using (var client = new UaClient(new Uri("opc.tcp://host-url")), options)
{
  client.Connect();
  // Use `client` here
}

and to use the DA Client instead:

using (var client = new DaClient(new Uri("opcda://host-url")))
{
  client.Connect();
  // Use `client` here
}

Exploring the nodes

You can get a reference to a node with...

var node = client.FindNode("path.to.my.node");

This will get you a reference to the node node in the folder path.to.my.

You can use the node reference to explore the hieriarchy of nodes with the properties Parent and SubNodes. For example...

Node parentNode = node.Parent;
IEnumerable<Node> children = client.ExploreFolder(node.Tag);
IENumerable<Node> grandChildren = children.SelectMany(m => client.ExploreFolder(m.Tag));

Read a node

Reading a variable? As simple as...

var myString = client.Read<string>("path.to.string").Value;
var myInt = client.Read<int>("path.to.num").Value;

The example above will read a string from the tags string and num in the folder path.to

Writing to a node

To write a value just...

client.Write("path.to.string", "My new value");
client.Write("path.to.num", 42);

Monitoring a tag

Dead-simple monitoring:

client.Monitor<string>("path.to.string", (readEvent, unsubscribe) =>
{
  DoSomethingWithYourValue(readEvent.Value);
  if(ThatsEnough == true)
    unsubscribe();
});

The second parameter is an Action<T, Action> that has two parameter:

• readEvent contains all the information relevant to the event such as timestamps, quality and the value
• unsubscribe is a function that unsubscribes the current monitored item. It's very handy when you want to terminate your callback

it's important that you either enclose the client into a using statement or call Dispose() when you are finished, to unsubscribe all the monitored items and terminate the connection!

Go Asynchronous!

Each method as an asynchornous counterpart that can be used with the async/await syntax. The asynchronous syntax is recommended over the synchronous one (maybe the synchronous one will be deprecated one day).

Command line

You can also use the command line interface project to quickly test your an OPC. Build the h-opc-cli project or download it from the release page of this repository, then run:

h-opc-cli.exe [OpcType] [server-url]

Where OpcType is the type of opc to use (e.g: "UA", "DA"). Once the project is running, you can use the internal command to manipulate the variable. To have more information aboute the internal commands, type help or ?

What's new in 1.0.0.105

• Modern async OPC UA stack: all OPC Foundation client APIs have been migrated from the obsolete synchronous/Begin-End set (Session.Read/Write/Browse, BeginRead/EndRead, Subscription.Create/Delete, Session.Create/Recreate, DiscoveryClient.Create/GetEndpoints, NodeCache.Find, parameterless telemetry ctors) to the supported Task-based set (ReadAsync/WriteAsync/BrowseAsync/CloseAsync/CreateAsync/RecreateAsync, telemetry-aware constructors). The library now compiles with zero obsolete-API warnings, which keeps it buildable against future OPC Foundation releases that remove the legacy APIs.
• The public API surface of UaClient/DaClient is unchanged: synchronous methods still exist and now wrap the async calls with deadlock-safe bridging (AsyncHelpers.RunSync), so existing code keeps working without changes. ReadAsync/WriteAsync now use the native task-based calls instead of hand-rolled TaskCompletionSource + Begin/End plumbing.
• ReConnect/RecreateSession now go through the session factory's RecreateAsync, the supported replacement for the removed Session.Reconnect/Session.Recreate methods.
• Bug fixes carried from 1.0.0.104.x maintenance: Monitor overload infinite recursion (StackOverflow), clear OpcException instead of NullReferenceException when reading unreadable/bad-quality tags into value types, correct GetDataType mapping for Float/String and other built-in types, thread-safe DA node cache, DA monitor subscriptions cleaned up on Dispose (no more server-side leaks), configurable DA MonitorInterval, per-entry folder cache expiry, hardened Dispose for both clients, CLI EOF handling and float/string writes.
• Restored and modernized the test suite (NUnit 4): offline unit tests plus UA/DA integration tests with environment-overridable endpoints; 55/55 tests pass, including integration tests against a live OPC UA demo server.

Disclaimer

This fork is maintained by XiaoyuvaX; the original project is hylasoft/h-opc by Hylasoft. OPC UA and DA connectivity is provided by the OPC Foundation .NET Standard stack and Quick.OpcNetApi.

Roadmap

• ...