Are these expressions the same?

Below is the explanation of the IL of the first case

.method public hidebysig static void  Main() cil managed
{
// 
    .maxstack  2                  // Denota que la pila tendrá máximo 2 elementos
    .locals init (int32 V_0,      // Declara las 5 variables de tipo Int32
                  int32 V_1,
                  int32 V_2,
                  int32 V_3,
                  int32 V_4)
    IL_0000:  nop                 // Autogenerado cuando se compila como DEBUG
    IL_0001:  ldc.i4.1            // Se coloca en la pila el valor 1
    IL_0002:  dup                 // Se duplica el valor 1 en la pila como segundo elemento
    IL_0003:  stloc.s    V_4      // Se desapila el segundo 1 y se almacena en la variable V_4 (E)
    IL_0005:  dup                 // Se duplica de nuevo el valor 1
    IL_0006:  stloc.3             // Se desapila el tercer 1 y se almacena en la variable 3 (V_3/D)
    IL_0007:  dup                 // Se duplica en valor 1 en la pila
    IL_0008:  stloc.2             // Se desapila el cuarto 1 y se almacena en la variable 2 (V_2/C)
    IL_0009:  dup                 // Se duplica el valor 1 en la pila
    IL_000a:  stloc.1             // Se desapila el quinto 1 y se amancena en la variable 1 (V_1/B)
    IL_000b:  stloc.0             // Se desapila el primer 1 y se apila en la variable 0 (V_0/A)
    IL_000c:  ret
} // end of method Program::Main

In this case, the algorithm that is followed is to place the value 1on the stack and then duplicate that value to store it temporarily in order to continue assigning it after assigning it to the corresponding variable, first a V_5then a V_4and so on until no more temporary storage is needed. the variable, in the end the stack is left empty and the value 1assigned to all the variables

In the second case assuming that the expression was:A = 1; B = 1; C = 1; D = 1; E = 1;

.method public hidebysig static void  Main() cil managed
{
// 
    .maxstack  1                  // Se define el tamaño máximo de pila en 1
    .locals init (int32 V_0,      // Se declaran las 5 variables de tipo Int32
                  int32 V_1,
                  int32 V_2,
                  int32 V_3,
                  int32 V_4)
    IL_0000:  nop                // Generado al compilar como DEBUG
    IL_0001:  ldc.i4.1           // Se apila el valor 1
    IL_0002:  stloc.0            // Se desapila el 1 y se asigna a la variable 0 (V_0/A)
    IL_0003:  ldc.i4.1           // Se apila el valor 1
    IL_0004:  stloc.1            // Se desapila el 1 y se asigna a la variable 1 (V_1/B)
    IL_0005:  ldc.i4.1           // Se apila el valor 1
    IL_0006:  stloc.2            // Se desapila el 1 y se asigna a la variable 2 (V_2/C)
    IL_0007:  ldc.i4.1           // Se apila el valor 1
    IL_0008:  stloc.3            // Se desapila el 1 y se asigna a la variable 3 (V_3/D)
    IL_0009:  ldc.i4.1           // Se apila el valor 1
    IL_000a:  stloc.s    V_4     // Se desapila el 1 y se asigna a V_4 (E)
    IL_000c:  ret
}

In this case, the algorithm simply consists of stacking the value 1 and assigning it to the corresponding variable. This is repeated 5 times.

As we can see in this case in the stack there is only one element at a time, since it is always stacked and unstacked immediately, in the previous case there were up to two 1since the same value was duplicated each time instead of stacking one same value 5 times.

Now answering why the first syntax in C# is valid is due to the following

The = Operatorhas a return value and it is the same value that is assigned to the variable on the left side, that is:

A = B = C = D = E = 1;

equals

A = (B = (C = (D = (E = 1))));

and executing it step by step:

A = (B = (C = (D = (E = 1))));    // E == 1
...
A = (B = (C = (D = 1)));          // E == 1, D == 1
...
A = (B = (C = 1));                // E == 1, D == 1, C == 1
...
A = (B = 1);                      // E == 1, D == 1, C == 1, B == 1
...
A = 1;                            // E == 1, D == 1, C == 1, B == 1, A == 1

int A, B, C, D, E;
A = B = C = D = E = 1;

My main question is the following, why is this type of expression valid?

The second statement contains multiple assignment expressions, an assignment expression assigns a value to a variable:

A = 1;

But that value can be an assignment expression itself:

A = B = 1;

The assignment expression B = 1that results in is first evaluated 1and that value is assigned to A. The same process is repeated for all variables in the assignment chain.

This is found in the language specification 7.13.1

The result of a simple assignment expression is the value assigned to the left operand. The result has the same type as the left operand and is always classified as a value.

At the IL level the code is different, however the result is the same when assigning the same value to all the variables.

A = 1; B = 1; C = 1; D = 1; E = 1;