pregunta corta2

No es así. Cuando un tipo es transformado a un tipo base, también se

realiza

un boxing.

Eh... no, eso no es asi. Cualquier objeto puede ser visto como cualquier
tipo en la jerarquia de tipos. En este caso, cualquier objeto puede ser
visto, pues, como un Object. No es necesario, y como dice Mike, es imposible
hacer boxing de un "reference type".

-JG

Al hacer un cast desde object al tipo original es necesario hacer una
conversión.

Nota: Esto se evita con el uso de genéricos.

.assembly extern mscorlib
{
.ver 1:0:3300:0
}
.assembly '13'
{
.hash algorithm 0x00008004
.ver 0:0:0:0
}
.class private auto ansi beforefieldinit programa
extends [mscorlib]System.Object
{

// method line 1
.method public hidebysig specialname rtspecialname
instance default void .ctor() cil managed
{
// Method begins at RVA 0x20ec
// Code size 101 (0x65)
.maxstack 7
.locals init (
object[] V_0,
object V_1,
object V_2,
object V_3,
object[] V_4,
int32 V_5)
IL_0000: ldarg.0
IL_0001: call instance void valuetype [corlib]System.Object::.ctor()
IL_0006: ldc.i4.3
IL_0007: newarr [mscorlib]System.Object
IL_000c: stloc.s 4
IL_000e: ldloc.s 4
IL_0010: ldc.i4.0
IL_0011: newobj instance void valuetype [corlib]System.Object::.ctor()
IL_0016: stelem.ref
IL_0017: ldloc.s 4
IL_0019: ldc.i4.1
IL_001a: ldloca.s 5
IL_001c: initobj [mscorlib]System.Int32
IL_0022: ldloc.s 5
IL_0024: box [mscorlib]System.Int32
IL_0029: stelem.ref
IL_002a: ldloc.s 4
IL_002c: ldc.i4.2
IL_002d: newobj instance void class [corlib]System.Exception::.ctor()
IL_0032: stelem.ref
IL_0033: ldloc.s 4
IL_0035: stloc.0
IL_0036: ldloc.0
IL_0037: ldc.i4.0
IL_0038: ldelem.ref
IL_0039: stloc.1
IL_003a: ldloc.1
IL_003b: call void class [corlib]System.Console::WriteLine(object)
IL_0040: ldloc.0
IL_0041: ldc.i4.1
IL_0042: ldelem.ref
IL_0043: unbox [mscorlib]System.Int32
IL_0048: ldind.i4
IL_0049: box [mscorlib]System.Int32
IL_004e: stloc.2
IL_004f: ldloc.2
IL_0050: call void class [corlib]System.Console::WriteLine(object)
IL_0055: ldloc.0
IL_0056: ldc.i4.2
IL_0057: ldelem.ref
IL_0058: castclass [mscorlib]System.Exception
IL_005d: stloc.3
IL_005e: ldloc.3
IL_005f: call void class [corlib]System.Console::WriteLine(object)
IL_0064: ret
} // end of method programa::instance default void .ctor()

// method line 2
.method public static
default void Main() cil managed
{
// Method begins at RVA 0x215d
.entrypoint
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method programa::default void Main()

} // end of type programa





"Michael Giagnocavo [MVP]" escribió en el mensaje
news:%23%

using System;
class c1 {
public static void Main() {
object[] arreglo = new object[] { new Exception(), new Int32(), new
Object() };
}
}

Compilar con CSC. ILDASM:
.method public hidebysig static void Main() cil managed
{
.entrypoint
// Code size 35 (0x23)
.maxstack 3
.locals init (object[] V_0,
object[] V_1)
IL_0000: ldc.i4.3
IL_0001: newarr [mscorlib]System.Object
IL_0006: stloc.1
IL_0007: ldloc.1
IL_0008: ldc.i4.0
IL_0009: newobj instance void [mscorlib]System.Exception::.ctor()
IL_000e: stelem.ref
IL_000f: ldloc.1
IL_0010: ldc.i4.1
IL_0011: ldc.i4.0
IL_0012: box [mscorlib]System.Int32
IL_0017: stelem.ref
...
IL_0022: ret
} // end of method c1::Main

Dime, donde esta el box para el Exception? Boxing solo existe para
ValueTypes. Como puedes ver, para tipos referencia, no es necesario hacer
un box. Ni es posible.

-mike
MVP


"Juan Cristóbal Olivares C." wrote in message
news:
> No es así. Cuando un tipo es transformado a un tipo base, también se
realiza
> un boxing.
>
> "Michael Giagnocavo [MVP]" escribió en el

mensaje

> news:uNg$
> > > object[] arreglo = new object { new Exception (), new Int32 (), new
> Object
> > > () };
> > >
> > > Todos los elementos son almacenados como objects, pero aquí hay dos
> > > problemas:
> > >
> > > 1.- Rendimiento: los elementos tienen que ser encapsulados (boxing)
> hacia
> > > object y, para volver a usarlos, hay que desencapsularlos. Esto baja
el
> > > rendimiento de la aplicación.
> >
> > Bueno, solo los ValueTypes tendran que ser boxeados (el Int32 en este
> caso).
> > Los otros elementos (tipos referencia) seran almacenados directamente
> > (stelem.ref).
> >
> > -mike
> > MVP
> >
> >
>
>

Tienes razón. Creo que debí utilizar la palabra Casting en vez de Boxing.
"Juan Gabriel Del Cid" escribió en el mensaje
news:OCxl%

> No es así. Cuando un tipo es transformado a un tipo base, también se
realiza
> un boxing.

Eh... no, eso no es asi. Cualquier objeto puede ser visto como cualquier
tipo en la jerarquia de tipos. En este caso, cualquier objeto puede ser
visto, pues, como un Object. No es necesario, y como dice Mike, es

imposible

hacer boxing de un "reference type".

-JG

Al hacer un cast desde object al tipo original es necesario hacer una
conversión.

ESO si, pero no tiene NADA que ver al respeto de boxing (solo con los
valuetypes tendras un unbox), ni al guardar un tipo referencia en un array
object[].

-mike
MVP

Nota: Esto se evita con el uso de genéricos.

.assembly extern mscorlib
{
.ver 1:0:3300:0
}
.assembly '13'
{
.hash algorithm 0x00008004
.ver 0:0:0:0
}
.class private auto ansi beforefieldinit programa
extends [mscorlib]System.Object
{

// method line 1
.method public hidebysig specialname rtspecialname
instance default void .ctor() cil managed
{
// Method begins at RVA 0x20ec
// Code size 101 (0x65)
.maxstack 7
.locals init (
object[] V_0,
object V_1,
object V_2,
object V_3,
object[] V_4,
int32 V_5)
IL_0000: ldarg.0
IL_0001: call instance void valuetype [corlib]System.Object::.ctor()
IL_0006: ldc.i4.3
IL_0007: newarr [mscorlib]System.Object
IL_000c: stloc.s 4
IL_000e: ldloc.s 4
IL_0010: ldc.i4.0
IL_0011: newobj instance void valuetype [corlib]System.Object::.ctor()
IL_0016: stelem.ref
IL_0017: ldloc.s 4
IL_0019: ldc.i4.1
IL_001a: ldloca.s 5
IL_001c: initobj [mscorlib]System.Int32
IL_0022: ldloc.s 5
IL_0024: box [mscorlib]System.Int32
IL_0029: stelem.ref
IL_002a: ldloc.s 4
IL_002c: ldc.i4.2
IL_002d: newobj instance void class [corlib]System.Exception::.ctor()
IL_0032: stelem.ref
IL_0033: ldloc.s 4
IL_0035: stloc.0
IL_0036: ldloc.0
IL_0037: ldc.i4.0
IL_0038: ldelem.ref
IL_0039: stloc.1
IL_003a: ldloc.1
IL_003b: call void class [corlib]System.Console::WriteLine(object)
IL_0040: ldloc.0
IL_0041: ldc.i4.1
IL_0042: ldelem.ref
IL_0043: unbox [mscorlib]System.Int32
IL_0048: ldind.i4
IL_0049: box [mscorlib]System.Int32
IL_004e: stloc.2
IL_004f: ldloc.2
IL_0050: call void class [corlib]System.Console::WriteLine(object)
IL_0055: ldloc.0
IL_0056: ldc.i4.2
IL_0057: ldelem.ref
IL_0058: castclass [mscorlib]System.Exception
IL_005d: stloc.3
IL_005e: ldloc.3
IL_005f: call void class [corlib]System.Console::WriteLine(object)
IL_0064: ret
} // end of method programa::instance default void .ctor()

// method line 2
.method public static
default void Main() cil managed
{
// Method begins at RVA 0x215d
.entrypoint
// Code size 1 (0x1)
.maxstack 8
IL_0000: ret
} // end of method programa::default void Main()

} // end of type programa





"Michael Giagnocavo [MVP]" escribió en el mensaje
news:%23%
> using System;
> class c1 {
> public static void Main() {
> object[] arreglo = new object[] { new Exception(), new Int32(), new
> Object() };
> }
> }
>
> Compilar con CSC. ILDASM:
> .method public hidebysig static void Main() cil managed
> {
> .entrypoint
> // Code size 35 (0x23)
> .maxstack 3
> .locals init (object[] V_0,
> object[] V_1)
> IL_0000: ldc.i4.3
> IL_0001: newarr [mscorlib]System.Object
> IL_0006: stloc.1
> IL_0007: ldloc.1
> IL_0008: ldc.i4.0
> IL_0009: newobj instance void [mscorlib]System.Exception::.ctor()
> IL_000e: stelem.ref
> IL_000f: ldloc.1
> IL_0010: ldc.i4.1
> IL_0011: ldc.i4.0
> IL_0012: box [mscorlib]System.Int32
> IL_0017: stelem.ref
> ...
> IL_0022: ret
> } // end of method c1::Main
>
> Dime, donde esta el box para el Exception? Boxing solo existe para
> ValueTypes. Como puedes ver, para tipos referencia, no es necesario

hacer

> un box. Ni es posible.
>
> -mike
> MVP
>
>
> "Juan Cristóbal Olivares C." wrote in message
> news:
> > No es así. Cuando un tipo es transformado a un tipo base, también se
> realiza
> > un boxing.
> >
> > "Michael Giagnocavo [MVP]" escribió en el
mensaje
> > news:uNg$
> > > > object[] arreglo = new object { new Exception (), new Int32 (),

new

> > Object
> > > > () };
> > > >
> > > > Todos los elementos son almacenados como objects, pero aquí hay

dos

> > > > problemas:
> > > >
> > > > 1.- Rendimiento: los elementos tienen que ser encapsulados

(boxing)

> > hacia
> > > > object y, para volver a usarlos, hay que desencapsularlos. Esto

baja

> el
> > > > rendimiento de la aplicación.
> > >
> > > Bueno, solo los ValueTypes tendran que ser boxeados (el Int32 en

este

> > caso).
> > > Los otros elementos (tipos referencia) seran almacenados

directamente

> > > (stelem.ref).
> > >
> > > -mike
> > > MVP
> > >
> > >
> >
> >
>
>

Ya lo dejé claro en un mensaje anterior:

"debí utilizar la palabra Casting en vez de Boxing"

"Michael Giagnocavo [MVP]" escribió en el mensaje
news:

> Al hacer un cast desde object al tipo original es necesario hacer una
> conversión.

ESO si, pero no tiene NADA que ver al respeto de boxing (solo con los
valuetypes tendras un unbox), ni al guardar un tipo referencia en un array
object[].

-mike
MVP


> Nota: Esto se evita con el uso de genéricos.
>
> .assembly extern mscorlib
> {
> .ver 1:0:3300:0
> }
> .assembly '13'
> {
> .hash algorithm 0x00008004
> .ver 0:0:0:0
> }
> .class private auto ansi beforefieldinit programa
> extends [mscorlib]System.Object
> {
>
> // method line 1
> .method public hidebysig specialname rtspecialname
> instance default void .ctor() cil managed
> {
> // Method begins at RVA 0x20ec
> // Code size 101 (0x65)
> .maxstack 7
> .locals init (
> object[] V_0,
> object V_1,
> object V_2,
> object V_3,
> object[] V_4,
> int32 V_5)
> IL_0000: ldarg.0
> IL_0001: call instance void valuetype [corlib]System.Object::.ctor()
> IL_0006: ldc.i4.3
> IL_0007: newarr [mscorlib]System.Object
> IL_000c: stloc.s 4
> IL_000e: ldloc.s 4
> IL_0010: ldc.i4.0
> IL_0011: newobj instance void valuetype [corlib]System.Object::.ctor()
> IL_0016: stelem.ref
> IL_0017: ldloc.s 4
> IL_0019: ldc.i4.1
> IL_001a: ldloca.s 5
> IL_001c: initobj [mscorlib]System.Int32
> IL_0022: ldloc.s 5
> IL_0024: box [mscorlib]System.Int32
> IL_0029: stelem.ref
> IL_002a: ldloc.s 4
> IL_002c: ldc.i4.2
> IL_002d: newobj instance void class [corlib]System.Exception::.ctor()
> IL_0032: stelem.ref
> IL_0033: ldloc.s 4
> IL_0035: stloc.0
> IL_0036: ldloc.0
> IL_0037: ldc.i4.0
> IL_0038: ldelem.ref
> IL_0039: stloc.1
> IL_003a: ldloc.1
> IL_003b: call void class [corlib]System.Console::WriteLine(object)
> IL_0040: ldloc.0
> IL_0041: ldc.i4.1
> IL_0042: ldelem.ref
> IL_0043: unbox [mscorlib]System.Int32
> IL_0048: ldind.i4
> IL_0049: box [mscorlib]System.Int32
> IL_004e: stloc.2
> IL_004f: ldloc.2
> IL_0050: call void class [corlib]System.Console::WriteLine(object)
> IL_0055: ldloc.0
> IL_0056: ldc.i4.2
> IL_0057: ldelem.ref
> IL_0058: castclass [mscorlib]System.Exception
> IL_005d: stloc.3
> IL_005e: ldloc.3
> IL_005f: call void class [corlib]System.Console::WriteLine(object)
> IL_0064: ret
> } // end of method programa::instance default void .ctor()
>
> // method line 2
> .method public static
> default void Main() cil managed
> {
> // Method begins at RVA 0x215d
> .entrypoint
> // Code size 1 (0x1)
> .maxstack 8
> IL_0000: ret
> } // end of method programa::default void Main()
>
> } // end of type programa
>
>
>
>
>
> "Michael Giagnocavo [MVP]" escribió en el

mensaje

> news:%23%
> > using System;
> > class c1 {
> > public static void Main() {
> > object[] arreglo = new object[] { new Exception(), new Int32(), new
> > Object() };
> > }
> > }
> >
> > Compilar con CSC. ILDASM:
> > .method public hidebysig static void Main() cil managed
> > {
> > .entrypoint
> > // Code size 35 (0x23)
> > .maxstack 3
> > .locals init (object[] V_0,
> > object[] V_1)
> > IL_0000: ldc.i4.3
> > IL_0001: newarr [mscorlib]System.Object
> > IL_0006: stloc.1
> > IL_0007: ldloc.1
> > IL_0008: ldc.i4.0
> > IL_0009: newobj instance void

[mscorlib]System.Exception::.ctor()

> > IL_000e: stelem.ref
> > IL_000f: ldloc.1
> > IL_0010: ldc.i4.1
> > IL_0011: ldc.i4.0
> > IL_0012: box [mscorlib]System.Int32
> > IL_0017: stelem.ref
> > ...
> > IL_0022: ret
> > } // end of method c1::Main
> >
> > Dime, donde esta el box para el Exception? Boxing solo existe para
> > ValueTypes. Como puedes ver, para tipos referencia, no es necesario
hacer
> > un box. Ni es posible.
> >
> > -mike
> > MVP
> >
> >
> > "Juan Cristóbal Olivares C." wrote in message
> > news:
> > > No es así. Cuando un tipo es transformado a un tipo base, también se
> > realiza
> > > un boxing.
> > >
> > > "Michael Giagnocavo [MVP]" escribió en el
> mensaje
> > > news:uNg$
> > > > > object[] arreglo = new object { new Exception (), new Int32 (),
new
> > > Object
> > > > > () };
> > > > >
> > > > > Todos los elementos son almacenados como objects, pero aquí hay
dos
> > > > > problemas:
> > > > >
> > > > > 1.- Rendimiento: los elementos tienen que ser encapsulados
(boxing)
> > > hacia
> > > > > object y, para volver a usarlos, hay que desencapsularlos. Esto
baja
> > el
> > > > > rendimiento de la aplicación.
> > > >
> > > > Bueno, solo los ValueTypes tendran que ser boxeados (el Int32 en
este
> > > caso).
> > > > Los otros elementos (tipos referencia) seran almacenados
directamente
> > > > (stelem.ref).
> > > >
> > > > -mike
> > > > MVP
> > > >
> > > >
> > >
> > >
> >
> >
>
>