If I have a Struct with arrays of other structs, is this than still a value-based type? In detail what I don´t understand is, that usually structs are meant to be value-based, but arrays for example are reference-based, right? So is such a struct now value-based or reference-based? And what does this mean in case of multithreading?
To put this in a applicable context:
If I generate a struct instance (which contains arrays of structs) within a Thread, read it from another Thread and assign it there to a property, can I than change and reuse this newly assigned property without conflicting with the struct instance from the original thread?
A structure is a value type and a class is a reference type. That never changes.
If you have a local variable in a method in your code, when that code is executed, space is allocated for that variable on the stack. If that variable is a value type then the structure instance will be stored in the variable itself while, if the variable is a reference type, space will be allocated for the object on the heap and a reference to that object will be stored in the variable.
When an object is created, whether on the stack or the heap, that object contains its member variables. If the object is created on the stack then the member variables exist on the stack and if the object is created on the heap then the member variables exist on the heap. Whether those member variables exist on the stack or the heap, they still behave exactly as value types and reference types always do, i.e. the value type variables contain the objects and the reference type variables contain references to objects created on the heap.
If you have a structure with a member variable that is an array then the structure will behave like value types always do, i.e. the object will be stored in the variable, wherever that variable happens to be. The array field will contain a reference to an array created on the heap. If the array is of a value type then the array will contain the element objects themselves while an array that is of a reference type will contain references to objects stored elsewhere on the heap.
It's pretty simple really: