pregunta corta2

Tienes razón. Creo que debí utilizar la palabra Casting en vez de Boxing.

Exacto, casting y boxing son cosas *totalmente* diferentes.

Casting existe solo para asegurar "type-safety" y tiene que ver con
herencia. Herencia es uno de los *fundamentos* de la programación orientada
a objetos. Al castear un objeto, lo único que haces es cambiar el "actual
type" del objeto, nada más.

Boxing te permite poder ver cosas que no son objectos (i.e. value types)
como objetos y es un proceso más largo. Básicamente, lo que se hace es
*crear un nuevo objeto* y fijar su único atributo con el valor indicado.

Por eso es que los benchmarks que te muestra Mike tienen ese resultado.
Casting no tiene en costo alguno (o por lo menos es despreciable) y boxing
si.

-JG

Tú lo has dicho. "No ayudan MUCHO", pero ayudan ya que no hay que hacer
cast.

Eso es todo
Juan C. Olivares

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

> no voy a discutir contigo...

Buena idea.

> basta con que hagas unos benchmarks

Perfecto! Ahi va el archivo .cs. Hace pruebas de meter y sacar objetos

(un

string) y ints a un ArrayList y despues a un List<T>.

Te gustaron los resultados? Use la version 1.2.30703 del Framework.

Elapsed time for Refs with ArrayList (16777216 iterations):
00:00:00.3069657
Elapsed time for Ints with ArrayList (16777216 iterations):
00:00:03.0303180
Elapsed time for Refs with List<T> (16777216 iterations):
00:00:00.3553765
Elapsed time for Ints with List<T> (16777216 iterations):
00:00:00.2043779

Como notas, los generics ayudan a los tipos de valores porque no hay que
hacer el box y unbox (costoso porque esto genera un nuevo objeto). No
ayudan mucho a los tipos de referencia, porque un castclass no tiene mucho
costo.

Preguntas o comentarios?

(Yo tengo un P4c 3GHz , pero solo el 533MHz FSB (512MB Dual channel DDR333
RAM)).

-mike
MVP


>
> "Michael Giagnocavo [MVP]" escribió en el

mensaje

> news:e%
> > Generics daran mas rendimiento cuando usas *valuetypes* (porque ya no
hay
> > que hacer boxing). Con los reference types, ahorras el castclass

cuando

> > sacas un objeto.
> >
> > Creo que estas un poco confundido con todos estos terminos. No

necesito

> > buscar mas informacion, ya que tengo casi 3 anios trabajando con .NET,

y

> un
> > rato usando generics en C#.
> >
> > -mike
> > MVP
> >
> > "Juan Cristóbal Olivares C." wrote in message
> > news:
> > > Sí hay problemas de rendimiento. Por favor busca información acerca

de

> los
> > > genéricos.
> > >
> > > "Michael Giagnocavo [MVP]" escribió en el
> mensaje
> > > news:%
> > > > > Ya lo dejé claro en un mensaje anterior:
> > > > >
> > > > > "debí utilizar la palabra Casting en vez de Boxing"
> > > >
> > > > Si, el mensaje que llego despues de que envie el mio :).
> > > >
> > > > Aun asi, no tienes que el opcode castclass para meter un tipo
> referencia
> > > en
> > > > un objeto. No hay ningun problema de rendimiento al meter un tipo
> > > > referencia en un array de objeto[]. Eso era el punto. No pasa
boxing
> > ni
> > > > casting ni asi, solo un stelem.ref, como dije.
> > > >
> > > > De hecho, si quieres ser tecnico (este hilo es algo tecnico no?)

ni

> > tienes
> > > > que usar castclass cuando sacas algo de un object[]. castclass
sirve
> > para
> > > > que tu codigo sea verficable, pero es posible en IL. C# no lo
> generara,
> > > > pero el CLR lo soporta.
> > > >
> > > > Gracias,
> > > > -mike
> > > > MVP
> > > >
> > > >
> > > > "Juan Cristóbal Olivares C." wrote in message
> > > > news:
> > > >
> > > > >
> > > > > "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
> > > > > > > > > >
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > >
> > > > > > > >
> > > > > > >
> > > > > > >
> > > > > >
> > > > > >
> > > > >
> > > > >
> > > >
> > > >
> > >
> > >
> >
> >
> >
>
>

Desde cuando estabamos discutiendo eso? Creo que has cambiado tu punto
desde que te diste cuenta que boxing no era casting...

Pero bueno, si ves el resultado para la collecion generico veras que toma un
poquito mas (y no hace el cast). El castclass no es "un problema de
rendimiento" como dijiste. Eso es el punto. ADEMAS, en respuesta a tu post
original, meter un ref en un objeto no tiene ningun costo adicional.

Mejor revisa bien el hilo y quizas entenderas un poco mas del runtime.

Hasta el proximo hilo,
-mike
MVP
www.atrevido.net


"Juan Cristóbal Olivares C." wrote in message
news:

Tú lo has dicho. "No ayudan MUCHO", pero ayudan ya que no hay que hacer
cast.

