PluginSetups Property (ComponentParameters)

Setups of plug-ins for the client object instance.

Syntax

Visual Basic
C#
C++/CLI

'Declaration
 
Public Property PluginSetups As PluginSetupCollection

'Usage
 
Dim instance As ComponentParameters
Dim value As PluginSetupCollection
 
instance.PluginSetups = value
 
value = instance.PluginSetups

public PluginSetupCollection PluginSetups {get; set;}

public:
property PluginSetupCollection^ PluginSetups {
   PluginSetupCollection^ get();
   void set (    PluginSetupCollection^ value);
}

Example

.NET

COM

CSharp
Python
VB.NET

// Shows how to disable and enable the OPC UA Complex Data plug-in.
//
// 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.ComplexData._PluginSetup
{
    class Enabled
    {
        public static void Main1()
        {
            // Define which server and node 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/"
            UANodeDescriptor nodeDescriptor =
                "nsu=http://test.org/UA/Data/ ;i=10239"; // [ObjectsFolder]/Data.Static.Scalar.StructureValue


            // We will explicitly disable the Complex Data plug-in, and read a node which returns complex data. We will 
            // receive an object of type UAExtensionObject, which contains the encoded data in its binary form. In this 
            // form, the data cannot be easily further processed by your application.
            //
            // Disabling the Complex Data plug-in may be useful e.g. for licensing reasons (when the product edition you 
            // have does not support the Complex Data plug-in, and you want to avoid the associated error), or for
            // performance reasons (if you do not need the internal content of the value, for example if your code just
            // needs to take the value read, and write it elsewhere).

            var client1 = new EasyUAClient();
            client1.InstanceParameters.PluginSetups.FindName("UAComplexDataClient").Enabled = false;

            object value1;
            try
            {
                value1 = client1.ReadValue(endpointDescriptor, nodeDescriptor);
            }
            catch (UAException uaException)
            {
                Console.WriteLine("*** Failure: {0}", uaException.GetBaseException().Message);
                return;
            }
            Console.WriteLine(value1);


            // Now we will read the same value, but with the Complex Data plug-in enabled. This time we will receive an
            // object of type UAGenericObject, which contains the data in the decoded form, accessible for further 
            // processing by your application.
            //
            // Note that it is not necessary to explicitly enable the Complex Data plug-in like this, because it is enabled
            // by default.

            var client2 = new EasyUAClient();
            client2.InstanceParameters.PluginSetups.FindName("UAComplexDataClient").Enabled = true;

            object value2 = client2.ReadValue(endpointDescriptor, nodeDescriptor);
            Console.WriteLine(value2);


            // Example output:
            //
            // Binary Byte[1373]; {nsu=http://test.org/UA/Data/ ;i=11437}
            // (ScalarValueDataType) structured

            // On the first line, the type and length of the encoded data is shown, and the node ID is the encoding ID.
            // On the 2nd line, the kind (structured) and the name of the complex data type (ScalarValueDataType) is shown.
        }
    }
}

# Shows how to disable and enable the OPC UA Complex Data plug-in.
#
# 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/'

# [ObjectsFolder]/Data.Static.Scalar.StructureValue
nodeDescriptor = UANodeDescriptor('nsu=http://test.org/UA/Data/ ;i=10239')


# We will explicitly disable the Complex Data plug-in, and read a node which returns complex data. We will
# receive an object of type UAExtensionObject, which contains the encoded data in its binary form. In this
# form, the data cannot be easily further processed by your application.
#
# Disabling the Complex Data plug-in may be useful e.g. for licensing reasons (when the product edition you
# have does not support the Complex Data plug-in, and you want to avoid the associated error), or for
# performance reasons (if you do not need the internal content of the value, for example if your code just
# needs to take the value read, and write it elsewhere).

client1 = EasyUAClient()
client1.InstanceParameters.PluginSetups.FindName('UAComplexDataClient').Enabled = False

try:
    value1 = IEasyUAClientExtension.ReadValue(client1, endpointDescriptor, nodeDescriptor)
except UAException as uaException:
    print('*** Failure: ' + uaException.GetBaseException().Message)
    exit()
print(value1)


# Now we will read the same value, but with the Complex Data plug-in enabled. This time we will receive an
# object of type UAGenericObject, which contains the data in the decoded form, accessible for further
# processing by your application.
#
# Note that it is not necessary to explicitly enable the Complex Data plug-in like this, because it is enabled
# by default.

client2 = EasyUAClient()
client2.InstanceParameters.PluginSetups.FindName('UAComplexDataClient').Enabled = True

try:
    value2 = IEasyUAClientExtension.ReadValue(client2, endpointDescriptor, nodeDescriptor)
except UAException as uaException:
    print('*** Failure: ' + uaException.GetBaseException().Message)
    exit()
print(value2)

print()
print('Finished.')

' Shows how to disable and enable the OPC UA Complex Data plug-in.
'
' Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

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

