pass - ref out c# ejemplos

¿Cómo funciona la palabra clave ref(en términos de memoria)

Question

C # tiene una palabra clave ref . Usando ref puedes pasar un int a un método por referencia. ¿Qué sucede en el marco de la pila cuando llama a un método que acepta un int por referencia?

public void SampleMethod(ref int i) { }

Answer 1

Pasando una variable local como referencia

En el nivel bajo, la variable int local referenciada se colocará en la pila (la mayoría de los enteros de tiempo se almacenarán en registros), y se pasará un puntero a la pila a la función invocada (el puntero en sí es más probable que se pase) en un registro). Considere el siguiente ejemplo:

var i = 7;
Console.WriteLine(i);
inc(ref i);
Console.WriteLine(i);

Esto será JIT-et a algo como esto (la arquitectura de destino es x86):

 17: var i = 7;
# allocate space on the stack for args and i
00482E3B sub esp,8
# initialize i to 0
00482E3E xor eax,eax
00482E40 mov dword ptr [ebp-8],eax
# args saved to stack (could be optimised out)
00482E43 mov dword ptr [ebp-4],ecx
00482E46 cmp dword ptr ds:[3ACAECh],0
00482E4D je 00482E54
00482E4F call 7399CB2D
# i = 7
00482E54 mov dword ptr [ebp-8],7
18: Console.WriteLine(i);
# load the value of i into ecx, and call cw
00482E5B mov ecx,dword ptr [ebp-8]
00482E5E call 72E729DC
19: inc(ref i);
# load the address of i into ecx, and call inc
00482E63 lea ecx,[ebp-8]
00482E66 call dword ptr ds:[4920860h]
20: Console.WriteLine(i);
# load the value of i into ecx, and call cw
00482E6C mov ecx,dword ptr [ebp-8]
00482E6F call 72E729DC
21: }
00482E74 nop
00482E75 mov esp,ebp
00482E77 pop ebp
00482E78 ret 

Pasar un elemento de matriz o un miembro de objeto como referencia

Casi lo mismo sucede aquí, se obtiene la dirección del campo o elemento, y el puntero se pasa a la función:

var i = new[]{7};
Console.WriteLine(i[0]);
inc(ref i[0]);
Console.WriteLine(i[0]);

Compila (sin la parte aburrida):

 18: Console.WriteLine(i[0]);
00C82E91 mov eax,dword ptr [ebp-8]
00C82E94 cmp dword ptr [eax+4],0
00C82E98 ja 00C82E9F
00C82E9A call 7399BDC2
00C82E9F mov ecx,dword ptr [eax+8]
00C82EA2 call 72E729DC
19: inc(ref i[0]);
# loading the reference of the array to eax
00C82EA7 mov eax,dword ptr [ebp-8]
# array boundary check is inlined
00C82EAA cmp dword ptr [eax+4],0
00C82EAE ja 00C82EB5
# this would throw an OutOfBoundsException, but skipped by ja
00C82EB0 call 7399BDC2
# load the address of the element in ecx, and call inc
00C82EB5 lea ecx,[eax+8]
00C82EB8 call dword ptr ds:[4F80860h] 

Tenga en cuenta que la matriz no tiene que estar anclada en este caso , ya que el marco de trabajo sabe que la dirección en ecx está apuntando un elemento dentro de la matriz, por lo que si se produce una compresión del montón entre lea y call o dentro de la función inc, puede reajustar el valor de ecx directamente.

Puede investigar el ensamblaje JIT-ed usted mismo utilizando el depurador de Visual Studio abriendo la ventana Desensamblar ( Depurar / Windows / Desensamblar )

Answer 2

Aquí hay un ejemplo simple en código C #:

void Main()
{
int i = 1;
inc(ref i);
Console.WriteLine(i);
}
public void inc(ref int i) {
i++;
}

Aquí está el código IL generado

IL_0000: nop
IL_0001: ldc.i4.1
IL_0002: stloc.0 // i
IL_0003: ldarg.0
IL_0004: ldloca.s 00 // i
IL_0006: call inc
IL_000B: nop
IL_000C: ldloc.0 // i
IL_000D: call System.Console.WriteLine
IL_0012: nop
IL_0013: ret
inc:
IL_0000: nop
IL_0001: ldarg.1
IL_0002: dup
IL_0003: ldind.i4
IL_0004: ldc.i4.1
IL_0005: add
IL_0006: stind.i4
IL_0007: ret 

Tenga en cuenta que con este caso simple realmente hay solo una diferencia: ldloca.s 00 o ldloc.0. Cargar dirección local o de carga (de offset 00)

Esa es la diferencia en el nivel más simple (que es lo que pidió en su comentario): si carga el valor de la variable o si carga la dirección de la variable. La cosa puede complicarse rápidamente: si la función que está llamando no es local, si la variable que está pasando no es local, etc., etc. Pero a un nivel básico, esta es la diferencia.

Usé el linqpad para hacer mi desmontaje rápido, lo recomiendo. http://www.linqpad.net/

Answer 3

La dirección de la variable o campo local. En la IL, la instrucción ldloca.s se usa para una variable local.

Carga la dirección de la variable local en un índice específico en la pila de evaluación

La instrucción stind se utiliza para almacenar el valor de nuevo en la variable

Almacene el valor del tipo (...) en la memoria en la dirección

La dirección es de 32/64 bits, dependiendo de la arquitectura de destino.

Answer 4

Pasará la variable local por referencia en lugar de enviar una nueva copia para ella