QuickOPC User's Guide and Reference
WriteItemValueList Method (_EasyDAClient)
Example 



OpcLabs.EasyOpcClassic Assembly > OpcLabs.EasyOpc.DataAccess.ComTypes Namespace > _EasyDAClient Interface : WriteItemValueList Method
Writes named items into an OPC server or OPC servers. Values, qualities and timestamps are written.
Syntax
'Declaration
 
<ElementsNotNullAttribute()>
<NotNullAttribute()>
Function WriteItemValueList( _
   ByVal argumentsList As IList _
) As _ElasticVector
'Usage
 
Dim instance As _EasyDAClient
Dim argumentsList As IList
Dim value As _ElasticVector
 
value = instance.WriteItemValueList(argumentsList)
[ElementsNotNull()]
[NotNull()]
_ElasticVector WriteItemValueList( 
   IList argumentsList
)
[ElementsNotNull()]
[NotNull()]
_ElasticVector^ WriteItemValueList( 
   IList^ argumentsList
) 

Parameters

argumentsList

Return Value

The function returns an array of OpcLabs.BaseLib.OperationModel.OperationResult objects. The indices of elements in the output array are the same as those in the input arrays.
Exceptions
ExceptionDescription

A null reference (Nothing in Visual Basic) is passed to a method that does not accept it as a valid argument.

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.

Remarks

The size of the input array will become the size of the output array. The element positions (indices) in the output array are the same as in the input array.

The servers can be local or can be remotely accessed via DCOM. Optionally, an access path can be specified or a specific data type can be requested.

This method does not throw an exception in case of OPC operation failures. Instead, the eventual exception related to each item is returned in Exception property of each returned OpcLabs.BaseLib.OperationModel.OperationResult element.

 

This is a multiple-operation method. In a properly written program, it does not throw any exceptions. You should therefore not put try/catch statements or similar constructs around calls to this method. The only exceptions thrown by this method are for usage errors, i.e. when your code violates the usage contract of the method, such as passing in invalid arguments or calling the method when the state of the object does not allow it. Any operation-related errors (i.e. errors that depend on external conditions that your code cannot reliably check) are indicated in the result objects returned by the method. For more information, see Multiple-operation Methods and Do not catch any exceptions with asynchronous or multiple-operation methods.

This method uses lists instead of arrays.

Example

.NET

COM

// This example shows how to write values, timestamps and qualities into 3 items at once.

using System;
using System.Diagnostics;
using OpcLabs.BaseLib.OperationModel;
using OpcLabs.EasyOpc.DataAccess;
using OpcLabs.EasyOpc.DataAccess.OperationModel;

namespace DocExamples.DataAccess._EasyDAClient
{
    class WriteMultipleItems
    {
        public static void Main1()
        {
            // Instantiate the client object.
            var client = new EasyDAClient();

            Console.WriteLine("Writing multiple items...");
            OperationResult[] resultArray = client.WriteMultipleItems(
                new[] { 
                    new DAItemVtqArguments("OPCLabs.KitServer.2", "Simulation.Register_I4", 
                        new DAVtq(23456, DateTime.UtcNow, DAQualities.GoodNonspecific)),
                    new DAItemVtqArguments("OPCLabs.KitServer.2", "Simulation.Register_R8", 
                        new DAVtq(2.34567890, DateTime.UtcNow, DAQualities.GoodNonspecific)),
                    new DAItemVtqArguments("OPCLabs.KitServer.2", "Simulation.Register_BSTR", 
                        new DAVtq("ABC", DateTime.UtcNow, DAQualities.GoodNonspecific))
                });
            
            for (int i = 0; i < resultArray.Length; i++)
            {
                Debug.Assert(resultArray[i] != null);
                if (resultArray[i].Succeeded)
                    Console.WriteLine("Result {0}: success", i);
                else
                {
                    Debug.Assert(!(resultArray[i].Exception is null));
                    Console.WriteLine("Result {0} *** Failure: {1}", i, resultArray[i].ErrorMessageBrief);
                }
            }
        }
    }
}
# This example shows how to write values, timestamps and qualities into 3 items at once.

#requires -Version 5.1
using namespace System
using namespace OpcLabs.EasyOpc.DataAccess
using namespace OpcLabs.EasyOpc.DataAccess.OperationModel

# The path below assumes that the current directory is [ProductDir]/Examples-NET/PowerShell/Windows .
Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcClassicCore.dll"
Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcClassic.dll"
Add-Type -Path "../../../Components/Opclabs.QuickOpc/net472/OpcLabs.EasyOpcClassicComponents.dll"

# Instantiate the client object.
$client = New-Object EasyDAClient

Write-Host "Writing multiple items..."
$resultArray = $client.WriteMultipleItems(@(
    (New-Object DAItemVtqArguments("OPCLabs.KitServer.2", "Simulation.Register_I4", 
        (New-Object DAVtq(23456, [DateTime]::UtcNow, [DAQualities]::GoodNonspecific)))),
    (New-Object DAItemVtqArguments("OPCLabs.KitServer.2", "Simulation.Register_R8", 
        (New-Object DAVtq(2.345667890, [DateTime]::UtcNow, [DAQualities]::GoodNonspecific)))),
    (New-Object DAItemVtqArguments("OPCLabs.KitServer.2", "Simulation.Register_BSTR",
        (New-Object DAVtq("ABC", [DateTime]::UtcNow, [DAQualities]::GoodNonspecific))))
    ))

