pregunta corta2

Mostrar la cita

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

realiza
Mostrar la cita

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%
Mostrar la cita

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
Mostrar la cita

> 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%
Mostrar la cita

> 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
Mostrar la cita

hacer boxing de un "reference type".

-JG

Mostrar la cita

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


Mostrar la cita

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
Mostrar la cita

> 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
Mostrar la cita

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

dos
Mostrar la cita

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

(boxing)
Mostrar la cita

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

baja
Mostrar la cita

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

este
Mostrar la cita

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

directamente
Mostrar la cita

> > > (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:
Mostrar la cita

> 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
Mostrar la cita

> 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()
Mostrar la cita

> > 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
> > > >
> > > >
> > >
> > >
> >
> >
>
>