OPC Studio User's Guide and Reference
OneDimension(Int32) Method
Example 



OpcLabs.EasyOpcUA Assembly > OpcLabs.EasyOpc.UA Namespace > UAIndexRangeList Class > OneDimension Method : OneDimension(Int32) Method
A value for range's minimum and maximum.
Creates a one dimensional index range list containing a single value.
Syntax
'Declaration
 
<ElementsNotNullAttribute()>
<NotNullAttribute()>
Public Overloads Shared Function OneDimension( _
   ByVal single As Integer _
) As UAIndexRangeList
'Usage
 
Dim single As Integer
Dim value As UAIndexRangeList
 
value = UAIndexRangeList.OneDimension(single)
[ElementsNotNull()]
[NotNull()]
public static UAIndexRangeList OneDimension( 
   int single
)
[ElementsNotNull()]
[NotNull()]
public:
static UAIndexRangeList^ OneDimension( 
   int single
) 

Parameters

single
A value for range's minimum and maximum.

Return Value

Returns the created index range list.
Exceptions
ExceptionDescription

The value of an argument is outside the allowable range of values as defined by the invoked method.

This is a usage error, i.e. it will never occur (the exception will not be thrown) in a correctly written program. Your code should not catch this exception.

Example

.NET

COM

.NET

.NET

// This example shows how to read a range of values from an array.
//
// Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

using System;
using OpcLabs.EasyOpc.UA;
using OpcLabs.EasyOpc.UA.OperationModel;

namespace UADocExamples._UAIndexRangeList
{
    partial class Usage
    {
        public static void ReadValue()
        {
            UAEndpointDescriptor endpointDescriptor =
                "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";
            // or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            // or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            // Instantiate the client object
            var client = new EasyUAClient();

            // Obtain the value, indicating that just the elements 2 to 4 should be returned
            object value;
            try
            {
                value = client.ReadValue(
                    new UAReadArguments(
                        endpointDescriptor,
                        "nsu=http://test.org/UA/Data/ ;ns=2;i=10305",   // /Data.Static.Array.Int32Value
                        UAIndexRangeList.OneDimension(2, 4)));
            }
            catch (UAException uaException)
            {
                Console.WriteLine("*** Failure: {0}", uaException.GetBaseException().Message);
                return;
            }

            // Cast to typed array
            var arrayValue = (Int32[]) value;

            // Display results
            for (int i = 0; i < 3; i++)
                Console.WriteLine("arrayValue[{0}]: {1}", i, arrayValue[i]);


            // Example output:
            //arrayValue[0]: 180410224
            //arrayValue[1]: 1919239969
            //arrayValue[2]: 1700185172
        }
    }
}
# This example shows how to read a range of values from an array.
#
# Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
# OPC client and subscriber examples in Python on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-Python .
# The QuickOPC package is needed. Install it using "pip install opclabs_quickopc".
import opclabs_quickopc

# Import .NET namespaces.
from OpcLabs.EasyOpc.UA import *
from OpcLabs.EasyOpc.UA.OperationModel import *


endpointDescriptor = UAEndpointDescriptor('opc.tcp://opcua.demo-this.com:51210/UA/SampleServer')
# or 'http://opcua.demo-this.com:51211/UA/SampleServer' (currently not supported)
# or 'https://opcua.demo-this.com:51212/UA/SampleServer/'

# Instantiate the client object.
client = EasyUAClient()

# Obtain the value, indicating that just the elements 2 to 4 should be returned
try:
    arrayValue = IEasyUAClientExtension.ReadValue(client,
                                                  endpointDescriptor,
                                                  UANodeDescriptor('nsu=http://test.org/UA/Data/ ;ns=2;i=10305'),    # /Data.Static.Array.Int32Value
                                                  UAIndexRangeList.OneDimension(2, 4))
except UAException as uaException:
    print('*** Failure: ' + uaException.GetBaseException().Message)
    exit()

# Display results.
for i, elementValue in enumerate(arrayValue):
    print('arrayValue[', i, ']: ', elementValue, sep='')

print()
print('Finished.')
' This example shows how to read a range of values from an array.
'
' Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

Imports OpcLabs.EasyOpc.UA
Imports OpcLabs.EasyOpc.UA.OperationModel

