Ok, figured out how that is supposed to work. I found the VarStructureCreate function in UAVariants.

What you do is create a normal variant array and then add the type structure with VarStructureCreate(...) to each element of that array. So something like this (this example omits a couple steps but highlights the part of how to create the array of the structure type.

var
V: Variant
myStruct: IUaDynamicStructure;
begin
MyTypeVar := MyNodeManager.CreateVar(‘test’);
MyTypeVar.DataType := MyStructType2;
MyTypeVar.DataTypeID := MyStructType2.NodeID;

MyBuilder := UAServer.TypeDictionary.CreateDynamicStructureBuilder(myStructType2.NodeId);

//fill normal elements
V := VarArrayCreate([0, 1], varVariant);
for i := 0 to 2 do
begin
myStruct := CreateStructure(..); //this creates the actual structure using the Builder Interface
V[i] := VarStructureCreate(MyStruct);
end;

MyBuilder.SetFieldValue('Field2', TUaVariant.Create(V));

MyTypeVar.Value := MyBuilder.Build;
end;

I didn't remember even myself by heart, but managed to create the sample. It's a bit too complicated to work together with TUaVariant and Variant and the arrays require Variants.

So, it goes like this:

where 'CreateMyStructureValue' returns a single 'IUaStructure' value, similar to what I wrote above (I will add the function definition in there, too).

How do I create an array of a complex type? For example my Structure looks like this:

MyStructureType
-> Field1: Integer
-> Field2: String
-> Field3: array of String

MyStructureType2
-> Field1: string
-> Field2: array of MyStructureType

Just to clarify I'm not talking about the declaration of the type this time, that works perfectly fine but the creation of the actual value for it using the

MyBuilder := UAServer.TypeDictionary.CreateDynamicStructureBuilder(MyStructureType2.NodeID);

the standard fields are clear, just call

MyBuilder.SetFieldValue('Field1', 'Test')

For an array of simple types I use something like this:
var
v: Variant;

v := VarArrayCreate([0, 6], varString);
TUaVariant.Create(v);

for a complex type I tried using this:
var
A: Array of TUaVariant;
MyTypeVar: TUaVariable;
begin
MyTypeVar := MyNodeManager.CreateVar('test');
MyTypeVar.DataType := MyStructType2;
MyTypeVar.DataTypeID := MyStructType2.NodeID;

MyBuilder := UAServer.TypeDictionary.CreateDynamicStructureBuilder(myStructType2.NodeId);

SetLength(A, 3);

for i := 0 to 2 do
begin
p := CreateStructure(...); //this one creates a builder for the MyStructType and fills it with values, that works
A[0] := p;
end;

MyBuilder.SetField('Field2', TUaVariant.Create(A));

MyTypeVar.Value := MyBuilder.Build;
end;

that compiles without problems but gives me a runtime error "Invalid class typecast" when I try to assign the actual build variable to the UAVariable, so last line there.

I tried a couple different approaches too but always ran in some kind of runtime error. I'm pretty sure I'm doing something wrong there but I'm not sure what...

And it's always nice to work on things that people use for real. So, let us know if you bump into something else along the way.

Thank you for the help with this and if you found a couple bugs along the way that's a nice benefit for you too. Fewer bugs are always nice 😉

A couple of hurdles (bugs) were just making it a bit harder...

This method defines a new structure type:

and then you can create the variable with:

and then you can create the value, with

where

I will get the bugs fixed to the next release, and can provide you a beta as well.

But fix the BrowseName for your ObjectType as well. Prosys OPC UA Browser didn't seem to like it, if it was missing...

I tried to find the proper way to do it, but it may be that the SDK needs a bit of tweaks to enable what you need. I will keep you updated.

What I got so far is the following:

MyType2 := (MyNodeManager.GetType(Id_StructureType) as TUaDataType)
.AddSubtype(TUaNodeId.Create(MyNodeManager.Namespace, 9998), 'MyTestStruct') as TUaDataType;

pDef := TUaDataTypeDefinition.Create;

//define the actual datatype
//?

MyType2.DataTypeDefinition := pDef;

The problem is I don't see a way to actually define the fields in the TypeDefinition, as it seems like it only allows to read fields, but not to actually define them. Using the Builder Interface (TUaDataTypeDefinition.Builder) doesn't seem to help either, as that again expects a definition to create the structure...

When you create your object instances, you should not place them in the PackMLNodeManager, but your own. So always use

MyNodeManager.CreateInstance and TUaNodeId.Create(MyNodeManager, ...)

for them. The PackMLNodeManager is hosting the types defined in that model and you should not extend it yourself.

Note that CreateInstance will also define a new NodeId based on the name, by default, if you omit the NodeId. But you can see which strategy works the best for you.

For the optional members, you need to define the names using the PackML Namespace. The default is the OPC UA Standard namespace, which works for those types only. And again, modify your own NodeManager. So, try this:

MyNodeManager.NodeBuilderConfiguration :=
TUaTypeDefinitionBasedNodeBuilderConfiguration.Builder
.AddOptional(TUaQualifiedName.Create(PackMLNodeManager.Namespace, ‘Parameter’))
.AddOptional(TUaQualifiedName.Create(PackMLNodeManager.Namespace, ‘Product’))
.AddOptional(TUaQualifiedName.Create(PackMLNodeManager.Namespace, ‘MaterialInterlocked’))
.Build;

p := MyNodeManager.CreateVariable('Test');
instead of
p := TUaVariable.Create(MyNodeManager);