for ($i = 0; $i -lt $resultArray.Length; $i++) {
    $result = $resultArray[$i]
    if ($result.Succeeded) {
        Write-Host "Result $($i): success"
    }
    else {
        Write-Host "Result $($i) *** Failure: $($result.ErrorMessageBrief)"
    }
}
# This example shows how to write values, timestamps and qualities into 3 items at once.

# The QuickOPC package is needed. Install it using "pip install opclabs_quickopc".
import opclabs_quickopc

# Import .NET namespaces.
from System import *
from OpcLabs.EasyOpc import *
from OpcLabs.EasyOpc.DataAccess import *
from OpcLabs.EasyOpc.DataAccess.OperationModel import *
from OpcLabs.EasyOpc.OperationModel import *


# Instantiate the client object.
client = EasyDAClient()

print('Writing multiple items...')
operationResultArray = client.WriteMultipleItems([
    DAItemVtqArguments(ServerDescriptor('OPCLabs.KitServer.2'), DAItemDescriptor('Simulation.Register_I4'),
                       DAVtq(23456, DateTime.UtcNow, DAQuality(DAQualities.GoodNonspecific))),
    DAItemVtqArguments(ServerDescriptor('OPCLabs.KitServer.2'), DAItemDescriptor('Simulation.Register_R8'),
                       DAVtq(2.34567890, DateTime.UtcNow, DAQuality(DAQualities.GoodNonspecific))),
    DAItemVtqArguments(ServerDescriptor('OPCLabs.KitServer.2'), DAItemDescriptor('Simulation.Register_BSTR'),
                       DAVtq('ABC', DateTime.UtcNow, DAQuality(DAQualities.GoodNonspecific))),
    ])

for i, operationResult in enumerate(operationResultArray):
    assert operationResult is not None
    if operationResult.Succeeded:
        print('operationResultArray[', i, ']: success', sep='')
    else:
        assert operationResult.Exception is not None
        print('operationResultArray[', i, '] *** Failure: ', operationResult.ErrorMessageBrief, sep='')

print('Finished.')
// Shows how to write into multiple OPC items using a single method call, and itemValue multiple item values back.

mle_outputtext.Text = ""

// Instantiate the client object
OLEObject client
client = CREATE OLEObject
client.ConnectToNewObject("OpcLabs.EasyOpc.DataAccess.EasyDAClient")

// Prepare arguments. 

OLEObject itemValueArguments1
itemValueArguments1 = CREATE OLEObject
itemValueArguments1.ConnectToNewObject("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments")
itemValueArguments1.ServerDescriptor.ServerClass = "OPCLabs.KitServer.2"
itemValueArguments1.ItemDescriptor.ItemID = "Simulation.Register_I4"
itemValueArguments1.Value = 12345

OLEObject itemValueArguments2
itemValueArguments2 = CREATE OLEObject
itemValueArguments2.ConnectToNewObject("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments")
itemValueArguments2.ServerDescriptor.ServerClass = "OPCLabs.KitServer.2"
itemValueArguments2.ItemDescriptor.ItemID = "Simulation.Register_BOOL"
itemValueArguments2.Value = TRUE

OLEObject itemValueArguments3
itemValueArguments3 = CREATE OLEObject
itemValueArguments3.ConnectToNewObject("OpcLabs.EasyOpc.DataAccess.OperationModel.DAItemValueArguments")
itemValueArguments3.ServerDescriptor.ServerClass = "OPCLabs.KitServer.2"
itemValueArguments3.ItemDescriptor.ItemID = "Simulation.Register_R4"
itemValueArguments3.Value = 234.56

OLEObject itemValueArgumentsList
itemValueArgumentsList = CREATE OLEObject
itemValueArgumentsList.ConnectToNewObject("OpcLabs.BaseLib.Collections.ElasticVector")
itemValueArgumentsList.Add(itemValueArguments1)
itemValueArgumentsList.Add(itemValueArguments2)
itemValueArgumentsList.Add(itemValueArguments3)

// Modify value of nodes

OLEObject operationResultList
operationResultList = client.WriteItemValueList(itemValueArgumentsList)

// Display results
Int i
FOR i = 0 TO operationResultList.Count - 1
    OLEObject operationResult
    operationResult = operationResultList.Item[i]
    IF operationResult.Succeeded THEN
        mle_outputtext.Text = mle_outputtext.Text + "Result " + String(i) + ": success" + "~r~n"
    ELSE
        mle_outputtext.Text = mle_outputtext.Text + "Result " + String(i) + ": " + operationResult.Exception.GetBaseException().Message + "~r~n"
    END IF    
NEXT

mle_outputtext.Text = mle_outputtext.Text + "~r~n" 
mle_outputtext.Text = mle_outputtext.Text + "Finished." + "~r~n" 
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