Namespace _UAIndexRangeList
    Friend Class Usage
        Public Shared Sub ReadValue()

            Dim endpointDescriptor As UAEndpointDescriptor =
                    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
            ' or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            ' or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            ' Instantiate the client object
            Dim client = New EasyUAClient()

            ' Obtain the value, indicating that just the elements 2 to 4 should be returned
            Dim value As Object
            Try
                value = client.ReadValue( _
                    New UAReadArguments( _
                        endpointDescriptor, _
                        "nsu=http://test.org/UA/Data/ ;i=10305", _
                        UAIndexRangeList.OneDimension(2, 4)))
                ' or "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
            Catch uaException As UAException
                Console.WriteLine("*** Failure: {0}", uaException.GetBaseException.Message)
                Exit Sub
            End Try

            ' Cast to typed array
            Dim arrayValue = DirectCast(value, Int32())

            ' Display results
            For i = 0 To 2
                Console.WriteLine("arrayValue[{0}]: {1}", i, arrayValue(i))
            Next
        End Sub
    End Class
End Namespace
// This example shows how to read a range of values from an array.
//
// Find all latest examples here : https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

class procedure Usage.ReadValue;
var
  Client: _EasyUAClient;
  EndpointDescriptor: string;
  ReadArguments1: _UAReadArguments;
  Arguments, Results: OleVariant;
  I: Cardinal;
  IndexRange: _UAIndexRange;
  IndexRangeList: OpcLabs_EasyOpcUA_TLB._UAIndexRangeList;
  ArrayValue: OleVariant;
  Value: Integer;
  ValueResult: _ValueResult;
begin
  EndpointDescriptor := 
    //'http://opcua.demo-this.com:51211/UA/SampleServer';
    //'https://opcua.demo-this.com:51212/UA/SampleServer/';
    'opc.tcp://opcua.demo-this.com:51210/UA/SampleServer';

  // Instantiate the client object
  Client := CoEasyUAClient.Create;

  // Prepare the arguments, indicating that just the elements 2 to 4 should be returned.
  IndexRangeList := CoUAIndexRangeList.Create;
  IndexRange := CoUAIndexRange.Create;
  IndexRange.Minimum := 2;
  IndexRange.Maximum := 4;
  IndexRangeList.Add(IndexRange);

  ReadArguments1 := CoUAReadArguments.Create;
  ReadArguments1.EndpointDescriptor.UrlString := EndpointDescriptor;
  ReadArguments1.NodeDescriptor.NodeId.ExpandedText := 'nsu=http://test.org/UA/Data/ ;ns=2;i=10305';
  ReadArguments1.IndexRangeList := IndexRangeList;

  Arguments := VarArrayCreate([0, 0], varVariant);
  Arguments[0] := ReadArguments1;

  // Obtain value.
  TVarData(Results).VType := varArray or varVariant;
  TVarData(Results).VArray := PVarArray(Client.ReadMultipleValues(Arguments));

  ValueResult := IInterface(Results[0]) as _ValueResult;
  if not ValueResult.Succeeded then
    begin
      WriteLn(' *** Failure: ', ValueResult.Exception.GetBaseException.Message);
      Exit;
    end;

  // Display results
  ArrayValue := ValueResult.Value;
  for I := VarArrayLowBound(ArrayValue, 1) to VarArrayHighBound(ArrayValue, 1) do
  begin
      Value := ArrayValue[I];
      WriteLn('arrayValue[', I, ']: ', Value);
  end;

  VarClear(Results);
  VarClear(Arguments);

  // Example output:
  //arrayValue[0]: 180410224
  //arrayValue[1]: 1919239969
  //arrayValue[2]: 1700185172
end;
// This example shows how to read a range of values from an array.
//
// Find all latest examples here : https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

$EndpointDescriptor = 
    //"http://opcua.demo-this.com:51211/UA/SampleServer";
    //"https://opcua.demo-this.com:51212/UA/SampleServer/";
    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";

// Instantiate the client object
$Client = new COM("OpcLabs.EasyOpc.UA.EasyUAClient");

// Prepare the arguments, indicating that just the elements 2 to 4 should be returned.
$IndexRangeList = new COM("OpcLabs.EasyOpc.UA.UAIndexRangeList");
$IndexRange = new COM("OpcLabs.EasyOpc.UA.UAIndexRange");
$IndexRange->Minimum = 2;
$IndexRange->Maximum = 4;
$IndexRangeList->Add($IndexRange);

