'Declaration
Property ValueTypeCode As TypeCode
'Usage
Dim instance As _UAWriteArguments Dim value As TypeCode instance.ValueTypeCode = value value = instance.ValueTypeCode
TypeCode ValueTypeCode {get; set;}
'Declaration
Property ValueTypeCode As TypeCode
'Usage
Dim instance As _UAWriteArguments Dim value As TypeCode instance.ValueTypeCode = value value = instance.ValueTypeCode
TypeCode ValueTypeCode {get; set;}
When the type code is System.TypeCode.Empty, and the OpcLabs.EasyOpc.UA.OperationModel.UAAttributeArguments.AttributeId is equal to OpcLabs.EasyOpc.UA.UAAttributeId.Value, it means that the component will determine the type of the Value attribute from the DataType and ValueRank attributes of the node first. This can have negative implication on the performance, and introduces a dependency of the value written on the behavior of the OPC server itself.
// This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success of // each write and displays the exception message in case of failure. // // Reasons for specifying the type explicitly might be: // - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written. // - The data type that the reports is incorrect. // - Writing with an explicitly specified type is more efficient. // // Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties. using System; using OpcLabs.BaseLib.OperationModel; using OpcLabs.EasyOpc.UA; using OpcLabs.EasyOpc.UA.OperationModel; namespace UADocExamples._EasyUAClient { partial class WriteMultipleValues { public static void ValueTypeCode() { 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("Modifying values of nodes..."); OperationResult[] operationResultArray = client.WriteMultipleValues(new[] { new UAWriteValueArguments(endpointDescriptor, "nsu=http://test.org/UA/Data/ ;i=10221", 23456) {ValueTypeCode = TypeCode.Int32}, // here is the type explicitly specified new UAWriteValueArguments(endpointDescriptor, "nsu=http://test.org/UA/Data/ ;i=10226", "This string cannot be converted to Double") {ValueTypeCode = TypeCode.Double}, // here is the type explicitly specified new UAWriteValueArguments(endpointDescriptor, "nsu=http://test.org/UA/Data/ ;s=UnknownNode", "ABC") {ValueTypeCode = TypeCode.String} // here is the type explicitly specified }); for (int i = 0; i < operationResultArray.Length; i++) if (operationResultArray[i].Succeeded) Console.WriteLine($"Result {i}: success"); else Console.WriteLine($"Result {i}: {operationResultArray[i].Exception.GetBaseException().Message}"); // Example output: // //Modifying values of nodes... //Result 0: success //Result 1: Input string was not in a correct format. //+ Attempting to change an object of type "System.String" to type "System.Double". //+ The specified original value (string) was "This string cannot be converted to Double". //+ The node descriptor used was: NodeId="nsu=http://test.org/UA/Data/ ;i=10226". //+ The client method called (or event/callback invoked) was 'WriteMultiple[3]'. //Result 2: OPC UA service result - {BadNodeIdUnknown}. The node id refers to a node that does not exist in the server address space. //+ The node descriptor used was: NodeId="nsu=http://test.org/UA/Data/ ;s=UnknownNode". //+ The client method called (or event/callback invoked) was 'WriteMultiple[3]'. } } }
# This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success of # each write and displays the exception message in case of failure. # # Reasons for specifying the type explicitly might be: # - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written. # - The data type that the reports is incorrect. # - Writing with an explicitly specified type is more efficient. # # Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties. #requires -Version 5.1 using namespace OpcLabs.EasyOpc.UA using namespace OpcLabs.EasyOpc.UA.OperationModel # The path below assumes that the current directory is [ProductDir]/Examples-NET/PowerShell/Windows . Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcUA.dll" Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcUAComponents.dll" [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. $client = New-Object EasyUAClient Write-Host "Modifying values of nodes..." $operationResultArray = $client.WriteMultipleValues([UAWriteValueArguments[]]@( (New-Object UAWriteValueArguments($endpointDescriptor, "nsu=http://test.org/UA/Data/ ;i=10221", 23456) ` -Property @{ValueTypeCode = [TypeCode]::Int32}), # here is the type explicitly specified (New-Object UAWriteValueArguments($endpointDescriptor, "nsu=http://test.org/UA/Data/ ;i=10226", "This string cannot be converted to Double") ` -Property @{ValueTypeCode = [TypeCode]::Double}), # here is the type explicitly specified (New-Object UAWriteValueArguments($endpointDescriptor, "nsu=http://test.org/UA/Data/ ;s=UnknownNode", "ABC") ` -Property @{ValueTypeCode = [TypeCode]::String}) # here is the type explicitly specified )) for ($i = 0; $i -lt $operationResultArray.Length; $i++) { if ($operationResultArray[$i].Succeeded) { Write-Host "Result $($i): success" } else { Write-Host "Result $($i): $($operationResultArray[$i].Exception.GetBaseException().Message)" } } # Example output: # #Modifying values of nodes... #Result 0: success #Result 1: Input string was not in a correct format. #+ Attempting to change an object of type "System.String" to type "System.Double". #+ The specified original value (string) was "This string cannot be converted to Double". #+ The node descriptor used was: NodeId="nsu=http://test.org/UA/Data/ ;i=10226". #+ The client method called (or event/callback invoked) was 'WriteMultiple[3]'. #Result 2: The status of the OPC-UA attribute data is not Good. The actual status is 'BadNodeIdUnknown'. #+ During writing or method calls, readings may occur when value type is not specified. #+ The node descriptor used was: NodeId="nsu=http://test.org/UA/Data/ ;s=UnknownNode". #+ The client method called (or event/callback invoked) was 'WriteMultiple[3]'.
# This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success # of each write and displays the exception message in case of failure. # # Reasons for specifying the type explicitly might be: # - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written. # - The data type that the reports is incorrect. # - Writing with an explicitly specified type is more efficient. # # Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties. # The QuickOPC package is needed. Install it using "pip install opclabs_quickopc". import opclabs_quickopc # Import .NET namespaces. from System import * 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() print('Modifying values of nodes...') writeValueArguments1 = UAWriteValueArguments(endpointDescriptor, UANodeDescriptor('nsu=http://test.org/UA/Data/ ;i=10221'), 23456) writeValueArguments1.ValueTypeCode = TypeCode.Int32 # here is the type explicitly specified writeValueArguments2 = UAWriteValueArguments(endpointDescriptor, UANodeDescriptor('nsu=http://test.org/UA/Data/ ;i=10226'), 'This string cannot be converted to Double') writeValueArguments2.ValueTypeCode = TypeCode.Double # here is the type explicitly specified writeValueArguments3 = UAWriteValueArguments(endpointDescriptor, UANodeDescriptor('nsu=http://test.org/UA/Data/ ;s=UnknownNode'), 'ABC') writeValueArguments3.ValueTypeCode = TypeCode.String # here is the type explicitly specified writeResultArray = IEasyUAClientExtension.WriteMultipleValues(client, [writeValueArguments1, writeValueArguments2, writeValueArguments3]) for i, writeResult in enumerate(writeResultArray): if writeResult.Succeeded: print('writeResultArray[', i, ']: success', sep='') else: print('writeResultArray[', i, '] *** Failure: ', writeResult.Exception.GetBaseException().Message, sep='') print() print('Finished.')
' This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success of ' each write and displays the exception message in case of failure. ' ' Reasons for specifying the type explicitly might be: ' - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written. ' - The data type that the reports is incorrect. ' - Writing with an explicitly specified type is more efficient. ' ' Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties. Imports System Imports OpcLabs.BaseLib.OperationModel Imports OpcLabs.EasyOpc.UA Imports OpcLabs.EasyOpc.UA.OperationModel Namespace _EasyUAClient Partial Friend Class WriteMultipleValues Public Shared Sub ValueTypeCode() ' 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() ' Modify value of a node Dim operationResultArray() As OperationResult = client.WriteMultipleValues(New UAWriteValueArguments() _ { _ New UAWriteValueArguments(endpointDescriptor, _ "nsu=http://test.org/UA/Data/ ;i=10221", 23456) _ With {.ValueTypeCode = TypeCode.Int32}, _ New UAWriteValueArguments(endpointDescriptor, _ "nsu=http://test.org/UA/Data/ ;i=10226", "This string cannot be converted to Double") _ With {.ValueTypeCode = TypeCode.Double}, _ New UAWriteValueArguments(endpointDescriptor, _ "nsu=http://test.org/UA/Data/ ;s=UnknownNode", "ABC") _ With {.ValueTypeCode = TypeCode.String} _ } _ ) For i As Integer = 0 To operationResultArray.Length - 1 If operationResultArray(i).Succeeded Then Console.WriteLine("Result {0}: success", i) Else Console.WriteLine("Result {0}: {1}", i, operationResultArray(i).Exception.GetBaseException().Message) End If Next i End Sub End Class End Namespace
// This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success of // each write and displays the exception message in case of failure. // // Reasons for specifying the type explicitly might be: // - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written. // - The data type that the reports is incorrect. // - Writing with an explicitly specified type is more efficient. // // Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties. class procedure WriteMultipleValues.ValueTypeCode; var Arguments: OleVariant; Client: OpcLabs_EasyOpcUA_TLB._EasyUAClient; I: Cardinal; WriteResult: _UAWriteResult; WriteValueArguments1, WriteValueArguments2, WriteValueArguments3: _UAWriteValueArguments; Results: OleVariant; begin WriteValueArguments1 := CoUAWriteValueArguments.Create; WriteValueArguments1.EndpointDescriptor.UrlString := //'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'; WriteValueArguments1.NodeDescriptor.NodeId.ExpandedText := 'nsu=http://test.org/UA/Data/ ;i=10221'; WriteValueArguments1.Value := 23456; WriteValueArguments1.ValueTypeCode := TypeCode_Int32; // here is the type explicitly specified WriteValueArguments2 := CoUAWriteValueArguments.Create; WriteValueArguments2.EndpointDescriptor.UrlString := //'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'; WriteValueArguments2.NodeDescriptor.NodeId.ExpandedText := 'nsu=http://test.org/UA/Data/ ;i=10226'; WriteValueArguments2.Value := 'This string cannot be converted to Double'; WriteValueArguments2.ValueTypeCode := TypeCode_Double; // here is the type explicitly specified WriteValueArguments3 := CoUAWriteValueArguments.Create; WriteValueArguments3.EndpointDescriptor.UrlString := //'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'; WriteValueArguments3.NodeDescriptor.NodeId.ExpandedText := 'nsu=http://test.org/UA/Data/ ;s=UnknownNode'; WriteValueArguments3.Value := 'ABC'; WriteValueArguments3.ValueTypeCode := TypeCode_String; // here is the type explicitly specified Arguments := VarArrayCreate([0, 2], varVariant); Arguments[0] := WriteValueArguments1; Arguments[1] := WriteValueArguments2; Arguments[2] := WriteValueArguments3; // Instantiate the client object Client := CoEasyUAClient.Create; // Modify values of nodes TVarData(Results).VType := varArray or varVariant; TVarData(Results).VArray := PVarArray(Client.WriteMultipleValues(Arguments)); // Display results for I := VarArrayLowBound(Results, 1) to VarArrayHighBound(Results, 1) do begin WriteResult := IInterface(Results[I]) as _UAWriteResult; if WriteResult.Succeeded then WriteLn('Result ', I, ' success') else WriteLn('Result ', I, ': ', WriteResult.Exception.GetBaseException.Message); end; VarClear(Results); VarClear(Arguments); end;
// This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success of // each write and displays the exception message in case of failure. // // Reasons for specifying the type explicitly might be: // - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written. // - The data type that the reports is incorrect. // - Writing with an explicitly specified type is more efficient. // // Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties. const TypeCode_Int32 = 9; const TypeCode_Double = 14; const TypeCode_String = 18; $WriteValueArguments1 = new COM("OpcLabs.EasyOpc.UA.OperationModel.UAWriteValueArguments"); $WriteValueArguments1->EndpointDescriptor->UrlString = //"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"; $WriteValueArguments1->NodeDescriptor->NodeId->ExpandedText = "nsu=http://test.org/UA/Data/ ;i=10221"; $WriteValueArguments1->Value = 23456; $WriteValueArguments1->ValueTypeCode = TypeCode_Int32; // here is the type explicitly specified $WriteValueArguments2 = new COM("OpcLabs.EasyOpc.UA.OperationModel.UAWriteValueArguments"); $WriteValueArguments2->EndpointDescriptor->UrlString = //"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"; $WriteValueArguments2->NodeDescriptor->NodeId->ExpandedText = "nsu=http://test.org/UA/Data/ ;i=10226"; $WriteValueArguments2->Value = "This string cannot be converted to Double"; $WriteValueArguments2->ValueTypeCode = TypeCode_Double; // here is the type explicitly specified $WriteValueArguments3 = new COM("OpcLabs.EasyOpc.UA.OperationModel.UAWriteValueArguments"); $WriteValueArguments3->EndpointDescriptor->UrlString = //"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"; $WriteValueArguments3->NodeDescriptor->NodeId->ExpandedText = "nsu=http://test.org/UA/Data/ ;s=UnknownNode"; $WriteValueArguments3->Value = "ABC"; $WriteValueArguments3->ValueTypeCode = TypeCode_String; // here is the type explicitly specified $arguments[0] = $WriteValueArguments1; $arguments[1] = $WriteValueArguments2; $arguments[2] = $WriteValueArguments3; // Instantiate the client object $Client = new COM("OpcLabs.EasyOpc.UA.EasyUAClient"); // Modify values of nodes $results = $Client->WriteMultipleValues($arguments); // Display results for ($i = 0; $i < count($results); $i++) { $WriteResult = $results[$i]; if ($WriteResult->Succeeded) printf("Result %d success\n", $i); else printf("Result s \n", $i, $WriteResult->Exception->GetBaseException()->Message); }
Rem This example shows how to write values into 3 nodes at once, specifying a type code explicitly. It tests for success of Rem each write and displays the exception message in case of failure. Rem Rem Reasons for specifying the type explicitly might be: Rem - The data type in the server has subtypes, and the client therefore needs to pick the subtype to be written. Rem - The data type that the reports is incorrect. Rem - Writing with an explicitly specified type is more efficient. Rem Rem Alternative ways of specifying the type are using the ValueType or ValueTypeFullName properties. Public Sub WriteMultipleValues_ValueTypeCode_Command_Click() OutputText = "" Const TypeCode_Int32 = 9 Const TypeCode_Double = 14 Const TypeCode_String = 18 ' Instantiate the client object Dim Client As New EasyUAClient Dim WriteValueArguments1 As New UAWriteValueArguments WriteValueArguments1.endpointDescriptor.UrlString = "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer" WriteValueArguments1.nodeDescriptor.NodeId.expandedText = "nsu=http://test.org/UA/Data/ ;i=10221" WriteValueArguments1.SetValue 23456 WriteValueArguments1.ValueTypeCode = TypeCode_Int32 ' here is the type explicitly specified Dim WriteValueArguments2 As New UAWriteValueArguments WriteValueArguments2.endpointDescriptor.UrlString = "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer" WriteValueArguments2.nodeDescriptor.NodeId.expandedText = "nsu=http://test.org/UA/Data/ ;i=10226" WriteValueArguments2.SetValue "This string cannot be converted to Double" WriteValueArguments2.ValueTypeCode = TypeCode_Double ' here is the type explicitly specified Dim WriteValueArguments3 As New UAWriteValueArguments WriteValueArguments3.endpointDescriptor.UrlString = "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer" WriteValueArguments3.nodeDescriptor.NodeId.expandedText = "nsu=http://test.org/UA/Data/ ;s=UnknownNode" WriteValueArguments3.SetValue "ABC" WriteValueArguments3.ValueTypeCode = TypeCode_String ' here is the type explicitly specified Dim arguments(2) As Variant Set arguments(0) = WriteValueArguments1 Set arguments(1) = WriteValueArguments2 Set arguments(2) = WriteValueArguments3 ' Modify values of nodes Dim results As Variant results = Client.WriteMultipleValues(arguments) ' Display results Dim i: For i = LBound(results) To UBound(results) Dim Result As UAWriteResult: Set Result = results(i) If Result.Succeeded Then OutputText = OutputText & "Result " & i & " success" & vbCrLf Else OutputText = OutputText & "Result " & i & ": " & Result.Exception.GetBaseException().Message & vbCrLf End If Next End Sub