Eso es todo
Juan C. Olivares

"Michael Giagnocavo [MVP]" escribió en el mensaje
news:
> > no voy a discutir contigo...
>
> Buena idea.
>
> > basta con que hagas unos benchmarks
>
> Perfecto! Ahi va el archivo .cs. Hace pruebas de meter y sacar objetos
(un
> string) y ints a un ArrayList y despues a un List<T>.
>
> Te gustaron los resultados? Use la version 1.2.30703 del Framework.
>
> Elapsed time for Refs with ArrayList (16777216 iterations):
> 00:00:00.3069657
> Elapsed time for Ints with ArrayList (16777216 iterations):
> 00:00:03.0303180
> Elapsed time for Refs with List<T> (16777216 iterations):
> 00:00:00.3553765
> Elapsed time for Ints with List<T> (16777216 iterations):
> 00:00:00.2043779
>
> Como notas, los generics ayudan a los tipos de valores porque no hay que
> hacer el box y unbox (costoso porque esto genera un nuevo objeto). No
> ayudan mucho a los tipos de referencia, porque un castclass no tiene

mucho

> costo.
>
> Preguntas o comentarios?
>
> (Yo tengo un P4c 3GHz , pero solo el 533MHz FSB (512MB Dual channel

DDR333

> RAM)).
>
> -mike
> MVP
>
>
> >
> > "Michael Giagnocavo [MVP]" escribió en el
mensaje
> > news:e%
> > > Generics daran mas rendimiento cuando usas *valuetypes* (porque ya

no

> hay
> > > que hacer boxing). Con los reference types, ahorras el castclass
cuando
> > > sacas un objeto.
> > >
> > > Creo que estas un poco confundido con todos estos terminos. No
necesito
> > > buscar mas informacion, ya que tengo casi 3 anios trabajando con

.NET,

y
> > un
> > > rato usando generics en C#.
> > >
> > > -mike
> > > MVP
> > >
> > > "Juan Cristóbal Olivares C." wrote in message
> > > news:
> > > > Sí hay problemas de rendimiento. Por favor busca información

acerca

de
> > los
> > > > genéricos.
> > > >
> > > > "Michael Giagnocavo [MVP]" escribió en el
> > mensaje
> > > > news:%
> > > > > > Ya lo dejé claro en un mensaje anterior:
> > > > > >
> > > > > > "debí utilizar la palabra Casting en vez de Boxing"
> > > > >
> > > > > Si, el mensaje que llego despues de que envie el mio :).
> > > > >
> > > > > Aun asi, no tienes que el opcode castclass para meter un tipo
> > referencia
> > > > en
> > > > > un objeto. No hay ningun problema de rendimiento al meter un

tipo

> > > > > referencia en un array de objeto[]. Eso era el punto. No pasa
> boxing
> > > ni
> > > > > casting ni asi, solo un stelem.ref, como dije.
> > > > >
> > > > > De hecho, si quieres ser tecnico (este hilo es algo tecnico no?)
ni
> > > tienes
> > > > > que usar castclass cuando sacas algo de un object[]. castclass
> sirve
> > > para
> > > > > que tu codigo sea verficable, pero es posible en IL. C# no lo
> > generara,
> > > > > pero el CLR lo soporta.
> > > > >
> > > > > Gracias,
> > > > > -mike
> > > > > MVP
> > > > >
> > > > >
> > > > > "Juan Cristóbal Olivares C." wrote in

message

> > > > > news:
> > > > >
> > > > > >
> > > > > > "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
> > > > > > > > > > >
> > > > > > > > > > >
> > > > > > > > > >
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > >
> > > > > > > >
> > > > > > >
> > > > > > >
> > > > > >
> > > > > >
> > > > >
> > > > >
> > > >
> > > >
> > >
> > >
> > >
> >
> >
>
>
>

Cuando dije Boxing me refería al casting y ya lo aclaré. Nunca fue mi
intención referirme al boxing, fue sólo un problema de traducción.

Es un problema de rendimiento desde que genera un retardo.

Según las especificaciones de C#2:
"...the result of the Pop method must explicitly be cast back to the
appropriate type, which is tedious to write and carries a PERFORMANE PENALTY
for run-time type checking:..."

Atte,
Juan C. Olivares

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

Desde cuando estabamos discutiendo eso? Creo que has cambiado tu punto
desde que te diste cuenta que boxing no era casting...

Pero bueno, si ves el resultado para la collecion generico veras que toma

un

poquito mas (y no hace el cast). El castclass no es "un problema de
rendimiento" como dijiste. Eso es el punto. ADEMAS, en respuesta a tu

post

original, meter un ref en un objeto no tiene ningun costo adicional.

Mejor revisa bien el hilo y quizas entenderas un poco mas del runtime.

Hasta el proximo hilo,
-mike
MVP
www.atrevido.net


"Juan Cristóbal Olivares C." wrote in message
news:
> Tú lo has dicho. "No ayudan MUCHO", pero ayudan ya que no hay que hacer
> cast.
>
> Eso es todo
> Juan C. Olivares
>
> "Michael Giagnocavo [MVP]" escribió en el