Namespace ComplexData._PluginSetup

    Friend Class Enabled

        Public Shared Sub Main1()

            ' 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/"

            ' Define which node we will work with.
            Dim nodeDescriptor As UANodeDescriptor = _
                "nsu=http://test.org/UA/Data/ ;i=10239"  ' [ObjectsFolder]/Data.Static.Scalar.StructureValue


            ' We will explicitly disable the Complex Data plug-in, and read a node which returns complex data. We will 
            ' receive an object of type UAExtensionObject, which contains the encoded data in its binary form. In this 
            ' form, the data cannot be easily further processed by your application.
            '
            ' Disabling the Complex Data plug-in may be useful e.g. for licensing reasons (when the product edition you 
            ' have does not support the Complex Data plug-in, and you want to avoid the associated error), or for
            ' performance reasons (if you do not need the internal content of the value, for example if your code just
            ' needs to take the value read, and write it elsewhere).

            Dim client1 = New EasyUAClient
            client1.InstanceParameters.PluginSetups.FindName("UAComplexDataClient").Enabled = False

            Dim value1 As Object
            Try
                value1 = client1.ReadValue(endpointDescriptor, nodeDescriptor)
            Catch uaException As UAException
                Console.WriteLine("*** Failure: {0}", uaException.GetBaseException.Message)
                Exit Sub
            End Try
            Console.WriteLine(value1)


            ' Now we will read the same value, but with the Complex Data plug-in enabled. This time we will receive an
            ' object of type UAGenericObject, which contains the data in the decoded form, accessible for further 
            ' processing by your application.
            '
            ' Note that it is not necessary to explicitly enable the Complex Data plug-in like this, because it is enabled
            ' by default.

            Dim client2 = New EasyUAClient
            client2.InstanceParameters.PluginSetups.FindName("UAComplexDataClient").Enabled = True

            Dim value2 As Object
            Try
                value2 = client2.ReadValue(endpointDescriptor, nodeDescriptor)
            Catch uaException As UAException
                Console.WriteLine("*** Failure: {0}", uaException.GetBaseException.Message)
                Exit Sub
            End Try
            Console.WriteLine(value2)


            ' Example output:
            '
            ' Binary Byte[1373]; {nsu=http://test.org/UA/Data/ ;i=11437}
            ' (ScalarValueDataType) structured

            ' On the first line, the type and length of the encoded data is shown, and the node ID is the encoding ID.
            ' On the 2nd line, the kind (structured) and the name of the complex data type (ScalarValueDataType) is shown.
        End Sub
    End Class
End Namespace

Object Pascal

// Shows how to disable and enable the OPC UA Complex Data plug-in.
//
// Find all latest examples here : https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .

class procedure Enabled.Main;
var
  Client1, Client2: _EasyUAClient;
  EndpointDescriptor: string;
  NodeDescriptor: string;
  Value1, Value2: OleVariant;
begin
  // Define which server and node we will work with.
  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';
  NodeDescriptor := 'nsu=http://test.org/UA/Data/ ;i=10239';  // [ObjectsFolder]/Data.Static.Scalar.StructureValue

  // We will explicitly disable the Complex Data plug-in, and read a node which returns complex data. We will
  // receive an object of type UAExtensionObject, which contains the encoded data in its binary form. In this
  // form, the data cannot be easily further processed by your application.
  //
  // Disabling the Complex Data plug-in may be useful e.g. for licensing reasons (when the product edition you
  // have does not support the Complex Data plug-in, and you want to avoid the associated error), or for
  // performance reasons (if you do not need the internal content of the value, for example if your code just
  // needs to take the value read, and write it elsewhere).
  Client1 := CoEasyUAClient.Create;
  Client1.InstanceParameters.PluginSetups.FindName('UAComplexDataClient').Enabled := false;

  try
    Value1 := Client1.ReadValue(EndpointDescriptor, NodeDescriptor);
  except
    on E: EOleException do
    begin
      WriteLn(Format('*** Failure: %s', [E.GetBaseException.Message]));
      Exit;
    end;
  end;
  WriteLn(Value1);

  // Now we will read the same value, but with the Complex Data plug-in enabled. This time we will receive an
  // object of type UAGenericObject, which contains the data in the decoded form, accessible for further
  // processing by your application.
  //
  // Note that it is not necessary to explicitly enable the Complex Data plug-in like this, because it is enabled
  // by default.

  Client2 := CoEasyUAClient.Create;
  Client2.InstanceParameters.PluginSetups.FindName('UAComplexDataClient').Enabled := true;

  Value2 := Client2.ReadValue(EndpointDescriptor, NodeDescriptor);
  WriteLn(Value2);

  // Example output:
  //
  // Binary Byte[1373]; {nsu=http://test.org/UA/Data/ ;i=11437}
  // (ScalarValueDataType) structured

  // On the first line, the type and length of the encoded data is shown, and the node ID is the encoding ID.
  // On the 2nd line, the kind (structured) and the name of the complex data type (ScalarValueDataType) is shown.

end;

Requirements

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

Reference

ComponentParameters Class
ComponentParameters Members

Send Documentation Feedback. Technical Support