Memory allocation for reference type variable

In the c# specification:
The run-time processing of a simple assignment of the form x = y with type T is performed as an assignment to x of y with type T, which consists of the following recursive steps:

• x is evaluated if it wasn’t already.
• If x is classified as a variable, y is evaluated and, if required, converted to T through an implicit conversion (§10.2).
  • If the variable given by x is an array element of a reference_type, a run-time check is performed to ensure that the value computed for y is compatible with the array instance of which x is an element. The check succeeds if y is null, or if an implicit reference conversion (§10.2.8) exists from the type of the instance referenced by y to the actual element type of the array instance containing x. Otherwise, a System.ArrayTypeMismatchException is thrown.
  • The value resulting from the evaluation and conversion of y is stored into the location given by the evaluation of x, and is yielded as a result of the assignment.
• If x is classified as a property or indexer access:
  • y is evaluated and, if required, converted to T through an implicit conversion (§10.2).
  • The set accessor of x is invoked with the value resulting from the evaluation and conversion of y as its value argument.
  • The value resulting from the evaluation and conversion of y is yielded as the result of the assignment.
• If x is classified as a tuple (x1, ..., xn) with arity n:
  • y is deconstructed with n elements to a tuple expression e.
  • a result tuple t is created by converting e to T using an implicit tuple conversion.
  • for each xi in order from left to right, an assignment to xi of t.Itemi is performed, except that the xi are not evaluated again.
  • t is yielded as the result of the assignment.

Now, I think:
1.Declaration must allocate memory to variable according to the type of variable. If it doesn't, you can't assign a value to it. Because no memory to hold the value. Assignment(=) does not allocate memory for its left operand except the left operand is immutable type.
2.Declaring variables of non-nullable reference type and variables of nullable reference are the same thing. Because 'null' is the default value fo non-nullable reference type(it is a history of c# language). They all allocate memory for variables, one for reference, one for object.Now, the "object" has not been constructed, it is just a block of all-bits-zero memory, and is treated as "null".  
3."null" is a value, which like a state flag.As a value, it occupies memory.

1. The declaration itself does not allocate memory for the object.
2. A reference is just a pointer to an object, and memory for this pointer (usually 4 or 8 bytes) is allocated if the variable is part of an instance (class or struct) or a field.
3. The distinction is primarily in compile-time constraints for nullability, not in runtime memory allocation differences.

1. Declaring a non-nullable reference type variable:

   • When you declare a variable like Someclass v;, memory is allocated to store the reference itself, but at this point, it doesn't point to any actual object. The reference is initially set to null, meaning it doesn't reference any valid instance of Someclass. So, yes, memory is allocated to hold the reference (which is currently null).

2. Declaring a nullable reference type variable:

   • When you declare a variable like Someclass? v;, it behaves similarly. Memory is allocated for the reference, and it can also initially point to null. In this case, the nullable type allows you to explicitly indicate that the variable can hold a null value, which is useful for situations where an object may or may not be present.

In your sample code, if "SomeClass v" does not allocate any memory for "v", the assignment "v=new SomeClass()" could not assign any value to a variable to which is no memory allocated. Operator= should not allocate memory for a variable.

When you declare a non-nullable reference type, as Someclass v; it does not allocate memory for the reference value or for the object immediately.

Here v, is declared but not initialized. Since it can't be null, the compiler asks for one before using it by directly assigning a value and assigning an object to it or usage of a constructor. The reference itself (a pointer or handle) will occupycop memory once it is allocated, but declaring it alone doesn't occupy any memory immediately. However if this declaration happens in a method, the compiler would reserve space for it on the stack based on conditions.

In Someclass? v; the variable v can be null, which means it can either point to an object or have no value.

Like the above, v is declared but not initialized. The only difference here is that the compiler does not require initializing before it's used and the declaration of the variable does not directly allocate memory for the reference or an object. The memory will be allocated when the variable is used-for example, when it's initialized or passed into a method.

public class Someclass { }

void ExampleMethod()
{
    Someclass v;            // Non-nullable: No memory allocated yet.
    Someclass? vNull;       // Nullable: No memory allocated yet.

    v = new Someclass();    // Memory allocated for the object and the reference.
    vNull = null;           // Memory allocated for the reference but holds null.
}

In above code v gets a memory allocation when assigned new Someclass() and vNull only allocates memory for the reference itself, which holds null.