Dynamic structures the values are not assigned

Question

1.00/5 (1 vote)

See more:

I have checked this problem for years. I have two different structures that I need to pass as parameters to a common function. The two structures have within another structure that is common to both. If the root is dynamic, the values are not assigned in the internal structure.

In the background there is also the problem that instead of having a single structure ref dynamic I have to have two structures because you cannot pass ref struct to ref dynamic or vice versa. Why?

The interior structures are sized although it does not appear in this code.

It does not help me to be told to think things differently because in the common function I have many things that are general to both structures and some things that are different.

C#

public struct St_A
{
  public dynamic MyValue1; 
  public string  MyValue2; 

  public struct St_A1     StProp
  public struct St_COMMON StCommon;
}

public struct St_B
{
  public struct St_COMMON StCommon;
}

public struct St_A1
{
  public dynamic MyValue3; 
  public string  MyValue4; 
}

public struct St_COMMON
{
  public int Value;
}

MyFunction()
{
  struct St_A StA = new St_A();
  struct St_B StB = new St_B();
  dynamic MyRet = Function_Common(true, ref StA, ref StB)
}

public static Function_Common(bool Struct_is_A, ref St_A StA, ref St_B StB)
{
  dynamic MyStruct = null;

  if (Struct_is_A)
    MyStruct = (St_A)StA;
  else
    MyStruct = (St_B)StB;

  // This Works.
  MyStruct.MyValue1 = "10";
  MyStruct.MyValue2 = "10";

  // PROBLEM. It does not produce an error and does not assign the value. If from the 
  // debugger I perform the same action, then it is assigned.
  MyStruct.StProp.MyValue3 = "10";
  MyStruct.StProp.MyValue4 = "10";

  // PROBLEM. It does not produce an error and does not assign the value. If from the 
  // debugger I perform the same action, then it is assigned.
  MyStruct.StCommon.Value = 10;
}

What I have tried:

in al sites of internet.in al sites of internet.

Posted 23-Sep-19 0:48am

zequion

Updated 23-Sep-19 2:45am

v7

Add a Solution

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Dave Kreskowiak · Accepted Answer · 2019-09-23T02:45:00

Structure types are kept on the stack. The problem with dynamic is that it's not possible to determine the size of the object it's holding, so how far does the code move the stack pointer so one object or function return doesn't overwrite part of your structure? It's not possible.

You're trying to violate just about every point listed in the ref documentation:

Quote:
Ref struct types
Adding the ref modifier to a struct declaration defines that instances of that type must be stack allocated. In other words, instances of these types can never be created on the heap as a member of another class. The primary motivation for this feature was Span<t> and related structures.

The goal of keeping a ref struct type as a stack-allocated variable introduces several rules that the compiler enforces for all ref struct types.

You can't box a ref struct. You cannot assign a ref struct type to a variable of type object, dynamic, or any interface type.
ref struct types cannot implement interfaces.
You can't declare a ref struct as a field member of a class or a normal struct. This includes declaring an auto-implemented property, which creates a compiler generated backing field.
You cannot declare local variables that are ref struct types in async methods. You can declare them in synchronous methods that return Task, Task<tresult> or Task-like types.
You cannot declare ref struct local variables in iterators.
You cannot capture ref struct variables in lambda expressions or local functions.
These restrictions ensure you don't accidentally use a ref struct in a manner that could promote it to the managed heap.

You can combine modifiers to declare a struct as readonly ref. A readonly ref struct combines the benefits and restrictions of ref struct and readonly struct declarations.