mensaje

> news:
> > > no voy a discutir contigo...
> >
> > Buena idea.
> >
> > > basta con que hagas unos benchmarks
> >
> > Perfecto! Ahi va el archivo .cs. Hace pruebas de meter y sacar

objetos

> (un
> > string) y ints a un ArrayList y despues a un List<T>.
> >
> > Te gustaron los resultados? Use la version 1.2.30703 del Framework.
> >
> > Elapsed time for Refs with ArrayList (16777216 iterations):
> > 00:00:00.3069657
> > Elapsed time for Ints with ArrayList (16777216 iterations):
> > 00:00:03.0303180
> > Elapsed time for Refs with List<T> (16777216 iterations):
> > 00:00:00.3553765
> > Elapsed time for Ints with List<T> (16777216 iterations):
> > 00:00:00.2043779
> >
> > Como notas, los generics ayudan a los tipos de valores porque no hay

que

> > hacer el box y unbox (costoso porque esto genera un nuevo objeto). No
> > ayudan mucho a los tipos de referencia, porque un castclass no tiene
mucho
> > costo.
> >
> > Preguntas o comentarios?
> >
> > (Yo tengo un P4c 3GHz , pero solo el 533MHz FSB (512MB Dual channel
DDR333
> > RAM)).
> >
> > -mike
> > MVP
> >
> >
> > >
> > > "Michael Giagnocavo [MVP]" escribió en el
> mensaje
> > > news:e%
> > > > Generics daran mas rendimiento cuando usas *valuetypes* (porque ya
no
> > hay
> > > > que hacer boxing). Con los reference types, ahorras el castclass
> cuando
> > > > sacas un objeto.
> > > >
> > > > Creo que estas un poco confundido con todos estos terminos. No
> necesito
> > > > buscar mas informacion, ya que tengo casi 3 anios trabajando con
.NET,
> y
> > > un
> > > > rato usando generics en C#.
> > > >
> > > > -mike
> > > > MVP
> > > >
> > > > "Juan Cristóbal Olivares C." wrote in message
> > > > news:
> > > > > Sí hay problemas de rendimiento. Por favor busca información
acerca
> de
> > > los
> > > > > genéricos.
> > > > >
> > > > > "Michael Giagnocavo [MVP]" escribió en

el

> > > mensaje
> > > > > news:%
> > > > > > > Ya lo dejé claro en un mensaje anterior:
> > > > > > >
> > > > > > > "debí utilizar la palabra Casting en vez de Boxing"
> > > > > >
> > > > > > Si, el mensaje que llego despues de que envie el mio :).
> > > > > >
> > > > > > Aun asi, no tienes que el opcode castclass para meter un tipo
> > > referencia
> > > > > en
> > > > > > un objeto. No hay ningun problema de rendimiento al meter un
tipo
> > > > > > referencia en un array de objeto[]. Eso era el punto. No

pasa

> > boxing
> > > > ni
> > > > > > casting ni asi, solo un stelem.ref, como dije.
> > > > > >
> > > > > > De hecho, si quieres ser tecnico (este hilo es algo tecnico

no?)

> ni
> > > > tienes
> > > > > > que usar castclass cuando sacas algo de un object[].

castclass

> > sirve
> > > > para
> > > > > > que tu codigo sea verficable, pero es posible en IL. C# no lo
> > > generara,
> > > > > > pero el CLR lo soporta.
> > > > > >
> > > > > > Gracias,
> > > > > > -mike
> > > > > > MVP
> > > > > >
> > > > > >
> > > > > > "Juan Cristóbal Olivares C." wrote in
message
> > > > > > news:
> > > > > >
> > > > > > >
> > > > > > > "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
> > > > > > > > > > > >
> > > > > > > > > > > >
> > > > > > > > > > >
> > > > > > > > > > >
> > > > > > > > > >
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > >
> > > > > > > >
> > > > > > >
> > > > > > >
> > > > > >
> > > > > >
> > > > >
> > > > >
> > > >
> > > >
> > > >
> > >
> > >
> >
> >
> >
>
>

No sé hasta cuando quieren seguir discutiendo esto, ya lo aclaré.

"Juan Gabriel Del Cid" escribió en el mensaje
news:

> Tienes razón. Creo que debí utilizar la palabra Casting en vez de

Boxing.

Exacto, casting y boxing son cosas *totalmente* diferentes.

Casting existe solo para asegurar "type-safety" y tiene que ver con
herencia. Herencia es uno de los *fundamentos* de la programación

orientada

a objetos. Al castear un objeto, lo único que haces es cambiar el "actual
type" del objeto, nada más.

Boxing te permite poder ver cosas que no son objectos (i.e. value types)
como objetos y es un proceso más largo. Básicamente, lo que se hace es
*crear un nuevo objeto* y fijar su único atributo con el valor indicado.

Por eso es que los benchmarks que te muestra Mike tienen ese resultado.
Casting no tiene en costo alguno (o por lo menos es despreciable) y boxing
si.

-JG