$ReadArguments1 = new COM("OpcLabs.EasyOpc.UA.OperationModel.UAReadArguments");
$ReadArguments1->EndpointDescriptor->UrlString = $EndpointDescriptor;
$ReadArguments1->NodeDescriptor->NodeId->ExpandedText = "nsu=http://test.org/UA/Data/ ;ns=2;i=10305";
$ReadArguments1->IndexRangeList = $IndexRangeList;

$arguments[0] = $ReadArguments1;

// Obtain value.
$results = $Client->ReadMultipleValues($arguments);

$ValueResult = $results[0];

if (!$ValueResult->Succeeded) {
    printf("*** Failure: %s\n", $ValueResult->ErrorMessageBrief);
    Exit();
}

// Display results
$ArrayValue = $ValueResult->Value;
for ($i = 0; $i <= 2; $i++)
{
    printf("arrayValue[d]s\n", $i, $ArrayValue[$i]);
}

// Example output:
//arrayValue[0]: 180410224
//arrayValue[1]: 1919239969
//arrayValue[2]: 1700185172
REM This example shows how to read a range of values from an array.
REM
REM Find all latest examples here : https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

Private Sub Usage_ReadValue_Command_Click()
    OutputText = ""
    
    Dim endpointDescriptor As String
    'endpointDescriptor = "http://opcua.demo-this.com:51211/UA/SampleServer"
    'endpointDescriptor = "https://opcua.demo-this.com:51212/UA/SampleServer/"
    endpointDescriptor = "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"

    ' Instantiate the client object
    Dim Client As New EasyUAClient

    ' Prepare the arguments, indicating that just the elements 2 to 4 should be returned.
    Dim indexRangeList As New UAIndexRangeList
    Dim indexRange As New UAIndexRange
    indexRange.Minimum = 2
    indexRange.Maximum = 4
    indexRangeList.Add indexRange
    
    Dim readArguments1 As New UAReadArguments
    readArguments1.endpointDescriptor.UrlString = endpointDescriptor
    readArguments1.NodeDescriptor.NodeId.expandedText = "nsu=http://test.org/UA/Data/ ;ns=2;i=10305"
    Set readArguments1.indexRangeList = indexRangeList

    Dim arguments(0) As Variant
    Set arguments(0) = readArguments1

    ' Obtain value.
    Dim results() As Variant
    results = Client.ReadMultipleValues(arguments)

    Dim valueResult As valueResult
    Set valueResult = results(0)
    If Not valueResult.Succeeded Then
        OutputText = OutputText & "*** Failure: " & valueResult.Exception.GetBaseException.Message & vbCrLf
        Exit Sub
    End If
    
    ' Display results
    Dim arrayValue() As Long
    arrayValue = valueResult.value
    
    Dim i: For i = LBound(arrayValue) To UBound(arrayValue)
        OutputText = OutputText & "arrayValue(" & i & "):" & arrayValue(i) & vbCrLf
    Next

    ' Example output:
    'arrayValue(0): 180410224
    'arrayValue(1): 1919239969
    'arrayValue(2): 1700185172
End Sub
Rem This example shows how to read a range of values from an array.
Rem
Rem Find all latest examples here : https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

Option Explicit

Dim endpointDescriptor: endpointDescriptor = _
    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
    '"http://opcua.demo-this.com:51211/UA/SampleServer"  
    '"https://opcua.demo-this.com:51212/UA/SampleServer/"

' Instantiate the client object
Dim Client: Set Client = CreateObject("OpcLabs.EasyOpc.UA.EasyUAClient")

' Prepare the arguments, indicating that just the elements 2 to 4 should be returned.
Dim IndexRangeList: Set IndexRangeList = CreateObject("OpcLabs.EasyOpc.UA.UAIndexRangeList")
Dim IndexRange: Set IndexRange = CreateObject("OpcLabs.EasyOpc.UA.UAIndexRange")
IndexRange.Minimum = 2
IndexRange.Maximum = 4
IndexRangeList.Add IndexRange
'
Dim ReadArguments1: Set ReadArguments1 = CreateObject("OpcLabs.EasyOpc.UA.OperationModel.UAReadArguments")
ReadArguments1.EndpointDescriptor.UrlString = endpointDescriptor
ReadArguments1.NodeDescriptor.NodeId.ExpandedText = "nsu=http://test.org/UA/Data/ ;ns=2;i=10305"
ReadArguments1.IndexRangeList = IndexRangeList

