¿Se implementa el boxeo/unboxing a través de la unión tardía o temprana (es decir, en tiempo de ejecución o tiempos compilantes)?

Question

Para EG:

int i=10;
object o = i; //late or early??

Similarmente,

object o = "11";
int i = (int)o;//late or early??

Answer 1

¿Se implementan el boxeo y el unboxing a través de la unión tardía o temprana? Es decir, ¿la vinculación se realiza en tiempo de ejecución o tiempo de compilación?

Estoy un poco confundido por la pregunta. La "unión" se usa típicamente para significar el resultado de algún tipo de análisis. La "vinculación temprana" generalmente significa que algún nombre se ha asociado con alguna ranura de método en el momento de la compilación; "Late Binding" asocia el nombre con la ranura en tiempo de ejecución. ¿Qué quieres decir con "vinculante" aquí en el contexto del boxeo?

Supongo que quieres decir que la vinculación tardía entra en juego solo para llamadas de método y método y no para operaciones de asignación/conversiones de tipo. Para implementar la unión dinámica, referimos objetos derivados con variables de clase base.

Eso no es exactamente lo que quise decir; Estaba usando llamadas de método como un ejemplo canónico que ilustra la diferencia entre la unión temprana y tardía. Veo mejor tu punto ahora; El análisis que determina con precisión cómo se realiza una conversión también se puede realizar en tiempo de ejecución o tiempo de compilación y, por lo tanto, es en cierto sentido también una forma de "vinculación tardía" o "vinculación temprana".

Tomemos como ejemplo esta conversión:

int x = Whatever();
short y = (short)x;

Esa conversión explícita está completamente "vinculada" en el momento de la compilación. El compilador sabe que el operando es un int, que el tipo de destino es corto, que la conversión se realizará truncando los cuatro bytes int en un byte corto. La conversión, por supuesto, se realiza en tiempo de ejecución.

Ahora dejemos un poco menos claro:

int x = Whatever();
short y = checked((short)x);

La conversión explícita está nuevamente vinculada en el momento de la compilación. Sabemos cómo se realizará la operación. Pero también sabemos que En tiempo de ejecución, el valor int se verificará para asegurarse de que se ajuste a un corto.

¿Eso cuenta como "vínculo tardío" en su libro? Parte del análisis se realiza en el momento de la compilación, pero parte del análisis se realiza en tiempo de ejecución.

Ahora consideremos el boxeo:

int x = Whatever();
object q = x;

Esto se analiza completamente en el momento de la compilación. El compilador sabe que Q es un objeto y X es un INT y, por lo tanto, tendrá que emitir instrucciones que encerren el INT en tiempo de ejecución.

¿Qué pasa con el unboxing?

int x = Whatever();
object q = x;
int y = (int)q;

¿Qué análisis se realiza en el momento de la compilación? Todo lo que sabemos en el momento de la compilación es que es una conversión de unboxing. La verificación de tipo real se realiza en tiempo de ejecución. ¿Es esa una forma de "enlace tardío" porque se realiza una verificación de tipo en tiempo de ejecución, por su definición de vinculación tardía?

¿Qué tal esto?

int x = Whatever();
object q = x;
int y = (short)q;

Eso lanza una excepción en el tiempo de ejecución. En el momento de la compilación sabemos que es una conversión de unboxing. En tiempo de ejecución, no hacemos "encuadernación tardía" para decir "Oye, tengo un INT en caja, déjame descubrir cómo convertirlo en un corto sin caja". Más bien, decimos "estamos tratando de desempaquetar un int to breve; lanza una excepción". Una T en caja solo se puede desempaquetar a una T o una T. anulable.

Entonces, ¿es el unboxing "Bound Bound" o "Tard Bound"? Está temprano en el sentido de que sabemos en el momento de la compilación que es una conversión de unboxing. Está atrasado en el sentido de que hacemos una verificación de tipo en el tiempo de ejecución. No está atrasado en el sentido de que no en tiempo de ejecución rehacemos el análisis de tipo que se habría realizado para una conversión int-breve en el momento de la compilación.

¿Y esto?

int x = Whatever();
object q = x;
int y = Convert.ToInt16(q);

o

int x = Whatever();
dynamic q = x;
int y = (int)q;

Ahora nosotros hacer Realice todo ese análisis en tiempo de ejecución; En ambos casos, hacemos el análisis de tipo de Q en tiempo de ejecución, determinamos que Q es un int en caja y "enlace tardío" la conversión.

¿Está todo claro? Es difícil responder a su pregunta porque es un poco vago con respecto a lo que quiere decir con "vinculación tardía" una conversión. ¿Qué parte del análisis es el "vinculante" para ti?

Answer 2

El boxeo se hornea en las instrucciones de IL en el tiempo de compilación si eso es lo que está buscando.

Si intenta descifrar en un tipo que no sea el tipo original, se lanzaría una excepción. Ej#1 Simplemente se encuentra implícitamente (tipo de valor para el Cast de tipo REF). Ex#2 Un elenco inválido explota en tiempo de ejecución.

No estoy seguro de cómo la vinculación temprana o tardía entra en la imagen.

Answer 3

los compilador emitirá instrucciones de boxeo que podrá ver en la IL. Código dado

int item = 10;
object obj = item;
item = (int)obj;

Te compilarás a algo como

IL_0000:  ldc.i4.s    0A 
IL_0002:  stloc.0     
IL_0003:  ldloc.0     
IL_0004:  box         System.Int32
IL_0009:  stloc.1     
IL_000A:  ldloc.1     
IL_000B:  unbox.any   System.Int32
IL_0010:  stloc.0     

En la segunda versión, eso solo va a explotar. Un objeto de cadena de tipo no se puede lanzar a un entero.

Answer 4

El C# compila las instrucciones que se ejecutan en tiempo de ejecución.

El boxeo implica un costo de tiempo de ejecución (no desconsiderable); El boxeo y el unboxing pueden causar errores de tiempo de ejecución (como su ejemplo "int i = (int) o" ilustra).

La "vinculación tardía" vs "la vinculación temprana" implica que algo es "dinámico" (por ejemplo, la vinculación del tiempo de ejecución del método virtual de algún objeto). En este caso, el boxeo es "arreglado". Así que supongo que se podría decir que es "encuentro temprano".