Services

// Read multiple values
var results = await client.ReadAsync(new[]
{
    new ReadValueId { NodeId = new NodeId(0, 2258), AttributeId = AttributeIds.Value },
    new ReadValueId { NodeId = new NodeId(0, 2259), AttributeId = AttributeIds.Value }
});

// Write a value
var statusCodes = await client.WriteAsync(new[]
{
    new WriteValue
    {
        NodeId = new NodeId(2, "MyVar"),
        AttributeId = AttributeIds.Value,
        Value = new DataValue(new Variant(42))
    }
});

// Browse children of the Objects folder
var browseResults = await client.BrowseAsync(new[]
{
    new BrowseDescription
    {
        NodeId = ObjectIds.ObjectsFolder,
        BrowseDirection = BrowseDirection.Forward,
        ReferenceTypeId = ReferenceTypeIds.HierarchicalReferences,
        IncludeSubtypes = true,
        ResultMask = (uint)BrowseResultMask.All
    }
});

foreach (var reference in browseResults[0].References)
{
    Console.WriteLine($"{reference.DisplayName} ({reference.NodeId})");
}

// Limit references per node (useful for large address spaces)
var pagedResults = await client.BrowseAsync(new[]
{
    new BrowseDescription
    {
        NodeId = ObjectIds.ObjectsFolder,
        BrowseDirection = BrowseDirection.Forward
    }
}, requestedMaxReferencesPerNode: 100);

// Batch API — takes BrowsePath[]
var results = await client.TranslateBrowsePathsToNodeIdsAsync(new[]
{
    new BrowsePath
    {
        StartingNode = ObjectIds.ObjectsFolder,
        RelativePath = RelativePath.Parse("Server/ServerStatus/CurrentTime")
    }
});

// Convenience API — single path
var result = await client.TranslateBrowsePathAsync(
    ObjectIds.ObjectsFolder,
    "Server/ServerStatus/CurrentTime");

var results = await client.CallAsync(new[]
{
    new CallMethodRequest
    {
        ObjectId = new NodeId(2, "MyObject"),
        MethodId = new NodeId(2, "MyMethod"),
        InputArguments = new Variant[] { new Variant(42), new Variant("hello") }
    }
});

// Create a subscription
var subscription = await client.CreateSubscriptionAsync(
    publishingInterval: 1000,
    lifetimeCount: 60,
    maxKeepAliveCount: 10);

// Delete subscriptions
var statusCodes = await client.DeleteSubscriptionsAsync(
    new[] { subscription.SubscriptionId });

// Create monitored items
var items = await client.CreateMonitoredItemsAsync(
    subscription.SubscriptionId,
    new[]
    {
        new MonitoredItemCreateRequest
        {
            ItemToMonitor = new ReadValueId
            {
                NodeId = new NodeId(0, 2258),
                AttributeId = AttributeIds.Value
            },
            MonitoringMode = MonitoringMode.Reporting,
            RequestedParameters = new MonitoringParameters
            {
                SamplingInterval = 500,
                QueueSize = 10,
                DiscardOldest = true
            }
        }
    });

// Handle data changes
client.DataChanged += (sender, args) =>
{
    Console.WriteLine($"Node {args.NodeId}: {args.Value}");
};

// Modify monitored items at runtime
var modifyResults = await client.ModifyMonitoredItemsAsync(
    subscription.SubscriptionId,
    new[]
    {
        new MonitoredItemModifyRequest
        {
            MonitoredItemId = items[0].MonitoredItemId,
            RequestedParameters = new MonitoringParameters
            {
                SamplingInterval = 100
            }
        }
    });

// Delete monitored items
var deleteResults = await client.DeleteMonitoredItemsAsync(
    subscription.SubscriptionId,
    new[] { items[0].MonitoredItemId });

// Get available endpoints
var endpoints = await client.GetEndpointsAsync();
foreach (var ep in endpoints)
{
    Console.WriteLine($"{ep.EndpointUrl} — {ep.SecurityPolicyUri} [{ep.SecurityMode}]");
}