Antes que nada, dos puntos importantes en el sistema de tipos de .

NET:
Herencia! Todos los tipos derivan de System.Object. Eso todo lo que est!
debajo es la "TS.
"ada tipo en la "TS esta de#inido, o bien como tipo valor o tipo re#erencia.
$os tipos que de#inimos usando la palabra clave struct son tipos por valor.
Todos los tipos numericos son struct%s.
$os tipos de#inidos con la palabra clave class son tipos por re#erencia.
Ambos tienen di#erentes re&las de compilacion y di#erente comportamiento en
tiempo de ejecucion.
Tipos por valor:
'erivan de System.(alueType Tienen especial comportamiento en tiempo de
ejecucion.
$as variables de este tipo contienen directamente sus valores.
$a memoria se va asi&nando )en linea) cualquiera sea el conte*to en que se
declara la variable.
No van en un )+eap) ,o mont-n. separado, no se usa un recolector de basura
para las variables por valor.
Hay dos cate&orias de variables por valor: enum y struct.
$os tipos numericos son struct, con propiedades y metodos a los que se puede
acceder:
byte b / 0yte.1a*(alue2
los declaras como valores no3a&re&ados.
byte num / 4*A2
int i / 52
c+ar c / %6%2
Estos tipos estan )sellados), osea que no se puede +eredar de ellos ni podes
+acer que +erede de al&o mas. Solo +eredan de System.(alueType.
7or otra parte, pueden implementar inter#aces varias, y asi se la puede castear
al tipo de una inter#a8 ,bo*in&..
9"uando uso struct: ;eneralmente se utili8a para crear un set peque<o de
variables relacionadas, ej:
public struct "oOrds
=
public int *, y2
public "oOrds,int p>, int p?.
=
* / p>2
y / p?2
@
@
$os enum: Estos de#inen un set de constantes enteras nombradas.
7or ejemplo, System.AO.Bile1ode es un enum:
public enum Bile1ode
=
"reateNeC / >,
"reate / ?,
Open / D,
OpenOr"reate / E,
Truncate / 5,
Append / F,
@
"reate tiene un valor ?, podriamos usar solo el numero, pero un nombre +ace un
codi&o mas le&ible que un numero.
Gn enum +ereda de System.Enum que a su ve8 +ereda de System.(alueType,
asi que todo lo que se aplica a struct se aplica a enum.
Tipos por referencia: Gn tipo de#inido como class, del&ate, array, o inter#ace es un
tipo por re#erencia.
En tiempo de ejecucion, cuando se declara una variable por re#erencia, esta
contiene el valor )null) a menos que e*plicitamente se cree una instancia del
objeto usando el operador )neC), o asi&nandle otro objeto que ya +a sido
creado en al&un otro lu&ar.Ej:
1y"lass mc / neC 1y"lass,.2
1y"lass mc? / mc2
Gna inter#a8 debe ser iniciali8ada junto con un objeto del tipo de la clase que
la implementa, ima&inando que 1y"lass implementa A1yAnter#ace seria:
A1yAnter#ace i#ace / neC 1y"lass,.2
HHo
1y"lass my"lass / neC 1y"lass,.2
A1yAnter#ace i#ace / my"lass2
"uando se crea un objeto, se aloja la memoria que va a usar en el )mana&ed
+eap), y la variable contiene solo una re#erencia a la locacion del objeto.
$os tipos alojados ac!, requieren un &asto e*tra2 cuando son alojadas o
cuando son requeridas por la cuncionalidad de manejo de memoria de la "I$
mejor conocida como )&arba&e collector). 'e cualquier manera la ;" est!
muy optimi8ada y en la mayorJa de los escenarios no &enera un proble de
per#ormance.
$os arre&los son tipos por re#erencia mas all! de que sus elementos sean tipos
por valor. Amplicitamente derivan de System.Array, pero se los puede declarar
y usar con una sinta*is simpli#icada de cK.
HH 'eclare and initiali8e an array o# inte&ers.
intLM nums / = >, ?, D, E, 5 @2
HH Access an instance property o# System.Array.
int len / nums.$en&t+2
$os tipos por re#erencia tienen todo el soporte necesario para la +erencia, se
puede +eredar de lo que sea que no estN sellado a +erencia, y otras pueden
+eredar de un t.d.r. y sobreescribir sus metodos virtuales.
Boxing y Unboxing: 0o*in& es el proceso de convertir un tipo por valor al tipo
objeto o al tipo de al&una de las inter#aces que implemente.
"uando la "$I )cajonea) ,)bo*es) 3O )bo*ea):, )encaja):. un tipo por valor, esta
ajusta dic+o valor dentro de un objeto System.Object y lo almacena en la )mana&ed
+eap). Gnbo*in&, e*trae el valor por tipo del objeto. E$ proceso de 0o*in& es
implicito, el de Gnbo*in& es e*plicito.
Este concepto subyace en el +ec+o de que un valor de cualquier tipo puede ser tratado
como un objeto.
Boxing:
int i / >?D2
HH T+e #olloCin& line bo*es i.
object o / i2
Unboxing:
o / >?D2
i / ,int.o2 HH unbo*in&
Gn ejemplo de uso:
"onsole.Prite$ine,Strin&."oncat,)AnsCer), E?, true..2
$istQobjectO mi*ed$ist / neC $istQobjectO,.2
HH Add a strin& element to t+e list.
mi*ed$ist.Add,)Birst ;roup:).2
HH Add some inte&ers to t+e list.
#or ,int j / >2 j Q 52 j.
=
HH Iest t+e mouse pointer over j to veri#y t+at you are addin&
HH an int to a list o# objects. Eac+ element j is bo*ed C+en
HH you add j to mi*ed$ist.
mi*ed$ist.Add,j.2
@
HH 'isplay t+e elements in t+e list. 'eclare t+e loop variable by
HH usin& var, so t+at t+e compiler assi&ns its type.
#oreac+ ,var item in mi*ed$ist.
=
HH Iest t+e mouse pointer over item to veri#y t+at t+e elements
HH o# mi*ed$ist are objects.
"onsole.Prite$ine,item.2
@
Todo muy lindo, pero...
Performance: En relacion a las simples asi&naciones, el bo*in& tiene un costo
computacional alto, por la construccion del objeto y la locacion en el +eap. El casteo
requerido para +acer el unbo*in& tambien es costoso, un poco menos, pero mas
costoso que una asi&nacion simple al #in.
El articulo o#icial de la documentacion de .NET sobre per#ormance, aconseja no usar
tipos por valor si se sabe que en al&un momento van a su#rir bo*in&Hunbo*in& un
numero considerable de veces. 'ice que el proceso puede tomar cerca de ?4 veces
mayor tiempo que una asi&nacion simple para bo*in&, y cuatro veces mayor para
unbo*in& por el casteo.
Todo esto y muc+o mas en: +ttp:HHmsdn.microso#t.comHlibraryH !!