If you can contact our support by email, we can check this in more detail.

I got everything working with the dynamic types now (at least I thought so) but found a new, somewhat peculiar, issue.

When I run my program in 32Bit everything works just fine but running it in 64Bit got me an exception that a structure is missing mandatory field values.

Project raised exception class EUaException with message 'Mandatory Field Values for DynamicStructure type ExtensionObjectType undefined: ID,Name,ValueString'.

After digging around a bit I found that the following code snipped seems not to work in 64Bit.

pNames := IStruct.GetFieldNames; //<- this return [] in 64 bit and ['ID', 'Name', 'ValueString'] in 32Bit (for this specific type, of course the names can vary depending on the type definition)

for s in pNames do
begin
pField := IStruct.FieldValues[s];
[...]
IBuilder.SetFieldValue(s, TUaVariant.Create(V));
end;

The GetFieldNames returns the list with the correct field names in 32Bit, but returns an empty list in 64Bit. The curios part is, when I hardcode a field name I know exist, the FieldValues[] function returns the field and the exception message gives me the missing field names as well. So the type itself seems to be correct and knows those fields do exist, just the GetFieldNames function won't disclose that information.

IStruct is a created by doing this:

pTo.Value.AsStructure

where pTo is a TUaVariable holding a custom structure type (checked with IsStructure beforehand).

Any Idea what might be the cause of this?

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...