Dim arguments(0)
Set arguments(0) = ReadArguments1

' Obtain the value.
Dim results: results = Client.ReadMultipleValues(arguments)
Dim ValueResult: Set ValueResult = results(0)
If Not ValueResult.Succeeded Then
    WScript.Echo "*** Failure: " & ValueResult.Exception.GetBaseException().Message
    WScript.Quit
End If
' VBScript can only handle well arrays of VARIANTs; most other COM tool will be able to use simply the .Value property.
Dim arrayValue: arrayValue = ValueResult.RegularizedValue

' Display results
Dim i: For i = 0 To 2
    WScript.Echo "arrayValue[" & i & "]: " & arrayValue(i)
Next


' Example output:
'arrayValue[0]: 180410224
'arrayValue[1]: 1919239969
'arrayValue[2]: 1700185172
// This example shows how to subscribe to range of values from an array.
//
// Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

using System;
using OpcLabs.EasyOpc.UA;
using OpcLabs.EasyOpc.UA.OperationModel;

namespace UADocExamples._UAIndexRangeList
{
    partial class Usage
    {
        public static void Subscribe()
        {
            UAEndpointDescriptor endpointDescriptor =
                "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";
            // or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            // or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            // Instantiate the client object
            var client = new EasyUAClient();

            Console.WriteLine("Subscribing to range...");
            var attributeArguments = new UAAttributeArguments(endpointDescriptor, "nsu=http://test.org/UA/Data/ ;i=10933")
                {
                    IndexRangeList = UAIndexRangeList.OneDimension(2, 4)
                };
            var monitoredItemArguments = new UAMonitoredItemArguments(attributeArguments, monitoringParameters:1000);
            // The callback is a lambda expression the displays the value
            client.SubscribeMonitoredItem(monitoredItemArguments,
                (sender, eventArgs) =>
                {
                    if (eventArgs.Succeeded)
                    {
                        var arrayValue = eventArgs.AttributeData.Value as Int32[];
                        if (!(arrayValue is null))
                            Console.WriteLine($"Value: {{{String.Join(",", arrayValue)}}}");
                    }
                    else
                        Console.WriteLine($"*** Failure: {eventArgs.ErrorMessageBrief}");
                });

            Console.WriteLine("Processing data change events for 10 seconds...");
            System.Threading.Thread.Sleep(10 * 1000);

            Console.WriteLine("Unsubscribing...");
            client.UnsubscribeAllMonitoredItems();

            Console.WriteLine("Waiting for 2 seconds...");
            System.Threading.Thread.Sleep(2 * 1000);
        }
    }
}
# This example shows how to subscribe to range of values from an array.
#
# Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
# OPC client and subscriber examples in Python on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-Python .
# The QuickOPC package is needed. Install it using "pip install opclabs_quickopc".
import opclabs_quickopc
import time

# Import .NET namespaces.
from OpcLabs.EasyOpc.UA import *
from OpcLabs.EasyOpc.UA.OperationModel import *


def dataChangeNotification(sender, eventArgs):
    # Display value.
    if eventArgs.Succeeded:
        arrayValue = eventArgs.AttributeData.Value
        print('Value: {', ", ".join(["{}"]*len(arrayValue)).format(*arrayValue), '}', sep='')
    else:
        print('*** Failure: ', eventArgs.ErrorMessageBrief, sep='')


endpointDescriptor = UAEndpointDescriptor('opc.tcp://opcua.demo-this.com:51210/UA/SampleServer')
# or 'http://opcua.demo-this.com:51211/UA/SampleServer' (currently not supported)
# or 'https://opcua.demo-this.com:51212/UA/SampleServer/'

# Instantiate the client object.
client = EasyUAClient()

print('Subscribing to range...')
attributeArguments = UAAttributeArguments(endpointDescriptor, UANodeDescriptor('nsu=http://test.org/UA/Data/ ;i=10933'))
attributeArguments.IndexRangeList = UAIndexRangeList.OneDimension(2, 4)
monitoredItemArguments = UAMonitoredItemArguments(attributeArguments, UAMonitoringParameters(1000))
IEasyUAClientExtension.SubscribeMonitoredItem(client,
    monitoredItemArguments,
    EasyUADataChangeNotificationEventHandler(dataChangeNotification))

print('Processing data change events for 10 seconds...')
time.sleep(10)

print('Unsubscribing...')
client.UnsubscribeAllMonitoredItems()

print('Waiting for 2 seconds...')
time.sleep(2)

print('Finished.')
' This example shows how to subscribe to range of values from an array.
'
' Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

Imports Opc.Ua
Imports OpcLabs.EasyOpc.UA
Imports OpcLabs.EasyOpc.UA.OperationModel

Namespace _UAIndexRangeList
    Partial Friend Class Usage
        Public Shared Sub Subscribe()

            ' Define which server we will work with.
            Dim endpointDescriptor As UAEndpointDescriptor =
                    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
            ' or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            ' or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            ' Instantiate the client object
            Dim client = New EasyUAClient()

            Console.WriteLine("Subscribing to range...")
            Dim attributeArguments = New UAAttributeArguments(endpointDescriptor, "nsu=http://test.org/UA/Data/ ;i=10933") With
                {
                    .IndexRangeList = UAIndexRangeList.OneDimension(2, 4)
                }
            Dim monitoredItemArguments = New UAMonitoredItemArguments(attributeArguments, monitoringParameters:=1000)
            ' The callback is a lambda expression the displays the value
            client.SubscribeMonitoredItem(monitoredItemArguments,
                Sub(sender, eventArgs)
                    If eventArgs.Succeeded Then
                        Dim arrayValue = CType(eventArgs.AttributeData.Value, Int32())
                        If (arrayValue IsNot Nothing) Then
                            Console.WriteLine($"Value: {{{String.Join(",", arrayValue)}}}")
                        End If
                    Else
                        Console.WriteLine("*** Failure: {0}", eventArgs.ErrorMessageBrief)
                    End If
                End Sub)

            Console.WriteLine("Processing data change events for 10 seconds...")
            Threading.Thread.Sleep(10 * 1000)

            Console.WriteLine("Unsubscribing...")
            client.UnsubscribeAllMonitoredItems()

            Console.WriteLine("Waiting for 2 seconds...")
            Threading.Thread.Sleep(2 * 1000)
        End Sub
    End Class
End Namespace
// Shows how to create an observable for a range of OPC UA array elements, and subscribe to it.
//
// Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

using OpcLabs.EasyOpc.UA.Reactive;
using System;
using System.Threading;
using OpcLabs.EasyOpc.UA;
using OpcLabs.EasyOpc.UA.OperationModel;

namespace ReactiveDocExamples
{
    namespace _UADataChangeNotificationObservable
    {
        partial class Subscribe
        {
            public static void IndexRangeList()
            {
                // Define which server we will work with.
                UAEndpointDescriptor endpointDescriptor =
                    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";
                // or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
                // or "https://opcua.demo-this.com:51212/UA/SampleServer/"

                Console.WriteLine("Creating observable...");
                var attributeArguments = new UAAttributeArguments(endpointDescriptor, "nsu=http://test.org/UA/Data/ ;i=10933")
                {
                    IndexRangeList = UAIndexRangeList.OneDimension(2, 4)
                };
                var monitoredItemArguments = new UAMonitoredItemArguments(attributeArguments, monitoringParameters: 1000);
                UADataChangeNotificationObservable<Int32[]> observable =
                    UADataChangeNotificationObservable.Create<Int32[]>(monitoredItemArguments);

                Console.WriteLine("Subscribing...");
                using (observable.Subscribe(e => Console.WriteLine(
                    (e.Exception is null) ? e.AttributeData.ToString() : e.Exception.GetBaseException().ToString())))
                {
                    Console.WriteLine("Waiting for 10 seconds...");
                    Thread.Sleep(10*1000);

                    Console.WriteLine("Unsubscribing...");
                }

                Console.WriteLine("Waiting for 2 seconds...");
                Thread.Sleep(2 * 1000);
            }
        }
    }
}
Requirements

Target Platforms: .NET Framework: Windows 10 (selected versions), Windows 11 (selected versions), Windows Server 2016, Windows Server 2022; .NET: Linux, macOS, Microsoft Windows

See Also