El lenguaje de programación C# Índice

INTRODUCCIÓN A LA OBRA .................................................................................... 8
REQUISITOS PREVIOS RECOMENDADOS ..................................................................................... 8
ESTRUCTURA DE LA OBRA ...................................................................................................... 8
CONVENIOS DE NOTACIÓN ...................................................................................................... 8
TEMA 1: INTRODUCCIÓN A MICROSOFT.NET ................................................. 11
MICROSOFT.NET .............................................................................................................. 11
COMMON LANGUAGE RUNTIME (CLR) .............................................................................. 11
MICROSOFT INTERMEDIATE LANGUAGE (MSIL) .................................................................. 14
METADATOS ....................................................................................................................... 16
ENSAMBLADOS .................................................................................................................... 17
LIBRERÍA DE CLASE BASE (BCL) ......................................................................................... !
COMMON T"PE S"STEM (CTS) .......................................................................................... 1
COMMON LANGUAGE SPECIFICATION (CLS) ........................................................................ 1
TEMA : INTRODUCCIÓN A C# .............................................................................. $
ORIGEN " NECESIDAD DE UN NUEVO LENGUA%E ....................................................................... $
CARACTERÍSTICAS DE C# .................................................................................................... $
ESCRITURA DE APLICACIONES ............................................................................................... 8
APLICACIÓN BÁSICA ¡HLA !"N#$ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &'
P"N(S #E EN()A#A %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% *+
C!PILACIÓN EN LÍNEA #E C!AN#S %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% *+
C!PILACIÓN CN ,IS"AL S("#I%NE( %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% **
TEMA $: EL PREPROCESADOR .............................................................................. $7
CONCEPTO DE PREPROCESADOR ............................................................................................ $7
DIRECTIVAS DE PREPROCESADO ............................................................................................ $7
CNCEP( #E #I)EC(I,A% SIN(A-IS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% *.
#E/INICIÓN #E I#EN(I/ICA#)ES #E P)EP)CESA# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% *'
ELI!INACIÓN #E I#EN(I/ICA#)ES #E P)EP)CESA# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% *0
C!PILACIÓN CN#ICINAL %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% *0
1ENE)ACIÓN #E A,ISS 2 E)))ES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 3&
CA!BIS EN LA N"!E)ACIÓN #E LÍNEAS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 3*
!A)CA# #E )E1INES #E CÓ#I1 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 3*
TEMA 4: ASPECTOS L&'ICOS ................................................................................ 46
COMENTARIOS .................................................................................................................... 46
IDENTIFICADORES ................................................................................................................ 47
PALABRAS RESERVADAS ....................................................................................................... 47
LITERALES ......................................................................................................................... 4(
OPERADORES ...................................................................................................................... )1
4o56 An7onio 1on89le8 Seco P9gina :
El lenguaje de programación C# Índice
TEMA ): CLASES ........................................................................................................ )8
DEFINICIÓN DE CLASES ........................................................................................................ )8
CNCEP(S #E CLASE 2 B4E( %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ;'
SIN(A-IS #E #E/INICIÓN #E CLASES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ;'
CREACIÓN DE OB%ETOS ........................................................................................................ 61
PE)A#) NE< %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% =:
CNS()"C() P) #E/EC( %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% =*
)E/E)ENCIA AL B4E( AC("AL CN (HIS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% =*
*ERENCIA " M&TODOS VIRTUALES ........................................................................................ 64
CNCEP( #E HE)ENCIA %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% =3
LLA!A#AS P) #E/EC( AL CNS()"C() BASE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ==
!>(#S ,I)("ALES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ==
CLASES ABS()AC(AS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% =0
LA CLASE PRIMEGENIA: S"STEM.OB%ECT .............................................................................. 6(
POLIMORFISMO ................................................................................................................... 7$
CNCEP( #E PLI!)/IS! %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% .*
!>(#S 1EN>)ICS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% .3
#E(E)!INACIÓN #E (IP% PE)A#) IS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% .;
ACCES A LA CLASE BASE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% .;
#<NCAS(IN1 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ..
CLASES 2 !>(#S SELLA#S %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ..
OCULTACIÓN DE MIEMBROS ................................................................................................. 78
MIEMBROS DE TIPO ............................................................................................................. 8$
ENCAPSULACIÓN ................................................................................................................. 84
TEMA 6: ESPACIOS DE NOMBRES ........................................................................ 8(
CONCEPTO DE ESPACIO DE NOMBRES ..................................................................................... 8(
DEFINICIÓN DE ESPACIOS DE NOMBRES .................................................................................. 8(
IMPORTACIÓN DE ESPACIOS DE NOMBRES ............................................................................... (!
SEN(ENCIA "SIN1 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 0+
ESPECI/ICACIÓN #E ALIAS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 0&
ESPACIO DE NOMBRES DISTRIBUIDOS ..................................................................................... ($
TEMA 7: VARIABLES " TIPOS DE DATOS .......................................................... ()
DEFINICIÓN DE VARIABLES ................................................................................................... ()
TIPOS DE DATOS B+SICOS ..................................................................................................... (6
TABLAS .............................................................................................................................. (8
(ABLAS "NI#I!ENSINALES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 0'
(ABLAS #EN(A#AS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :++
(ABLAS !"L(I#I!ENSINALES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :+:
(ABLAS !I-(AS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :+*
C,A)IAN?A #E (ABLAS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :+*
LA CLASE S2S(E!%A))A2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :+*
CADENAS DE TE'TO ........................................................................................................... 1!4
CONSTANTES .................................................................................................................... 1!(
VARIABLES DE SÓLO LECTURA ............................................................................................ 11!
4o56 An7onio 1on89le8 Seco P9gina &
El lenguaje de programación C# Índice
ORDEN DE INICIALI,ACIÓN DE VARIABLES ............................................................................ 111
TEMA 8: M&TODOS ................................................................................................. 11$
CONCEPTO DE M&TODO ...................................................................................................... 11$
DEFINICIÓN DE M&TODOS ................................................................................................... 11$
LLAMADA A M&TODOS ....................................................................................................... 114
TIPOS DE PAR+METROS. SINTA'IS DE DEFINICIÓN ................................................................. 114
PA)Á!E()S #E EN()A#A %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ::;
PA)Á!E()S #E SALI#A %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ::=
PA)Á!E()S P) )E/E)ENCIA %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ::.
PA)Á!E()S #E N@!E) IN#E/INI# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ::.
SB)ECA)1A #E (IPS #E PA)Á!E()S %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ::'
M&TODOS E'TERNOS ......................................................................................................... 118
CONSTRUCTORES ............................................................................................................... 11(
CNCEP( #E CNS()"C()ES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ::0
#E/INICIÓN #E CNS()"C()ES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :&+
LLA!A#A AL CNS()"C() %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :&+
LLA!A#AS EN()E CNS()"C()ES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :&+
CNS()"C() P) #E/EC( %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :&&
LLA!A#AS PLI!Ó)/ICAS EN CNS()"C()ES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :&*
CNS()"C() #E (IP %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :&3
DESTRUCTORES ................................................................................................................. 1)
TEMA (: PROPIEDADES ......................................................................................... 1(
CONCEPTO DE PROPIEDAD .................................................................................................. 1(
DEFINICIÓN DE PROPIEDADES .............................................................................................. 1(
ACCESO A PROPIEDADES .................................................................................................... 1$!
IMPLEMENTACIÓN INTERNA DE PROPIEDADES ........................................................................ 1$1
TEMA 1!: INDI,ADORES ........................................................................................ 1$$
CONCEPTO DE INDI,ADOR .................................................................................................. 1$$
DEFINICIÓN DE INDI,ADOR ................................................................................................. 1$$
ACCESO A INDI,ADORES ..................................................................................................... 1$4
IMPLEMENTACIÓN INTERNA DE INDI,ADORES ........................................................................ 1$)
TEMA 11: REDEFINICIÓN DE OPERADORES ................................................... 1$6
CONCEPTO DE REDEFINICIÓN DE OPERADOR ......................................................................... 1$6
DEFINICIÓN DE REDEFINICIONES DE OPERADORES .................................................................. 1$7
SIN(A-IS 1ENE)AL #E )E#E/INICIÓN #E PE)A#) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :*.
)E#E/INICIÓN #E PE)A#)ES "NA)IS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :*0
)E#E/INICIÓN #E PE)A#)ES BINA)IS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :3+
REDEFINICIONES DE OPERADORES DE CONVERSIÓN ................................................................ 141
4o56 An7onio 1on89le8 Seco P9gina *
El lenguaje de programación C# Índice
TEMA 1: DELEGADOS " EVENTOS ................................................................... 146
CONCEPTO DE DELEGADO ................................................................................................... 146
DEFINICIÓN DE DELEGADOS ................................................................................................ 146
MANIPULACIÓN DE OB%ETOS DELEGADOS ............................................................................. 148
LA CLASE S"STEM.MULTICASTDELEGATE .......................................................................... 1)1
LLAMADAS ASÍNCRONAS ..................................................................................................... 1)
IMPLEMENTACIÓN INTERNA DE LOS DELEGADOS .................................................................... 1))
EVENTOS .......................................................................................................................... 1)7
CNCEP( #E E,EN( %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :;.
SIN(A-IS BÁSICA #E #E/INICIÓN #E E,EN(S %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :;.
SIN(A-IS C!PLE(A #E #E/INICIÓN #E E,EN(S %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :;.
TEMA 1$: ESTRUCTURAS ...................................................................................... 16!
CONCEPTO DE ESTRUCTURA ................................................................................................ 16!
DIFERENCIAS ENTRE CLASES " ESTRUCTURAS ....................................................................... 16!
BO'ING " UNBO'ING ......................................................................................................... 161
CONSTRUCTORES ............................................................................................................... 16$
TEMA 14: ENUMERACIONES ................................................................................ 166
CONCEPTO DE ENUMERACIÓN ............................................................................................. 166
DEFINICIÓN DE ENUMERACIONES ......................................................................................... 167
USO DE ENUMERACIONES ................................................................................................... 168
LA CLASE S"STEM.ENUM ................................................................................................. 16(
ENUMERACIONES DE FLAGS ................................................................................................ 171
TEMA 1): INTERFACES .......................................................................................... 174
CONCEPTO DE INTERFA, .................................................................................................... 174
DEFINICIÓN DE INTERFACES ............................................................................................... 174
IMPLEMENTACIÓN DE INTERFACES ....................................................................................... 176
ACCESO A MIEMBROS DE UNA INTERFA, .............................................................................. 17(
ACCES A !IE!B)S #E IN(E)/ACES 2 B-IN1 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :':
TEMA 16: INSTRUCCIONES ................................................................................... 18$
CONCEPTO DE INSTRUCCIÓN ............................................................................................... 18$
INSTRUCCIONES B+SICAS .................................................................................................... 18$
#E/INICINES #E ,A)IABLES LCALES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :'*
ASI1NACINES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :'*
LLA!A#AS A !>(#S %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :'3
INS()"CCIÓN N"LA %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :'3
INSTRUCCIONES CONDICIONALES ......................................................................................... 184
INS()"CCIÓN I/ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :'3
INS()"CCIÓN S<I(CH %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :';
4o56 An7onio 1on89le8 Seco P9gina 3
El lenguaje de programación C# Índice
INSTRUCCIONES ITERATIVAS ............................................................................................... 187
INS()"CCIÓN <HILE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :'.
INS()"CCIÓN #%%%<HILE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :''
INS()"CCIÓN /) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :''
INS()"CCIÓN /)EACH %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :'0
INSTRUCCIONES DE E'CEPCIONES ........................................................................................ 1($
CNCEP( #E E-CEPCIÓN% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :0*
LA CLASE S2S(E!%E-CEP(IN %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :03
E-CEPCINES P)E#E/INI#AS C!"NES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :0;
LAN?A!IEN( #E E-CEPCINES% INS()"CCIÓN (H)< %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :0=
CAP(")A #E E-CEPCINES% INS()"CCIÓN ()2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% :0.
INSTRUCCIONES DE SALTO .................................................................................................. !1
INS()"CCIÓN B)EAA %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &+:
INS()"CCIÓN CN(IN"E %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &+&
INS()"CCIÓN )E(")N %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &+&
INS()"CCIÓN 1( %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &+*
INS()"CCIÓN (H)< %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &+3
OTRAS INSTRUCCIONES ...................................................................................................... !4
INS()"CCINES CHECAE# 2 "NCHECAE# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &+3
INS()"CCIÓN LCA %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &+;
INS()"CCIÓN "SIN1 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &+=
INS()"CCIÓN /I-E# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &+'
TEMA 17: ATRIBUTOS ............................................................................................ !(
CONCEPTO DE ATRIBUTO .................................................................................................... !(
UTILI,ACIÓN DE ATRIBUTOS ............................................................................................... !(
DEFINICIÓN DE NUEVOS ATRIBUTOS ..................................................................................... 11
ESPECI/ICACIÓN #EL N!B)E #EL A()IB"( %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &::
ESPECI/ICACIÓN #EL "S #E "N A()IB"( %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &::
ESPECI/ICACIÓN #E PA)Á!E()S ,ÁLI#S %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &:*
LECTURA DE ATRIBUTOS EN TIEMPO DE E%ECUCIÓN ............................................................... 1$
ATRIBUTOS DE COMPILACIÓN ............................................................................................. 17
A()IB"( S2S(E!%A(()IB"(E"SA1E %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &:.
A()IB"( S2S(E!%BSLE(E %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &:.
A()IB"( S2S(E!%#IA1NS(ICS%CN#I(INAL %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &:'
A()IB"( S2S(E!%CLSC!PLIAN( %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &:0
PSEUDOATRIBUTOS ............................................................................................................ 1(
TEMA 18: CÓDIGO INSEGURO ............................................................................. 1
CONCEPTO DE CÓDIGO INSEGURO ........................................................................................ 1
COMPILACIÓN DE CÓDIGOS INSEGUROS ................................................................................ 1
MARCADO DE CÓDIGOS INSEGUROS .....................................................................................
DEFINICIÓN DE PUNTEROS .................................................................................................. $
MANIPULACIÓN DE PUNTEROS ............................................................................................. 4
B(ENCIÓN #E #I)ECCIÓN #E !E!)IA% PE)A#) B %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &&3
ACCES A CN(ENI# #E P"N(E)% PE)A#) C %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &&;
ACCES A !IE!B) #E CN(ENI# #E P"N(E)% PE)A#) DE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &&;
4o56 An7onio 1on89le8 Seco P9gina ;
El lenguaje de programación C# Índice
CN,E)SINES #E P"N(E)S %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &&=
A)I(!>(ICA #E P"N(E)S %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &&.
OPERADORES RELACIONADOS CON CÓDIGO INSEGURO ........................................................... 8
PE)A#) SI?E/% B(ENCIÓN #E (A!AF #E (IP %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &&'
PE)A#) S(ACAALLC% C)EACIÓN #E (ABLAS EN PILA% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &&0
FI%ACIÓN DE VARIABLES APUNTADAS ................................................................................... $!
TEMA 1(: DOCUMENTACIÓN 'ML .................................................................... $$
CONCEPTO " UTILIDAD DE LA DOCUMENTACIÓN 'ML ......................................................... $$
INTRODUCCIÓN A 'ML .................................................................................................... $4
COMENTARIOS DE DOCUMENTACIÓN 'ML .......................................................................... $)
SIN(A-IS 1ENE)AL %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &*;
EL A()IB"( C)E/ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &*=
ETIQUETAS RECOMENDADAS PARA DOCUMENTACIÓN 'ML .................................................. $8
E(IG"E(AS #E "S 1EN>)IC %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &*'
E(IG"E(AS )ELA(I,AS A !>(#S %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &*0
E(IG"E(AS )ELA(I,AS A P)PIE#A#ES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &3+
E(IG"E(AS )ELA(I,AS A E-CEPCINES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &3+
E(IG"E(AS )ELA(I,AS A /)!A( %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &3:
GENERACIÓN DE DOCUMENTACIÓN 'ML ............................................................................ 4$
1ENE)ACIÓN A ()A,>S #EL C!PILA#) EN LÍNEA #E C!AN#S %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &3*
1ENE)ACIÓN A ()A,>S #E ,IS"AL S("#I%NE( %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &33
ESTRUCTURA DE LA DOCUMENTACIÓN 'ML ....................................................................... 4)
SEPARACIÓN ENTRE DOCUMENTACIÓN 'ML " CÓDIGO FUENTE ............................................. 48
TEMA !: EL COMPILADOR DE C# DE MICROSOFT ..................................... )!
INTRODUCCIÓN ................................................................................................................. )!
SINTA'IS GENERAL DE USO DEL COMPILADOR ....................................................................... )!
OPCIONES DE COMPILACIÓN ............................................................................................... )
PCINES BÁSICAS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &;&
!ANIP"LACIÓN #E )EC")SS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &;;
CN/I1")ACIÓN #E !ENSA4ES #E A,ISS 2 E)))ES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &;=
/ICHE)S #E )ESP"ES(A %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &;'
PCINES #E #EP")ACIÓN %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &=+
C!PILACIÓN INC)E!EN(AL %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &=:
PCINES )ELA(I,AS AL LEN1"A4E %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &=&
()AS PCINES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &=*
ACCESO AL COMPILADOR DESDE VISUAL STUDIO.NET ........................................................ 6)
TEMA 1: NOVEDADES DE C# .! ........................................................................ 68
INTRODUCCIÓN ................................................................................................................. 68
GEN&RICOS ...................................................................................................................... 68
CNCEP( %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &='
"SS #E LS 1EN>)ICS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &.+
SIN(A-IS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &.:
4o56 An7onio 1on89le8 Seco P9gina =
El lenguaje de programación C# Índice
LI!I(ACINES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &.&
)ES()ICCINES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &.3
,AL)ES P) #E/EC( %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &.0
A!BI1HE#A#ES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &'+
TIPOS PARCIALES .............................................................................................................. 8!
ITERADORES ..................................................................................................................... 8
ME%ORAS EN LA MANIPULACIÓN DE DELEGADOS ................................................................... 8)
IN/E)ENCIA #E #ELE1A#S %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &';
!>(#S ANÓNI!S %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &'=
C,A)IAN?A 2 CN()A,A)IAN?A #E #ELE1A#S %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &'0
TIPOS ANULABLES ............................................................................................................. (!
CNCEP( %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &0+
SIN(A-IS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &0:
CN,E)SINES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &0&
PE)ACINES CN N"LS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &0*
PE)A#) #E /"SIÓN IJJK %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &03
MODIFICADORES DE VISIBILIDAD DE BLOQUES GET " SET ....................................................... ()
CLASES EST+TICAS ............................................................................................................ ()
REFERENCIAS A ESPACIOS DE NOMBRES ............................................................................... (6
ALIAS 1LBAL 2 CALI/ICA#) LL %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &0=
ALIAS E-(E)NS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% &0'
SUPRESIÓN TEMPORAL DE AVISOS ........................................................................................ ((
ATRIBUTOS CONDICIONALES ............................................................................................... $!!
INCRUSTACIÓN DE TABLAS EN ESTRUCTURAS ......................................................................... $!!
MODIFICACIONES EN EL COMPILADOR ................................................................................. $!1
CN()L #E LA ,E)SIÓN #EL LEN1"A4E %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% *+:
CN()L #E LA PLA(A/)!A #E #ES(IN %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% *+&
EN,Í A"(!Á(IC #E E)))ES A !IC)S/( %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% *+&
CNC)E(I?ACIÓN #E A,ISS A ()A(A) C! E)))ES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% *+3
,ISIBILI#A# #E LS )EC")SS %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% *+;
/I)!A #E ENSA!BLA#S %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% *+;
DOCUMENTACIÓN DE REFERENCIA ................................................................ $!7
BIBLIOGRAFÍA ................................................................................................................... $!7
INFORMACIÓN EN INTERNET SOBRE C# ............................................................................... $!7
PORTALES ........................................................................................................................ $!8
GRUPOS DE NOTICIAS " LISTAS DE CORREO .......................................................................... $!8
4o56 An7onio 1on89le8 Seco P9gina .
El lenguaje de programación C# In7roducción a la oMra
Introducción a Ia obra
Requisitos previos recomendados
En principioN para en7ender con Oacilidad e57a oMra e5 recomendaMle e57ar Oamiliari8ado
con lo5 concep7o5 M95ico5 de programación orien7ada a oMje7o5N en par7icular con lo5
lenguaje5 de programación CPP o 4aQaN de lo5 Rue C# deriQa%
Sin emMargoN e57o5 no 5on reRui5i7o5 Oundamen7ale5 para en7enderla Sa Rue cada Qe8 Rue
en ella 5e in7roduce algTn elemen7o del lenguaje 5e deOinen S eUplican lo5 concep7o5
M95ico5 Rue permi7en en7enderlo% ATn a5VN 5igue 5iendo recomendaMle di5poner de lo5
reRui5i7o5 an7e5 mencionado5 para poder moQer5e con maSor 5ol7ura por el liMro S
aproQecWarlo al m9Uimo%
Estructura de la obra
B95icamen7e el eje cen7ral de la oMra e5 el lenguaje de programación C#N del Rue no 5ólo
5e de5criMe 5u 5in7aUi5 5ino Rue 7amMi6n 5e in7en7a eUplicar cu9le5 5on la5 ra8one5 Rue
ju57iOican la5 deci5ione5 7omada5 en 5u di5eXo S cu9le5 5on lo5 errore5 m95 diOVcile5 de
de7ec7ar Rue pueden producir5e al de5arrollar de aplicacione5 con 6l% Sin emMargoN lo5
&+ 7ema5 u7ili8ado5 para ello pueden de5componer5e en 7re5 grande5 MloRue5L
• B-./01 1: I234.5066782 9 C# : .NET L An7e5 de empe8ar a de5criMir el lenguaje
e5 oMliga7orio eUplicar el porRu6 de 5u eUi57enciaN S para ello e5 nece5ario an7e5
in7roducir la pla7aOorma %NE( de !icro5oO7 con la Rue e579 muS ligado% E5e e5 el
oMje7iQo de lo5 7ema5 : S &N donde 5e eUplican la5 carac7erV57ica5 S concep7o5
M95ico5 de C# S %NE(N la5 noQedo5a5 apor7acione5 de amMo5 S 5e in7roduce la
programación S compilación de aplicacione5 en C# con el 7Vpico ¡Hola !undo$
• B-./01 : D1;647<6782 51- -12=09>1: E57e MloRue con57i7uSe el grue5o de la
oMra S e579 Oormado por lo5 7ema5 comprendido5 en7re el * S el :0% En ello5 5e
de5criMen pormenori8adamen7e lo5 a5pec7o5 del lenguaje mo57rando ejemplo5 de
5u u5oN eUplicando 5u porRu6 S aQi5ando de cu9le5 5on lo5 proMlema5 m95
diOVcile5 de de7ec7ar Rue pueden 5urgir al u7ili8arlo5 S cómo eQi7arlo5%
• B-./01 $: D1;647<6782 51- 6.?<7-95.4 L E57e Tl7imo MloRueN Oormado 5olamen7e
por el 7ema &+N de5criMe cómo 5e u7ili8a el compilador de C# 7an7o de5de la
Qen7ana de con5ola como de5de la Werramien7a ,i5ual S7udio%NE(% Como al
de5criMir el lenguajeN 7amMi6n 5e in7en7a dar una eUplicación lo m95 eUWau57iQaN
T7il S O9cil de en7ender po5iMle del 5igniOicadoN porRu6 S aplicaMilidad de la5
opcione5 de compilación Rue oOrece%
Convenios de notación
El lenguaje de programación C# In7roducción a la oMra
Para aSudar a re5al7ar la inOormación claQe 5e u7ili8an diOeren7e5 conQencione5 re5pec7o
a lo5 7ipo5 de le7ra u5ado5 para repre5en7ar cada 7ipo de con7enidoL
• El 7eU7o corre5pondien7e a eUplicacione5 5e Wa e5cri7o u5ando la Ouen7e (ime5
NeY )oman de :& pun7o5 de 7amaXoN como e5 el ca5o de e57e p9rraOo%
• Lo5 Oragmen7o5 de código Ouen7e 5e Wan e5cri7o u5ando la Ouen7e Arial de :+
pun7o5 de 7amaXo 7al S como 5e mue57ra a con7inuaciónL
class HolaMundo
{
static void Main()
{
System.Console.WriteLine(“¡Hola Mundo!”);
}
Z
E57a mi5ma Ouen7e e5 la Rue 5e u5ar9 de5de la5 eUplicacione5 cada Qe8 Rue 5e
Waga reOerencia a algTn elemen7o del código Ouen7e% Si adem95 dicWo elemen7o e5
una palaMra re5erQada del lenguaje o Qiene predeOinido en la liMrerVa de %NE(N 5u
nomMre 5e e5criMir9 en negri7a para a5V re5al7ar el car9c7er e5pecial del mi5mo
• La5 reOerencia5 a 7eU7o5 de la in7erOa8 del 5i57ema opera7iQo InomMre5 de
OicWero5 S direc7orio5N 7eU7o de la lVnea de comando5N e7c% K 5e Wan e5cri7o u5ando
la Ouen7e Courier NeY de :+ pun7o5 de 7amaXo% Por ejemploL
csc HolaMundo.cs
Cuando adem95 e57e 7ipo de 7eU7o 5e u7ilice para Wacer reOerencia a elemen7o5
predeOinido5 7ale5 como eU7en5ione5 de OicWero5 recomendada5 o nomMre5 de
aplicacione5 incluida5 en el S#AN 5e e5criMir9 en negri7a%
• Al de5criMir5e la 5in7aUi5 de deOinición de lo5 elemen7o5 del lenguaje 5e u5ar9
Ouen7e Arial de :+ pun7o5 de 7amaXo S 5e repre5en7ar9n en cur5iQa lo5 elemen7o5
opcionale5 en la mi5maN en negri7a lo5 Rue deMan e5criMir5e 7al cualN S 5in
negri7a S en7re 5VmMolo5 [ S E lo5 Rue repre5en7en de 7eU7o Rue deMa colocar5e
en 5u lugar% Por ejemploN cuando 5e dice Rue una cla5e Wa de deOinir5e a5VL
cIass <nombreClase>
{
<miembros>
}
Lo Rue 5e e579 diciendo e5 Rue Wa de e5criMir5e la palaMra re5erQada cla55N
5eguida de 7eU7o Rue repre5en7e el nomMre de la cla5e a deOinirN 5eguido de una
llaQe de aper7ura I\KN 5eguido opcionalmen7e de 7eU7o Rue 5e corre5ponda con
deOinicione5 de miemMro5 S 5eguido de una llaQe de cierre IZK
• Si lo Rue 5e deOine e5 la 5in7aUi5 de llamada a alguna aplicación concre7aN
en7once5 la no7ación Rue 5e u5ar9 e5 5imilar a la an7erior 5ólo Rue en Qe8 de
Ouen7e Arial 5e u7ili8ar9 Ouen7e Courier NeY de :+ pun7o5 de 7amaXo%
El lenguaje de programación C# In7roducción a la oMra
El lenguaje de programación C# (ema :L In7roducción a !icro5oO7%NE(
TEMA 1: Introducción a Microsoft.NET
Microsoft.NET
!icro5oO7%NE( e5 el conjun7o de nueQa5 7ecnologVa5 en la5 Rue !icro5oO7 Wa e57ado
7raMajando duran7e lo5 Tl7imo5 aXo5 con el oMje7iQo de oM7ener una pla7aOorma 5encilla S
po7en7e para di57riMuir el 5oO7Yare en Oorma de 5erQicio5 Rue puedan 5er 5umini57rado5
remo7amen7e S Rue puedan comunicar5e S comMinar5e uno5 con o7ro5 de manera
7o7almen7e independien7e de la pla7aOormaN lenguaje de programación S modelo de
componen7e5 con lo5 Rue WaSan 5ido de5arrollado5% >57a e5 la llamada <-939@.4?9
.NETN S a lo5 5erQicio5 an7e5 comen7ado5 5e le5 denomina ;14A767.; B1C%
Para crear aplicacione5 para la pla7aOorma %NE(N 7an7o 5erQicio5 <eM como aplicacione5
7radicionale5 Iaplicacione5 de con5olaN aplicacione5 de Qen7ana5N 5erQicio5 de <indoY5
N(N e7c%KN !icro5oO7 Wa puMlicado el denominado ]i7 de de5arrollo de 5oO7Yare conocido
como .NET F49?1D.4E SDFN Rue incluSe la5 Werramien7a5 nece5aria5 7an7o para 5u
de5arrollo como para 5u di57riMución S ejecución S V7;09- S3057..NETN Rue permi7e
Wacer 7odo la an7erior de5de una in7erOa8 Qi5ual Ma5ada en Qen7ana5% AmMa5 Werramien7a5
pueden de5cargar5e gra7ui7amen7e de5de W77pL^^YYY%m5dn%micro5oO7%com^ne7N aunRue la
Tl7ima 5ólo e579 di5poniMle para 5uM5crip7ore5 !S#N "niQer5al Ilo5 no 5uM5crip7ore5
pueden pedirlo de5de dicWa dirección S 5e le5 enQiar9 gra7i5 por correo ordinarioK
El concep7o de !icro5oO7%NE( 7amMi6n incluSe al conjun7o de nueQa5 aplicacione5 Rue
!icro5oO7 S 7ercero5 Wan Io e579nK de5arrollando para 5er u7ili8ada5 en la pla7aOorma
%NE(% En7re ella5 podemo5 de57acar aplicacione5 de5arrollada5 por !icro5oO7 7ale5 como
<indoY5%NE(N Hail57ormN ,i5ual S7udio%NE(N !SN%NE(N OOice%NE(N S lo5 nueQo5
5erQidore5 para empre5a5 de !icro5oO7 ISGL SerQer%NE(N EUcWange%NE(N e7c%K
Common Language Runtime (CLR)
El C.??.2 L92=09=1 R0237?1 ICLRK e5 el nTcleo de la pla7aOorma %NE(% E5 el
mo7or encargado de ge57ionar la ejecución de la5 aplicacione5 para ella de5arrollada5 S a
la5 Rue oOrece numero5o5 5erQicio5 Rue 5impliOican 5u de5arrollo S OaQorecen 5u
OiaMilidad S 5eguridad% La5 principale5 carac7erV57ica5 S 5erQicio5 Rue oOrece el CL) 5onL
• M.51-. 51 <4.=49?96782 6.2;7;31231: A 7odo5 lo5 5erQicio5 S Oacilidade5
oOrecido5 por el CL) 5e accede de la mi5ma OormaL a 7raQ65 de un modelo de
programación orien7ado a oMje7o5% E57o e5 una diOerencia impor7an7e re5pec7o al
modo de acce5o a lo5 5erQicio5 oOrecido5 por lo5 alguno5 5i57ema5 opera7iQo5
ac7uale5 Ipor ejemploN lo5 de la Oamilia <indoY5KN en lo5 Rue a alguno5 5erQicio5
5e le5 accede a 7raQ65 de llamada5 a Ouncione5 gloMale5 deOinida5 en #LL5 S a
o7ro5 a 7raQ65 de oMje7o5 IoMje7o5 C! en el ca5o de la Oamilia <indoY5K
• M.51-. 51 <4.=49?96782 ;1267--.: Con el CL) de5aparecen mucWo5 elemen7o5
complejo5 incluido5 en lo5 5i57ema5 opera7iQo5 ac7uale5 Iregi57ro de <indoY5N
1"I#5N H)ES"L(SN I"n]noYnN e7c%K El CL) no e5 Rue aM57raiga al
El lenguaje de programación C# (ema :L In7roducción a !icro5oO7%NE(
programador de e57o5 concep7o5N 5ino Rue 5on concep7o5 Rue no eUi57en en la
pla7aOorma %NE(
• E-7?7296782 51- G72@7142. 51 -9; DLL;H: En la pla7aOorma %NE( de5aparece el
proMlema conocido como _inOierno de la5 #LL5` Rue 5e da en lo5 5i57ema5
opera7iQo5 ac7uale5 de la Oamilia <indoY5N proMlema Rue con5i57e en Rue al
5u57i7uir5e Qer5ione5 Qieja5 de #LL5 compar7ida5 por Qer5ione5 nueQa5 puede
Rue aplicacione5 Rue Oueron di5eXada5 para 5er ejecu7ada5 u5ando la5 Qieja5
dejen de Ouncionar 5i la5 nueQa5 no 5on :++a compa7iMle5 con la5 an7eriore5% En
la pla7aOorma %NE( la5 Qer5ione5 nueQa5 de la5 #LL5 pueden coeUi57ir con la5
Qieja5N de modo Rue la5 aplicacione5 di5eXada5 para ejecu7ar5e u5ando la5 Qieja5
podr9n 5eguir u59ndola5 7ra5 in57alación de la5 nueQa5% E57oN oMQiamen7eN
5impliOica mucWo la in57alación S de5in57alación de 5oO7Yare%
• E>1606782 ?0-37<-939@.4?9: El CL) ac7Ta como una m9Ruina Qir7ualN
encarg9ndo5e de ejecu7ar la5 aplicacione5 di5eXada5 para la pla7aOorma %NE(% E5
decirN cualRuier pla7aOorma para la Rue eUi57a una Qer5ión del CL) podr9
ejecu7ar cualRuier aplicación %NE(% !icro5oO7 Wa de5arrollado Qer5ione5 del
CL) para la maSorVa de la5 Qer5ione5 de <indoY5L <indoY5 0;N <indoY5 0'N
<indoY5 !EN <indoY5 N( 3%+N <indoY5 &+++N <indoY5 -P S <indoY5 CE
IRue puede 5er u5ado en CP"5 Rue no 5ean de la Oamilia U'=K Por o7ro lado
!icro5oO7 Wa Oirmado un acuerdo con Corel para por7ar el CL) a LinuU S
7amMi6n WaS 7ercero5 Rue e579n de5arrollando de manera independien7e Qer5ione5
de liMre di57riMución del CL) para LinuU% A5imi5moN dado Rue la arRui7ec7ura
del CL) e579 7o7almen7e aMier7aN e5 po5iMle Rue en el Ou7uro 5e di5eXen Qer5ione5
del mi5mo para o7ro5 5i57ema5 opera7iQo5%
• I231=496782 51 -12=09>1;: #e5de cualRuier lenguaje para el Rue eUi57a un
compilador Rue genere código para la pla7aOorma %NE( e5 po5iMle u7ili8ar código
generado para la mi5ma u5ando cualRuier o7ro lenguaje 7al S como 5i de código
e5cri7o u5ando el primero 5e 7ra7a5e% !icro5oO7 Wa de5arrollado un compilador de
C# Rue genera código de e57e 7ipoN a5V como Qer5ione5 de 5u5 compiladore5 de
,i5ual Ba5ic I,i5ual Ba5ic%NE(K S CPP ICPP con eU7en5ione5 ge57ionada5K Rue
7amMi6n lo generan S una Qer5ión del in76rpre7e de 4Scrip7 I4Scrip7%NE(K Rue
puede in7erpre7arlo% La in7egración de lenguaje5 e5 7al Rue e5 po5iMle e5criMir una
cla5e en C# Rue Werede de o7ra e5cri7a en ,i5ual Ba5ic%NE( RueN a 5u Qe8N Werede
de o7ra e5cri7a en CPP con eU7en5ione5 ge57ionada5%
• G1;3782 51 ?1?.479: El CL) incluSe un 416.-163.4 51 C9;049 Rue eQi7a Rue el
programador 7enga Rue 7ener en cuen7a cu9ndo Wa de de57ruir lo5 oMje7o5 Rue
dejen de 5erle T7ile5% E57e recolec7or e5 una aplicación Rue 5e ac7iQa cuando 5e
Ruiere crear algTn oMje7o nueQo S 5e de7ec7a Rue no Rueda memoria liMre para
WacerloN ca5o en Rue el recolec7or recorre la memoria din9mica a5ociada a la
aplicaciónN de7ec7a Ru6 oMje7o5 WaS en ella Rue no puedan 5er accedido5 por el
código de la aplicaciónN S lo5 elimina para limpiar la memoria de _oMje7o5
Ma5ura` S permi7ir la creación de o7ro5 nueQo5% 1racia5 a e57e recolec7or 5e
eQi7an errore5 de programación muS comune5 como in7en7o5 de Morrado de
oMje7o5 Sa Morrado5N ago7amien7o de memoria por olQido de eliminación de
oMje7o5 inT7ile5 o 5olici7ud de acce5o a miemMro5 de oMje7o5 Sa de57ruido5%
El lenguaje de programación C# (ema :L In7roducción a !icro5oO7%NE(
• S1=047595 51 37<.;: El CL) Oacili7a la de7ección de errore5 de programación
diOVcile5 de locali8ar comproMando Rue 7oda conQer5ión de 7ipo5 Rue 5e realice
duran7e la ejecución de una aplicación %NE( 5e Waga de modo Rue lo5 7ipo5
origen S de57ino 5ean compa7iMle5%
• A7;-9?7123. 51 <4.61;.;: El CL) a5egura Rue de5de código per7enecien7e a un
de7erminado proce5o no 5e pueda acceder a código o da7o5 per7enecien7e5 a o7roN
lo Rue eQi7a errore5 de programación muS Orecuen7e5 e impide Rue uno5 proce5o5
puedan a7acar a o7ro5% E57o 5e con5igue gracia5 al 5i57ema de 5eguridad de 7ipo5
an7e5 comen7adoN pue5 eQi7a Rue 5e pueda conQer7ir un oMje7o a un 7ipo de
maSor 7amaXo Rue el 5uSo propioN Sa Rue al 7ra7arlo como un oMje7o de maSor
7amaXo podrVa acceder5e a e5pacio5 en memoria ajeno5 a 6l Rue podrVan
per7enecer a o7ro proce5o% (amMi6n 5e con5igue gracia5 a Rue no 5e permi7e
acceder a po5icione5 arMi7raria5 de memoria%
• T4939?7123. 51 1I61<67.21;: En el CL) 7odo lo5 errore5 Rue 5e puedan
producir duran7e la ejecución de una aplicación 5e propagan de igual maneraL
median7e eUcepcione5% E57o e5 muS diOeren7e a como 5e QenVa Waciendo en lo5
5i57ema5 <indoY5 Wa57a la aparición de la pla7aOorma %NE(N donde cier7o5
errore5 5e 7ran5mi7Van median7e código5 de error en Oorma7o <in*&N o7ro5
median7e H)ES"L(5 S o7ro5 median7e eUcepcione5%
El CL) permi7e Rue eUcepcione5 lan8ada5 de5de código para %NE( e5cri7o en un
cier7o lenguaje 5e puedan cap7urar en código e5cri7o u5ando o7ro lenguajeN e
incluSe mecani5mo5 de depuración Rue pueden 5al7ar de5de código e5cri7o
para %NE( en un de7erminado lenguaje a código e5cri7o en cualRuier o7ro% Por
ejemploN 5e puede recorrer la pila de llamada5 de una eUcepción aunRue 657a
incluSa m67odo5 deOinido5 en o7ro5 módulo5 u5ando o7ro5 lenguaje5%
• S.<.431 ?0-37J7-.: El CL) e5 capa8 de 7raMajar con aplicacione5 diQidida5 en
mTl7iple5 Wilo5 de ejecución Rue pueden ir eQolucionando por 5eparado en
paralelo o in7ercal9ndo5eN 5egTn el nTmero de proce5adore5 de la m9Ruina 5oMre
la Rue 5e ejecu7en% La5 aplicacione5 pueden lan8ar nueQo5 Wilo5N de57ruirlo5N
5u5penderlo5 por un 7iempo o Wa57a Rue le5 llegue una no7iOicaciónN enQiarle5
no7iOicacione5N 5incroni8arlo5N e7c%
• D7;347C06782 3492;<941231: El CL) oOrece la inOrae57ruc7ura nece5aria para
crear oMje7o5 remo7o5 S acceder a ello5 de manera comple7amen7e 7ran5paren7e a
5u locali8ación realN 7al S como 5i 5e encon7ra5en en la m9Ruina Rue lo5 u7ili8a%
• S1=047595 9A92K959: El CL) proporciona mecani5mo5 para re57ringir la
ejecución de cier7o5 código5 o lo5 permi5o5 a5ignado5 a lo5 mi5mo5 5egTn 5u
procedendecia o el u5uario Rue lo5 ejecu7e% E5 decirN puede no dar5e el mi5mo
niQel de conOian8a a código proceden7e de In7erne7 Rue a código in57alado
localmen7e o proceden7e de una red localb puede no dar5e lo5 mi5mo5 permi5o5 a
código proceden7e de un de7erminado OaMrican7e Rue a código de o7rob S puede
no dar5e lo5 mi5mo5 permi5o5 a un mi5mo código5 5egTn el u5uario Rue lo e576
ejecu7ando o 5egTn el rol Rue 657e de5empeXe% E57o permi7e a5egurar al
admini57rador de un 5i57ema Rue el código Rue 5e e576 ejecu7ando no pueda
poner en peligro la in7egridad de 5u5 arcWiQo5N la del regi57ro de <indoY5N e7c%
El lenguaje de programación C# (ema :L In7roducción a !icro5oO7%NE(
• I2314.<149C7-7595 6.2 6857=. 9237=0.: El CL) incorpora lo5 mecani5mo5
nece5ario5 para poder acceder de5de código e5cri7o para la pla7aOorma %NE( a
código e5cri7o preQiamen7e a la aparición de la mi5ma SN por 7an7oN no preparado
para 5er ejecu7ando den7ro de ella% E57o5 mecani5mo5 permi7en 7an7o el acce5o a
oMje7o5 C! como el acce5o a Ouncione5 5uel7a5 de #LL5 preeUi57en7e5 Icomo
la API <in*&K
Como 5e puede deducir de la5 carac7erV57ica5 comen7ada5N el CL) lo Rue Wace e5
ge57ionar la ejecución de la5 aplicacione5 di5eXada5 para la pla7aOorma %NE(% Por e57a
ra8ónN al código de e57a5 aplicacione5 5e le 5uele llamar 6857=. =1;37.295.N S al código
no e5cri7o para 5er ejecu7ado direc7amen7e en la pla7aOorma %NE( 5e le 5uele llamar
6857=. 2. =1;37.295.%
Microsoft ntermediate Language (M!L)
Ninguno de lo5 compiladore5 Rue generan código para la pla7aOorma %NE( produce
código m9Ruina para CP"5 U'= ni para ningTn o7ro 7ipo de CP" concre7aN 5ino Rue
generan código e5cri7o en el lenguaje in7ermedio conocido como M764.;.@3
I2314?157931 L12=09=1 IMSILK El CL) da a la5 aplicacione5 la 5en5ación de Rue 5e
e579n ejecu7ando 5oMre una m9Ruina Qir7ualN S preci5amen7e !SIL e5 el código m9Ruina
de e5a m9Ruina Qir7ual% E5 decirN !SIL e5 el Tnico código Rue e5 capa8 de in7erpre7ar el
CL)N S por 7an7o cuando 5e dice Rue un compilador genera código para la pla7aOorma
%NE( lo Rue 5e e579 diciendo e5 Rue genera !SIL%
!SIL Wa 5ido creado por !icro5oO7 7ra5 con5ul7ar a numero5o5 e5peciali57a5 en la
e5cri7ura de compiladore5 S lenguaje5 7an7o del mundo acad6mico como empre5arial% E5
un lenguaje de un niQel de aM57racción mucWo m95 al7o Rue el de la maSorVa de lo5
código5 m9Ruina de la5 CP"5 eUi57en7e5N e incluSe in57ruccione5 Rue permi7en 7raMajar
direc7amen7e con oMje7o5 Icrearlo5N de57ruirlo5N iniciali8arlo5N llamar a m67odo5
Qir7uale5N e7c%KN 7aMla5 S eUcepcione5 Ilan8arla5N cap7urarla5 S 7ra7arla5K
2a 5e comen7ó Rue el compilador de C# compila direc7amen7e el código Ouen7e a !SILN
Rue !icro5oO7 Wa de5arrollado nueQa5 Qer5ione5 de 5u5 lenguaje5 ,i5ual Ba5ic I,i5ual
Ba5ic%NE(K S CPP ICPP con eU7en5ione5 ge57ionada5K cuSo5 compiladore5 generan
!SILN S Rue Wa de5arrollado un in76rpre7e de 4Scrip7 I4Scrip7%NE(K Rue genera código
!SIL% Pue5 MienN 7amMi6n WaS numero5o5 7ercero5 Rue Wan anunciado e57ar reali8ando
Qer5ione5 para la pla7aOorma %NE( de o7ro5 lenguaje5 como APLN CA!LN CoMolN EiOOelN
/or7ranN Ha5]ellN 4aQa I4#KN !ercurSN !LN !ondrianN MeronN 8N Pa5calN PerlN PS7WonN
)P1N ScWeme S Small7al]%
La principal Qen7aja del !SIL e5 Rue Oacili7a la ejecución mul7ipla7aOorma S la
in7egración en7re lenguaje5 al 5er independien7e de la CP" S proporcionar un Oorma7o
comTn para el código m9Ruina generado por 7odo5 lo5 compiladore5 Rue generen código
para %NE(% Sin emMargoN dado Rue la5 CP"5 no pueden ejecu7ar direc7amen7e !SILN
an7e5 de ejecu7arlo WaMr9 Rue conQer7irlo al código na7iQo de la CP" 5oMre la Rue 5e
QaSa a ejecu7ar% #e e57o 5e encarga un componen7e del CL) conocido como compilador
4I( I4u57DInD(imeK o ji77er Rue Qa conQir7iendo din9micamen7e el código !SIL a
ejecu7ar en código na7iQo 5egTn 5ea nece5ario% E57e ji77er 5e di57riMuSe en 7re5 Qer5ione5L
El lenguaje de programación C# (ema :L In7roducción a !icro5oO7%NE(
• >73314 2.4?9-: E5 el Rue 5e 5uele u5ar por deOec7oN S 5ólo compila el código
!SIL a código na7iQo a medida Rue Qa 5iendo nece5arioN pue5 a5V 5e aWorra
7iempo S memoria al eQi7ar5e 7ener Rue compilar innece5ariamen7e código Rue
nunca 5e ejecu7e% Para con5eguir e57oN el cargador de cla5e5 del CL) 5u57i7uSe
inicialmen7e la5 llamada5 a m67odo5 de la5 nueQa5 cla5e5 Rue QaSa cargando por
llamada5 a Ouncione5 auUiliare5 I57uM5K Rue 5e encarguen de compilar el
Qerdadero código del m67odo% "na Qe8 compiladoN la llamada al 57uM e5
5u57i7uida por una llamada direc7a al código Sa compiladoN con lo Rue po57eriore5
llamada5 al mi5mo no nece5i7ar9n compilación%
• >73314 16.28?76.: /unciona de Oorma 5imilar al ji77er normal 5olo Rue no reali8a
ninguna op7imi8ación de código al compilar 5ino Rue 7raduce cada in57rucción
!SIL por 5u eRuiQalen7e en el código m9Ruina 5oMre la Rue 5e ejecu7e% E57a
e5pecialmen7e pen5ado para 5er u5ado en di5po5i7iQo5 empo7rado5 Rue di5pongan
de poca po7encia de CP" S poca memoriaN pue5 aunRue genere código m95
ineOicien7e e5 menor el 7iempo S memoria Rue nece5i7a para compilar% E5 m95N
para aWorrar memoria e57e ji77er puede de5cargar código Sa compilado Rue lleQe
cier7o 7iempo 5in ejecu7ar5e S 5u57i7uirlo de nueQo por el 57uM apropiado% Por
e57a5 ra8one5N e57e e5 el ji77er u5ado por deOec7o en <indoY5 CEN 5i57ema
opera7iQo Rue 5e 5uele incluir en lo5 di5po5i7iQo5 empo7rado5 an7e5 mencionado5%
7ra u7ilidad del ji77er económico e5 Rue Oacili7a la adap7ación de la
pla7aOorma %NE( a nueQo5 5i57ema5 porRue e5 mucWo m95 5encillo de
implemen7ar Rue el normal% #e e57e modoN gracia5 a 6l e5 po5iMle de5arrollar
r9pidamen7e una Qer5ión del CL) Rue pueda ejecu7ar aplicacione5 ge57ionada5
aunRue 5ea de una Oorma poco eOicien7eN S una Qe8 de5arrollada e5 po5iMle
cen7rar5e en de5arrollar el ji77er normal para op7imi8ar la ejecución de la5
mi5ma5%
• <41>73314: Se di57riMuSe como una aplicación en lVnea de comando5 llamada
ngen.exe median7e la Rue e5 po5iMle compilar comple7amen7e cualRuier
ejecu7aMle o liMrerVa IcualRuier en5amMlado en generalN aunRue e57e concep7o 5e
Qer9 m95 adelan7eK Rue con7enga código ge57ionado S conQer7irlo a código
na7iQoN de modo Rue po57eriore5 ejecucione5 del mi5mo 5e War9n u5ando e57a
Qer5ión Sa compilada S no 5e perder9 7iempo en Wacer la compilación din9mica%
La ac7uación de un ji77er duran7e la ejecución de una aplicación ge57ionada puede dar la
5en5ación de Wacer Rue 657a 5e ejecu7e m95 len7amen7e deMido a Rue Wa de inQer7ir5e
7iempo en la5 compilacione5 din9mica5% E57o e5 cier7oN pero WaS Rue 7ener en cuen7a Rue
e5 una 5olución mucWo m95 eOicien7e Rue la u5ada en o7ra5 pla7aOorma5 como 4aQaN Sa
Rue en %NE( cada código no e5 in7erpre7ado cada Qe8 Rue 5e ejecu7a 5ino Rue 5ólo e5
compilado la primera Qe8 Rue 5e llama al m67odo al Rue per7enece% E5 m95N el WecWo de
Rue la compilación 5e realice din9micamen7e permi7e Rue el ji77er 7enga acce5o a mucWa
m95 inOormación 5oMre la m9Ruina en Rue 5e ejecu7ar9 la aplicación del Rue 7endrVa
cualRuier compilador 7radicionalN con lo Rue puede op7imi8ar el código para ella
generado Ipor ejemploN u5ando la5 in57ruccione5 e5peciale5 del Pen7ium III 5i la
m9Ruina la5 admi7eN u5ando regi57ro5 eU7raN incluSendo código inlineN e7c%K Adem95N
como el recolec7or de Ma5ura de %NE( man7iene 5iempre compac7ada la memoria
din9mica la5 re5erQa5 de memoria 5e War9n m95 r9pidoN 5oMre 7odo en aplicacione5 Rue
El lenguaje de programación C# (ema :L In7roducción a !icro5oO7%NE(
no ago7en la memoria SN por 7an7oN no nece5i7en de una recolección de Ma5ura% Por e57a5
ra8one5N lo5 ingeniero5 de !icro5oO7 pien5an Rue Ou7ura5 Qer5ione5 de 5u5 ji77er5 podr9n
inclu5o con5eguir Rue el código ge57ionado 5e ejecu7e m95 r9pido Rue el no ge57ionado%
Metadatos
En la pla7aOorma %NE( 5e di57inguen do5 7ipo5 de ?850-.; de código compiladoL
1>16039C-1; IeU7en5ión .1I1K S -7C414L9; 51 12-961 572M?76. IeU7en5ión .5--
generalmen7eK AmMo5 5on OicWero5 Rue con7ienen deOinicione5 de 7ipo5 de da7o5N S la
diOerencia en7re ello5 e5 Rue 5ólo lo5 primero5 di5ponen de un m67odo e5pecial Rue 5irQe
de pun7o de en7rada a par7ir del Rue e5 po5iMle ejecu7ar el código Rue con7ienen Waciendo
una llamada de5de la lVnea de comando5 del 5i57ema opera7iQo% A amMo5 7ipo5 de
módulo5 5e le5 5uele llamar 1>16039C-1; <.439C-1; IPEKN Sa Rue 5u código puede
ejecu7ar5e en cualRuiera de lo5 diOeren7e5 5i57ema5 opera7iQo5 de la Oamilia <indoY5
para lo5 Rue eUi57e alguna Qer5ión del CL)%
El con7enido de un módulo no e5 5ólo !SILN 5ino Rue 7amMi6n con57a de o7ra5 do5 9rea5
muS impor7an7e5L la caMecera de CL) S lo5 me7ada7o5L
• La 69C16149 51 CLR e5 un peRueXo MloRue de inOormación Rue indica Rue 5e 7ra7a
de un módulo ge57ionado e indica e5 la Qer5ión del CL) Rue nece5i7aN cu9l e5 5u
Oirma digi7alN cu9l e5 5u pun7o de en7rada I5i e5 un ejecu7aMleKN e7c%
• Lo5 ?139593.; 5on un conjun7o de da7o5 organi8ado5 en Oorma de 7aMla5 Rue
almacenan inOormación 5oMre lo5 7ipo5 deOinido5 en el móduloN lo5 miemMro5 de
657o5 S 5oMre cu9le5 5on lo5 7ipo5 eU7erno5 al módulo a lo5 Rue 5e le5 reOerencia en el
módulo% Lo5 me7ada7o5 de cada modulo lo5 genera au7om97icamen7e el compilador
al crearloN S en7re 5u5 7aMla5 5e incluSen
:
L

T9C-9 D1;647<6782
!odule#eO #eOine la5 carac7erV57ica5 del módulo% Con57a de un Tnico elemen7o
Rue almacena un iden7iOicador de Qer5ión de módulo I1"I# creado
por el compiladorK S el nomMre de OicWero Rue 5e dio al módulo al
compilarlo Ia5V e57e nomMre 5iempre e57ar9 di5poniMleN aunRue 5e
renomMre el OicWeroK
(Spe#eO #eOine la5 carac7erV57ica5 de lo5 7ipo5 deOinido5 en el módulo% #e cada
7ipo 5e almacena 5u nomMreN 5u 7ipo padreN 5u5 modiOicadore5 de
acce5o S reOerencia5 a lo5 elemen7o5 de la5 7aMla5 de miemMro5
corre5pondien7e5 a 5u5 miemMro5%
!e7Wod#eO #eOine la5 carac7erV57ica5 de lo5 m67odo5 deOinido5 en el módulo% #e
cada m67odo 5e guarda 5u nomMreN 5igna7ura Ipor cada par9me7ro 5e
incluSe una reOerencia al elemen7o apropiado en la 7aMla Param#eOKN
modiOicadore5 S po5ición del módulo donde comien8a el código !SIL
de 5u cuerpo%
Param#eO #eOine la5 carac7erV57ica5 de lo5 par9me7ro5 deOinido5 en el módulo% #e
cada par9me7ro 5e guarda 5u nomMre S modiOicadore5%
:
No 5e preocupe 5i no en7iende aTn alguno5 de lo5 concep7o5 nueQo5 in7roducido en la5 de5cripcione5 de
la5 7aMla5 de me7ada7o5N pue5 m95 adelan7e 5e ir9n eUplicando de7alladamen7e%
El lenguaje de programación C# (ema :L In7roducción a !icro5oO7%NE(
/ield#eO #eOine la5 carac7erV57ica5 de lo5 campo5 deOinido5 en el módulo% #e
cada uno 5e almacena inOormación 5oMre cu9l e5 5u nomMreN 7ipo S
modiOicadore5%
Proper7S#eO #eOine la5 carac7erV57ica5 de la5 propiedade5 deOinida5 en el módulo%
#e cada una 5e indica 5u nomMreN 7ipoN modiOicadore5 S reOerencia5 a
lo5 elemen7o5 de la 7aMla !e7Wod#eO corre5pondien7e5 a 5u5 m67odo5
5e7^ge7%
EQen7#eO #eOine la5 carac7erV57ica5 de lo5 eQen7o5 deOinido5 en el módulo% #e
cada uno 5e indica 5u nomMreN 7ipoN modiOicadore5% S reOerencia5 a lo5
elemen7o5 de la 7aMla !e7Wod#eO corre5pondien7e5 a 5u5 m67odo5
add^remoQe%
A55emMlS)eO Indica cu9le5 5on lo5 en5amMlado5 eU7erno5 a lo5 Rue 5e reOerencia en
el módulo% #e cada uno 5e indica cu9l e5 5u nomMre de OicWero I5in
eU7en5iónKN Qer5iónN idioma S marca de claQe pTMlica%
!odule)eO Indica cu9le5 5on lo5 o7ro5 módulo5 del mi5mo en5amMlado a lo5 Rue
reOerencia el módulo% #e cada uno 5e indica cu9l e5 5u nomMre de
OicWero%
(Spe)eO Indica cu9le5 5on lo5 7ipo5 eU7erno5 a lo5 Rue 5e reOerencia en el
módulo% #e cada uno 5e indica cu9l e5 5u nomMre SN 5egTn donde
e576n deOinido5N una reOerencia a la po5ición adecuada en la 7aMla
A55emMlS)eO o en la 7aMla !odule)eO%
!emMer)eO Indican cu9le5 5on lo5 miemMro5 deOinido5 eU7ernamen7e a lo5 Rue 5e
reOerencia en el módulo% E57o5 miemMro5 pueden 5er campo5N m67odo5N
propiedade5 o eQen7o5b S de cada uno de ello5 5e almacena
inOormación 5oMre 5u nomMre S 5igna7uraN a5V como una reOerencia a la
po5ición de la 7aMla (Spe)eO donde 5e almacena inOormación rela7iQa
al 7ipo del Rue e5 miemMro%
T9C-9 1 : Principale5 7aMla5 de me7ada7o5
Nó7e5e Rue el 5igniOicado de lo5 me7ada7o5 e5 5imilar al de o7ra5 7ecnologVa5 preQia5 a la
pla7aOorma %NE( como lo 5on lo5 OicWero5 I#L% Sin emMargoN lo5 me7ada7o5 7ienen do5
Qen7aja5 impor7an7e5 5oMre 657a5L con7iene m95 inOormación S 5iempre 5e almacenan
incru57ado5 en el módulo al Rue de5criMenN Waciendo impo5iMle la 5eparación en7re
amMo5% Adem95N como 5e Qer9 m95 adelan7eN e5 po5iMle 7an7o con5ul7ar lo5 me7ada7o5 de
cualRuier módulo a 7raQ65 de la5 cla5e5 del e5pacio de nomMre5 S:;31?.R1@-1637.2 de la
BCL como aXadirle5 inOormación adicional median7e 9347C03.; I5e Qer9 m95 adelan7eK

Ensamblados
"n 12;9?C-95. e5 una agrupación lógica de uno o m95 módulo5 o OicWero5 de recur5o5
IOicWero5 %1I/N %H(!LN e7c%K Rue 5e engloMan Majo un nomMre comTn% "n programa
puede acceder a inOormación o código almacenado5 en un en5amMlado 5in 7ener Rue
conocer cu9l e5 el OicWero en concre7o donde 5e encuen7ranN por lo Rue lo5 en5amMlado5
no5 permi7en aM57raerno5 de la uMicación OV5ica del código Rue ejecu7emo5 o de lo5
recur5o5 Rue u5emo5% Por ejemploN podemo5 incluir 7odo5 lo5 7ipo5 de una aplicación en
un mi5mo en5amMlado pero colocando lo5 m95 Orecuen7emen7e u5ado5 en un cier7o
módulo S lo5 meno5 u5ado5 en o7roN de modo Rue 5ólo 5e de5carguen de In7erne7 lo5
Tl7imo5 5i e5 Rue 5e Qan a u5ar%
El lenguaje de programación C# (ema :L In7roducción a !icro5oO7%NE(
(odo en5amMlado con7iene un ?927@71;3.N Rue 5on me7ada7o5 con inOormación 5oMre la5
carac7erV57ica5 del en5amMlado% E57e maniOie57o puede almacenar5e en cualRuiera de lo5
módulo5 Rue Oormen el en5amMlado o en uno e5pecVOicamen7e creado para elloN 5iendo
lo Tl7imo nece5ario cuando 5ólo con7iene recur5o5 I12;9?C-95. ;93N-731K
La5 principale5 7aMla5 incluida5 en lo5 maniOie57o5 5on la5 5iguien7e5L
T9C-9 D1;647<6782
A55emMlS#eO #eOine la5 carac7erV57ica5 del en5amMlado% Con57a de un Tnico
elemen7o Rue almacena el nomMre del en5amMlado 5in
eU7en5iónN Qer5iónN idiomaN claQe pTMlica S 7ipo de algori7mo de
di5per5ión u5ado para Wallar lo5 Qalore5 de di5per5ión de la
7aMla /ile#eO%
/ile#eO #eOine cu9le5 5on lo5 arcWiQo5 Rue Oorman el en5amMlado% #e
cada uno 5e da 5u nomMre S Qalor de di5per5ión% Nó7e5e Rue
5ólo el módulo Rue con7iene el maniOie57o 5aMr9 Ru6 OicWero5
Rue Oorman el en5amMladoN pero el re57o de OicWero5 del mi5mo
no 5aMr9n 5i per7enecen o no a un en5amMlado Ino con7ienen
me7ada7o5 Rue le5 indiRue 5i per7enecen a un en5amMladoK
!aniOe57)e5ource#eO #eOine la5 carac7erV57ica5 de lo5 recur5o5 incluido5 en el
módulo% #e cada uno 5e indica 5u nomMre S modiOicadore5 de
acce5o% Si e5 un recur5o incru57ado 5e indica dónde empie8a
den7ro del PE Rue lo con7ieneN S 5i e5 un OicWero independien7e
5e indica cu9l e5 el elemen7o de la 7aMla /ile#eO
corre5pondien7e a dicWo OicWero%
EUpor7ed(Spe5#eO Indica cu9le5 5on lo5 7ipo5 deOinido5 en el en5amMlado S
acce5iMle5 de5de Ouera del mi5mo% Para aWorrar e5pacio 5ólo
recogen lo5 Rue no per7ene8can al módulo donde 5e incluSe el
maniOie57oN S de cada uno 5e indica 5u nomMreN la po5ición en
la 7aMla /ile#eO del OicWero donde 5e Wa implemen7ado S la
po5ición en la 7aMla (Spe#eO corre5pondien7e a 5u deOinición%
A55emMlSProcce5or#eO Indica en Ru6 proce5adore5 5e puede ejecu7ar el en5amMladoN lo
Rue puede 5er T7il 5aMerlo 5i el en5amMlado con7iene módulo5
con código na7iQo IpodrVa Wacer5e u5ando CPP con
eU7en5ione5 ge57ionada5K Suele e57ar QacVaN lo Rue indica Rue 5e
puede ejecu7ar en cualRuier proce5adorb pero 5i e57uQie5e llenaN
cada elemen7o indicarVa un 7ipo de proce5ador admi7ido 5egTn
el Oorma7o de iden7iOicadore5 de proce5ador del OicWero
<inN(%W incluido con ,i5ual S7udio%NE( Ipor ejemploN ;'= c
Pen7iumN &&++ c ArRui7ec7ura IA=3N e7c%K
A55emMlSS#eO Indica Majo Ru6 5i57ema5 opera7iQo5 5e puede ejecu7ar el
en5amMladoN lo Rue puede 5er T7il 5i con7iene módulo5 con
7ipo5 o m67odo5 di5poniMle5 5ólo en cier7o5 5i57ema5% Suele
e57ar QacVaN lo Rue indica Rue 5e puede ejecu7ar en cualRuier
proce5adorb pero 5i e57uQie5e llenaN indicarVa el iden7iOicador de
cada uno de lo5 5i57ema5 admi7ido5 5iguiendo el Oorma7o del
<inN(%W de ,i5ual S7udio%NE( Ipor ejemploN + c Oamilia
<indoY5 0-N : c Oamilia <indoY5 N(N e7c%K S el nTmero de la
Qer5ión del mi5mo a par7ir de la Rue 5e admi7e%
El lenguaje de programación C# (ema :L In7roducción a !icro5oO7%NE(
T9C-9 : Principale5 7aMla5 de un maniOie57o
Para a5egurar Rue no 5e WaSa al7erado la inOormación de ningTn en5amMlado 5e u5a el
crip7o5i57ema de claQe pTMlica )SA% Lo Rue 5e Wace e5 calcular el código de di5per5ión
SHAD: del módulo Rue con7enga el maniOie57o e incluir 7an7o e57e Qalor ciOrado con
)SA I@74?9 57=739-K como la claQe pTMlica nece5aria para de5ciOrarlo en algTn lugar del
módulo Rue 5e indicar9 en la caMecera de CL)% Cada Qe8 Rue 5e QaSa a cargar en
memoria el en5amMlado 5e calcular9 5u Qalor de di5per5ión de nueQo S 5e comproMar9
Rue e5 igual al re5ul7ado de de5ciOrar el original u5ando 5u claQe pTMlica% Si no Oue5e a5V
5e de7ec7arVa Rue 5e Wa adul7erado 5u con7enido%
Para a5egurar 7amMi6n Rue lo5 con7enido5 del re57o de OicWero5 Rue Oormen un
en5amMlado no WaSan 5ido al7erado5 lo Rue 5e Wace e5 calcular el código de di5per5ión
de 657o5 an7e5 de ciOrar el en5amMlado S guardarlo en el elemen7o corre5pondien7e a cada
OicWero en la 7aMla /ile#eO del maniOie57o% El algori7mo de ciOrado u5ado por deOec7o e5
SHAD:N aunRue en e57e ca5o 7amMi6n 5e da la po5iMilidad de u5ar !#;% En amMo5 ca5o5N
cada Qe8 Rue 5e accede al OicWero para acceder a un 7ipo o recur5o 5e calcular9 de nueQo
5u Qalor de di5per5ión S 5e comproMar9 Rue coincida con el almacenado en /ile#eO%
#ado Rue la5 claQe5 pTMlica5 5on Qalore5 Rue ocupan mucWo5 MS7e5 I&+3' Mi75KN lo Rue
5e Wace para eQi7ar Rue lo5 me7ada7o5 5ean eUce5iQamen7e grande5 e5 no incluir en la5
reOerencia5 a en5amMlado5 eU7erno5 de la 7aMla A55emMlS)eO la5 claQe5 pTMlica5 de
dicWo5 en5amMlado5N 5ino 5ólo lo5 =3 Tl7imo5 Mi75 re5ul7an7e5 de aplicar un algori7mo de
di5per5ión a dicWa5 claQe5% A e57e Qalor recor7ado 5e le llama ?9469 51 6-9A1 <OC-769%
HaS do5 7ipo5 de en5amMlado5L 12;9?C-95.; <47A95.; S 12;9?C-95.; 6.?<94375.;%
Lo5 priQado5 5e almacenan en el mi5mo direc7orio Rue la aplicación Rue lo5 u5a S 5ólo
puede u5arlo5 657aN mien7ra5 Rue lo5 compar7ido5 5e almacenan en un 696JN 51
12;9?C-95. =-.C9- I1ACK S pueden u5arlo5 cualRuiera Rue WaSa 5ido compilada
reOerenci9ndolo5%
Lo5 compar7ido5 Wan de ciOra5e con )SA Sa Rue lo Rue lo5 iden7iOica e5 en el 1AC e5
5u nomMre I5in eU7en5iónK m95 5u claQe pTMlicaN lo Rue permi7e Rue en el 1AC puedan
in57alar5e Qario5 en5amMlado5 con el mi5mo nomMre S diOeren7e5 claQe5 pTMlica5% E5
decirN e5 como 5i la claQe pTMlica Oorma5e par7e del nomMre del en5amMladoN ra8ón por
la Rue a lo5 en5amMlado5 a5V ciOrado5 5e le5 llama 12;9?C-95.; 51 2.?C41 @01431% E57a
polV7ica permi7e re5olQer lo5 conOlic7o5 deriQado5 de Rue 5e in7en7e in57alar en un mi5mo
eRuipo Qario5 en5amMlado5 compar7ido5 con el mi5mo nomMre pero proceden7e5 de
di57in7a5 empre5a5N pue5 657a5 7endr9n di57in7a5 claQe5 pTMlica5%
(amMi6n para eQi7ar proMlema5N en el 1AC 5e pueden man7ener mTl7iple5 Qer5ione5 de
un mi5mo en5amMlado% A5VN 5i una aplicación Oue compilada u5ando una cier7a Qer5ión
de un de7erminado en5amMlado compar7idoN cuando 5e ejecu7e 5ólo podr9 Wacer u5o de
e5a Qer5ión del en5amMlado S no de alguna o7ra m95 moderna Rue 5e WuMie5e in57alado
en el 1AC% #e e57a Oorma 5e 5oluciona el proMlema del 72@7142. 51 -9; DLL comen7ado
al principio del 7ema%
En realidad e5 po5iMle modiOicar 7an7o la5 polV7ica5 de MT5Rueda de en5amMlado5 Ipor
ejemploN para Mu5car en5amMlado5 priQado5 Ouera del direc7orio de la aplicaciónK como
la polV7ica de acep7ación de en5amMlado5 compar7ido5 Ipor ejemploN para Rue 5e Waga
El lenguaje de programación C# (ema :L In7roducción a !icro5oO7%NE(
au7om97icamen7e u5o de la5 nueQa5 Qer5ione5 Rue 5e in57alen de #LL5 compar7ida5K
incluSendo en el direc7orio de in57alación de la aplicación un OicWero de conOiguración
en Oorma7o -!L con la5 nueQa5 regla5 para la5 mi5ma5% E57e OicWero Wa de llamar5e
igual Rue el ejecu7aMle de la aplicación pero Wa de 7ener eU7en5ión .6@=%
Librer"a de clase base (#CL)
La LiMrerVa de Cla5e Ba5e IBCLK e5 una liMrerVa incluida en el .NET Framework
Oormada por cien7o5 de 7ipo5 de da7o5 Rue permi7en acceder a lo5 5erQicio5 oOrecido5 por
el CL) S a la5 Ouncionalidade5 m95 Orecuen7emen7e u5ada5 a la Wora de e5criMir
programa5% Adem95N a par7ir de e57a5 cla5e5 preOaMricada5 el programador puede crear
nueQa5 cla5e5 Rue median7e Werencia eU7iendan 5u Ouncionalidad S 5e in7egren a la
perOección con el re57o de cla5e5 de la BCL% Por ejemploN implemen7ando cier7o5
in7erOace5 podemo5 crear nueQo5 7ipo5 de coleccione5 Rue 5er9n 7ra7ada5 eUac7amen7e
igual Rue cualRuiera de la5 coleccione5 incluida5 en la BCL%
E57a liMrerVa e579 e5cri7a en !SILN por lo Rue puede u5ar5e de5de cualRuier lenguaje
cuSo compilador genere !SIL% A 7raQ65 de la5 cla5e5 5umini57rada5 en ella e5 po5iMle
de5arrollar cualRuier 7ipo de aplicaciónN de5de la5 7radicionale5 aplicacione5 de
Qen7ana5N con5ola o 5erQicio de <indoY5 N( Wa57a lo5 noQedo5o5 5erQicio5 <eM S
p9gina5 ASP%NE(% E5 7al la riRue8a de 5erQicio5 Rue oOrece Rue inclu5o e5 po5iMle crear
lenguaje5 Rue care8can de liMrerVa de cla5e5 propia S 5ólo 5e Ma5en en la BCL Dcomo C#%
#ada la ampli7ud de la BCLN Wa 5ido nece5ario organi8ar la5 cla5e5 en ella incluida en
1;<967.; 51 2.?C41; Rue agrupen cla5e5 con Ouncionalidade5 5imilare5% Por ejemploN
lo5 e5pacio5 de nomMre5 m95 u5ado5 5onL
E;<967. 51 2.?C41; U37-7595 51 -.; 37<.; 51 593.; /01 6.237121
System
(ipo5 muS Orecuen7emen7e u5ado5N como lo5 lo5 7ipo5
M95ico5N 7aMla5N eUcepcione5N OecWa5N nTmero5 alea7orio5N
recolec7or de Ma5uraN en7rada^5alida en con5olaN e7c%
System.CoIIections
Coleccione5 de da7o5 de u5o comTn como pila5N cola5N
li57a5N diccionario5N e7c%
System.Data
!anipulación de Ma5e5 de da7o5% /orman la denominada
arRui7ec7ura ADO.NET%
System.IO
!anipulación de OicWero5 S o7ro5 Olujo5 de da7o5%
System.Net
)eali8ación de comunicacione5 en red%
System.RefIection
Acce5o a lo5 me7ada7o5 Rue acompaXan a lo5 módulo5 de
código%
System.Runtime.Remoting
Acce5o a oMje7o5 remo7o5%
System.Security
Acce5o a la polV7ica de 5eguridad en Rue 5e Ma5a el CL)%
System.Threading
!anipulación de Wilo5%
System.Web.UI.WebControIs
Creación de in7erOace5 de u5uario Ma5ada5 en Qen7ana5
para aplicacione5 <eM%
System.Windows.Forms
Creación de in7erOace5 de u5uario Ma5ada5 en Qen7ana5
para aplicacione5 e579ndar%
System.XML
Acce5o a da7o5 en Oorma7o -!L%
El lenguaje de programación C# (ema :L In7roducción a !icro5oO7%NE(
T9C-9 $ : E5pacio5 de nomMre5 de la BCL m95 u5ado5
Common T$pe !$stem (CT!)
El C.??.2 T:<1 S:;31? IC(SK o Si57ema de (ipo ComTn e5 el conjun7o de regla5
Rue Wan de 5eguir la5 deOinicione5 de 7ipo5 de da7o5 para Rue el CL) la5 acep7e% E5
decirN aunRue cada lenguaje ge57ionado di5ponga de 5u propia 5in7aUi5 para deOinir 7ipo5
de da7o5N en el !SIL re5ul7an7e de la compilación de 5u5 código5 Ouen7e 5e Wan de
cumplir la5 regla5 del C(S% Alguno5 ejemplo5 de e57a5 regla5 5onL
• Cada 7ipo de da7o puede con57ar de cero o m95 miemMro5% Cada uno de e57o5
miemMro5 puede 5er un campoN un m67odoN una propiedad o un eQen7o%
• No puede WaMer Werencia mTl7ipleN S 7odo 7ipo de da7o Wa de Weredar direc7a o
indirec7amen7e de System.Object%
• Lo5 modiOicadore5 de acce5o admi7ido5 5onL
M.57@7695.4 C857=. 51;51 1- /01 1; 9661;7C-1 1- ?71?C4.
pubIic
CualRuier código
private
Código del mi5mo 7ipo de da7o
famiIy
Código del mi5mo 7ipo de da7o o de Wijo5 de 657e%
assembIy
Código del mi5mo en5amMlado
famiIy and
assembIy
Código del mi5mo 7ipo o de Wijo5 de 657e uMicado en
el mi5mo en5amMlado
famiIy or
assembIy
Código del mi5mo 7ipo o de Wijo5 de 657eN o código
uMicado en el mi5mo en5amMlado
T9C-9 4 : !odiOicadore5 de acce5o a miemMro5 admi7ido5 por el C(S
Common Language !pecification (CL!)
El C.??.2 L92=09=1 S<167@76937.2 ICLSK o E5peciOicación del Lenguaje ComTn e5
un conjun7o de regla5 Rue Wan de 5eguir la5 deOinicione5 de 7ipo5 Rue 5e Wagan u5ando
un de7erminado lenguaje ge57ionado 5i 5e de5ea Rue 5ean acce5iMle5 de5de cualRuier o7ro
lenguaje ge57ionado% MQiamen7eN 5ólo e5 nece5ario 5eguir e57a5 regla5 en la5
deOinicione5 de 7ipo5 S miemMro5 Rue 5ean acce5iMle5 eU7ernamen7eN S no la en la5 de
lo5 priQado5% Adem95N 5i no impor7a la in7eroperaMilidad en7re lenguaje5 7ampoco e5
nece5ario 5eguirla5% A con7inuación 5e li57an alguna5 de regla5 5igniOica7iQa5 del CLSL
• Lo5 7ipo5 de da7o5 M95ico5 admi7ido5 5on booIN charN byteN shortN intN IongN fIoatN
doubIeN string S object Nó7e5e pue5 Rue no 7odo5 lo5 lenguaje5 7ienen porRu6
admi7ir lo5 7ipo5 M95ico5 en7ero5 5in 5igno o el 7ipo decimaI como lo Wace C#%
• La5 7aMla5 Wan de 7ener una o m95 dimen5ione5N S el nTmero de dimen5ione5 de
cada 7aMla Wa de 5er Oijo% Adem95N Wan de indeUar5e empe8ando a con7ar de5de +%
El lenguaje de programación C# (ema :L In7roducción a !icro5oO7%NE(
• Se pueden deOinir 7ipo5 aM57rac7o5 S 7ipo5 5ellado5% Lo5 7ipo5 5ellado5 no pueden
7ener miemMro5 aM57rac7o5%
• La5 eUcepcione5 Wan de deriQar de System.ExceptionN lo5 delegado5 de
System.DeIegateN la5 enumeracione5 de System.EnumN S lo5 7ipo5 por Qalor Rue
no 5ean enumeracione5 de System.VaIueType%
• Lo5 m67odo5 de acce5o a propiedade5 en Rue 5e 7radu8can la5 deOinicione5
ge7^5e7 de 657a5 Wan de llamar5e de la Oorma get_X S set_X re5pec7iQamen7eN
donde - e5 el nomMre de la propiedadb lo5 de acce5o a indi8adore5 Wan de
7raducir5e en m67odo5 get_Item S set_Itemb S en el ca5o de lo5 eQen7o5N 5u5
deOinicione5 add^remoQe Wan de 7raducir5e en m67odo5 add_X S remove_X%
• En la5 deOinicione5 de a7riMu7o5 5ólo pueden u5ar5e enumeracione5 o da7o5 de lo5
5iguien7e5 7ipo5L System.TypeN stringN charN booIN byteN shortN intN IongN fIoatN
doubIe S object%
• En un mi5mo 9mMi7o no 5e pueden deOinir Qario5 iden7iOicadore5 cuSo5 nomMre5
5ólo diOieran en la capi7ali8ación u5ada% #e e57e modo 5e eQi7an proMlema5 al
acceder a ello5 u5ando lenguaje5 no 5en5iMle5 a maST5cula5%
• La5 enumeracione5 no pueden implemen7ar in7erOace5N S 7odo5 5u5 campo5 Wan
de 5er e5797ico5 S del mi5mo 7ipo% El 7ipo de lo5 campo5 de una enumeración 5ólo
puede 5er uno de e57o5 cua7ro 7ipo5 M95ico5L byteN shortN int o Iong%
El lenguaje de programación C# (ema &L In7roducción a C#
Tema 2: Introducción a C#
%rigen $ necesidad de un nuevo lengua&e
C# IleVdo en ingl65 _C SWarp` S en e5paXol _C AlmoWadilla`K e5 el nueQo lenguaje de
propó5i7o general di5eXado por !icro5oO7 para 5u pla7aOorma %NE(% Su5 principale5
creadore5 5on Sco77 <il7amu7W S Ander5 Hejl5MergN 657e Tl7imo 7amMi6n conocido por
WaMer 5ido el di5eXador del lenguaje (urMo Pa5cal S la Werramien7a )A# #elpWi%
AunRue e5 po5iMle e5criMir código para la pla7aOorma %NE( en mucWo5 o7ro5 lenguaje5N
C# e5 el Tnico Rue Wa 5ido di5eXado e5pecVOicamen7e para 5er u7ili8ado en ellaN por lo
Rue programarla u5ando C# e5 mucWo m95 5encillo e in7ui7iQo Rue Wacerlo con
cualRuiera de lo5 o7ro5 lenguaje5 Sa Rue C# carece de elemen7o5 Weredado5 innece5ario5
en %NE(% Por e57a ra8ónN 5e 5uele decir Rue C# e5 el -12=09>1 2937A. 51 .NET
La 5in7aUi5 S e57ruc7uración de C# e5 muS parecida a la de CPP o 4aQaN pue57o Rue la
in7ención de !icro5oO7 e5 Oacili7ar la migración de código5 e5cri7o5 en e57o5 lenguaje5 a
C# S Oacili7ar 5u aprendi8aje a lo5 de5arrolladore5 WaMi7uado5 a ello5% Sin emMargoN 5u
5encille8 S el al7o niQel de produc7iQidad 5on comparaMle5 con lo5 de ,i5ual Ba5ic%
"n lenguaje Rue WuMie5e 5ido ideal u7ili8ar para e57o5 mene57ere5 e5 4aQaN pero deMido a
proMlema5 con la empre5a creadora del mi5mo DSunDN !icro5oO7 Wa 7enido Rue
de5arrollar un nueQo lenguaje Rue aXadie5e a la5 Sa proMada5 Qir7ude5 de 4aQa la5
modiOicacione5 Rue !icro5oO7 7enVa pen5ado aXadirle para mejorarlo aTn m95 S Wacerlo
un lenguaje orien7ado al de5arrollo de componen7e5%
En re5umenN C# e5 un lenguaje de programación Rue 7oma la5 mejore5 carac7erV57ica5 de
lenguaje5 preeUi57en7e5 como ,i5ual Ba5icN 4aQa o CPP S la5 comMina en uno 5olo% El
WecWo de 5er rela7iQamen7e recien7e no implica Rue 5ea inmaduroN pue5 !icro5oO7 Wa
e5cri7o la maSor par7e de la BCL u59ndoloN por lo Rue 5u compilador e5 el m95 depurado
S op7imi8ado de lo5 incluido5 en el .NET Framework SDK
Caracter"sticas de C'
Con la idea de Rue lo5 programadore5 m95 eUperimen7ado5 puedan oM7ener una Qi5ión
general del lenguajeN a con7inuación 5e recoge de manera re5umida la5 principale5
carac7erV57ica5 de C# Alguna de la5 carac7erV57ica5 aRuV 5eXalada5 no 5on eUac7amen7e
propia5 del lenguaje 5ino de la pla7aOorma %NE( en generalN S 5i aRuV 5e comen7an e5
porRue 7ienen una repercu5ión direc7a en el lenguajeL
• S1267--1K: C# elimina mucWo5 elemen7o5 Rue o7ro5 lenguaje5 incluSen S Rue 5on
innece5ario5 en %NE(% Por ejemploL
o El código e5cri7o en C# e5 903.6.231275.N lo Rue 5igniOica Rue no
nece5i7a de OicWero5 adicionale5 al propio Ouen7e 7ale5 como OicWero5 de
caMecera o OicWero5 I#L
El lenguaje de programación C# (ema &L In7roducción a C#
o El 7amaXo de lo5 7ipo5 de da7o5 M95ico5 e5 Oijo e independien7e del
compiladorN 5i57ema opera7iQo o m9Ruina para Ruiene5 5e compile Ino
como en CPPKN lo Rue Oacili7a la por7aMilidad del código%
o No 5e incluSen elemen7o5 poco T7ile5 de lenguaje5 como CPP 7ale5 como
macro5N Werencia mTl7iple o la nece5idad de un operador diOeren7e del
pun7o I.K acceder a miemMro5 de e5pacio5 de nomMre5 I::K
• M.51427595: C# incorpora en el propio lenguaje elemen7o5 Rue a lo largo de
lo5 aXo5 Wa ido demo57r9ndo5e 5on muS T7ile5 para el de5arrollo de aplicacione5
S Rue en o7ro5 lenguaje5 como 4aQa o CPP WaS Rue 5imularN como un 7ipo M95ico
decimaI Rue permi7a reali8ar operacione5 de al7a preci5ión con reale5 de :&' Mi75
ImuS T7il en el mundo OinancieroKN la inclu5ión de una in57rucción foreach Rue
permi7a recorrer coleccione5 con Oacilidad S e5 ampliaMle a 7ipo5 deOinido5 por el
u5uarioN la inclu5ión de un 7ipo M95ico string para repre5en7ar cadena5 o la
di57inción de un 7ipo booI e5pecVOico para repre5en7ar Qalore5 lógico5%
• O4712396782 9 .C>13.;: Como 7odo lenguaje de programación de propó5i7o
general ac7ualN C# e5 un lenguaje orien7ado a oMje7o5N aunRue e5o e5 m95 Mien
una carac7erV57ica del C(S Rue de C#% "na diOerencia de e57e enOoRue orien7ado a
oMje7o5 re5pec7o al de o7ro5 lenguaje5 como CPP e5 Rue el de C# e5 m95 puro en
7an7o Rue no admi7en ni Ouncione5 ni QariaMle5 gloMale5 5ino Rue 7odo el código S
da7o5 Wan de deOinir5e den7ro de deOinicione5 de 7ipo5 de da7o5N lo Rue reduce
proMlema5 por conOlic7o5 de nomMre5 S Oacili7a la legiMilidad del código%
C# 5opor7a 7oda5 la5 carac7erV57ica5 propia5 del paradigma de programación
orien7ada a oMje7o5L 1269<;0-96782N J1412679 S <.-7?.4@7;?.%
En lo reOeren7e a la encap5ulación e5 impor7an7e 5eXalar Rue apar7e de lo5 7Vpico5
modiOicadore5 pubIicN private S protectedN C# aXade un cuar7o modiOicador
llamado internaIN Rue puede comMinar5e con protected e indica Rue al elemen7o a
cuSa deOinición precede 5ólo puede acceder5e de5de 5u mi5mo en5amMlado%
)e5pec7o a la Werencia Da diOerencia de CPP S al igual Rue 4aQaD C# 5ólo admi7e
Werencia 5imple de cla5e5 Sa Rue la mTl7iple proQoca m95 RueMradero5 de caMe8a
Rue Oacilidade5 S en la maSorVa de lo5 ca5o5 5u u7ilidad puede 5er 5imulada con
Oacilidad median7e Werencia mTl7iple de in7erOace5% #e 7odo5 modo5N e57o QuelQe
a 5er m95 Mien una carac7erV57ica propia del C(S Rue de C#%
Por o7ro lado S a diOerencia de 4aQaN en C# 5e Wa op7ado por Wacer Rue 7odo5 lo5
m67odo5 5ean por deOec7o 5ellado5 S Rue lo5 redeOiniMle5 WaSan de marcar5e con
el modiOicador virtuaI Icomo en CPPKN lo Rue permi7e eQi7ar errore5 deriQado5 de
redeOinicione5 acciden7ale5% Adem95N un eOec7o 5ecundario de e57o e5 Rue la5
llamada5 a lo5 m67odo5 5er9n m95 eOicien7e5 por deOec7o al no 7ener5e Rue Mu5car
en la 7aMla de Ouncione5 Qir7uale5 la implemen7ación de lo5 mi5mo5 a la Rue 5e Wa
de llamar% 7ro eOec7o 5ecundario e5 Rue permi7e Rue la5 llamada5 a lo5 m67odo5
Qir7uale5 5e puedan Wacer m95 eOicien7emen7e al con7riMuir a Rue el 7amaXo de
dicWa 7aMla 5e redu8ca%
El lenguaje de programación C# (ema &L In7roducción a C#
• O4712396782 9 6.?<.21231;: La propia 5in7aUi5 de C# incluSe elemen7o5
propio5 del di5eXo de componen7e5 Rue o7ro5 lenguaje5 7ienen Rue 5imular
median7e con57ruccione5 m95 o meno5 compleja5% E5 decirN la 5in7aUi5 de C#
permi7e deOinir cómodamen7e <4.<715951; I5imilare5 a campo5 de acce5o
con7roladoKN 1A123.; Ia5ociación con7rolada de Ouncione5 de re5pue57a a
no7iOicacione5K o 9347C03.; IinOormación 5oMre un 7ipo o 5u5 miemMro5K
• G1;3782 903.?M3769 51 ?1?.479: Como Sa 5e comen7óN 7odo lenguaje de %NE(
7iene a 5u di5po5ición el recolec7or de Ma5ura del CL)% E57o 7iene el eOec7o en el
lenguaje de Rue no e5 nece5ario incluir in57ruccione5 de de57rucción de oMje7o5%
Sin emMargoN dado Rue la de57rucción de lo5 oMje7o5 a 7raQ65 del recolec7or de
Ma5ura e5 inde7ermini57a S 5ólo 5e reali8a cuando 657e 5e ac7iQe dSa 5ea por Oal7a
de memoriaN Oinali8ación de la aplicación o 5olici7ud eUplVci7a en el Ouen7eDN C#
7amMi6n proporciona un mecani5mo de liMeración de recur5o5 de7ermini57a a
7raQ65 de la in57rucción using%
• S1=047595 51 37<.;: C# incluSe mecani5mo5 Rue permi7en a5egurar Rue lo5
acce5o5 a 7ipo5 de da7o5 5iempre 5e realicen correc7amen7eN lo Rue permi7e eQi7a
Rue 5e produ8can errore5 diOVcile5 de de7ec7ar por acce5o a memoria no
per7enecien7e a ningTn oMje7o S e5 e5pecialmen7e nece5ario en un en7orno
ge57ionado por un recolec7or de Ma5ura% Para ello 5e 7oman medida5 del 7ipoL
o Sólo 5e admi7en 6.2A14;7.21; 12341 37<.; 6.?<937C-1;% E57o e5N en7re un
7ipo S an7ece5ore5 5uSo5N en7re 7ipo5 para lo5 Rue eUplVci7amen7e 5e WaSa
deOinido un operador de conQer5iónN S en7re un 7ipo S un 7ipo Wijo 5uSo
del Rue un oMje7o del primero almacena5e una reOerencia del 5egundo
I5.D269;372=K MQiamen7eN lo Tl7imo 5ólo puede comproMarlo en 7iempo
de ejecución el CL) S no el compiladorN por lo Rue en realidad el CL) S
el compilador colaMoran para a5egurar la corrección de la5 conQer5ione5%
o No 5e pueden u5ar A9479C-1; 2. 727679-7K959;% El compilador da a lo5
campo5 un Qalor por deOec7o con5i57en7e en ponerlo5 a cero S con7rola
median7e an9li5i5 del Olujo de con7rol del Ouen7e Rue no 5e lea ninguna
QariaMle local 5in Rue 5e le WaSa a5ignado preQiamen7e algTn Qalor%
o Se comprueMa Rue 7odo 9661;. 9 -.; 1-1?123.; 51 029 39C-9 5e realice
con Vndice5 Rue 5e encuen7ren den7ro del rango de la mi5ma%
o Se puede con7rolar la <4.5066782 51 51;C.459?7123.; en operacione5
ari7m67ica5N inOorm9ndo5e de ello con una eUcepción cuando ocurra% Sin
emMargoN para con5eguir5e un maSor rendimien7o en la ari7m67ica e57a5
comproMacione5 no 5e Wacen por deOec7o al operar con QariaMle5 5ino 5ólo
con con57an7e5 I5e pueden de7ec7ar en 7iempo de compilaciónK
o A diOerencia de 4aQaN C# incluSe 51-1=95.;N Rue 5on 5imilare5 a lo5
pun7ero5 a Ouncione5 de CPP pero 5iguen un enOoRue orien7ado a oMje7o5N
pueden almacenar reOerencia5 a Qario5 m67odo5 5imul79neamen7eN S 5e
comprueMa Rue lo5 m67odo5 a lo5 Rue apun7en 7engan par9me7ro5 S Qalor
de re7orno del 7ipo indicado al deOinirlo5%
El lenguaje de programación C# (ema &L In7roducción a C#
o Pueden deOinir5e m67odo5 Rue admi7an un nTmero indeOinido de
par9me7ro5 de un cier7o 7ipoN S a diOerencia lenguaje5 como C^CPPN en
C# 5iempre 5e comprueMa Rue lo5 Qalore5 Rue 5e le5 pa5en en cada
llamada 5ean de lo5 7ipo5 apropiado5%
• I2;340667.21; ;1=049;: Para eQi7ar errore5 muS comune5N en C# 5e Wan
impue57o una 5erie de re57riccione5 en el u5o de la5 in57ruccione5 de con7rol m95
comune5% Por ejemploN la guarda de 7oda condición Wa de 5er una eUpre5ión
condicional S no ari7m67icaN con lo Rue 5e eQi7an errore5 por conOu5ión del
operador de igualdad I==K con el de a5ignación I=Kb S 7odo ca5o de un ;D736J Wa
de 7erminar en un break o goto Rue indiRue cu9l e5 la 5iguien7e acción a reali8arN
lo Rue eQi7a la ejecución acciden7al de ca5o5 S Oacili7a 5u reordenación%
• S7;31?9 51 37<.; 027@7695.: A diOerencia de CPPN en C# 7odo5 lo5 7ipo5 de da7o5
Rue 5e deOinan 5iempre deriQar9nN aunRue 5ea de manera implVci7aN de una cla5e
Ma5e comTn llamada System.ObjectN por lo Rue di5pondr9n de 7odo5 lo5
miemMro5 deOinido5 en 657a cla5e Ie5 decirN 5er9n _oMje7o5`K
A diOerencia de 4aQaN en C# e57o 7amMi6n e5 aplicaMle a lo5 7ipo5 de da7o5 M95ico5
Adem95N para con5eguir Rue ello no 7enga una repercu5ión nega7iQa en 5u niQel
de rendimien7oN 5e Wa incluido un mecani5mo 7ran5paren7e de boxing S unboxing
con el Rue 5e con5igue Rue 5ólo 5ean 7ra7ado5 como oMje7o5 cuando la 5i7uación
lo reRuieraN S mien7ra5 7an7o puede aplic9r5ele5 op7imi8acione5 e5pecVOica5%
El WecWo de Rue 7odo5 lo5 7ipo5 del lenguaje deriQen de una cla5e comTn Oacili7a
enormemen7e el di5eXo de coleccione5 gen6rica5 Rue puedan almacenar oMje7o5
de cualRuier 7ipo%
• EI312;7C7-7595 51 37<.; CM;76.;: C# permi7e deOinirN a 7raQ65 de 1;34063049;N
7ipo5 de da7o5 para lo5 Rue 5e apliRuen la5 mi5ma5 op7imi8acione5 Rue para lo5
7ipo5 de da7o5 M95ico5% E5 decirN Rue 5e puedan almacenar direc7amen7e en pila
Iluego 5u creaciónN de57rucción S acce5o 5er9n m95 r9pido5K S 5e a5ignen por
Qalor S no por reOerencia% Para con5eguir Rue lo Tl7imo no 7enga eOec7o5
nega7iQo5 al pa5ar e57ruc7ura5 como par9me7ro5 de m67odo5N 5e da la po5iMilidad
de pa5ar reOerencia5 a pila a 7raQ65 del modiOicador de par9me7ro ref%
• EI312;7C7-7595 51 .<1495.41;: Para Oacili7ar la legiMilidad del código S
con5eguir Rue lo5 nueQo5 7ipo5 de da7o5 M95ico5 Rue 5e deOinan a 7raQ65 de la5
e57ruc7ura5 e576n al mi5mo niQel Rue lo5 M95ico5 predeOinido5 en el lenguajeN al
igual Rue CPP S a diOerencia de 4aQaN C# permi7e redeOinir el 5igniOicado de la
maSorVa de lo5 operadore5 Dincluido5 lo5 de conQer5iónN 7an7o para conQer5ione5
implVci7a5 como eUplVci7a5D cuando 5e apliRuen a diOeren7e5 7ipo5 de oMje7o5%
La5 redeOinicione5 de operadore5 5e Wacen de manera in7eligen7eN de modo Rue a
par7ir de una Tnica deOinición de lo5 operadore5 ++ S -- el compilador puede
deducir au7om97icamen7e como ejecu7arlo5 de manera preOija5 S po57iOjab S
deOiniendo operadore5 5imple5 Icomo +KN el compilador deduce cómo aplicar 5u
Qer5ión de a5ignación compue57a IPcK Adem95N para a5egurar la con5i57enciaN el
compilador Qigila Rue lo5 operadore5 con opue57o 5iempre 5e redeOinan por
pareja5 Ipor ejemploN 5i 5e redeOine ==N 7amMi6n WaS Rue redeOinir !=K
El lenguaje de programación C# (ema &L In7roducción a C#
(amMi6n 5e da la po5iMilidadN a 7raQ65 del concep7o de 7257K95.4N de redeOinir el
5igniOicado del operador [] para lo5 7ipo5 de da7o deOinido5 por el u5uarioN con lo
Rue 5e con5igue Rue 5e pueda acceder al mi5mo como 5i Oue5e una 7aMla% E57o e5
muS T7il para 7raMajar con 7ipo5 Rue ac7Ten como coleccione5 de oMje7o5%
• EI312;7C7-7595 51 ?.57@7695.41;: C# oOreceN a 7raQ65 del concep7o de
9347C03.;N la po5iMilidad de aXadir a lo5 me7ada7o5 del módulo re5ul7an7e de la
compilación de cualRuier Ouen7e inOormación adicional a la generada por el
compilador Rue luego podr9 5er con5ul7ada en 7iempo ejecución a 7raQ65 de la
liMrerVa de reOleUión de %NE( % E57oN Rue m95 Mien e5 una carac7erV57ica propia de
la pla7aOorma %NE( S no de C#N puede u5ar5e como un mecani5mo para deOinir
nueQo5 modiOicadore5%
• V14;7.29C-1: C# incluSe una <.-L3769 51 A14;7.295. Rue permi7e crear nueQa5
Qer5ione5 de 7ipo5 5in 7emor a Rue la in7roducción de nueQo5 miemMro5
proQoRuen errore5 diOVcile5 de de7ec7ar en 7ipo5 Wijo5 preQiamen7e de5arrollado5
S Sa eU7endido5 con miemMro5 de igual nomMre a lo5 reci6n in7roducido5%
Si una cla5e in7roduce un nueQo m67odo cuSa5 redeOinicione5 deMan 5eguir la
regla de llamar a la Qer5ión de 5u padre en algTn pun7o de 5u códigoN
diOVcilmen7e 5eguirVan e57a regla miemMro5 de 5u mi5ma 5igna7ura deOinido5 en
cla5e5 Wija5 preQiamen7e a la deOinición del mi5mo en la cla5e padreb o 5i
in7roduce un nueQo campo con el mi5mo nomMre Rue algTn m67odo de una cla5e
WijaN la cla5e Wija dejar9 de Ouncionar% Para eQi7ar Rue e57o ocurraN en C# 5e
7oman do5 medida5L
o Se oMliga a Rue 7oda redeOinición deMa incluir el modiOicador overrideN
con lo Rue la Qer5ión de la cla5e Wija nunca 5erVa con5iderada como una
redeOinición de la Qer5ión de miemMro en la cla5e padre Sa Rue no
incluirVa override% Para eQi7ar Rue por acciden7e un programador incluSa
e57e modiOicadorN 5ólo 5e permi7e incluirlo en miemMro5 Rue 7engan la
mi5ma 5igna7ura Rue miemMro5 marcado5 como redeOiniMle5 median7e el
modiOicador virtuaI% A5V adem95 5e eQi7a el error 7an Orecuen7e en 4aQa de
creer5e WaMer redeOinido un miemMroN pue5 5i el miemMro con override no
eUi57e en la cla5e padre 5e producir9 un error de compilación%
o Si no 5e con5idera redeOiniciónN en7once5 5e con5idera Rue lo Rue 5e
de5ea e5 ocul7ar el m67odo de la cla5e padreN de modo Rue para la cla5e
Wija 5ea como 5i nunca WuMie5e eUi57ido% El compilador aQi5ar9 de e57a
deci5ión a 7raQ65 de un men5aje de aQi5o Rue puede 5uprimir5e
incluSendo el modiOicador new en la deOinición del miemMro en la cla5e
Wija para a5V indicarle eUplVci7amen7e la in7ención de ocul7ación%
• E@7671231: En principioN en C# 7odo el código incluSe numero5a5 re57riccione5
para a5egurar 5u 5eguridad S no permi7e el u5o de pun7ero5% Sin emMargoN S a
diOerencia de 4aQaN en C# e5 po5iMle 5al7ar5e dicWa5 re57riccione5 manipulando
oMje7o5 a 7raQ65 de pun7ero5% Para ello Ma57a marcar regione5 de código como
in5egura5 ImodiOicador unsafeK S podr9n u5ar5e en ella5 pun7ero5 de Oorma
El lenguaje de programación C# (ema &L In7roducción a C#
5imilar a cómo 5e Wace en CPPN lo Rue puede re5ul7ar Qi7al para 5i7uacione5
donde 5e nece5i7e una eOiciencia S Qelocidad proce5amien7o muS grande5%
• C.?<937C-1: Para Oacili7ar la migración de programadore5N C# no 5ólo man7iene
una 5in7aUi5 muS 5imilar a CN CPP o 4aQa Rue permi7e incluir direc7amen7e en
código e5cri7o en C# Oragmen7o5 de código e5cri7o en e57o5 lenguaje5N 5ino Rue el
CL) 7amMi6n oOreceN a 7raQ65 de lo5 llamado5 P-93@.4? I2A.6937.2 S14A761;
IPI2A.E1KN la po5iMilidad de acceder a código na7iQo e5cri7o como Ouncione5
5uel7a5 no orien7ada5 a oMje7o5 7ale5 como la5 #LL5 de la API <in*&% Nó7e5e
Rue la capacidad de u5ar pun7ero5 en código in5eguro permi7e Rue 5e pueda
acceder con Oacilidad a e57e 7ipo de Ouncione5N Sa Rue 657a5 mucWa5 Qece5
e5peran reciMir o deQuelQen pun7ero5%
(amMi6n e5 po5iMle acceder de5de código e5cri7o en C# a oMje7o5 C!% Para
Oacili7ar e57oN el .NET Framework SDK incluSe una Werramien7a5 llamada5
tlbimp S regasm median7e la5 Rue e5 po5iMle generar au7om97icamen7e cla5e5
proUS Rue permi7anN re5pec7iQamen7eN u5ar oMje7o5 C! de5de %NE( como 5i de
oMje7o5 %NE( 5e 7ra7a5e S regi57rar oMje7o5 %NE( para 5u u5o de5de C!%
/inalmen7eN 7amMi6n 5e da la po5iMilidad de u5ar con7role5 Ac7iQe- de5de código
%NE( S QiceQer5a% Para lo primero 5e u7ili8a la u7ilidad aximpN mien7ra5 Rue para
lo 5egundo 5e u5a la Sa mencionada regasm%
Escritura de aplicaciones
ApIicación básica ¡HoIa Mundo!
B95icamen7e una aplicación en C# puede Qer5e como un conjun7o de uno o m95
OicWero5 de código Ouen7e con la5 in57ruccione5 nece5aria5 para Rue la aplicación
Ouncione como 5e de5ea S Rue 5on pa5ado5 al compilador para Rue genere un ejecu7aMle%
Cada uno de e57o5 OicWero5 no e5 m95 Rue un OicWero de 7eU7o plano e5cri7o u5ando
carac7ere5 "nicode S 5iguiendo la 5in7aUi5 propia de C#%

Como primer con7ac7o con el lenguajeN nada mejor Rue el 7Vpico programa de iniciación
_¡Hola !undo$` Rue lo Tnico Rue Wace al ejecu7ar5e e5 mo57rar por pan7alla el men5aje
¡Hola Mundo! Su código e5L
&
1: class HolaMundo
2: {
3: static void Main()
4: {
5: System.Console.WriteLine(“¡Hola Mundo!”);
6: }
7: }
(odo el código e5cri7o en C# 5e Wa de e5criMir den7ro de una deOinición de cla5eN S lo
Rue en la lVnea 1: 5e dice e5 Rue 5e Qa a deOinir una cla5e I6-9;;K de nomMre HolaMundo1
&
Lo5 nTmero5 de lVnea no Oorman par7e del código 5ino Rue 5ólo 5e incluSen para Oacili7ar 5u po57erior
eUplicación%
El lenguaje de programación C# (ema &L In7roducción a C#
cuSa deOinición e57ar9 comprendida en7re la llaQe de aper7ura de la lVnea : S 5u
corre5pondien7e llaQe de cierre en la lVnea lVnea 7:
#en7ro de la deOinición de la cla5e IlVnea $:K 5e deOine un m67odo de nomMre Main cuSo
código e5 el indicado en7re la llaQe de aper7ura de la lVnea 4: S 5u re5pec7iQa llaQe de
cierre IlVnea 6:K "n m67odo no e5 m95 Rue un conjun7o de in57ruccione5 a la5 Rue 5e le5
a5ocia un nomMreN de modo Rue para po57eriormen7e ejecu7arla5 Ma57e reOerenciarla5 por
5u nomMre en Qe8 de 7ener Rue re5criMirla5%
La par7Vcula Rue an7ecede al nomMre del m67odo indica cu9l e5 el 7ipo de Qalor Rue 5e
deQuelQe 7ra5 la ejecución del m67odoN S en e57e ca5o e5 A.75 Rue 5igniOica Rue no 5e
deQuelQe nada% Por 5u par7eN lo5 par6n7e5i5 colocado5 7ra5 el nomMre del m67odo indican
cu9le5 5on lo5 par9me7ro5 Rue 657e 7omaN S el Rue e576n QacVo5 5igniOica Rue el m67odo
no 7oma ninguno% Lo5 par9me7ro5 de un m67odo permi7en modiOicar el re5ul7ado de 5u
ejecución en Ounción de lo5 Qalore5 Rue 5e le5 d6 en cada llamada%
La palaMra ;39376 Rue an7ecede a la declaración del 7ipo de Qalor deQuel7o e5 un
?.57@7695.4 del 5igniOicado de la declaración de m67odo Rue indica Rue el m67odo e579
a5ociado a la cla5e den7ro de la Rue 5e deOine S no a lo5 oMje7o5 Rue 5e creen a par7ir de
ella% Main() e5 lo Rue 5e denomina el <023. 51 1234959 de la aplicaciónN Rue no e5 m95
Rue el m67odo por el Rue comen8ar9 5u ejecución% Nece5i7a del modiOicador static para
eQi7ar Rue para llamarlo WaSa Rue crear algTn oMje7o de la cla5e donde 5e WaSa deOinido%
/inalmen7eN la lVnea 5: con7iene la in57rucción con el código a ejecu7arN Rue lo Rue 5e
Wace e5 5olici7ar la ejecución del m67odo B4731L721() de la cla5e C.2;.-1 deOinida en el
e5pacio de nomMre5 System pa59ndole como par9me7ro la cadena de 7eU7o con el
con7enido ¡Hola Mundo! Nó7e5e Rue la5 cadena5 de 7eU7o5 5on 5ecuencia5 de carac7ere5
delimi7ada5 por comilla5 doMle5 aunRue dicWa5 comilla5 no Oorman par7e de la cadena%
Por 5u par7eN un e5pacio de nomMre5 puede con5iderar5e Rue e5 para la5 cla5e5 algo
5imilar a lo Rue un direc7orio e5 para lo5 OicWero5L una Oorma de agruparla5%
El m67odo WriteLine() 5e u5ar9 muS a menudo en lo5 próUimo5 7ema5N por lo Rue e5
conQenien7e 5eXalar aWora Rue una Oorma de llamarlo Rue 5e u7ili8ar9 en repe7ida5
oca5ione5 con5i57e en pa5arle un nTmero indeOinido de o7ro5 par9me7ro5 de cualRuier
7ipo e incluir en el primero 5uMcadena5 de la Oorma {i}% Con ello 5e con5igue Rue 5e
mue57re por la Qen7ana de con5ola la cadena Rue 5e le pa5a como primer par9me7ro pero
5u57i7uS6ndole la5 5uMcadena5 {i} por el Qalor conQer7ido en cadena de 7eU7o del
par9me7ro Rue ocupe la po5ición iP& en la llamada a WriteLine()% Por ejemploN la
5iguien7e in57rucción mo57rarVa Tengo 5 años por pan7alla 5i x Qalie5e ;L
System.Console.WriteLine(“Tengo {! años"# $%&
Para indicar cómo conQer7ir cada oMje7o en un cadena de 7eU7o Ma57a redeOinir 5u m67odo
ToString()N aunRue e57o e5 algo Rue no 5e Qer9 Wa57a el Tema 5: Clases%

An7e5 de 5eguir e5 impor7an7e re5al7ar Rue C# e5 5en5iMle a la5 maST5cula5N lo5 Rue
5igniOica Rue no da igual la capi7ali8ación con la Rue 5e e5criMan lo5 iden7iOicadore5% E5
decirN no e5 lo mi5mo e5criMir Console Rue COnsole o CONSOLEN S 5i 5e Wace de alguna
de la5 do5 Tl7ima5 Oorma5 el compilador producir9 un error deMido a Rue en el e5pacio
de nomMre5 System no eUi57e ninguna cla5e con dicWo5 nomMre5% En e57e 5en7idoN caMe
5eXalar Rue un error comTn en7re programadore5 aco57umMrado5 a 4aQa e5 llamar al
El lenguaje de programación C# (ema &L In7roducción a C#
pun7o de en7rada main en Qe8 de MainN lo Rue proQoca un error al compilar ejecu7aMle5 en
7an7o Rue el compilador no de7ec7ar9 ninguna deOinición de pun7o de en7rada%
Puntos de entrada
2a 5e Wa dicWo Rue el <023. 51 1234959 de una aplicación e5 un m67odo de nomMre
Main Rue con7endr9 el código por donde 5e Wa de iniciar la ejecución de la mi5ma% Ha57a
aWora 5ólo 5e Wa Qi57o una Qer5ión de Main() Rue no 7oma par9me7ro5 S 7iene como 7ipo
de re7orno voidN pero en realidad 7oda5 5u5 po5iMle5 Qer5ione5 5onL
static void Main()
static int Main()
static int Main(string[] args)
static void Main(string[] args)
Como 5e QeN WaS Qer5ione5 de Main() Rue deQuelQen un Qalor de 7ipo int% "n 723 no e5
m95 Rue un 7ipo de da7o5 capa8 de almacenar Qalor en7ero5 comprendido5 en7re d
&%:3.
:
3'*%=3' S &%:3.
:
3'*%=3.N S el nTmero deQuel7o por Main() 5erVa in7erpre7ado como
código de re7orno de la aplicación% >57e Qalor 5uele u5ar5e para indicar 5i la aplicación a
7erminado con 6Ui7o Igeneralmen7e Qalor +K o no IQalor 5egTn la cau5a de la 7erminación
anormalKN S en el Tema 8: Métodos 5e eUplicar9 como deQolQer Qalore5%
(amMi6n WaS Qer5ione5 de Main() Rue 7oman un par9me7ro donde 5e almacenar9 la li57a
de argumen7o5 con lo5 Rue 5e llamó a la aplicaciónN por lo Rue 5ólo e5 T7il u5ar e57a5
Qer5ione5 del pun7o de en7rada 5i la aplicación Qa a u7ili8ar dicWo5 argumen7o5 para algo%
El 7ipo de e57e par9me7ro e5 string[]N lo Rue 5igniOica Rue e5 una 7aMla de cadena5 de
7eU7o Ien el Tema 5: Claes 5e eUplicar9 de7enidamen7e Ru6 5on la5 7aMla5 S la5 cadena5KN
S 5u nomMre DRue e5 el Rue WaMr9 de u5ar5e den7ro del código de Main() para Wacerle
reOerenciaD e5 args en el ejemploN aunRue podrVa d9r5ele cualRuier o7ro
CompiIación en Iínea de comandos
"na Qe8 e5cri7o el código an7erior con algTn edi7or de 7eU7o5 dcomo el Bloc de Notas
de <indoY5' S almacenado en Oorma7o de 7eU7o plano en un OicWero HolaMundo.cs
(
N
para compilarlo Ma57a aMrir una Qen7ana de con5ola I!SD#S en <indoY5KN colocar5e
en el direc7orio donde 5e encuen7re S pa59r5elo como par9me7ro al compilador a5VL
csc HolaMundo.cs
csc.exe e5 el compilador de C# incluido en el %NE( /rameYor] S#A para <indoY5
de !icro5oO7% AunRue en principio el programa de in57alación del S#A lo aXade
au7om97icamen7e al pa7W para poder llamarlo 5in proMlema5 de5de cualRuier direc7orioN
5i lo Wa in57alado a 7raQ65 de ,S%NE( e57o no ocurrir9 S deMer9 conOigur9r5elo Sa 5ea
manualmen7eN o Mien ejecu7ando el OicWero por lo7e5 Common7\Tools\vsvars32.bat
Rue ,S%NE( incluSe Majo 5u direc7orio de in57alaciónN o aMriendo la Qen7ana de con5ola
de5de el icono *1449?71239; 51 V7;09- S3057..NET  SL?C.-. 51- ;7;31?9 51
V7;09- S3057..NET corre5pondien7e al grupo de programa5 de ,S%NE( en el menT
*
El nomMre Rue 5e d6 al OicWero puede 5er cualRuieraN aunRue 5e recomienda darle la eU7en5ión .cs Sa
Rue e5 la u7ili8ada por conQenio
El lenguaje de programación C# (ema &L In7roducción a C#
Inicio de <indoY5 Rue no Wace m95 Rue aMrir la Qen7ana de con5ola S llamar
au7om97icamen7e a vsvars32.bat% En cualRuier ca5oN 5i u5a o7ro5 compiladore5 de C#
puede Rue Qarie la Oorma de reali8ar la compilaciónN por lo Rue lo Rue aRuV 5e eUplica
en principio 5ólo 5er9 Q9lido para lo5 compiladore5 de C# de !icro5oO7 para <indoY5%
(ra5 la compilación 5e oM7endrVa un ejecu7aMle llamado HolaMundo.e$e cuSa ejecución
producirVa la 5iguien7e 5alida por la Qen7ana de con5olaL
¡Hola Mundo!
Si la aplicación Rue 5e QaSa a compilar no u7ili8a5e la Qen7ana de con5ola para mo57rar
5u 5alida 5ino una in7erOa8 gr9Oica de Qen7ana5N en7once5 WaMrVa Rue compilarla pa5ando
al compilador la opción /t con el Qalor winexe an7e5 del nomMre del OicWero a
compilar% Si no 5e Wicie5e a5V 5e aMrVrVa la Qen7ana de con5ola cada Qe8 Rue ejecu7a5e la
aplicación de Qen7ana5N lo Rue 5uele 5er inde5eaMle en e57e 7ipo de aplicacione5% A5VN
para compilar )entanas.cs como ejecu7aMle de Qen7ana5 5erVa conQenien7e e5criMirL
csc *t+,ine$e )entanas.cs
Nó7e5e Rue aunRue el nomMre winexe d6 la 5en5ación de Rue e57e Qalor para la opción
/t 5ólo permi7e generar ejecu7aMle5 de Qen7ana5N en realidad lo Rue permi7e e5 generar
ejecu7aMle5 5in Qen7ana de con5ola a5ociada% Por 7an7oN 7amMi6n puede u5ar5e para
generar ejecu7aMle5 Rue no 7engan ninguna in7erOa8 a5ociadaN ni de con5ola ni gr9Oica%

Si en lugar de un ejecu7aMle DSa 5ea de con5ola o de Qen7ana5D 5e de5ea oM7ener una
liMrerVaN en7once5 al compilar WaS Rue pa5ar al compilador la opción /t con el Qalor
library% Por ejemploN 5iguiendo con el ejemplo inicial WaMrVa Rue e5criMirL
csc *t+li-rary HolaMundo.cs
En e57e ca5o 5e generarVa un OicWero HolaMundo.dll cuSo5 7ipo5 de da7o5 podrVan
u7ili8ar5e de5de o7ro5 Ouen7e5 pa5ando al compilador una reOerencia a lo5 mi5mo5
median7e la opción /r% Por ejemploN para compilar como ejecu7aMle un Ouen7e ..cs Rue
u5e la cla5e HolaMundo de la liMrerVa HolaMundo.dll 5e e5criMirVaL
csc *r+HolaMundo.dll ..cs
En general /r permi7e reOerenciar a 7ipo5 deOinido5 en cualRuier en5amMladoN por lo Rue
el Qalor Rue 5e le indiRue 7amMi6n puede 5er el nomMre de un ejecu7aMle% Adem95N en
cada compilación e5 po5iMle reOerenciar mTl7iple5 en5amMlado5 Sa 5ea incluiSendo la
opción /r una Qe8 por cada uno o incluiSendo mTl7iple5 reOerencia5 en una Tnica
opción /r u5ando coma5 o pun7o5 S coma5 como 5eparadore5% Por ejemploN la5
5iguien7e5 7re5 llamada5 al compilador 5on eRuiQalen7e5L
csc *r+HolaMundo.dll&/tro.dll&/troM0s.e$e ..cs
csc *r+HolaMundo.dll#/tro.dll#/troM0s.e$e ..cs
csc *t+HolaMundo.dll *r+/tro.dll *r+/troM0s.e$e ..cs
HaS Rue 5eXalar Rue aunRue no 5e indiRue nadaN en 7oda compilación 5iempre 5e
reOerencia por deOec7o a la liMrerVa mscorlib.dll de la BCLN Rue incluSe lo5 7ipo5 de
u5o m95 Orecuen7e% Si 5e u5an 7ipo5 de la BCL no incluido5 en ella WaMr9 Rue incluir al
compilar reOerencia5 a la5 liMrerVa5 donde e576n deOinido5 Ien la documen7ación del S#A
5oMre cada 7ipo de la BCL puede encon7rar inOormación 5oMre donde 5e deOinióK
El lenguaje de programación C# (ema &L In7roducción a C#
(an7o la5 liMrerVa5 como lo5 ejecu7aMle5 5on en5amMlado5% Para generar un módulo de
código Rue no Oorme par7e de ningTn en5amMlado 5ino Rue con7enga deOinicione5 de
7ipo5 Rue puedan aXadir5e a en5amMlado5 Rue 5e compilen po57eriormen7eN el Qalor Rue
Wa de dar5e al compilar a la opción /t e5 module% Por ejemploL
csc *t+module HolaMundo.cs
Con la in57rucción an7erior 5e generarVa un módulo llamado HolaMundo.netmodule
Rue podrVa 5er aXadido a compilacione5 de en5amMlado5 incluS6ndolo como Qalor de la
opción /addmodule% Por ejemploN para aXadir el módulo an7erior a la compilación del
Ouen7e liMrerVa Li-.cs como liMrerVa 5e e5criMirVaL
csc *t+li-rary *addmodule+HolaMundo.netmodule Li-.cs
AunRue Wa57a aWora 7oda5 la5 compilacione5 de ejemplo 5e Wan reali8ado u7ili8ando un
Tnico OicWero de código Ouen7eN en realidad nada impide Rue 5e puedan u7ili8ar m95% Por
ejemploN para compilar lo5 OicWero5 ..cs S 1.cs en una liMrerVa ..dll 5e ejecu7arVaL
csc *t+li-rary ..cs 1.cs
Nó7e5e Rue el nomMre Rue por deOec7o 5e d6 al ejecu7aMle generado 5iempre e5 igual al
del primer Ouen7e e5peciOicado pero con la eU7en5ión propia del 7ipo de compilación
reali8ada I.exe para ejecu7aMle5N .dll para liMrerVa5 S .netmodule para módulo5K Sin
emMargoN puede e5peciOic9r5e como Qalor en la opción /out del compilador cualRuier
o7ro 7al S como mue57ra el 5iguien7e ejemplo Rue compila el OicWero ..cs como una
liMrerVa de nomMre Li-.e$eL
csc *t+li-rary *out+Li-.e$e ..cs
,6a5e Rue aunRue 5e WaSa dado un nomMre 7erminado en .exe al OicWero re5ul7an7eN
657e 5igue 5iendo una liMrerVa S no un ejecu7aMle e in7en7ar ejecu7arlo producirVa un
men5aje de error% MQiamen7e no 7iene mucWo 5en7ido darle e5a eU7en5iónN S 5ólo 5e le
Wa dado en e57e ejemplo para demo57rar RueN aunRue recomendaMleN la eU7en5ión del
OicWero no 7iene porRu6 corre5ponder5e realmen7e con el 7ipo de OicWero del Rue 5e 7ra7e%
A la Wora de e5peciOicar OicWero5 a compilar 7amMi6n 5e pueden u7ili8ar lo5 carac7ere5 de
comodVn 7Vpico5 del 5i57ema opera7iQo% Por ejemploN para compilar 7odo5 lo5 OicWero5
con eU7en5ión .cs del direc7orio ac7ual en una liMrerVa llamada )arios.dll 5e WarVaL
csc *t+li-rary *out+2arios.dll 3.cs
Con lo Rue WaS Rue 7ener cuidadoN S en e5pecial al compilar Qario5 Ouen7e5N e5 con Rue
no 5e compilen a la Qe8 m95 de un 7ipo de da7o con pun7o de en7radaN pue5 en7once5 el
compilador no 5aMrVa cu9l u5ar como inicio de la aplicación% Para orien7arloN puede
e5peciOicar5e como Qalor de la opción /main el nomMre del 7ipo Rue con7enga el Main()
Wa u5ar como pun7o de en7rada% A5VN para compilar lo5 OicWero5 ..cs S 1.cs en un
ejecu7aMle cuSo pun7o de en7rada 5ea el deOinido en el 7ipo PrincipalN WaMrVa Rue e5criMirL
csc *main+4rinci5al ..cs 1.cs
El lenguaje de programación C# (ema &L In7roducción a C#
Lógicamen7eN para Rue e57o Ouncione ..cs o 1.cs 7iene Rue con7ener alguna deOinición
de algTn 7ipo llamado Principal con un Tnico m67odo Q9lido como pun7o de en7rada
IoMQiamen7eN 5i con7iene Qario5 5e QolQerVa a 7ener el proMlema de no 5aMer cu9l u7ili8arK
CompiIación con VisuaI Studio.NET
Para compilar una aplicación en ,i5ual S7udio%NE( primero WaS Rue incluirla den7ro de
algTn proSec7o% Para ello Ma57a pul5ar el Mo7ón New ro!ect en la p9gina de inicio Rue
5e mue57ra nada m95 arrancar dicWa Werramien7aN 7ra5 lo Rue 5e oM7endr9 una pan7alla
con el a5pec7o mo57rado en la Ilu57ración :%
En el recuadro de la Qen7ana mo57rada e7iRue7ado como ro!ect Types 5e Wa de
5eleccionar el 7ipo de proSec7o a crear% MQiamen7eN 5i 5e Qa a 7raMajar en C# la opción
Rue WaMr9 Rue e5coger en la mi5ma 5er9 5iempre )isual C6 4ro7ects%
En el recuadro T1?<-931; 5e Wa de 5eleccionar la plan7illa corre5pondien7e al 5uM7ipo
de proSec7o den7ro del 7ipo indicado en ro!ect Types Rue 5e Qa a reali8ar% Para
reali8ar un ejecu7aMle de con5olaN como e5 nue57ro ca5oN WaS Rue 5eleccionar el icono
e7iRue7ado como Console .55lication% Si 5e Rui5ie5e reali8ar una liMrerVa WaMrVa Rue
5eleccionar Class Li-raryN S 5i 5e Rui5ie5 reali8ar un ejecu7aMle de Qen7ana5 WaMrVa
Rue 5eleccionar Windo,s .55lication% Nó7e5e Rue no 5e oOrece ninguna plan7illa para
reali8ar módulo5N lo Rue 5e deMe a Rue de5de ,i5ual S7udio%NE( no pueden crear5e%
Por Tl7imoN en el recuadro de 7eU7o N9?1 5e Wa de e5criMir el nomMre a dar al proSec7o S
en L.6937.2 el del direc7orio Ma5e a5ociado al mi5mo% Nó7e5e Rue Majo de L.6937.2
aparecer9 un men5aje inOormando 5oMre cual 5er9 el direc7orio donde Oinalmen7e 5e
almacenar9n lo5 arcWiQo5 del proSec7oN Rue 5er9 el re5ul7an7e de conca7enar la ru7a
e5peciOicada para el direc7orio Ma5e S el nomMre del proSec7o%
I-0;3496782 1: ,en7ana de creación de nueQo proSec7o en ,i5ual S7udio%NE(
El lenguaje de programación C# (ema &L In7roducción a C#
"na Qe8 conOigurada5 7oda5 e57a5 opcione5N al pul5ar Mo7ón OF ,i5ual S7udio crear9
7oda la inOrae57ruc7ura adecuada para empe8ar a 7raMajar cómodamen7e en el proSec7o%
Como puede apreciar5e en la Ilu57ración &N e57a inOrae57ruc7ura con5i57ir9 en la
generación de un Ouen7e Rue 5erQir9 de plan7illa para la reali8ación de proSec7o5 del 7ipo
elegido Ien nue57ro ca5oN aplicacione5 de con5ola en C#KL
I-0;3496782 : Plan7illa para aplicacione5 de con5ola generada por ,i5ual S7udio%NE(
A par7ir de e57a plan7illaN e5criMir el código de la aplicación de ejemplo e5 7an 5encillo
con 5implemen7e 7eclear System.Console.WriteLine(“¡Hola Mundo!”) den7ro de la deOinición
del m67odo Main() creada por ,i5ual S7udio%NE(% Claro e579N o7ra po5iMilidad e5 Morrar
7oda la plan7illa S 5u57i7uirla por el código para HolaMundo mo57rado an7eriormen7e%
Sea Waga como 5e WagaN para compilar S ejecu7ar 7ra5 ello la aplicación 5ólo WaS Rue
pul5ar CT"#$%& o 5eleccionar 'ebug  (tart )it*out 'ebugging en el menT
principal de ,i5ual S7udio%NE(% Para 5ólo compilar el proSec7oN en7once5 WaS Rue
5eleccionar Build  "ebuild +ll% #e 7oda5 Oorma5N en amMo5 ca5o5 el ejecu7aMle
generado 5e almacenar9 en el 5uMdirec7orio 1in89e-ug del direc7orio del proSec7o%
En el eU7remo derecWo de la Qen7ana principal de ,i5ual S7udio%NE( puede encon7rar el
denominado (olution ,xplorer I5i no lo encuen7raN 5eleccione -iew  (olution
EI<-.414KN Rue e5 una Werramien7a Rue permi7e con5ul7ar cu9le5 5on lo5 arcWiQo5 Rue
Oorman el proSec7o% Si 5elecciona en 6l el icono corre5pondien7e al proSec7o en Rue
e57amo5 7raMajando S pul5a -iew  roperty ages oM7endr9 una Woja de
propiedade5 del proSec7o con el a5pec7o mo57rado en la Ilu57ración *L
El lenguaje de programación C# (ema &L In7roducción a C#
I-0;3496782 $: Hoja de propiedade5 del proSec7o en ,i5ual S7udio%NE(
E57a Qen7ana permi7e conOigurar de manera Qi5ual la maSorVa de opcione5 con la5 Rue 5e
llamar9 al compilador en lVnea de comando5% Por ejemploN para camMiar el nomMre del
OicWero de 5alida Iopción /outK 5e indica 5u nueQo nomMre en el cuadro de 7eU7o Common
roperties  .eneral  +ssembly NameN para camMiar el 7ipo de proSec7o a
generar Iopción /tK 5e u7ili8a Common roperties  .eneral  /utput Type
Icomo Qer9 5i in7en7a camMiarloN no e5 po5iMle generar módulo5 de5de ,i5ual
S7udio%NE(KN S el 7ipo Rue con7iene el pun7o de en7rada a u7ili8ar Iopción /mainK 5e
indica en Common roperties  .eneral  (tartup /b!ect
/inalemen7eN para aXadir al proSec7o reOerencia5 a en5amMlado5 eU7erno5 Iopción /rK
Ma57a 5eleccionar ro!ect  +dd "e0erence en el menT principal de ,S%NE(%
El lenguaje de programación C# (ema &L In7roducción a C#
El lenguaje de programación C# (ema *L El Preproce5ador
TEMA 3: EL PREPROCESADOR
Concepto de preprocesador
El <41<4.61;95. e5 un pa5o preQio
3
a la compilación median7e el Rue e5 po5iMle
con7rolar la Oorma en Rue 5e reali8ar9 657a% El <41<4.61;95.4 e5 el módulo auUiliar Rue
u7ili8a el compilador para reali8ar e57a5 7area5N S lo Rue Oinalmen7e el compilador
compila e5 el re5ul7ado de aplicar el preproce5ador al OicWero de 7eU7o Ouen7eN re5ul7ado
Rue 7amMi6n e5 un OicWero de 7eU7o% Nó7e5e pue5N Rue mien7ra5 Rue el compilador Wace
una 7raducción de 7eU7o a MinarioN lo Rue el preproce5ador Wace e5 una 7raducción de
7eU7o a 7eU7o%
ARuello5 Rue 7engan eUperiencia en el u5o del preproce5ador en lenguaje5 como CPP S
cono8can lo5 proMlema5 Rue implica el u5o del mi5mo pueden re5pirar 7ranRuilo5N Sa
Rue en C# 5e Wan eliminado la maSorVa de carac7erV57ica5 de 657e Rue proQocaMan errore5
diOVcile5 de de7ec7ar Imacro5N direc7iQa5 de inclu5iónN e7c%K S pr9c7icamen7e 5ólo 5e u5a
para permi7ir reali8ar compilacione5 condicionale5 de código%
(irectivas de preprocesado
Concepto de directiva. Sintaxis
El preproce5ador no in7erpre7a de ninguna manera el código Ouen7e del OicWeroN 5ino Rue
5ólo in7erpre7a de dicWo OicWero lo Rue 5e denominan 5741637A9; 51 <41<4.61;95.% E57a5
direc7iQa5 5on lVnea5 de 7eU7o del OicWero Ouen7e Rue 5e carac7eri8an porRue en ella5 el
primer car9c7er no Mlanco Rue aparece e5 una almoWadilla Icar9c7er #K Por ejemploL
#define TEST
#error Ha habido un error fatal
No 5e preocupe aWora 5i no en7iendo el 5igniOicado de e57a5 direc7iQa5N Sa Rue 5e
eUplicar9n m95 adelan7e% Lo Tnico deMe 5aMer e5 Rue el nomMre Rue 5e indica 7ra5 el
5VmMolo # e5 el nomMre de la direc7iQaN S el 7eU7o Rue 5e incluSe 7ra5 6l Ino 7oda5 la5
direc7iQa5 7ienen porRu6 incluirloK e5 el Qalor Rue 5e le da% Por 7an7oN la 5in7aUi5 de una
direc7iQa e5L
#<nombreDirectiva> <valorDirectiva>
E5 po5iMle incluir comen7ario5 en la mi5ma lVnea en Rue 5e declara una direc7iQaN aunRue
e57o5 5ólo pueden 5er comen7ario5 de una lVnea Rue empiecen con // Por ejemploN el
5iguien7e comen7ario e5 Q9lidoL
#define TEST // Ha habido algún error durante el preprocesado
3
En realidadN en C# 5e reali8a a la Qe8 Rue el an9li5i5 l6Uico del código Ouen7eb pero para 5impliOicar la
eUplicación con5ideraremo5 Rue 5e reali8a an7e5 Rue 657eN en una e7apa preQia independien7e%
El lenguaje de programación C# (ema *L El Preproce5ador
Pero e57e o7ro noN pue5 aunRue ocupa una lVnea 7iene la 5in7aUi5 de lo5 comen7ario5 Rue
pueden ocupar Qaria5 lVnea5L
#define TEST /* Ha habido algún error durante el preprocesado */
Definición de identificadores de preprocesado
Como Sa 5e Wa comen7adoN la principal u7ilidad del preproce5ador en C# e5 la de
permi7ir de7erminar cu9le5 regione5 de código de un OicWero Ouen7e 5e Wan de compilar%
Para elloN lo Rue 5e Wace e5 encerrar la5 5eccione5 de código opcionale5 den7ro de
direc7iQa5 de compilación condicionalN de modo Rue 5ólo 5e compilar9n 5i de7erminado5
iden7iOicadore5 de preproce5ado e579n deOinido5% Para deOinir un iden7iOicador de e57e
7ipo la direc7iQa Rue 5e u5a 5igue e57a 5in7aUi5L
#define <nombreÌdentificador>
E57a direc7iQa deOine un iden7iOicador de preproce5ado :nom-re;denti<icador=%
AunRue m95 adelan7e e57udiaremo5 de7alladamen7e cu9le5 5on lo5 nomMre5 Q9lido5
como iden7iOicadore5 en C#N por aWora podemo5 con5iderar Rue 5on Q9lido5 aRuello5
Oormado5 por uno o m95 carac7ere5 alOanum6rico5 7ale5 Rue no 5ean ni true ni faIse S no
empiecen con un numero% Por ejemploN para deOinir un iden7iOicador de preproce5ado de
nomMre 4>?@1. 5e WarVaL
#define PRUEBA
Por conQenio 5e da a e57o5 iden7iOicadore5 nomMre5 en lo5 Rue 7oda5 la5 le7ra5 5e
e5criMen en maST5cula5N como en el ejemplo an7erior% AunRue e5 5ólo un conQenio S
nada oMliga a u5arloN 657a 5er9 la nomencla7ura Rue u5aremo5 en el pre5en7e documen7o
Sa Rue e5 la Rue 5igue !icro5oO7 en 5u5 código5 de ejemplo% ConQiene Oamiliari8ar5e
con ella porRue WaS mucWo código e5cri7o Rue la u5a S porRue emplearla Oacili7ar9 a lo5
dem95 la lec7ura de nue57ro código Sa Rue e5 la no7ación Rue e5perar9n encon7rar%
E5 impor7an7e 5eXalar Rue cualRuier deOinición de iden7iOicador Wa de preceder a
cualRuier aparición de código en el OicWero Ouen7e% Por ejemploN el 5iguien7e código no
e5 Q9lido pue57o Rue en 6l an7e5 del #define 5e Wa incluido código Ouen7e Iel class .KL
class A
#define PRUEBA
{}
Sin emMargoN aunRue no pueda WaMer código an7e5 de un 6de<ine 5V Rue eUi57e 7o7al
liMer7ad para precederlo de o7ra5 direc7iQa5 de preproce5ado%
EUi57e una Oorma al7erna7iQa de deOinir un iden7iOicador de preproce5ado S Rue adem95
permi7e Rue dicWa deOinición 5ólo 5ea Q9lida en una compilación en concre7o% E57a
Oorma con5i57e en pa5arle al compilador en 5u llamada la opción
*d+:nom-re;denti<icador= IOorma aMreQiada de
*de<ine+:nom-re;denti<icador=KN ca5o en Rue duran7e la compilación 5e con5iderar9
Rue al principio de 7odo5 lo5 OicWero5 Ouen7e a compilar 5e encuen7ra deOinido el
iden7iOicador indicado% La5 5iguien7e5 7re5 Oorma5 de llamar al compilador 5on
El lenguaje de programación C# (ema *L El Preproce5ador
eRuiQalen7e5 S deOinen iden7iOicadore5 de preproce5ado de nomMre5 4>?@1. S T>.A.
duran7e la compilación de un OicWero Ouen7e de nomMre e7em5lo.csL
csc *d+4>?@1. *d+T>.A. e7em5lo.cs
csc *d+4>?@1.#T>.A. e7em5lo.cs
csc *d+4>?@1.&T>.A. e7em5lo.cs
Nó7e5e en el ejemplo Rue 5i Rueremo5 deOinir m95 de un iden7iOicador u5ando e57a
76cnica 7enemo5 do5 al7erna7iQa5L incluir Qaria5 opcione5 /d en la llamada al compilador
o deOinir Qario5 de e57o5 iden7iOicadore5 en una mi5ma opción /d 5epar9ndolo5 median7e
carac7ere5 de coma I,K o pun7o S coma I;K
Si 5e 7raMaja con ,i5ual S7udio%NE( en lugar de direc7amen7e con el compilador en
lVnea de comando5N en7once5 puede con5eguir mi5mo eOec7o a 7raQ65 de -iew 
roperty ages  Con0iguration /ptions  Build  Conditional
Compilation ConstantsN donde nueQamen7e u5ado el pun7o S coma I;K o la coma I,K
como 5eparadore5N puede deOinir Qaria5 con57an7e5% Para Rue 7odo Ouncione MienN an7e5
de 5eleccionar -iew Wa de 5eleccionar en el SoIution ExpIorer I5e aMre con -iew 
(olution ,xplorerK el proSec7o al Rue aplicar la deOinición de la5 con57an7e5%
/inalmen7eN re5pec7o al u5o de #define 5ólo Rueda comen7ar Rue e5 po5iMle deOinir Qaria5
Qece5 una mi5ma direc7iQa 5in Rue ello proQoRue ningTn 7ipo de error en el compiladorN
lo Rue permi7e Rue podamo5 pa5ar 7an7o5 Qalore5 a la opción /d del compilador como
Rueramo5 5in 7emor a Rue en7ren en conOlic7o con iden7iOicadore5 de preproce5ado Sa
incluido5 en lo5 Ouen7e5 a compilar%
EIiminación de identificadores de preprocesado
#el mi5mo modo Rue e5 po5iMle deOinir iden7iOicadore5 de preproce5adoN 7amMi6n e5
po5iMle eliminar deOinicione5 de e57e 7ipo de iden7iOicadore5 preQiamen7e reali8ada5%
Para ello la direc7iQa Rue 5e u5a 7iene la 5iguien7e 5in7aUi5L
#undef <nombreÌdentificador>
En ca5o de Rue 5e in7en7e eliminar con e57a direc7iQa un iden7iOicador Rue no WaSa 5ido
deOinido o cuSa deOinición Sa WaSa 5ido eliminada no 5e producir9 error algunoN 5ino Rue
5implemen7e la direc7iQa de eliminación 5er9 ignorada% El 5iguien7e ejemplo mue57ra un
ejemplo de e57o en el Rue el 5egundo #undef e5 ignoradoL
#define VERSÌON1
#undef VERSÌON1
#undef VERSÌON1
Al igual Rue ocurrVa con la5 direc7iQa5 #defineN no 5e puede incluir código Ouen7e an7e5
de la5 direc7iQa5 #undefN 5ino RueN 7odo lo m95N lo Tnico Rue podrVan incluir5e an7e5 Rue
ella5 5erVan direc7iQa5 de preproce5ado%
CompiIación condicionaI
El lenguaje de programación C# (ema *L El Preproce5ador
Como 5e Wa repe7ido Qaria5 Qece5 a lo largo del 7emaN la principal u7ilidad del
preproce5ador en C# e5 la de permi7ir la compilación de código condicionalN lo Rue
con5i57e en 5ólo permi7ir Rue 5e compile de7erminada5 regione5 de código Ouen7e 5i la5
QariaMle5 de preproce5ado deOinida5 cumplen alguna condición de7erminada% Para
con5eguir e57o 5e u7ili8a el 5iguien7e juego de direc7iQa5L
#if <condición1>
<código1>
'elif <condición2>
<código2>
...
'else
<códigoElse>
#endif
El 5igniOicado de una e57ruc7ura como e57a e5 Rue 5i 5e cumple :condiciBnC= en7once5
5e pa5a al compilador el :cBdigoC=N 5i no ocurre e57o pero 5e cumple :condiciBnD=
en7once5 lo Rue 5e pa5arVa al compilador 5erVa :cBdigoD=N S a5V con7inuamen7e Wa57a
Rue 5e llegue a una rama #eIif cuSa condición 5e cumpla% Si no 5e cumple ninguna pero
WaS una rama #eIse 5e pa5ar9 al compilador el <códigoElse>N pero 5i dicWa rama no
eUi57ie5e en7once5 no 5e le pa5arVa código alguno S 5e con7inuarVa preproce5ando el
código 5iguien7e al #endif en el Ouen7e original%
AunRue la5 rama5 #eIse S #eIdif 5on opcionale5N WaS Rue 7ener cuidado S no me8clarla5N
Sa Rue la rama #eIse 5ólo puede aparecer como Tl7ima rama del MloRue #if%%%#endif%
E5 po5iMle anidar Qaria5 e57ruc7ura5 #if...#endifN como mue57ra el 5iguien7e códigoL

#define PRUEBA
using System;
class A
{
public static void Main()
{
#if PRUEBA
Console.Write (“Esto es una prueba”);
#if TRAZA
Console.Write(“ con traza”);
#elif !TRAZA
Console.Write(“ sin traza”);
#endif
#endif
}
}
Como 5e Qe en el ejemploN la5 condicione5 e5peciOicada5 5on nomMre5 de iden7iOicadore5
de preproce5adoN con5ider9ndo5e Rue cada condición 5ólo 5e cumple 5i el iden7iOicador
Rue 5e indica en ella e579 deOinido% lo Rue e5 lo mi5moL un iden7iOicador de
preproce5ado Qale cier7o Itrue en C#K 5i e579 deOinido S Oal5o I0alse en C#K 5i no%

El 5VmMolo ! incluido en jun7o al Qalor de la direc7iQa #eIif e5 el 5VmMolo de _no` lógicoN
S el #eIif en el Rue 5e u5a lo Rue no5 permi7e e5 indicar Rue en ca5o de Rue no 5e
El lenguaje de programación C# (ema *L El Preproce5ador
encuen7re deOinido el iden7iOicador de preproce5ado T>.A. 5e Wan de pa5ar al
compilador la5 in57ruccione5 a con7inuación indicada5 Io 5eaN el Console.Write(“sin
traEa"%&K
El código Ouen7e Rue el preproce5ador pa5ar9 al compilador en ca5o de Rue compilemo5
5in e5peciOicar ninguna opción /d en la llamada al compilador 5er9L

using System;
class A
{
public static void Main()
{
Console.Write(“Esto es una prueba”);
Console.Write(“ sin traza”);
}
}
Nó7e5e como en el código Rue 5e pa5a al compilador Sa no aparece ninguna direc7iQa de
preproce5adoN pue5 lo Rue el preproce5ador le pa5a e5 el código re5ul7an7e de aplicar al
original la5 direc7iQa5 de preproce5ado Rue con7uQie5e%
A5imi5moN 5i compil95emo5 el código Ouen7e original llamando al compilador con
*d+T>.A.N lo Rue el preproce5ador pa5arVa al compilador 5erVaL
using System;
class A
{
public static void Main()
{
Console.Write (“Esto es una prueba”);
Console.Write(“ sin traza”);
}
}
Ha57a aWora 5olo Wemo5 Qi57o Rue la condición de un #if o #eIif puede 5er un
iden7iOicador de preproce5adoN S Rue 657e Qaldr9 true o <alse 5egTn e576 o no deOinido%
Pue5 MienN 657o5 no 5on el Tnico 7ipo de condicione5 Q9lida5 en C#N 5ino Rue 7amMi6n e5
po5iMle incluir condicione5 Rue con7engan eUpre5ione5 lógica5 Oormada5 por
iden7iOicadore5 de preproce5adoN operadore5 lógico5 I! para _no7`N && para _and` S ||
para _or`KN operadore5 relacionale5 de igualdad I==K S de5igualdad I!=KN par6n7e5i5 I( S )K
S lo5 iden7iOicadore5 e5peciale5 true S faIse% Por ejemploL
#if TRAZA // Se cumple si TRAZA esta definido.
#if TRAZA==true // Ídem al ejemplo anterior aunque con una sintaxis menos cómoda
#if !TRAZA // Sólo se cumple si TRAZA no está definido.
#if TRAZA==false // Ídem a al ejemplo anterior aunque con una sintaxis menos cómoda
#if TRAZA == PRUEBA // Solo se cumple si tanto TRAZA como PRUEBA están
// definidos o si no ninguno lo está.
#if TRAZA != PRUEBA // Solo se cumple si TRAZA esta definido y PRUEBA no o
// viceversa
#if TRAZA && PRUEBA // Solo se cumple si están definidos TRAZA y PRUEBA.
#if TRAZA || PRUEBA // Solo se cumple si están definidos TRAZA o PRUEBA.
#if false // Nunca se cumple (por lo que es absurdo ponerlo)
El lenguaje de programación C# (ema *L El Preproce5ador
#if true // Siempre se cumple (por lo que es absurdo ponerlo)
E5 O9cil Qer Rue la cau5a de la re57ricción an7e5 comen7ada de Rue no e5 Q9lido dar un
como nomMre true o faIse a un iden7iOicador de preproce5ado 5e deMe al 5igniOicado
e5pecial Rue 657o5 7ienen en la5 condicione5 de lo5 #if S #eIif
Generación de avisos y errores
El preproce5ador de C# 7amMi6n oOrece direc7iQa5 Rue permi7en generar aQi5o5 S errore5
duran7e el proce5o de preproce5ado en ca5o de llegar a 5er in7erpre7ada5 por el
preproce5ador% E57a5 direc7iQa5 7ienen la 5iguien7e 5in7aUi5L
#warning <mensajeAviso>
#error <mensajeError>
La direc7iQa #warning lo Rue Wace al 5er proce5ada e5 proQocar Rue el compilador
produ8ca un men5aje de aQi5o Rue 5iga el Oorma7o e579ndar u5ado por 657e para ello S
cuSo 7eU7o de5crip7iQo 7enga el con7enido indicado en :mensa7e.2iso=b S #error Wace lo
mi5mo pero proQocando un men5aje de error en Qe8 de uno de aQi5o%
"5ando direc7iQa5 de compilación condicional 5e puede con7rolar cuando 5e Wan de
producir e57o5 men5aje5N cuando 5e Wan de proce5ar e57a5 direc7iQa5% #e WecWo la
principal u7ilidad de e57a5 direc7iQa5 e5 permi7ir con7rolar errore5 de a5ignación de
Qalore5 a lo5 diOeren7e5 iden7iOicadore5 de preproce5ado de un códigoN S un ejemplo de
ello e5 el 5iguien7eL
#warning Código aun no revisado
#define PRUEBA
#if PRUEBA && FÌNAL
#error Un código no puede ser simultáneamente de prueba y versión final
#endif
class A
{}
En e57e código 5iempre 5e producir9 el men5aje de aQi5oN pero el #if indica Rue 5ólo 5e
producir9 el men5aje de error 5i 5e Wan deOinido 5imul79neamen7e lo5 iden7iOicadore5 de
preproce5ado PRUEBA S FÌNAL
Como puede deducir5e del ejemploN el preproce5ador de C# con5idera Rue lo5 men5aje5
a5ociado5 a direc7iQa5 #warning o #error 5on 7odo el 7eU7o Rue 5e encuen7ra 7ra5 el
nomMre de dicWa5 direc7iQa5 S Wa57a el Oinal de la lVnea donde 657a5 aparecen% Por 7an7oN
7odo comen7ario Rue 5e incluSa en una lVnea de e57e 7ipo 5er9 con5iderado como par7e
del men5aje a mo57rarN S no como comen7ario como 7al% Por ejemploN an7e la direc7iQaL
#error La compilación ha fallado // Error
Lo Rue 5e mo57rar9 en pan7alla e5 un men5aje de la 5iguien7e OormaL

Fichero.cs(3,5): error CS1029: La compilación ha fallado // Error
El lenguaje de programación C# (ema *L El Preproce5ador
Cambios en Ia numeración de Iíneas
Por deOec7o el compilador enumera la5 lVnea5 de cada OicWero Ouen7e 5egTn el orden
normal en Rue e57a5 aparecen en el mi5moN S e57e orden e5 el Rue 5igue a la Wora de
inOormar de errore5 o de aQi5o5 duran7e la compilación% Sin emMargoN WaS 5i7uacione5 en
la5 Rue in7ere5a camMiar e57a numeraciónN S para ello 5e oOrece una direc7iQa con la
5iguien7e 5in7aUi5L
#Iine <número> )<nombreFichero>*
E57a direc7iQa indica al preproce5ador Rue Wa de con5iderar Rue la 5iguien7e lVnea del
OicWero Ouen7e en Rue aparece e5 la lVnea cuSo nTmero 5e le indicaN independien7emen7e
del Qalor Rue 7uQie5e 5egTn la numeración u5ada en e5e momen7o% El Qalor indicado en
“<nombreFichero>” e5 opcionalN S en ca5o de aparecer indica el nomMre Rue 5e Wa de
con5iderar Rue 7iene el OicWero a la Wora de dar men5aje5 de error% "n ejemploL
#line 127 “csmace.cs”
E57e u5o de #Iine indica Rue el compilador Wa de con5iderar Rue la lVnea 5iguien7e e5 la
lVnea :&. del OicWero csmace.cs% A par7ir de ella 5e 5eguir9 u5ando el 5i57ema de
numeración normal Ila 5iguien7e a e5a 5er9 la :&' de csmace.csN la próUima la CDFN
e7c%K 5alQo Rue m95 adelan7e 5e QuelQa a camMiar la numeración con o7ra direc7iQa #Iine%
AunRue en principio puede parecer Rue e57a direc7iQa e5 de e5ca5a u7ilidadN lo cier7o e5
Rue 5uele Qenir Ma57an7e Mien para la e5cri7ura de compiladore5 S o7ra5 Werramien7a5 Rue
generen código en C# a par7ir de código e5cri7o en o7ro5 lenguaje5%
Marcado de regiones de código
E5 po5iMle marcar regione5 de código S a5ociarle5 un nomMre u5ando el juego de
direc7iQa5 #region S #endregion% E57a5 direc7iQa5 5e u5an a5VL
#region <nombreRegión>
<código>
#endregion
La u7ilidad Rue 5e d6 a e57a5 marcacione5 depende de cada Werramien7aN pero en el
momen7o de e5criMir e57a5 lVnea5 la Tnica Werramien7a di5poniMle Rue WacVa u5o de ella5
era ,i5ual S7udio%NE(N donde 5e u5a para marcar código de modo Rue de5de la Qen7ana
de código podamo5 eUpandirlo S con7raerlo con una Tnica pul5ación de ra7ón% En
concre7oN en la Qen7ana de código de ,i5ual S7udio aparecer9 un 5VmMolo [-] jun7o a la5
regione5 de código a5V marcada5 de manera Rue pul5ando 5oMre 6l 7odo el código
con7enido en la región 5e comprimir9 S 5er9 5u57i7uido por el nomMre dado en
:nom-re>egiBn=% (ra5 elloN el eDf 5e conQer7ir9 en un ePf S 5i QolQemo5 a pul5arlo el
código con7raVdo 5e eUpandir9 S recuperar9 5u a5pec7o original% A con7inuación 5e
mue57ra un ejemplo de cada ca5oL
El lenguaje de programación C# (ema *L El Preproce5ador
I-0;3496782 4: Código de región eUpandido
I-0;3496782 ): Código de región con7raVdo
HaS Rue 7ener cuidado al anidar regione5 con direc7iQa5 de compilación condicionalN Sa
Rue 7odo MloRue #if...#endif Rue comience den7ro de una región Wa de 7erminar 7amMi6n
den7ro de ella% Por 7an7oN el 5iguien7e u5o de la direc7iQa #region no e5 Qalido Sa Rue
>egiBn@rrBnea 7ermina e57ando el MloRue #if...#endif aMier7oL

#region RegiónErrónea
#if A
#endregion
#endif
El lenguaje de programación C# (ema *L El Preproce5ador
El lenguaje de programación C# (ema 3L A5pec7o5 l6Uico5
TEMA 4: ASPECTOS LÉXICOS
Comentarios
"n 6.?123947. e5 7eU7o Rue 5e incluSe en el código Ouen7e para Oacili7ar 5u lec7ura a lo5
programadore5 S cuSo con7enido e5N por deOec7oN comple7amen7e ignorado por el
compilador% Suelen u5ar5e para incluir inOormación 5oMre el au7or del códigoN para
aclarar el 5igniOicado o el porRu6 de de7erminada5 5eccione5 de códigoN para de5criMir el
Ouncionamien7o de lo5 m67odo5 de la5 cla5e5N e7c%
En C# WaS do5 Oorma5 de e5criMir comen7ario5% La primera con5i57e en encerrar 7odo el
7eU7o Rue 5e de5ee comen7ar en7re carac7ere5 /* S */ 5iguiendo la 5iguien7e 5in7aUi5L
/*<texto>*/
E57o5 comen7ario5 pueden aMarcar 7an7a5 lVnea5 como 5ea nece5ario% Por ejemploL

/* Esto es un comentario
que ejemplifica cómo se escribe comentarios que ocupen varias líneas */

AWora MienN WaS Rue 7ener cuidado con el WecWo de Rue no e5 po5iMle anidar comen7ario5
de e57e 7ipo% E5 decirN no Qale e5criMir comen7ario5 como el 5iguien7eL
/* Comentario contenedor /* Comentario contenido */ */
E57o 5e deMe a Rue como el compilador ignora 7odo el 7eU7o con7enido en un comen7ario
S 5ólo Mu5ca la 5ecuencia */ Rue marca 5u OinalN ignorar9 el 5egundo /* S cuando llegue al
primer */ con5iderar9 Rue Wa acaMado el comen7ario aMier7o con el primer /* Ino el
aMier7o con el 5egundoK S pa5ar9 a Mu5car código% Como el */ 5ólo lo admi7e 5i Wa
de7ec7ado an7e5 algTn comen7ario aMier7o S aTn no cerrado Ino mien7ra5 Mu5ca códigoKN
cuando llegue al 5egundo */ con5iderar9 Rue Wa WaMido un error Sa Rue encon7rar9 el 1/
donde e5peraMa encon7rar código
#ado Rue mucWa5 Qece5 lo5 comen7ario5 Rue 5e e5criMen 5on muS cor7o5 S no 5uelen
ocupar m95 de una lVneaN C# oOrece una 5in7aUi5 al7erna7iQa m95 compac7a para la
e5cri7ura e57e 7ipo de comen7ario5 en la5 Rue 5e con5idera como indicador del comien8o
del comen7ario la pareja de carac7ere5 // S como indicador de 5u Oinal el Oin de lVnea% Por
7an7oN la 5in7aUi5 Rue 5iguen e57o5 comen7ario5 e5L
// <texto>
2 un ejemplo de 5u u5o e5L

// Este comentario ejemplifica como escribir comentarios abreviados de una sola línea
E57o5 comen7ario5 de una 5ola lVnea 5V Rue pueden anidar5e 5in ningTn proMlema% Por
ejemploN el 5iguien7e comen7ario e5 perOec7amen7e Q9lidoL

// Comentario contenedor // Comentario contenido
El lenguaje de programación C# (ema 3L A5pec7o5 l6Uico5

dentificadores
Al igual Rue en cualRuier lenguaje de programaciónN en C# un 751237@7695.4 no e5 m95
RueN como 5u propio nomMre indicaN un nomMre con el Rue iden7iOicaremo5 algTn
elemen7o de nue57ro códigoN Sa 5ea una cla5eN una QariaMleN un m67odoN e7c%
(Vpicamen7e el nomMre de un iden7iOicador 5er9 una 5ecuencia de cualRuier nTmero de
carac7ere5 alOanum6rico5 dincluida5 Qocale5 acen7uada5 S eXe5D 7ale5 Rue el primero de
ello5 no 5ea un nTmero% Por ejemploN iden7iOicadore5 Q9lido5 5erVanL ArribaN cañaN C3P0N
áëÎòN e7cb pero no lo 5erVan 3comN 127N e7c%
Sin emMargoN S aunRue por mo7iQo5 de legiMilidad del código no 5e recomiendaN C#
7amMi6n permi7e incluir den7ro de un iden7iOicador carac7ere5 e5peciale5 imprimiMle5
7ale5 como 5VmMolo5 de di6re5i5N 5uMraSado5N e7c% 5iempre S cuando e57o5 no 7engan un
5igniOicado e5pecial den7ro del lenguaje% Por ejemploN 7amMi6n 5erVan iden7iOicadore5
Q9lido5N _barco_N c¨k S A·Bb pero no C# I# indica inicio de direc7iQa de preproce5adoK o a!
b I! indica operación lógica _no7`K

/inalmen7eN C# da la po5iMilidad de poder e5criMir iden7iOicadore5 Rue incluSan
carac7ere5 "nicode Rue no 5e puedan imprimir u5ando el 7eclado de la m9Ruina del
programador o Rue no 5ean direc7amen7e Q9lido5 deMido a Rue 7engan un 5igniOicado
e5pecial en el lenguaje% Para elloN lo Rue permi7e e5 e5criMir e57o5 carac7ere5 u5ando
;16012679; 51 1;69<1N Rue no 5on m95 Rue 5ecuencia5 de carac7ere5 con la5 5in7aUi5L
\u<dígito><dígito><dígito><dígito>
ó \U<dígito><dígito><dígito><dígito><dígito><dígito><dígito><dígito>
E57o5 dVgi7o5 indican e5 el código "nicode del car9c7er Rue 5e de5ea incluir como par7e
del iden7iOicadorN S cada uno de ello5 Wa de 5er un dVgi7o WeUadecimal Q9lido% I'FN a'<
ó .'GK HaS Rue 5eXalar Rue el car9c7er u Wa de e5criMi5e en minT5cula cuando 5e
indiRuen carac7ere5 "nicode con 3 dVgi7o5 S en maST5cula cuando 5e indiRuen con
carac7ere5 de ocWo% Ejemplo5 de iden7iOicadore5 Q9lido5 5on C\u0064 IeRuiQale a C#N
pue5 =3 e5 el código de # en "nicodeK ó a\U00000033b IeRuiQale a a!bK
+alabras reservadas
AunRue an7e5 5e Wan dado una 5erie de re57riccione5 5oMre cu9le5 5on lo5 nomMre5
Q9lido5 Rue 5e pueden dar en C# a lo5 iden7iOicadore5N Oal7a 7odaQVa por dar unaL lo5
5iguien7e5 nomMre5 no 5on Q9lido5 como iden7iOicadore5 Sa Rue 7ienen un 5igniOicado
e5pecial en el lenguajeL
abstract, as, base, bool, break, byte, case, catch, char, checked, class, const,
continue, decimal, default, delegate, do, double, else, enum, event, explicit, extern,
false, finally, fixed, float, for, foreach, goto, if, implicit, in, int, interface, internal, lock,
is, long, namespace, new, null, object, operator, out, override, params, private,
protected, public, readonly, ref, return, sbyte, sealed, short, sizeof, stackalloc, static,
string, struct, switch, this, throw, true, try, typeof, uint, ulong, unchecked, unsafe, ushort,
using, virtual, void, while
El lenguaje de programación C# (ema 3L A5pec7o5 l6Uico5
Apar7e de e57a5 palaMra5 re5erQada5N 5i en Ou7ura5 implemen7acione5 del lenguaje 5e
decidie5e incluir nueQa5 palaMra5 re5erQada5N !icro5oO7 dice Rue dicWa5 palaMra5 WaMrVan
de incluir al meno5 do5 5VmMolo5 de 5uMraSado con5ecu7iQo5 I__K Por 7an7oN para eQi7ar
po5iMle5 conOlic7o5 Ou7uro5 no 5e recomienda dar a nue57ro5 iden7iOicadore5 nomMre5 Rue
con7engan dicWa 5ecuencia de 5VmMolo5%
AunRue direc7amen7e no podemo5 dar e57o5 nomMre5 a nue57ro5 iden7iOicadore5N C#
proporciona un mecani5mo para Wacerlo indirec7amen7e S de una Oorma mucWo m95
legiMle Rue u5ando 5ecuencia5 de e5cape% E57e mecani5mo con5i57e en u5ar el car9c7er 2
para preOijar el nomMre coinciden7e con el de una palaMra re5erQada Rue Rueramo5 dar a
nue57ra QariaMle% Por ejemploN el 5iguien7e código e5 Q9lidoL
class @class
{
static void @static(bool @bool)
{
if (@bool)
Console.WriteLine("cierto");
else
Console.WriteLine("falso");
}
}
Lo Rue 5e Wa WecWo en el código an7erior Wa 5ido u5ar @ para declarar una cla5e de
nomMre class con un m67odo de nomMre static Rue 7oma un par9me7ro de nomMre boolN
aTn cuando 7odo5 e57o5 nomMre5 5on palaMra5 re5erQada5 en C#%
HaS Rue preci5ar Rue aunRue el nomMre Rue no5o7ro5 e5criMamo5 5ea por ejemplo
@classN el nomMre con el Rue el compilador Qa a 7ra7ar in7ernamen7e al iden7iOicador e5
5olamen7e class% #e WecWoN 5i de5de código e5cri7o en o7ro lenguaje adap7ado a %NE(
di57in7o a C# Wacemo5 reOerencia a 657e iden7iOicador S en e5e lenguaje 5u nomMre no e5
una palaMra re5erQadaN el nomMre con el Rue deMeremo5 reOerenciarlo e5 classN S no
Hclass I5i 7amMi6n Oue5e en e5e lenguaje palaMra re5erQada WaMrVa Rue reOerenciarlo
con el mecani5mo Rue el lenguaje incluSe5e para elloN Rue Rui895 7amMi6n podrVa
con5i57ir en u5ar 2 como en C#K
En realidadN el u5o de @ no 5e 7iene porRu6 limi7ar a preceder palaMra5 re5erQada5 en
C#N 5ino Rue podemo5 preceder cualRuier nomMre con 6l% Sin emMargoN Wacer e57o no 5e
recomiendaN pue5 e5 con5iderado como un mal W9Mi7o de programación S puede
proQocar errore5 muS 5u7ile5 como el Rue mue57ra el 5iguien7e ejemploL
class A
{
int a; // (1)
int @a; // (2)
public static void Main()
{}
}

Si in7en7amo5 compilar e57e código 5e producir9 un error Rue no5 inOormar9 de Rue el
campo de nomMre a Wa 5ido declarado mTl7iple5 Qece5 en la cla5e A% E57o 5e deMe a Rue
El lenguaje de programación C# (ema 3L A5pec7o5 l6Uico5
como 2 no Oorma par7e en realidad del nomMre del iden7iOicador al Rue precedeN la5
declaracione5 marcada5 con comen7ario5 como I:K S I&K 5on eRuiQalen7e5%
HaS Rue 5eXalar por Tl7imo una co5a re5pec7o al car9c7er @L 5ólo puede preceder al
nomMre de un iden7iOicadorN pero no puede e57ar con7enido den7ro del mi5mo% E5 decirN
iden7iOicadore5 como i5322@fie.us.es no 5on Q9lido5%
Literales
"n -73149- e5 la repre5en7ación eUplVci7a de lo5 Qalore5 Rue pueden 7omar lo5 7ipo5
M95ico5 del lenguaje% A con7inuación 5e eUplica cu9l e5 la 5in7aUi5 con Rue 5e e5criMen
lo5 li7erale5 en C# de5glo59ndolo5 5egTn el 7ipo de Qalore5 Rue repre5en7anL
• L73149-1; 12314.;: "n nTmero en7ero 5e puede repre5en7ar en C# 7an7o en
Oorma7o decimal como WeUadecimal% En el primer ca5o Ma57a e5criMir lo5 dVgi7o5
decimale5 I0-9K del nTmero uno5 7ra5 o7ro5N mien7ra5 Rue en el 5egundo WaS Rue
preceder lo5 dVgi7o5 WeUadecimale5 I0-9N a-fN A-FK con el preOijo 0x% En amMo5
ca5o5 e5 po5iMle preceder el nTmero de lo5 operadore5 $ ó 3 para indicar 5i e5
po5i7iQo o nega7iQoN aunRue 5i no 5e pone nada 5e con5iderar9 Rue e5 po5i7iQo%
Ejemplo5 de li7erale5 en7ero5 5on 0N 5N +15N -23N 0x1AN -0x1aN e7c
En realidadN la 5in7aUi5 comple7a para la e5cri7ura de li7erale5 en7ero5 7amMi6n
puede incluir un 5uOijo Rue indiRue el 7ipo de da7o en7ero al Rue Wa de per7enecer
el li7eral% E57o no lo Qeremo5 Wa57a el Tema 7: Variables ti!os de datos%

• L73149-1; 419-1;: Lo5 nTmero5 reale5 5e e5criMen de Oorma 5imilar a lo5 en7ero5N
aunRue 5ólo 5e pueden e5criMir en Oorma decimal S para 5eparar la par7e en7era
de la real u5an el 7radicional pun7o decimal Icar9c7er .K (amMi6n e5 po5iMle
repre5en7ar lo5 reale5 en Oorma7o cien7VOicoN u59ndo5e para indicar el eUponen7e
lo5 carac7ere5 e ó E% Ejemplo5 de li7erale5 reale5 5on 0.0N 5.1N -5.1N +15.21N
3.02e10N 2.02e-2N 98.8E+1N e7c%
Al igual Rue ocurrVa con lo5 li7erale5 en7ero5N lo5 li7erale5 reale5 7amMi6n pueden
incluir 5uOijo5 Rue indiRuen el 7ipo de da7o real al Rue per7enecenN aunRue
nueQamen7e no lo5 Qeremo5 Wa57a el Tema 7: Variables ti!os de datos
• L73149-1; -8=76.;: Lo5 Tnico5 li7erale5 lógico5 Q9lido5 5on true S faIseN Rue
re5pec7iQamen7e repre5en7an lo5 Qalore5 lógico5 cier7o S Oal5o%
• L73149-1; 51 694M6314: Pr9c7icamen7e cualRuier car9c7er 5e puede repre5en7ar
encerr9ndolo en7re comilla5 5imple5% Por ejemploN 'a' Ile7ra aKN ' ' Icar9c7er de
e5pacioKN '?' I5VmMolo de in7errogaciónKN e7c% La5 Tnica5 eUcepcione5 a e57o 5on
lo5 carac7ere5 Rue 5e mue57ran en la T9C-9 4.1N Rue Wan de repre5en7ar5e con
5ecuencia5 de e5cape Rue indiRuen 5u Qalor como código "nicode o median7e un
Oorma7o e5pecial 7al S como 5e indica a con7inuaciónL
C94M6314 C857=. 51
1;69<1 U276.51
C857=. 51
1;69<1 1;<1679-
Comilla 5imple
\u0027


El lenguaje de programación C# (ema 3L A5pec7o5 l6Uico5
Comilla doMle
\u0022 ###BOT_TEXT###quot;
Car9c7er nulo
\u0000 ###BOT_TEXT###
Alarma
\u0007 \a
)e7roce5o
\u0008 \b
Sal7o de p9gina
\u000C \f
NueQa lVnea
\u000A \n
)e7orno de carro
\u000D \r
(aMulación Wori8on7al
\u0009 \t
(aMulación Qer7ical
\u000B \v
Barra inQer7ida
\u005C \
T9C-9 4.1: Código5 de e5cape e5peciale5
En realidadN de la 7aMla an7erior WaS Rue ma7i8ar Rue el car9c7er de comilla doMle
7amMi6n puede aparecer den7ro de un li7eral de cadena direc7amen7eN 5in
nece5idad de u5ar 5ecuencia5 de e5cape% Por 7an7oN o7ro5 ejemplo5 de li7erale5 de
car9c7er Q9lido5 5er9n '###BOT_TEXT###quot;'N '"'N '\f'N '\u0000'N '\'N '

Related Interests

'N e7c%
Apar7e de para repre5en7ar lo5 carac7ere5 de la 7aMla an7eriorN 7amMi6n e5 po5iMle
u5ar lo5 código5 de e5cape "nicode para repre5en7ar cualRuier código "nicodeN
lo Rue 5uele u5ar5e para repre5en7ar li7erale5 de carac7ere5 no incluido5 en lo5
7eclado5 e579ndare5%
4un7o al Oorma7o de repre5en7ación de código5 de e5cape "nicode Sa Qi57oN C#
incluSe un Oorma7o aMreQiado para repre5en7ar e57o5 código5 en lo5 li7erale5 de
car9c7er 5i nece5idad de e5criMir 5iempre cua7ro dVgi7o5 aTn cuando el código a
repre5en7ar 7enga mucWo5 cero5 en 5u par7e i8Ruierda% E57e Oorma7o con5i57e en
preceder el código de \x en Qe8 de \u% #e e57e modoN lo5 li7erale5 de car9c7er
'\U00000008'N '\u0008'N '\x0008'N '\x008'N '\x08' S '\x8' 5on 7odo5 eRuiQalen7e5% HaS Rue
7ener en cuen7a Rue e57e Oorma7o aMreQiado 5ólo e5 Q9lido en lo5 li7erale5 de
car9c7erN S no a la Wora de dar nomMre5 a lo5 iden7iOicadore5%
• L73149-1; 51 695129: "na 695129 no e5 m95 Rue una 5ecuencia de carac7ere5
encerrado5 en7re comilla5 doMle5% Por ejemplo "Hola, mundo"N "camión"N e7c% El
7eU7o con7enido den7ro e57o5 li7erale5 puede e57ar Oormado por cualRuier nTmero
de li7erale5 de car9c7er conca7enado5 S 5in la5 comilla5 5imple5N aunRue 5i
incluSe comilla5 doMle5 657a5 Wan de e5criMir5e u5ando 5ecuencia5 de e5cape
porRue 5i no el compilador la5 in7erpre7arVa como el Oinal de la cadena%
Apar7e del Oorma7o de e5cri7ura de li7erale5 de cadena5 an7e5 comen7adoN Rue e5
el comTnmen7e u7ili8ado en la maSorVa de lenguaje5 de programaciónN C#
7amMi6n admi7e uno nueQo con5i57en7e en precederlo5 de un 5VmMolo 2N ca5o en
Rue 7odo el con7enido de la cadena 5erVa in7erpre7ado 7al cualN 5in con5iderar la
eUi57encia de 5ecuencia5 de e5cape% A e57e 7ipo de li7erale5 5e le5 conoce como
-73149-1; 51 695129 <-92.; o -73149-1; A14C937? S pueden inclu5o ocupar Qaria5
lVnea5% La 5iguien7e 7aMla recoge alguno5 ejemplo5 de cómo 5e in7erpre7anL
L73149- 51 695129 I2314<41395. 6.?....
"Hola\tMundo"
Hola !undo
@”Hola\tMundo"
Holag7!undo
@"Hola
Hola
El lenguaje de programación C# (ema 3L A5pec7o5 l6Uico5
Mundo"
!undo
@”””Hola Mundo””"
_Hola !undo`
T9C-9 4.: Ejemplo5 de li7erale5 de cadena plano5
El Tl7imo ejemplo de la 7aMla 5e Wa aproQecWado para mo57rar Rue 5i den7ro de un
li7eral de cadena plano 5e de5ea incluir carac7ere5 de comilla doMle 5in Rue 5ean
conOundido5 con el Oinal de la cadena Ma57a duplicarlo5%
• L73149- 20-.: El -73149- 20-. e5 un Qalor e5pecial Rue 5e repre5en7a en C# con la
palaMra re5erQada nuII S 5e u5a como Qalor de la5 QariaMle5 de oMje7o no
iniciali8ada5 para a5V indicar Rue con7ienen reOerencia5 nula5%
%peradores
"n .<1495.4 en C# e5 un 5VmMolo Oormado por uno o m95 carac7ere5 Rue permi7e
reali8ar una de7erminada operación en7re uno o m95 da7o5 S produce un re5ul7ado%
A con7inuación 5e de5criMen cu9le5 5on lo5 operadore5 incluido5 en el lenguaje
cla5iOicado5 5egTn el 7ipo de operacione5 Rue permi7en reali8arN aunRue WaS Rue 7ener en
cuen7a Rue C# permi7e la redeOinición del 5igniOicado de la maSorVa de lo5 operadore5
5egTn el 7ipo de da7o 5oMre el Rue 5e apliRuenN por lo Rue lo Rue aRuV 5e cuen7a 5e
corre5ponde con lo5 u5o5 m95 comune5 de lo5 mi5mo5L
• O<14967.21; 9473?N3769; L Lo5 operadore5 ari7m67ico5 incluido5 en C# 5on lo5
7Vpico5 de 5uma I+KN re57a I-KN produc7o I*KN diQi5ión I/K S módulo I%K (amMi6n 5e
incluSen operadore5 de _meno5 unario` I-K S _m95 unario` I+K
)elacionado5 con la5 operacione5 ari7m67ica5 5e encuen7ran un par de operadore5
llamado5 checked S unchecked Rue permi7en con7rolar 5i 5e de5ea de7ec7ar lo5
de5Mordamien7o5 Rue puedan producir5e 5i al reali8ar e57e 7ipo de operacione5 el
re5ul7ado e5 5uperior a la capacidad del 7ipo de da7o5 de 5u5 operando5% E57o5
operadore5 5e u5an a5VL
checked (<expresiónAritmética>)
unchecked(<expresiónAritmética>)
AmMo5 operadore5 calculan el re5ul7ado de <expresiónAritmética> S lo deQuelQen
5i duran7e el c9lculo no 5e produce ningTn de5Mordamien7o% Sin emMargoN en
ca5o de Rue WaSa de5Mordamien7o cada uno ac7Ta de una Oorma di57in7aL checked
proQoca un error de compilación 5i <expresiónAritmética> e5 una eUpre5ión
con57an7e S una eUcepción System.OverfIowException 5i no lo e5N mien7ra5 Rue
unchecked deQuelQe el re5ul7ado de la eUpre5ión ari7m67ica 7runcado para Rue
Ruepa en el 7amaXo e5perado%
Por deOec7oN en au5encia de lo5 operadore5 checked S unchecked lo Rue 5e Wace
e5 eQaluar la5 operacione5 ari7m67ica5 en7re da7o5 con57an7e5 como 5i 5e le5
aplica5e checked S la5 operacione5 en7re da7o5 no con57an7e5 como 5i 5e le5
WuMie5e aplicado unchecked%
El lenguaje de programación C# (ema 3L A5pec7o5 l6Uico5
• O<14967.21; -8=769;: Se incluSen operadore5 Rue permi7en reali8ar la5
operacione5 lógica5 7Vpica5L _and` I&& y &KN _or` I|| S |KN _no7` I!K S _Uor` I^K
Lo5 operadore5 && S || 5e diOerencia de & S | en Rue lo5 primero5 reali8an
eQaluación pere8o5a S lo5 5egundo5 no% La eQaluación pere8o5a con5i57e en Rue
5i el re5ul7ado de eQaluar el primer operando permi7e deducir el re5ul7ado de la
operaciónN en7once5 no 5e eQalTa el 5egundo S 5e deQuelQe dicWo re5ul7ado
direc7amen7eN mien7ra5 Rue la eQaluación no pere8o5a con5i57e en eQaluar
5iempre amMo5 operando5% E5 decirN 5i el primer operando de una operación 44
e5 Oal5o 5e deQuelQe 0alse direc7amen7eN 5in eQaluar el 5egundob S 5i el primer
operando de una 55 e5 cier7o 5e deQuelQe true direc7amen7eN 5in eQaluar el o7ro%

• O<14967.21; 41-967.29-1;: Se Wan incluido lo5 7radicionale5 operadore5 de
igualdad I==KN de5igualdad I!=KN _maSor Rue` I>KN _menor Rue` I<KN _maSor o
igual Rue` I>=K S _menor o igual Rue` I<=K
• O<14967.21; 51 ?927<0-96782 51 C73; L Se Wan incluido operadore5 Rue
permi7en reali8ar a niQel de Mi75 operacione5 _and` I&KN _or` I|KN _no7` I~KN _Uor`
I^KN de5pla8amien7o a i8Ruierda I<<K S de5pla8amien7o a derecWa I>>K El
operador << de5pla8a a i8Ruierda rellenando con cero5N mien7ra5 Rue el 7ipo de
relleno reali8ado por >> depende del 7ipo de da7o 5oMre el Rue 5e aplicaL 5i e5 un
da7o con 5igno man7iene el 5ignoN S en ca5o con7rario rellena con cero5%
• O<14967.21; 51 9;7=296782: Para reali8ar a5ignacione5 5e u5a en C# el operador
=N operador Rue adem95 de reali8ar la a5ignación Rue 5e le 5olici7a deQuelQe el
Qalor a5ignado% Por ejemploN la eUpre5ión a = b a5igna a la QariaMle a el Qalor de
la QariaMle b S deQuelQe dicWo QalorN mien7ra5 Rue la eUpre5ión c = a = b a5igna a
la5 QariaMle5 c S a el Qalor de b Iel operador = e5 a5ocia7iQo por la derecWaK
(amMi6n 5e Wan incluido operadore5 de a5ignación compue57o5 Rue permi7en
aWorrar 7ecleo a la Wora de reali8ar a5ignacione5 7an comune5 comoL
temperatura = temperatura + 15; // Sin usar asignación compuesta
temperatura += 15; // Usando asignación compuesta
La5 do5 lVnea5 an7eriore5 5on eRuiQalen7e5N pue5 el operador compue57o +=
a5igna a 5u primer operando el Qalor Rue 7enVa m95 el de 5u 5egundo operando Io
5eaN le 5uma el 5egundo operandoK Como 5e QeN permi7e compac7ar Ma57an7e el
código%
Apar7e del operador de a5ignación compue57o +=N 7amMi6n 5e oOrecen operadore5
de a5ignación compue57o5 para la maSorVa de lo5 operadore5 Minario5 Sa Qi57o5%
E57o5 5onL +=N -=N *=N /=N %=N &=N |=N ^=N <<= S >>=% Nó7e5e Rue no WaS Qer5ione5
compue57a5 para lo5 operadore5 Minario5 44 S 55%
7ro5 do5 operadore5 de a5ignación incluido5 5on lo5 de incremen7oI++K S
decremen7o I--K E57o5 operadore5 permi7enN re5pec7iQamen7eN aumen7ar S
di5minuir en una unidad el Qalor de la QariaMle 5oMre el Rue 5e aplican% A5VN e57a5
lVnea5 de código 5on eRuiQalen7e5L
El lenguaje de programación C# (ema 3L A5pec7o5 l6Uico5
temperatura = temperatura + 1; // Sin usar asignación compuesta ni incremento
temperatura += 1; // Usando asignación compuesta
temperatura++; // Usando incremento
Si el operador ++ 5e coloca 7ra5 el nomMre de la QariaMle Icomo en el ejemploK
deQuelQe el Qalor de la QariaMle an7e5 de incremen7arlaN mien7ra5 Rue 5i 5e coloca
an7e5N deQuelQe el Qalor de 657a 7ra5 incremen7arlab S lo mi5mo ocurre con el
operador --% Por ejemploL
c = b++; // Se asigna a c el valor de b y luego se incrementa b
c = ++b; // Se incrementa el valor de b y luego se asigna a c
La Qen7aja de u5ar lo5 operadore5 ++ S -- e5 Rue en mucWa5 m9Ruina5 5on m95
eOicien7e5 Rue el re57o de Oorma5 de reali8ar 5uma5 o re57a5 de una unidadN pue5
el compilador puede 7raducirlo5 en una Tnica in57rucción en código m9Ruina
;
%
• O<14967.21; 6.2 695129;: Para reali8ar operacione5 de conca7enación de
cadena5 5e puede u5ar el mi5mo operador Rue para reali8ar 5uma5N Sa Rue en C#
5e Wa redeOinido 5u 5igniOicado para Rue cuando 5e apliRue en7re operando5 Rue
5ean cadena5 o Rue 5ean una cadena S un car9c7er lo Rue Waga 5ea conca7enarlo5%
Por ejemploN "Hola"+" mundo" deQuelQe "Hola mundo"N S "Hola mund" + 'o' 7amMi6n%
• O<14967.21; 51 9661;. 9 39C-9;: "na 39C-9 e5 un conjun7o de ordenado de
oMje7o5 de 7amaXo Oijo% Para acceder a cualRuier elemen7o de e57e conjun7o 5e
aplica el operador po57Oijo [] 5oMre la 7aMla para indicar en7re corcWe7e5 la
po5ición Rue ocupa el oMje7o al Rue 5e de5ea acceder den7ro del conjun7o% E5
decirN e57e operador 5e u5a a5VL
[<posiciónElemento>]
"n ejemplo de 5u u5o en el Rue 5e a5igna al elemen7o Rue ocupa la po5ición * en
una 7aMla de nomMre tablaPrueba el Qalor del elemen7o Rue ocupa la po5ición :'
de dicWa 7aMla e5 el 5iguien7eL
tablaPrueba[3] = tablaPrueba[18];
La5 7aMla5 5e e57udian de7enidamen7e en el Tema 7: Variables ti!os de datos
• O<1495.4 6.25767.29-: E5 el Tnico operador incluido en C# Rue 7oma *
operando5N S 5e u5a a5VL
<condición> ? <expresión1> : <expresión2>
El 5igniOicado del operando e5 el 5iguien7eL 5e eQalTa <condición> Si e5 cier7a 5e
deQuelQe el re5ul7ado de eQaluar <expresión1>, S 5i e5 Oal5a 5e deQuelQe el
re5ul7ado de eQaluar <condición2>% "n ejemplo de 5u u5o e5L
b = (a>0)? a : 0; // Suponemos a y b de tipos enteros
;
1eneralmen7eN en e57a5 m9Ruina5 ++ 5e conQier7e en una in57rucción ÌNC S -- en una in57rucción DEC
El lenguaje de programación C# (ema 3L A5pec7o5 l6Uico5
En e57e ejemploN 5i el Qalor de la QariaMle a e5 5uperior a 0 5e a5ignar9 a b el
Qalor de aN mien7ra5 Rue en ca5o con7rario el Qalor Rue 5e le a5ignar9 5er9 0%
HaS Rue 7ener en cuen7a Rue e57e operador e5 a5ocia7iQo por la derecWaN por lo
Rue una eUpre5ión como a?b:c?d:e e5 eRuiQalen7e a a?b:(c?d:e)
No WaS Rue conOundir e57e operador con la in57rucción condicional if Rue 5e
7ra7ar9 en el Tema 8:"nstr#$$ionesN pue5 aunRue 5u u7ilidad e5 5imilar al de 657aN
? deQuelQe un Qalor e if no%

• O<14967.21; 51 51-1=95.;: "n 51-1=95. e5 un oMje7o Rue puede almacenar en
reOerencia5 a uno o m95 m67odo5 S a 7raQ65 del cual e5 po5iMle llamar a e57o5
m67odo5% Para aXadir oMje7o5 a un delegado 5e u5an lo5 operadore5 + S +=N
mien7ra5 Rue para Rui79r5elo5 5e u5an lo5 operadore5 - S -=% E57o5 concep7o5 5e
e57udiar9n de7alladamen7e en el Tema %&: E'entos dele(ados
• O<14967.21; 51 9661;. 9 .C>13.;: Para acceder a lo5 miemMro5 de un oMje7o 5e
u5a el operador .N cuSa 5in7aUi5 e5L
<objeto>.<miembro>
Si a e5 un oMje7oN ejemplo5 de cómo llamar a diOeren7e5 miemMro5 5uSo5 5onL

a.b = 2; // Asignamos a su propiedad a el valor 2
a.f(); // Llamamos a su método f()
a.g(2); // Llamamos a su método g() pasándole como parámetro el valor entero 2
No 5e preocupe 5i no conoce lo5 concep7o5 de m67odo5N propiedade5N eQen7o5 S
delegado5 en lo5 Rue 5e Ma5a e57e ejemploN pue5 5e eUplican de7alladamen7e en
7ema5 po57eriore5%

• O<14967.21; 6.2 <02314.;: "n <02314. e5 una QariaMle Rue almacena una
reOerencia a una dirección de memoria% Para oM7ener la dirección de memoria de
un oMje7o 5e u5a el operador &N para acceder al con7enido de la dirección de
memoria almacenada en un pun7ero 5e u5a el operador *N para acceder a un
miemMro de un oMje7o cuSa dirección 5e almacena en un pun7ero 5e u5a ->N S para
reOerenciar una dirección de memoria de Oorma rela7iQa a un pun7ero 5e le aplica
el operador [] de la Oorma puntero[desplazamiento]% (odo5 e57o5 concep7o5 5e
eUplicar9n m95 a Oondo en el Tema %8: C)di(o inse(#ro%
• O<14967.21; 51 .C3126782 51 72@.4?96782 ;.C41 37<.;: #e 7odo5 lo5
operadore5 Rue no5 permi7en oM7ener inOormación 5oMre 7ipo5 de da7o5 el m95
impor7an7e e5 typeofN cuSa Oorma de u5o e5L
typeof(<nombreTipo>)
E57e operador deQuelQe un oMje7o de 7ipo System.Type con inOormación 5oMre el
7ipo de nomMre <nombreTipo> Rue podremo5 con5ul7ar a 7raQ65 de lo5 miemMro5
oOrecido5 por dicWo oMje7o% E57a inOormación incluSe de7alle5 7ale5 como cu9le5
5on 5u5 miemMro5N cu9l e5 5u 7ipo padre o a Ru6 e5pacio de nomMre5 per7enece%
El lenguaje de programación C# (ema 3L A5pec7o5 l6Uico5
Si lo Rue Rueremo5 e5 de7erminar 5i una de7erminada eUpre5ión e5 de un 7ipo u
o7roN en7once5 el operador a u5ar e5 isN cuSa 5in7aUi5 e5 la 5iguien7eL
<expresión> is <nombreTipo>
El 5igniOicado de e57e operador e5 el 5iguien7eL 5e eQalTa <expresión>. Si el
re5ul7ado de 657a e5 del 7ipo cuSo nomMre 5e indica en <nombreTipo> 5e deQuelQe
trueb S 5i noN 5e deQuelQe faIse% Como 5e Qer9 en el Tema 5: ClasesN e57e
operador 5uele u5ar5e en m67odo5 polimórOico5%
/inalmen7eN C# incorpora un 7ercer operador Rue permi7e oM7ener inOormación
5oMre un 7ipo de da7oL sizeof E57e operador permi7e oM7ener el nTmero de MS7e5
Rue ocupar9n en memoria lo5 oMje7o5 de un 7ipoN S 5e u5a a5VL
sizeof(<nombreTipo>)
sizeof 5ólo puede u5ar5e den7ro de código in5eguroN Rue por aWora Ma57a
con5iderar Rue 5on 8ona5 de código donde e5 po5iMle u5ar pun7ero5% No 5er9
Wa57a el Tema %8: C)di(o inse(#ro cuando lo 7ra7aremo5 en proOundidad%
Adem95N si6eo0 5ólo 5e puede aplicar 5oMre nomMre5 de 7ipo5 de da7o5 cuSo5
oMje7o5 5e puedan almacenar direc7amen7e en pila% E5 decirN Rue 5ean e57ruc7ura5
I5e Qer9n en el Tema %&K o 7ipo5 enumerado5 I5e Qer9n en el Tema %*K
• O<14967.21; 51 64196782 51 .C>13.; L El operador m95 7Vpicamen7e u5ado para
crear oMje7o5 e5 newN Rue 5e u5a a5VL
new <nombreTipo>(<parametros>)
E57e operador crea un oMje7o de <nombreTipo> pa59ndole a 5u m67odo con57ruc7or
lo5 par9me7ro5 indicado5 en <parámetros> S deQuelQe una reOerencia al mi5mo%
En Ounción del 7ipo S nTmero de e57o5 par9me7ro5 5e llamar9 a uno u o7ro de lo5
con57ruc7ore5 del oMje7o% A5VN 5uponiendo Rue a1 S a2 5ean QariaMle5 de 7ipo
AviónN ejemplo5 de u5o del operador new 5onL
Avión a1 = new Avión(); // Se llama al constructor sin parámetros de Avión
Avión a2 = new Avión(“Caza”); // Se llama al constructor de Avión que toma
// como parámetro una cadena
En ca5o de Rue el 7ipo del Rue 5e WaSa 5olici7ado la creación del oMje7o 5ea una
cla5eN 657e 5e crear9 en memoria din9micaN S lo Rue new deQolQer9 5er9 una
reOerencia a la dirección de pila donde 5e almacena una reOerencia a la dirección
del oMje7o en memoria din9mica% Sin emMargoN 5i el oMje7o a crear per7enece a
una e57ruc7ura o a un 7ipo enumeradoN en7once5 657e 5e crear9 direc7amen7e en la
pila S la reOerencia deQuel7a por el new 5e reOerir9 direc7amen7e al oMje7o creado%
Por e57a5 ra8one5N a la5 cla5e5 5e le5 conoce como 37<.; 41@1412679 Sa Rue de 5u5
oMje7o5 en pila 5ólo 5e almacena una reOerencia a la dirección de memoria
din9mica donde Qerdaderamen7e 5e encuen7ranb mien7ra5 Rue a la5 e57ruc7ura5 S
7ipo5 enumerado5 5e le5 conoce como 37<.; A9-.4 Sa 5u5 oMje7o5 5e almacenan
direc7amen7e en pila%
El lenguaje de programación C# (ema 3L A5pec7o5 l6Uico5
C# proporciona o7ro operador Rue 7amMi6n no5 permi7e crear oMje7o5% >57e e5
stackaIIocN S 5e u5a a5VL
stackaIIoc <nombreTipo>[<nElementos>]
E57e operador lo Rue Wace e5 crear en pila una 7aMla de 7an7o5 elemen7o5 de 7ipo
<nombreTipo> como indiRue <nElementos> S deQolQer la dirección de memoria en
Rue 657a Wa 5ido creada% Por ejemploL
int * p = stackalloc[100]; // p apunta a una tabla de 100 enteros.
stackaIIoc 5ólo puede u5ar5e para iniciali8ar pun7ero5 a oMje7o5 de 7ipo5 Qalor
declarado5 como QariaMle5 locale5%
• O<14967.21; 51 6.2A14;782: Para conQer7ir uno5 oMje7o5 en o7ro5 5e u7ili8a el
operador de conQer5iónN Rue no con5i57e m95 Rue en preceder la eUpre5ión a
conQer7ir del nomMre en7re par6n7e5i5 del 7ipo al Rue 5e de5ea conQer7ir el
re5ul7ado de eQaluarla% Por ejemploN 5i l e5 una QariaMle de 7ipo Iong S 5e de5ea
almacenar 5u Qalor den7ro de una QariaMle de 7ipo int llamada iN WaMrVa Rue
conQer7ir preQiamen7e 5u Qalor a 7ipo int a5VL
i = (int) l; // Asignamos a i el resultado de convertir el valor de l a tipo int
Lo5 7ipo5 int S Iong e579n predeOinido5 en C# S permi7e almacenar Qalore5
en7ero5 con 5igno% La capacidad de int e5 de *& Mi75N mien7ra5 Rue la de Iong e5
de =3 Mi75% Por 7an7oN a no 5er Rue Wagamo5 u5o del operador de conQer5iónN el
compilador no no5 dejar9 Wacer la a5ignaciónN Sa Rue al 5er maSor la capacidad
de lo5 IongN no 7odo Qalor Rue 5e pueda almacenar en un Iong 7iene porRu6
poder5e almacenar en un int% E5 decirN no e5 Q9lidoL
i = l; //ERROR: El valor de l no tiene porqué caber en i
E57a re57ricción en la a5ignación la impone el compilador deMido a Rue 5in ella
podrVan producir5e errore5 muS diOVcile5 de de7ec7ar an7e 7runcamien7o5 no
e5perado5 deMido al Rue el Qalor de la QariaMle Ouen7e e5 5uperior a la capacidad
de la QariaMle de57ino%
EUi57e o7ro operador Rue permi7e reali8ar operacione5 de conQer5ión de Oorma
muS 5imilar al Sa Qi57o% >57e e5 el operador asN Rue 5e u5a a5VL
<expresión> as <tipoDestino>
Lo Rue Wace e5 deQolQer el re5ul7ado de conQer7ir el re5ul7ado de eQaluar
<expresión> al 7ipo indicado en <tipoDestino> Por ejemploN para almacenar en una
QariaMle p el re5ul7ado de conQer7ir un oMje7o t a 7ipo 7ipo Persona 5e WarVaL
p = t as Persona;
La5 Tnica5 diOerencia5 en7re u5ar uno u o7ro operador de conQer5ión 5onL
El lenguaje de programación C# (ema 3L A5pec7o5 l6Uico5
 as 5ólo e5 aplicaMle a 7ipo5 reOerencia S 5ólo a aRuello5 ca5o5 en
Rue eUi57an conQer5ione5 predeOinida5 en el lenguaje% Como 5e Qer9 m95
adelan7eN e57o 5ólo incluSe conQer5ione5 en7re un 7ipo S 7ipo5 padre5
5uSo5 S en7re un 7ipo S 7ipo5 Wijo5 5uSo5%
"na con5ecuencia de e57o e5 Rue el programador puede deOinir cómo
Wacer conQer5ione5 de 7ipo5 por 6l deOinido5 S o7ro5 median7e el operador
()N pero no median7e as%E57o 5e deMe a Rue as Tnicamen7e indica Rue 5e
de5ea Rue una reOerencia a un oMje7o en memoria din9mica 5e 7ra7e como
5i el oMje7o Oue5e de o7ro 7ipoN pero no implica conQer5ión ninguna% Sin
emMargoN () 5V Rue implica conQer5ión 5i el <tipoDestino> no e5 compa7iMle
con el 7ipo del oMje7o reOerenciado% MQiamen7eN el operador 5e aplicar9
mucWo m95 r9pido en lo5 ca5o5 donde no 5ea nece5ario conQer7ir%
 En ca5o de Rue 5e 5olici7e Wacer una conQer5ión inQ9lida as
deQuelQe nuII mien7ra5 Rue () produce una eUcepción
System.InvaIidCastException%
El lenguaje de programación C# (ema ;L Cla5e5
TEMA 5: CIases
(efinición de clases
Conceptos de cIase y objeto
C# e5 un lenguaje orien7ado a oMje7o5 puro
=
N lo Rue 5igniOica Rue 7odo con lo Rue Qamo5
a 7raMajar en e57e lenguaje 5on oMje7o5% "n .C>13. e5 un agregado de da7o5 S de m67odo5
Rue permi7en manipular dicWo5 da7o5N S un programa en C# no e5 m95 Rue un conjun7o
de oMje7o5 Rue in7eraccionan uno5 con o7ro5 a 7raQ65 de 5u5 m67odo5%

"na 6-9;1 e5 la deOinición de la5 carac7erV57ica5 concre7a5 de un de7erminado 7ipo de
oMje7o5% E5 decirN de cu9le5 5on lo5 da7o5 S lo5 m67odo5 de lo5 Rue Qan a di5poner 7odo5
lo5 oMje7o5 de e5e 7ipo% Por e57a ra8ónN 5e 5uele decir Rue el 37<. 51 593. de un oMje7o e5
la cla5e Rue deOine la5 carac7erV57ica5 del mi5mo
.
%
Sintaxis de definición de cIases
La 5in7aUi5 M95ica para deOinir una cla5e e5 la Rue a con7inuación 5e mue57raL
cIass <nombreClase>
{
<miembros>
}
#e e57e modo 5e deOinirVa una cla5e de nomMre :nom-reClase= cuSo5 miemMro5 5on lo5
deOinido5 en :miem-ros=% Lo5 ?71?C4.; de una cla5e 5on lo5 da7o5 S m67odo5 de lo5
Rue Qan a di5poner 7odo5 lo5 oMje7o5 de la mi5ma% "n ejemplo de cómo declarar una
cla5e de nomMre . Rue no 7enga ningTn miemMro e5 la 5iguien7eL
class A
{}
"na cla5e a5V declarada no di5pondr9 de ningTn miemMro a eUcepción de lo5
implVci7amen7e deOinido5 de manera comTn para 7odo5 lo5 oMje7o5 Rue creemo5 en C#%
E57o5 miemMro5 lo5 Qeremo5 den7ro de poco en e57e mi5mo 7ema Majo el epVgraOe +a
$lase !rime(ina: Sstem.,b-e$t%
AunRue en C# WaS mucWo5 7ipo5 de miemMro5 di57in7o5N por aWora Qamo5 a con5iderar
Rue 657o5 Tnicamen7e pueden 5er campo5 o m67odo5 S Qamo5 a WaMlar un poco acerca de
ello5 S de cómo 5e deOinenL
=
E57a aOirmación no e5 del 7odo cier7aN pue5 como Qeremo5 m95 adelan7e WaS elemen7o5 del lenguaje Rue
no e579n a5ociado5 a ningTn oMje7o en concre7o% Sin emMargoN para 5impliOicar podemo5 con5iderarlo por
aWora como 7al%
.
En realidad WaS o7ra5 Oorma5 de deOinir la5 carac7erV57ica5 de un 7ipo de oMje7o5N como 5on la5 e57ruc7ura5
S la5 enumeracione5% Por 7an7oN el 7ipo de da7o de un oMje7o no 7iene porRu6 5er una cla5eN aunRue a
eOec7o5 de 5impliOicación por aWora con5ideraremo5 Rue 5iempre lo e5%
El lenguaje de programación C# (ema ;L Cla5e5
• C9?<.;: "n 69?<. e5 un da7o comTn a 7odo5 lo5 oMje7o5 de una de7erminada
cla5e% Para deOinir cu9le5 5on lo5 campo5 de lo5 Rue una cla5e di5pone 5e u5a la
5iguien7e 5in7aUi5 den7ro de la 8ona 5eXalada como <miembros> en la deOinición
de la mi5maL
<tipoCampo> <nombreCampo>;
El nomMre Rue demo5 al campo puede 5er cualRuier iden7iOicador Rue Rueramo5
5iempre S cuando 5iga la5 regla5 de5cri7a5 en el Tema *: .s!e$tos +é/i$os para la
e5cri7ura de iden7iOicadore5 S no coincida con el nomMre de ningTn o7ro miemMro
preQiamen7e deOinido en la deOinición de cla5e%
Lo5 campo5 de un oMje7o 5on a 5u Qe8 oMje7o5N S en <tipoCampo> Wemo5 de
indicar cu9l e5 el 7ipo de da7o del oMje7o Rue Qamo5 a crear% >57e 7ipo puede
corre5ponder5e con cualRuiera Rue lo5 predeOinido5 en la BCL o con cualRuier
o7ro Rue no5o7ro5 Wallamo5 deOinido 5iguiendo la 5in7aUi5 arriMa mo57rada% A
con7inuación 5e mue57ra un ejemplo de deOinición de una cla5e de nomMre
Persona Rue di5pone de 7re5 campo5L
class Persona
{
string Nombre; // Campo de cada objeto Persona que almacena su nombre
int Edad; // Campo de cada objeto Persona que almacena su edad
string NÌF; // Campo de cada objeto Persona que almacena su NÌF
}
SegTn e57a deOiniciónN 7odo5 lo5 oMje7o5 de cla5e Persona incorporar9n campo5
Rue almacenar9n cu9l e5 el nomMre de la per5ona Rue cada oMje7o repre5en7aN
cu9l e5 5u edad S cu9l e5 5u NI/% El 7ipo int incluido en la deOinición del campo
Edad e5 un 7ipo predeOinido en la BCL cuSo5 oMje7o5 5on capace5 de almacenar
nTmero5 en7ero5 con 5igno comprendido5 en7re D&%:3.%3'*%=3' S &%:3.%3'*%=3.
I*& Mi75KN mien7ra5 Rue string e5 un 7ipo predeOinido Rue permi7e almacenar
cadena5 de 7eU7o Rue 5igan el Oorma7o de lo5 li7erale5 de cadena Qi57o en el Tema
*: .s!e$tos +é/i$os
Para acceder a un campo de un de7erminado oMje7o 5e u5a la 5in7aUi5L
<objeto>.<campo>
Por ejemploN para acceder al campo Edad de un oMje7o Per5ona llamado p S
camMiar 5u Qalor por &+ 5e WarVaL
p.Edad = 20;
En realidad lo marcado como <objeto> no 7iene porRu6 5er nece5ariamen7e el
nomMre de algTn oMje7oN 5ino Rue puede 5er cualRuier eUpre5ión Rue produ8ca
como re5ul7ado una reOerencia no nula a un oMje7o I5i produje5e nuII 5e lan8arVa
una eUcepción del 7ipo predeOinido System.NuIIPointerExceptionK
• MN3.5.;: "n ?N3.5. e5 un conjun7o de in57ruccione5 a la5 Rue 5e le5 a5ocia un
nomMre de modo Rue 5i 5e de5ea ejecu7arla5 Ma57a reOerenciarla5 a 7raQ65 de
dicWo nomMre en Qe8 de 7ener Rue e5criMirla5% #en7ro de e57a5 in57ruccione5 e5
El lenguaje de programación C# (ema ;L Cla5e5
po5iMle acceder con 7o7al liMer7ad a la inOormación almacenada en lo5 campo5
per7enecien7e5 a la cla5e den7ro de la Rue el m67odo 5e Wa deOinidoN por lo Rue
como al principio del 7ema 5e indicóN lo5 m67odo5 permi7en manipular lo5 da7o5
almacenado5 en lo5 oMje7o5%
La 5in7aUi5 Rue 5e u5a en C# para deOinir lo5 m67odo5 e5 la 5iguien7eL
<tipoDevuelto> <nombreMétodo> (<parametros>)
{
<instrucciones>
}
(odo m67odo puede deQolQer un oMje7o como re5ul7ado de la ejecución de la5
in57ruccione5 Rue lo OormanN S el 7ipo de da7o al Rue per7enece e57e oMje7o e5 lo
Rue 5e indica en <tipoDevuelto>% Si no deQuelQe nada 5e indica voidN S 5i deQuelQe
algo e5 oMliga7orio Oinali8ar la ejecución de 5u5 in57ruccione5 con alguna
in57rucción return <objeto>; Rue indiRue Ru6 oMje7o Wa de deQolQer5e%
pcionalmen7e 7odo m67odo puede reciMir en cada llamada una li57a de oMje7o5 a
lo5 Rue podr9 acceder duran7e la ejecución de 5u5 in57ruccione5% En <parametros>
5e indica e5 cu9le5 5on lo5 7ipo5 de da7o de e57o5 oMje7o5 S cu9l e5 el nomMre con
el Rue War9n reOerencia la5 in57ruccione5 del m67odo a cada uno de ello5% AunRue
lo5 oMje7o5 Rue puede reciMir el m67odo pueden 5er diOeren7e5 cada Qe8 Rue 5e
5olici7e 5u ejecuciónN 5iempre Wan de 5er de lo5 mi5mo5 7ipo5 S Wan de 5eguir el
orden e57aMlecido en <parametros>%
"n ejemplo de cómo declarar un m67odo de nomMre Cumpleaños e5 la 5iguien7e
modiOicación de la deOinición de la cla5e 4ersona u5ada an7e5 como ejemploL
class Persona
{
string Nombre; // Campo de cada objeto Persona que almacena su nombre
int Edad; // Campo de cada objeto Persona que almacena su edad
string NÌF; // Campo de cada objeto Persona que almacena su NÌF
void Cumpleaños() // Ìncrementa en uno de la edad del objeto Persona
{
Edad++;
}
}
La 5in7aUi5 u5ada para llamar a lo5 m67odo5 de un oMje7o e5 la mi5ma Rue la
u5ada para llamar a 5u5 campo5N 5ólo Rue aWora 7ra5 el nomMre del m67odo al Rue
5e de5ea llamar WaS Rue indicar en7re par6n7e5i5 cu9le5 5on lo5 Qalore5 Rue 5e
de5ea dar a lo5 par9me7ro5 del m67odo al Wacer la llamada% 5eaN 5e e5criMeL
<objeto>.<método>(<parámetros>)
Como e5 lógicoN 5i el m67odo no 7oma5e par9me7ro5 5e dejarVan QacVo5 lo5
par9me7ro5 en la llamada al mi5mo% Por ejemploN para llamar al m67odo
Cumpleaños() de un oMje7o Persona llamado p 5e WarVaL
p.Cumpleaños(); // El método no toma parámetros, luego no le pasamos ninguno
El lenguaje de programación C# (ema ;L Cla5e5
E5 impor7an7e 5eXalar Rue en una mi5ma cla5e pueden deOinir5e Qario5 m67odo5
con el mi5mo nomMre 5iempre S cuando 7omen diOeren7e nTmero o 7ipo de
par9me7ro5% A e57o 5e le conoce como ;.C41694=9 51 ?N3.5.;N S e5 po5iMle Sa
Rue el compilador 5aMr9 a cual llamar a par7ir de lo5 <parámetros> e5peciOicado5%
Sin emMargoN lo Rue no 5e permi7e e5 deOinir Qario5 m67odo5 Rue Tnicamen7e 5e
diOerencien en 5u Qalor de re7ornoN Sa Rue como 657e no 5e 7iene porRu6 indicar al
llamarlo5 no podrVa diOerenciar5e a Rue m67odo en concre7o 5e Wace reOerencia en
cada llamada% Por ejemploN a par7ir de la llamadaL
p.Cumpleaños();
Si adem95 de la Qer5ión de Cumpleaños() Rue no re7orna nada WuMie5e o7ra Rue
re7orna5e un intN hcómo 5aMrVa en7once5 el compilador a cu9l llamarJ
An7e5 de con7inuar e5 preci5o 5eXalar Rue en C# 7odoN incluido lo5 li7erale5N 5on oMje7o5
del 7ipo de cada li7eral S por 7an7o pueden con7ar con miemMro5 a lo5 Rue 5e accederVa
7al S como 5e Wa eUplicado% Para en7ender e57o no WaS nada mejor Rue un ejemploL
string s = 12.ToString();
E57e código almacena el li7eral de cadena “12” en la QariaMle sN pue5 12 e5 un oMje7o de
7ipo int I7ipo Rue repre5en7a en7ero5K S cuen7a cuen7a con el m67odo comTn a 7odo5 lo5
int5 llamado ToString() Rue lo Rue Wace e5 deQolQer una cadena cuSo5 carac7ere5 5on lo5
dVgi7o5 Rue Oorman el en7ero repre5en7ado por el int 5oMre el Rue 5e aplicab S como la
QariaMle s e5 de 7ipo string I7ipo Rue repre5en7a cadena5K e5 perOec7amen7e po5iMle
almacenar dicWa cadena en ellaN Rue e5 lo Rue 5e Wace en el código an7erior%
Creación de ob&etos
Operador new
AWora Rue Sa 5aMemo5 cómo deOinir la5 cla5e5 de oMje7o5 Rue podremo5 u5ar en nue57ra5
aplicacione5 Wa llegado el momen7o de eUplicar cómo crear oMje7o5 de una de7erminada
cla5e% Algo de ello Sa 5e in7rodujo en el Tema *: .s!e$tos +é/i$os cuando 5e comen7ó la
u7ilidad del operador 21DN Rue preci5amen7e e5 crear oMje7o5 S cuSa 5in7aUi5 e5L
new <nombreTipo>(<parametros>)
E57e operador crea un nueQo oMje7o del 7ipo cuSo nomMre 5e le indica S llama duran7e 5u
proce5o de creación al con57ruc7or del mi5mo apropiado 5egTn lo5 Qalore5 Rue 5e le
pa5en en <parametros>N deQolQiendo una reOerencia al oMje7o reci6n creado% HaS Rue
re5al7ar el WecWo de Rue new no deQuelQe el propio oMje7o creadoN 5ino una reOerencia a
la dirección de memoria din9mica donde en realidad 5e Wa creado%
El an7e5 comen7ado 6.2;34063.4 de un oMje7o no e5 m95 Rue un m67odo deOinido en la
deOinición de 5u 7ipo Rue 7iene el mi5mo nomMre Rue la cla5e a la Rue per7enece el oMje7o
S no 7iene Qalor de re7orno% Como new 5iempre deQuelQe una reOerencia a la dirección
de memoria donde 5e cree el oMje7o S lo5 con57ruc7ore5 5ólo pueden u5ar5e como
El lenguaje de programación C# (ema ;L Cla5e5
operando5 de newN no 7iene 5en7ido Rue un con57ruc7or deQuelQa oMje7o5N por lo Rue no
7iene 5en7ido incluir en 5u deOinición un campo <tipoDevuelto> S el compilador con5idera
erróneo Wacerlo IaunRue 5e indiRue voidK
El con57ruc7or reciMe e5e nomMre deMido a Rue 5u código 5uele u5ar5e preci5amen7e para
con57ruir el oMje7oN para iniciali8ar 5u5 miemMro5% Por ejemploN a nue57ra cla5e de
ejemplo Persona le podrVamo5 aXadir un con57ruc7or dej9ndola a5VL
class Persona
{
string Nombre; // Campo de cada objeto Persona que almacena su nombre
int Edad; // Campo de cada objeto Persona que almacena su edad
string NÌF; // Campo de cada objeto Persona que almacena su NÌF
void Cumpleaños() // Ìncrementa en uno la edad del objeto Persona
{
Edad++;
}
Persona (string nombre, int edad, string nif) // Constructor
{
Nombre = nombre;
Edad = edad;
NÌF = nif;
}
}
Como 5e Qe en el códigoN el con57ruc7or 7oma como par9me7ro5 lo5 Qalore5 con lo5 Rue
de5eemo5 iniciali8ar el oMje7o a crear% 1racia5 a 6lN podemo5 crear un oMje7o Persona de
nomMre 4o56N de && aXo5 de edad S NI/ :&*33*&:DA a5VL
new Persona(“José”, 22, “12344321-A”)
Nó7e5e Rue la Oorma en Rue 5e pa5an par9me7ro5 al con57ruc7or con5i57e en indicar lo5
Qalore5 Rue 5e Wa de dar a cada uno de lo5 par9me7ro5 indicado5 en la deOinición del
mi5mo 5epar9ndolo5 por coma5% MQiamen7eN 5i un par9me7ro 5e deOinió como de 7ipo
string WaMr9 Rue pa5arle una cadenaN 5i 5e deOinió de 7ipo int WaMr9 Rue pa5arle un en7ero
SN en generalN a 7odo par9me7ro WaMr9 Rue pa5arle un Qalor de 5u mi5mo 7ipo Io de
alguno conQer7iMle al mi5moKN produci6ndo5e un error al compilar 5i no 5e Wace a5V%
En realidad un oMje7o puede 7ener mTl7iple5 con57ruc7ore5N aunRue para diOerenciar a
uno5 de o7ro5 e5 oMliga7orio Rue 5e diOerencien en el nTmero u orden de lo5 par9me7ro5
Rue acep7anN Sa Rue el nomMre de 7odo5 ello5 Wa de coincidir con el nomMre de la cla5e
de la Rue 5on miemMro5% #e e5e modoN cuando creemo5 el oMje7o el compilador podr9
in7eligen7emen7e de7erminar cu9l de lo5 con57ruc7ore5 Wa de ejecu7ar5e en Ounción de lo5
Qalore5 Rue le pa5emo5 al new%
"na Qe8 creado un oMje7o lo m95 normal e5 almacenar la dirección deQuel7a por new en
una QariaMle del 7ipo apropiado para el oMje7o creado% El 5iguien7e ejemplo DRue como e5
lógico ir9 den7ro de la deOinición de algTn m67odoD mue57ra cómo crear una QariaMle de
7ipo Persona llamada p S cómo almacenar en ella la dirección del oMje7o Rue deQolQerVa
la an7erior aplicación del operador newL
El lenguaje de programación C# (ema ;L Cla5e5
Persona p; // Creamos variable p
p = new Persona(“Jose”, 22, “12344321-A”); // Almacenamos en p el objeto creado con new
A par7ir de e57e momen7o la QariaMle p con7endr9 una reOerencia a un oMje7o de cla5e
Persona Rue repre5en7ar9 a una per5ona llamada 4o56 de && aXo5 S NI/ :&*33*&:DA%
lo Rue pr9c7icamen7e e5 lo mi5mo S 5uele 5er la Oorma comTnmen7e u5ada para decirloL
la QariaMle p repre5en7a a una per5ona llamada 4o56 de && aXo5 S NI/ :&*33*&:DA%
Como lo m95 normal 5uele 5er crear QariaMle5 donde almacenar reOerencia5 a oMje7o5
Rue creemo5N la5 in57ruccione5 an7eriore5 pueden compac7ar5e en una 5ola a5VL

Persona p = new Persona(“José”, 22, “12344321-A”);
#e WecWoN una 5in7aUi5 m95 general para la deOinición de QariaMle5 e5 la 5iguien7eL
<tipoDato> <nombreVariable> , <valorInicial>;
La par7e = <valorÌnicial> de e57a 5in7aUi5 e5 en realidad opcionalN S 5i no 5e incluSe la
QariaMle declarada pa5ar9 a almacenar una reOerencia nula Icon7endr9 el li7eral nuIIK
Constructor por defecto
No e5 oMliga7orio deOinir un con57ruc7or para cada cla5eN S en ca5o de Rue no deOinamo5
ninguno el compilador crear9 uno por no5o7ro5 5in par9me7ro5 ni in57ruccione5% E5 decirN
como 5i 5e WuMie5e deOinido de e57a OormaL
<nombreTipo>()
{
}
1racia5 a e57e con57ruc7or in7roducido au7om97icamen7e por el compiladorN 5i Coche e5
una cla5e en cuSa deOinición no 5e Wa incluido ningTn con57ruc7orN 5iempre 5er9 po5iMle
crear uno nueQo u5ando el operador new a5VL
Coche c = new Coche(); // Crea coche c llamando al constructor por defecto de Coche
HaS Rue 7ener en cuen7a una co5aL el con57ruc7or por deOec7o e5 5ólo incluido por el
compilador 5i no Wemo5 deOinido ningTn o7ro con57ruc7or% Por 7an7oN 5i 7enemo5 una
cla5e en la Rue WaSamo5 deOinido algTn con57ruc7or con par9me7ro5 pero ninguno 5in
par9me7ro5 no 5er9 Q9lido crear oMje7o5 de la mi5ma llamando al con57ruc7or 5in
par9me7ro5N pue5 el compilador no lo WaMr9 deOinido au7om97icamen7e% Por ejemploN con
la Tl7ima Qer5ión de la cla5e de ejemplo Persona e5 inQ9lido WacerL
Persona p = new Persona(); // ERROR: El único constructor de Persona toma 3 parámetros
Referencia aI objeto actuaI con this
#en7ro del código de cualRuier m67odo de un oMje7o 5iempre e5 po5iMle Wacer reOerencia
al propio oMje7o u5ando la palaMra re5erQada t*is% E57o puede Qenir Mien a la Wora de
El lenguaje de programación C# (ema ;L Cla5e5
e5criMir con57ruc7ore5 de oMje7o5 deMido a Rue permi7e Rue lo5 nomMre5 Rue demo5 a lo5
par9me7ro5 del con57ruc7or puedan coincidir nomMre5 de lo5 campo5 del oMje7o 5in Rue
WaSa ningTn proMlema% Por ejemploN el con57ruc7or de la cla5e Per5ona e5cri7o
an7eriormen7e 5e puede re5criMir a5V u5ando t*isL
Persona (string Nombre, int Edad, string NÌF)
{
this.Nombre = Nombre;
this.Edad = Edad;
this.NÌF = NÌF;
}
E5 decirN den7ro de un m67odo con par9me7ro5 cuSo5 nomMre5 coincidan con campo5N 5e
da preOerencia a lo5 par9me7ro5 S para Wacer reOerencia a lo5 campo5 WaS Rue preOijarlo5
con el t*is 7al S como 5e mue57ra en el ejemplo%
El ejemplo an7erior puede Rue no re5ul7e muS in7ere5an7e deMido a Rue para eQi7ar 7ener
Rue u5ar t*is podrVa WaMer5e e5cri7o el con57ruc7or 7al S como 5e mo57ró en la primera
Qer5ión del mi5moL dando nomMre5 Rue empiecen en minT5cula a lo5 par9me7ro5 S
nomMre5 Rue empiecen con maST5cula5 a lo5 campo5% #e WecWoN e5e e5 el conQenio Rue
!icro5oO7 recomienda u5ar% Sin emMargoN como m95 adelan7e 5e Qer9 5V Rue puede 5er
T7il t*is cuando lo5 campo5 a iniciali8ar a 5ean priQado5N Sa Rue el conQenio de
e5cri7ura de iden7iOicadore5 para campo5 priQado5 recomendado por !icro5oO7 coincide
con el u5ado para dar iden7iOicadore5 a par9me7ro5 IoMQiamen7e o7ra 5olución 5erVa dar
cualRuier o7ro nomMre a lo5 par9me7ro5 del con57ruc7or o lo5 campo5 aOec7ado5N aunRue
a5V el código perderVa algo legiMilidadK
"n u5o m95 Orecuen7e de t*is en C# e5 el de permi7ir reali8ar llamada5 a un m67odo de
un oMje7o de5de código uMicado en m67odo5 del mi5mo oMje7o% E5 decirN en C# 5iempre
e5 nece5ario Rue cuando llamemo5 a algTn m67odo de un oMje7o precedamo5 al operador
. de alguna eUpre5ión Rue indiRue cu9l e5 el oMje7o a cuSo m67odo 5e de5ea llamarN S 5i
657e m67odo per7enece al mi5mo oMje7o Rue Wace la llamada la Tnica Oorma de con5eguir
indicarlo en C# e5 u5ando t*is%
/inalmen7eN una 7ercera u7ilidad de this e5 permi7ir e5criMir m67odo5 Rue puedan
deQolQer como oMje7o el propio oMje7o 5oMre el Rue el m67odo e5 aplicado% Para ello
Ma57arVa u5ar una in57rucción return this; al indicar el oMje7o a deQolQer%
-erencia $ m.todos virtuales
Concepto de herencia
El mecani5mo de J1412679 e5 uno de lo5 pilare5 Oundamen7ale5 en lo5 Rue 5e Ma5a la
programación orien7ada a oMje7o5% E5 un mecani5mo Rue permi7e deOinir nueQa5 cla5e5
a par7ir de o7ra5 Sa deOinida5 de modo Rue 5i en la deOinición de una cla5e indicamo5 Rue
657a deriQa de o7raN en7once5 la primera Da la Rue 5e le 5uele llamar 6-9;1 J7>9D 5er9
7ra7ada por el compilador au7om97icamen7e como 5i 5u deOinición incluSe5e la deOinición
de la 5egunda da la Rue 5e le 5uele llamar 6-9;1 <9541 o 6-9;1 C9;1% La5 cla5e5 Rue
deriQan de o7ra5 5e deOinen u5ando la 5iguien7e 5in7aUi5L
El lenguaje de programación C# (ema ;L Cla5e5
cIass <nombreHija>:<nombrePadre>
{
<miembrosHija>
}
A lo5 miemMro5 deOinido5 en <miembrosHijas> 5e le aXadir9n lo5 Rue WuMi65emo5
deOinido en la cla5e padre% Por ejemploN a par7ir de la cla5e Persona puede crear5e una
cla5e Trabajador a5VL
class Trabajador:Persona
{
public int Sueldo;
public Trabajador(string nombre, int edad, string nif, int sueldo):
base(nombre, edad, nif)
{
Sueldo = sueldo;
}
}
Lo5 oMje7o5 de e57a cla5e Trabajador con7ar9n con lo5 mi5mo5 miemMro5 Rue lo5 oMje7o5
Persona S adem95 incorporar9n un nueQo campo llamado Sueldo Rue almacenar9 el
dinero Rue cada 7raMajador gane% Nó7e5e adem95 Rue a la Wora de e5criMir el con57ruc7or
de e57a cla5e Wa 5ido nece5ario e5criMirlo con una 5in7aUi5 e5pecial con5i57en7e en
preceder la llaQe de aper7ura del cuerpo del m67odo de una e57ruc7ura de la OormaL
: base(<parametrosBase>)
A e57a e57ruc7ura se le llama 727679-7K95.4 C9;1 S 5e u7ili8a para indicar cómo de5eamo5
iniciali8ar lo5 campo5 Weredado5 de la cla5e padre% No e5 m95 Rue una llamada al
con57ruc7or de la mi5ma con lo5 par9me7ro5 adecuado5N S 5i no 5e incluSe el compilador
con5iderarVa por deOec7o Rue Qale :base()N lo Rue 5erVa incorrec7o en e57e ejemplo deMido
a Rue Persona carece de con57ruc7or 5in par9me7ro5%
"n ejemplo Rue pone de maniOie57o cómo Ounciona la Werencia e5 el 5iguien7eL
using System;
class Persona
{
public string Nombre; // Campo de cada objeto Persona que almacena su nombre
public int Edad; // Campo de cada objeto Persona que almacena su edad
public string NÌF; // Campo de cada objeto Persona que almacena su NÌF
void Cumpleaños() // Ìncrementa en uno de edad del objeto Persona
{
Edad++;
}
public Persona (string nombre, int edad, string nif) // Constructor de Persona
{
Nombre = nombre;
Edad = edad;
NÌF = nif;
}
}
El lenguaje de programación C# (ema ;L Cla5e5
class Trabajador: Persona
{
public int Sueldo; // Campo de cada objeto Trabajador que almacena cuánto gana
Trabajador(string nombre, int edad, string nif, int sueldo): base(nombre, edad, nif)
{ // Ìnicializamos cada Trabajador en base al constructor de Persona
Sueldo = sueldo;
}
public static void Main()
{
Trabajador p = new Trabajador("Josan", 22, "77588260-Z", 100000);

Console.WriteLine ("Nombre="+p.Nombre);
Console.WriteLine ("Edad="+p.Edad);
Console.WriteLine ("NÌF="+p.NÌF);
Console.WriteLine ("Sueldo="+p.Sueldo);
}
}
Nó7e5e Rue Wa 5ido nece5ario preOijar la deOinición de lo5 miemMro5 de 4ersona del
palaMra re5erQada pubIic% E57o 5e deMe a Rue por deOec7o lo5 miemMro5 de una 7ipo 5ólo
5on acce5iMle5 de5de código incluido den7ro de la deOinición de dicWo 7ipoN e incluSendo
pubIic con5eguimo5 Rue 5ean acce5iMle5 de5de cualRuier códigoN como el m67odo Main()
deOinido en Trabajador% pubIic e5 lo Rue 5e denomina un ?.57@7695.4 51 9661;.N
concep7o Rue 5e 7ra7ar9 m95 adelan7e en e57e mi5mo 7ema Majo el epVgraOe 7i7ulado
Modi0i$adores de a$$eso%
LIamadas por defecto aI constructor base

Si en la deOinición del con57ruc7or de alguna cla5e Rue deriQe de o7ra no incluimo5
iniciali8ador Ma5e el compilador con5iderar9 Rue 657e e5 :base() Por ello WaS Rue e57ar
5eguro5 de Rue 5i no 5e incluSe base en la deOinición de algTn con57ruc7orN el 7ipo padre
del 7ipo al Rue per7ene8ca di5ponga de con57ruc7or 5in par9me7ro5%
E5 e5pecialmen7e 5igniOica7iQo re5eXar el ca5o de Rue no demo5 la deOinición de ningTn
con57ruc7or en la cla5e WijaN Sa Rue en e57o5 ca5o5 la deOinición del con57ruc7or Rue por
deOec7o in7roducir9 el compilador 5er9 en realidad de la OormaL
<nombreClase>(): base()
{}
E5 decirN e57e con57ruc7or 5iempre llama al con57ruc7or 5in par9me7ro5 del padre del 7ipo
Rue e57emo5 deOiniendoN S 5i 65e no di5pone de alguno 5e producir9 un error al compilar%
Métodos virtuaIes
2a Wemo5 Qi57o Rue e5 po5iMle deOinir 7ipo5 cuSo5 m67odo5 5e Wereden de deOinicione5
de o7ro5 7ipo5% Lo Rue aWora Qamo5 a Qer e5 Rue adem95 e5 po5iMle camMiar dicWar
deOinición en la cla5e WijaN para lo Rue WaMrVa Rue WaMer precedido con la palaMra
El lenguaje de programación C# (ema ;L Cla5e5
re5erQada virtuaI la deOinición de dicWo m67odo en la cla5e padre% A e57e 7ipo de m67odo5
5e le5 llama ?N3.5.; A74309-1;N S la 5in7aUi5 Rue 5e u5a para deOinirlo5 e5 la 5iguien7eL
virtuaI <tipoDevuelto> <nombreMétodo>(<parámetros>)
{
<código>
}
Si en alguna cla5e Wija Rui5i65emo5 dar una nueQa deOinición del <código> del m67odoN
5implemen7e lo QolQerVamo5 a deOinir en la mi5ma pero 5u57i7uSendo en 5u deOinición la
palaMra re5erQada virtuaI por override% E5 decirN u5arVamo5 e57a 5in7aUi5L
override <tipoDevuelto> <nombreMétodo>(<parámetros>)
{
<nuevoCódigo>
}
Nó7e5e Rue e57a po5iMilidad de camMiar el código de un m67odo en 5u cla5e Wija 5ólo 5e
da 5i en la cla5e padre el m67odo Oue deOinido como virtual% En ca5o con7rarioN el
compilador con5iderar9 un error in7en7ar redeOinirlo%
El lenguaje C# impone la re57ricción de Rue 7oda redeOinición de m67odo Rue Rueramo5
reali8ar incorpore la par7Vcula override para Oor8ar a Rue el programador e576 5eguro de
Rue Qerdaderamen7e lo Rue Ruiere Wacer e5 camMiar el 5igniOicado de un m67odo
Weredado% A5V 5e eQi7a Rue por acciden7e deOina un m67odo del Rue Sa eUi57a una
deOinición en una cla5e padre% Adem95N C# no permi7e deOinir un m67odo como
override S virtual a la Qe8N Sa Rue ello 7endrVa un 5igniOicado aM5urdoL e57arVamo5
dando una redeOinición de un m67odo Rue Qamo5 a deOinir%
Por o7ro ladoN cuando deOinamo5 un m67odo como override Wa de cumplir5e Rue en
alguna cla5e an7ece5ora I5u cla5e padreN 5u cla5e aMuelaN e7c%K de la cla5e en la Rue 5e Wa
reali8ado la deOinición del mi5mo eUi57a un m67odo Qir7ual con el mi5mo nomMre Rue el
redeOinido% Si noN el compilador inOormar9 de error por in7en7o de redeOinición de
m67odo no eUi57en7e o no Qir7ual% A5V 5e eQi7a Rue por acciden7e un programador crea
Rue e579 redeOiniendo un m67odo del Rue no eUi57a deOinición preQia o Rue redeOina un
m67odo Rue el creador de la cla5e Ma5e no de5ee Rue 5e pueda redeOinir%
Para aclarar mejor el concep7o de m67odo Qir7ualN Qamo5 a mo57rar un ejemplo en el Rue
camMiaremo5 la deOinición del m67odo Cumpleaños() en lo5 oMje7o5 Persona por una
nueQa Qer5ión en la Rue 5e mue57re un men5aje cada Qe8 Rue 5e ejecu7eN S redeOiniremo5
dicWa nueQa Qer5ión para lo5 oMje7o5 Trabajador de modo Rue el men5aje mo57rado 5ea
o7ro% El código de e57e ejemplo e5 el Rue 5e mue57ra a con7inuaciónL
using System;
class Persona
{
public string Nombre; // Campo de cada objeto Persona que almacena su nombre
public int Edad; // Campo de cada objeto Persona que almacena su edad
public string NÌF; // Campo de cada objeto Persona que almacena su NÌF
public virtual void Cumpleaños() // Ìncrementa en uno de la edad del objeto Persona
{
El lenguaje de programación C# (ema ;L Cla5e5
Edad++;
Console.WriteLine(“Ìncrementada edad de persona”);
}
public Persona (string nombre, int edad, string nif) // Constructor de Persona
{
Nombre = nombre;
Edad = edad;
NÌF = nif;
}
}
class Trabajador: Persona
{
public int Sueldo; // Campo de cada objeto Trabajador que almacena cuánto gana
Trabajador(string nombre, int edad, string nif, int sueldo): base(nombre, edad, nif)
{ // Ìnicializamos cada Trabajador en base al constructor de Persona
Sueldo = sueldo;
}

public override void Cumpleaños()
{
Edad++;
Console.WriteLine(“Ìncrementada edad de trabajador”);
}
public static void Main()
{
Persona p = new Persona("Carlos", 22, "77588261-Z");
Trabajador t = new Trabajador("Josan", 22, "77588260-Z", 100000);
t.Cumpleaños();
p.Cumpleaños();
}
}
Nó7e5e cómo 5e Wa aXadido el modiOicador virtuaI en la deOinición de Cumpleaños() en la
cla5e Persona para WaMili7ar la po5iMilidad de Rue dicWo m67odo puede 5er redeOinido en
cla5e Wija5 de Persona S cómo 5e Wa aXado override en la redeOinición del mi5mo
den7ro de la cla5e Trabajador para indicar Rue la nueQa deOinición del m67odo e5 una
redeOinición del Weredado de la cla5e% La 5alida de e57e programa conOirma Rue la
implemen7ación de Cumplea7os89 e5 di57in7a en cada cla5eN pue5 e5 de la OormaL

;ncrementada edad de tra-a7ador
;ncrementada edad de 5ersona
(amMi6n e5 impor7an7e 5eXalar Rue para Rue la redeOinición 5ea Q9lida Wa 5ido nece5ario
aXadir la par7Vcula pubIic a la deOinición del m67odo originalN pue5 5i no 5e incluSe5e 5e
con5iderarVa Rue el m67odo 5ólo e5 acce5iMle de5de den7ro de la cla5e donde 5e Wa
deOinidoN lo Rue no 7iene 5en7ido en m67odo5 Qir7uale5 Sa Rue en7once5 nunca podrVa 5er
redeOinido% #e WecWoN 5i 5e eUcluSe5e el modiOicador public el compilador inOormarVa
de un error an7e e57e aM5urdo% Adem95N e57e modiOicador 7amMi6n 5e Wa man7enido en la
redeOinición de Cumpleaños() porRue 7oda redeOinición de un m67odo Qir7ual Wa de
man7ener lo5 mi5mo5 modiOicadore5 de acce5o Rue el m67odo original para 5er Q9lida%
El lenguaje de programación C# (ema ;L Cla5e5
CIases abstractas
"na 6-9;1 9C;349639 e5 aRuella Rue Oor8o5amen7e 5e Wa de deriQar 5i 5e de5ea Rue 5e
puedan crear oMje7o5 de la mi5ma o acceder a 5u5 miemMro5 e5797ico5 Ie57o Tl7imo 5e
Qer9 m95 adelan7e en e57e mi5mo 7emaK Para deOinir una cla5e aM57rac7a 5e an7epone
abstract a 5u deOiniciónN como 5e mue57ra en el 5iguien7e ejemploL
public abstract class A
{
public abstract void F();
}
abstract public class B: A
{
public void G() {}
}
class C: B
{
public override void F()
{}
}
La5 cla5e5 A S B del ejemplo 5on aM57rac7a5N S como puede Qer5e e5 po5iMle comMinar en
cualRuier orden el modiOicador abstract con modiOicadore5 de acce5o%

La u7ilidad de la5 cla5e5 aM57rac7a5 e5 Rue pueden con7ener m67odo5 para lo5 Rue no 5e
d6 direc7amen7e una implemen7ación 5ino Rue 5e deje en mano5 de 5u5 cla5e5 Wija5 darla%
No e5 oMliga7orio Rue la5 cla5e5 aM57rac7a5 con7engan m67odo5 de e57e 7ipoN pero 5V lo e5
marcar como aM57rac7a a 7oda la Rue 7enga alguno% E57o5 m67odo5 5e deOinen
precediendo 5u deOinición del modiOicador abstract S 5u57i7uSendo 5u código por un
pun7o S coma I;KN como 5e mue57ra en el m67odo F() de la cla5e A del ejemplo Inó7e5e
Rue B 7amMi6n Wa de deOinir5e como aM57rac7a porRue 7ampoco implemen7a el m67odo F()
Rue Wereda de AK
MQiamen7eN como un m67odo aM57rac7o no 7iene código no e5 po5iMle llamarlo% HaS Rue
7ener e5pecial cuidado con e57o a la Wora de u7ili8ar this para llamar a o7ro5 m67odo5 de
un mi5mo oMje7oN Sa Rue llamar a lo5 aM57rac7o5 proQoca un error al compilar%
,6a5e Rue 7odo m67odo deOinido como aM57rac7o e5 implVci7amen7e Qir7ualN pue5 5i no
5erVa impo5iMle redeOinirlo para darle una implemen7ación en la5 cla5e5 Wija5 de la cla5e
aM57rac7a donde e576 deOinido% Por ello e5 nece5ario incluir el modiOicador override a la
Wora de darle implemen7ación S e5 redundan7e marcar un m67odo como abstract S
virtual a la Qe8 Ide WecWoN Wacerlo proQoca un error al compilarK
E5 po5iMle marcar un m67odo como abstract S override a la Qe8N lo Rue conQer7irVa al
m67odo en aM57rac7o para 5u5 cla5e5 Wija5 S Oor8arVa a Rue 657a5 lo 7uQie5en Rue
reimplemen7ar 5i no 5e Rui5ie5e Rue Oue5en cla5e5 aM57rac7a5%
La clase primegenia/ !$stem.%b&ect
AWora Rue 5aMemo5 lo Rue e5 la Werencia e5 el momen7o apropiado para eUplicar Rue
en %NE( 7odo5 lo5 7ipo5 Rue 5e deOinan Weredan implVci7amen7e de la cla5e
El lenguaje de programación C# (ema ;L Cla5e5
System.Object predeOinida en la BCLN por lo Rue di5pondr9n de 7odo5 lo5 miemMro5 de
657a% Por e57a ra8ón 5e dice Rue System.Object e5 la raV8 de la jerarRuVa de oMje7o5 de
%NE(%
A con7inuación Qamo5 a eUplicar cu9le5 5on e57o5 m67odo5 comune5 a 7odo5 lo5 oMje7o5L
• pubIic virtuaI booI EquaIs(object o)L Se u5a para comparar el oMje7o 5oMre el Rue
5e aplica con cualRuier o7ro Rue 5e le pa5e como par9me7ro% #eQuelQe true 5i
amMo5 oMje7o5 5on iguale5 S 0alse en ca5o con7rario%
La implemen7ación Rue por deOec7o 5e Wa dado a e57e m67odo con5i57e en u5ar
igualdad por reOerencia para lo5 7ipo5 por reOerencia e igualdad por Qalor para lo5
7ipo5 por Qalor% E5 decirN 5i lo5 oMje7o5 a comparar 5on de 7ipo5 por reOerencia
5ólo 5e deQuelQe true 5i amMo5 oMje7o5 apun7an a la mi5ma reOerencia en
memoria din9micaN S 5i lo5 7ipo5 a comparar 5on 7ipo5 por Qalor 5ólo 5e deQuelQe
true 5i 7odo5 lo5 Mi75 de amMo5 oMje7o5 5on iguale5N aunRue 5e almacenen en
po5icione5 diOeren7e5 de memoria%
Como 5e QeN el m67odo Wa 5ido deOinido como virtualN lo Rue permi7e Rue lo5
programadore5 puedan redeOinirlo para indicar cu9ndo Wa de con5iderar5e Rue
5on iguale5 do5 oMje7o5 de 7ipo5 deOinido5 por ello5% #e WecWoN mucWo5 de lo5
7ipo5 incluido5 en la BCL cuen7an con redeOinicione5 de e57e 7ipoN como e5 el
ca5o de stringN Ruien aTn 5iendo un 7ipo por reOerenciaN 5u5 oMje7o5 5e
con5ideran iguale5 5i apun7an a cadena5 Rue 5ean iguale5 car9c7er a car9c7er
IaunRue reOerencien a di57in7a5 direccione5 de memoria din9micaK
El 5iguien7e ejemplo mue57ra cómo Wacer una redeOinición de ,:uals89 de
manera Rue aunRue lo5 oMje7o5 Persona 5ean de 7ipo5 por reOerenciaN 5e con5idere
Rue do5 Personas 5on iguale5 5i 7ienen el mi5mo NI/L
public override bool Equals(object o)
{
if (o==null)
return this==null;
else
return (o is Persona) && (this.NÌF == ((Persona) o).NÌF);
}
HaS Rue 7ener en cuen7a Rue e5 conQenien7e Rue 7oda redeOinición del m67odo
,:uals89 Rue Wagamo5 cumpla con una 5erie de propiedade5 Rue mucWo5 de lo5
m67odo5 incluido5 en la5 di57in7a5 cla5e5 de la BCL e5peran Rue 5e cumplan%
E57a5 propiedade5 5onL
 R1@-1I7A7595 L (odo oMje7o Wa de 5er igual a 5V mi5mo% E5 decirN
x.Equals(x) 5iempre Wa de deQolQer true%
 S7?134L9 L Ha de dar igual el orden en Rue 5e Waga la comparación% E5
decirN x.Equals(y) Wa de deQolQer lo mi5mo Rue y.Equals(x) %
 T492;737A7595 L Si do5 oMje7o5 5on iguale5 S uno de ello5 e5 igual a o7roN
en7once5 el primero 7amMi6n Wa de 5er igual a e5e o7ro oMje7o% E5 decirN 5i
x.Equals(y) e y.Equals(z) en7once5 x.Equals(z) %
El lenguaje de programación C# (ema ;L Cla5e5
 C.2;7;312679: Siempre Rue el m67odo 5e apliRue 5oMre lo5 mi5mo5
oMje7o5 Wa de deQolQer el mi5mo re5ul7ado%
 T4939?7123. 51 .C>13.; 20-.;: Si uno de lo5 oMje7o5 comparado5 e5
nulo InuII)N 5ólo 5e Wa de deQolQer true 5i el o7ro 7amMi6n lo e5%
HaS Rue recalcar Rue el WecWo de Rue redeOinir Equals() no implica Rue el
operador de igualdad I==K Ruede 7amMi6n redeOinido% Ello WaMrVa Rue Wacerlo de
independien7emen7e como 5e indica en el Tema %%: 1ede0ini$i)n de o!eradores%
• pubIic virtuaI int GetHashCode()L #eQuelQe un código de di5per5ión IWa5WK Rue
repre5en7a de Oorma num6rica al oMje7o 5oMre el Rue el m67odo e5 aplicado%
GetHashCode() 5uele u5ar5e para 7raMajar con 7aMla5 de di5per5iónN S 5e cumple
Rue 5i do5 oMje7o5 5on iguale5 5u5 código5 de di5per5ión 5er9n iguale5N mien7ra5
Rue 5i 5on di57in7o5 la proMaMilidad de Rue 5ean iguale5 e5 VnOima%
En 7an7o Rue la MT5Rueda de oMje7o5 en 7aMla5 de di5per5ión no 5e reali8a
Tnicamen7e u5ando la igualdad de oMje7o5 Im67odo Equals()K 5ino u5ando 7amMi6n
la igualdad de código5 de di5per5iónN 5uele 5er conQenien7e redeOinir
GetHashCode() 5iempre Rue 5e redeOina Equals() #e WecWoN 5i no 5e Wace el
compilador inOorma de la 5i7uación con un men5aje de aQi5o%
• pubIic virtuaI string ToString()L #eQuelQe una repre5en7ación en Oorma de cadena
del oMje7o 5oMre el Rue 5e el m67odo e5 aplicadoN lo Rue e5 muS T7il para depurar
aplicacione5 Sa Rue permi7e mo57rar con Oacilidad el e57ado de lo5 oMje7o5%
La implemen7ación por deOec7o de e57e m67odo 5implemen7e deQuelQe una
cadena de 7eU7o con el nomMre de la cla5e a la Rue per7enece el oMje7o 5oMre el
Rue e5 aplicado% Sin emMargoN como lo WaMi7ual 5uele 5er implemen7ar ToString()
en cada nueQa cla5e Rue e5 deOinaN a con7inuación mo57raremo5 un ejemplo de
cómo redeOinirlo en la cla5e 4ersona para Rue mue57re lo5 Qalore5 de 7odo5 lo5
campo5 de lo5 oMje7o5 4ersonaL
public override string ToString()
{
string cadena = “”;
cadena += “DNÌ = “ + this.DNÌ + ”\n”;
cadena +=”Nombre = ” + this.Nombre + ”\n”;
cadena +=”Edad = ” + this.Edad + ”\n”;
return cadena;
}
E5 de re5eXar el WecWo de Rue en realidad lo5 Rue Wace el operador de
conca7enación de cadena5 I+K para conca7enar una cadena con un oMje7o
cualRuiera e5 conQer7irlo primero en cadena llamando a 5u m67odo ToString() S
luego reali8ar la conca7enación de amMa5 cadena5%
#el mi5mo modoN cuando a ConsoIe.WriteLine() S ConsoIe.Write() 5e le5 pa5a
como par9me7ro un oMje7o lo Rue Wacen e5 mo57rar por la 5alida e579ndar el
re5ul7ado de conQer7irlo en cadena llamando a 5u m67odo ToString()b S 5i 5e le5
pa5a como par9me7ro5 una cadena 5eguida de Qario5 oMje7o5 lo mue57ran por la
El lenguaje de programación C# (ema ;L Cla5e5
5alida e579ndar e5a cadena pero 5u57i7uSendo en ella 7oda 5uMcadena de la Oorma
{<número>} por el re5ul7ado de conQer7ir en cadena el par9me7ro Rue ocupe la
po5ición <número>P& en la li57a de Qalore5 de llamada al m67odo%

• protected ob!ect ;ember)iseClone89: #eQuelQe una copia ;J9--.D 6.<:
del oMje7o 5oMre el Rue 5e aplica% E57a copia e5 una copia Mi7 a Mi7 del mi5moN por
lo Rue el oMje7o re5ul7an7e de la copia man7endr9 la5 mi5ma5 reOerencia5 a o7ro5
Rue 7uQie5e el oMje7o copiado S 7oda modiOicación Rue 5e Waga a e57o5 oMje7o5 a
7raQ65 de la copia aOec7ar9 al oMje7o copiado S QiceQer5a%
Si lo Rue in7ere5a e5 di5poner de una copia m95 normalN en la Rue por cada oMje7o
reOerenciado 5e crea5e una copia del mi5mo a la Rue reOerencia5e el oMje7o
clonadoN en7once5 el programador Wa de e5criMir 5u propio m67odo clonador pero
puede 5erQir5e de MemberwiseClone() como Ma5e con la Rue copiar lo5 campo5
Rue no 5ean de 7ipo5 reOerencia%
• pubIic System.Type GetType()L #eQuelQe un oMje7o de cla5e System.Type Rue
repre5en7a al 7ipo de da7o del oMje7o 5oMre el Rue el m67odo e5 aplicado% A 7raQ65
de lo5 m67odo5 oOrecido5 por e57e oMje7o 5e puede acceder a me7ada7o5 5oMre el
mi5mo como 5u nomMreN 5u cla5e padreN 5u5 miemMro5N e7c% La eUplicación de
cómo u5ar lo5 miemMro5 de e57e oMje7o para oM7ener dicWa inOormación Rueda
Ouera del alcance de e57e documen7o Sa Rue e5 muS larga S puede 5er O9cilmen7e
con5ul7ada en la documen7ación Rue acompaXa al %NE( S#A%
• protected virtuaI void FinaIize(): Con7iene el código Rue 5e ejecu7ar9 5iempre Rue
QaSa Wa 5er de57ruido algTn oMje7o del 7ipo del Rue 5ea miemMro% La
implemen7ación dada por deOec7o a %inali6e89 con5i57e en no Wacer nada%
AunRue e5 un m67odo Qir7ualN en C# no 5e permi7e Rue el programador lo
redeOina eUplVci7amen7e dado Rue Wacerlo e5 peligro5o por ra8one5 Rue 5e
eUplicar9n en el Tema 8: Métodos Io7ro5 lenguaje5 de %NE( podrVan permi7irloK
Apar7e de lo5 m67odo5 Sa comen7ado5 Rue 7odo5 lo5 oMje7o5 WeredanN la cla5e
System.Object 7amMi6n incluSe en 5u deOinición lo5 5iguien7e5 m67odo5 de 7ipoL
• pubIic static booI EquaIs(object objeto1, object objeto2)  ,er5ión
e5797ica del m67odo EquaIs() Sa Qi57o% Indica 5i lo5 oMje7o5 Rue 5e le pa5an
como par9me7ro5 5on iguale5N S para compararlo5 lo Rue Wace e5 deQolQer el
re5ul7ado de calcular objeto1.EquaIs(objeto2) comproMando an7e5 5i alguno
de lo5 oMje7o5 Qale nuII I5ólo 5e deQolQerVa true 5ólo 5i el o7ro 7amMi6n lo e5K
MQiamen7e 5i 5e da una redeOinición al EquaIs() no e5797icoN 5u5 eOec7o5
7amMi6n 5e Qer9n cuando 5e llame al e5797ico%
• pubIic static booI ReferenceEquaIs(object objeto1, object objeto2) 
Indica 5i lo5 do5 oMje7o5 Rue 5e le pa5an como par9me7ro 5e almacenan en la
mi5ma po5ición de memoria din9mica% A 7raQ65 de e57e m67odoN aunRue 5e
WaSan redeOinido Equals() S el operador de igualdad I==K para un cier7o 7ipo
por reOerenciaN 5e podr9n 5eguir reali8ando comparacione5 por reOerencia
El lenguaje de programación C# (ema ;L Cla5e5
en7re oMje7o5 de e5e 7ipo en 7an7o Rue redeOinir de Equals() no aOec7a a e57e
m67odo% Por ejemploN dada la an7erior redeOinición de Equals() para oMje7o5
PersonaL
Persona p = new Persona(“José”, 22, “83721654-W”);
Persona q = new Persona(“Antonio”, 23, “83721654-W”);
Console.WriteLine(p.Equals(q));
Console.WriteLine(Object.Equals(p, q));
Console.WriteLine(Object.ReferenceEquals(p, q));
Console.WriteLine(p == q);
La 5alida Rue por pan7alla mo57rar9 el código an7erior e5L
True
True
Galse
Galse
En lo5 primero5 ca5o5 5e deQuelQe true porRue 5egTn la redeOinición de
Equals() do5 per5ona5 5on iguale5 5i 7ienen el mi5mo #NIN como pa5a con lo5
oMje7o5 p S q% Sin emMargoN en lo5 Tl7imo5 ca5o5 5e deQuelQe faIse porRue
aunRue amMo5 oMje7o5 7ienen el mi5mo #NI cada uno 5e almacena en la
memoria din9mica en una po5ición di57in7aN Rue e5 lo Rue comparan
ReferenceEquals() S el operador == I657e Tl7imo 5ólo por deOec7oK
+olimorfismo
Concepto de poIimorfismo
El <.-7?.4@7;?. e5 o7ro de lo5 pilare5 Oundamen7ale5 de la programación orien7ada a
oMje7o5% E5 la capacidad de almacenar oMje7o5 de un de7erminado 7ipo en QariaMle5 de
7ipo5 an7ece5ore5 del primero a co57aN claro e579N de 5ólo poder5e acceder a 7raQ65 de
dicWa QariaMle a lo5 miemMro5 comune5 a amMo5 7ipo5% Sin emMargoN la5 Qer5ione5 de lo5
m67odo5 Qir7uale5 a la5 Rue 5e llamarVa a 7raQ65 de e5a5 QariaMle5 no 5erVan la5 deOinida5
como miemMro5 del 7ipo de dicWa5 QariaMle5N 5ino la5 deOinida5 en el Qerdadero 7ipo de
lo5 oMje7o5 Rue almacenan%

A con7inuación 5e mue57ra un ejemplo de cómo una QariaMle de 7ipo Persona puede
u5ar5e para almacenar oMje7o5 de 7ipo Trabajador% En e5o5 ca5o5 el campo Sueldo del
oMje7o reOerenciado por la QariaMle no 5er9 acce5iMleN S la Qer5ión del m67odo
Cumpleaños() a la Rue 5e podrVa llamar a 7raQ65 de la QariaMle de 7ipo Persona 5erVa la
deOinida en la cla5e TrabajadorN S no la deOinida en PersonaL
using System;
class Persona
{
public string Nombre; // Campo de cada objeto Persona que almacena su nombre
public int Edad; // Campo de cada objeto Persona que almacena su edad
public string NÌF; // Campo de cada objeto Persona que almacena su NÌF
public virtual void Cumpleaños() // Ìncrementa en uno la edad del objeto Persona
{
El lenguaje de programación C# (ema ;L Cla5e5
Console.WriteLine(“Ìncrementada edad de persona”);
}
public Persona (string nombre, int edad, string nif) // Constructor de Persona
{
Nombre = nombre;
Edad = edad;
NÌF = nif;
}
}
class Trabajador: Persona
{
int Sueldo; // Campo de cada objeto Trabajador que almacena cuánto gana
Trabajador(string nombre, int edad, string nif, int sueldo): base(nombre, edad, nif)
{ // Ìnicializamos cada Trabajador en base al constructor de Persona
Sueldo = sueldo;
}

public override Cumpleaños()
{
Edad++;
Console.WriteLine("Ìncrementada edad de trabajador");
}
public static void Main()
{
Persona p = new Trabajador("Josan", 22, "77588260-Z", 100000);
p.Cumpleaños();
// p.Sueldo++; //ERROR: Sueldo no es miembro de Persona
}
}
El men5aje mo57rado por pan7alla al ejecu7ar e57e m67odo conOirma lo an7e5 dicWo
re5pec7o a Rue la Qer5ión de Cumpleaños() a la Rue 5e llamaN Sa Rue e5L

;ncrementada edad de tra-a7ador
Métodos genéricos
El polimorOi5mo e5 muS T7il Sa Rue permi7e e5criMir m67odo5 gen6rico5 Rue puedan
reciMir par9me7ro5 Rue 5ean de un de7erminado 7ipo o de cualRuiera de 5u5 7ipo5 Wijo5%
E5 m95N en 7an7o Rue cómo 5e Qer9 en el epVgraOe 5iguien7eN en C# 7odo5 lo5 7ipo5
deriQan implVci7amen7e del 7ipo System.ObjectN podemo5 e5criMir m67odo5 Rue admi7an
par9me7ro5 de cualRuier 7ipo 5in m95 Rue deOinirlo5 como m67odo5 Rue 7omen
par9me7ro5 de 7ipo System.Object% Por ejemploL
public void MétodoGenérico(object o)
{
// Código del método
}
El lenguaje de programación C# (ema ;L Cla5e5
Nó7e5e Rue en Qe8 de System.Object 5e Wa e5cri7o objectN Rue e5 el nomMre aMreQiado
incluido en C# para Wacer reOerencia de manera compac7a a un 7ipo 7an Orecuen7emen7e
u5ado como System.Object%
Determinación de tipo. Operador is
#en7ro de una ru7ina polimóriOica RueN como la del ejemplo an7eriorN admi7a par9me7ro5
Rue puedan 5er de cualRuier 7ipoN mucWa5 Qece5 e5 conQenien7e poder con5ul7ar en el
código de la mi5ma cu9l e5 el 7ipo en concre7o del par9me7ro Rue 5e WaSa pa5ado al
m67odo en cada llamada al mi5mo% Para ello C# oOrece el operador isN cuSa Oorma
5in7aUi5 de u5o e5L
<expresión> is <nombreTipo>
E57e operador deQuelQe true en ca5o de Rue el re5ul7ado de eQaluar :e$5resiBn= 5ea del
7ipo cuSo nomMre e5 <nombreTipo> S faIse en ca5o con7rario
'
% 1racia5 a ella5 podemo5
e5criMir m67odo5 gen6rico5 Rue puedan de7erminar cu9l e5 el 7ipo Rue 7ienen lo5
par9me7ro5 Rue en cada llamada en concre7o 5e le5 pa5en% 5eaN m67odo5 comoL
public void MétodoGenérico(object o)
{
if (o is int) // Si o es de tipo int (entero)...
// ...Código a ejecutar si el objeto o es de tipo int
else if (o is string) // Si no, si o es de tipo string (cadena)...
// ...Código a ejecutar si o es de tipo string
//... Ídem para otros tipos
}
El MloRue if...eIse e5 una in57rucción condicional Rue permi7e ejecu7ar un código u o7ro
en Ounción de 5i la condición indicada en7re par6n7e5i5 7ra5 el if e5 cier7a ItrueK o no
IfaIseK E57a in57rucción 5e eUplicar9 m95 de7alladamen7e en el Tema %2: "nstr#$$iones
Acceso a Ia cIase base
HaS de7erminada5 circun57ancia5 en la5 Rue cuando redeOinamo5 un de7erminado
m67odo no5 in7ere5e poder acceder al código de la Qer5ión original% Por ejemploN porRue
el código redeOinido Rue QaSamo5 a e5criMir Waga lo mi5mo Rue el original S adem95
alguna5 co5a5 eU7ra5% En e57o5 ca5o5 5e podrVa pen5ar Rue una Oorma de con5eguir e57o
5erVa conQir7iendo el oMje7o ac7ual al 7ipo del m67odo a redeOinir S en7once5 llamar a5V a
e5e m67odoN como por ejemplo en el 5iguien7e códigoL
using System;
class A
{
public virtual void F()
{
Console.WriteLine(“A”);
}
}
'
Si la eUpre5ión Qale nuII 5e deQolQer9 faIseN pue5 e57e Qalor no e579 a5ociado a ningTn 7ipo en concre7o%
El lenguaje de programación C# (ema ;L Cla5e5
class B:A
{
public override void F()
{
Console.WriteLine(“Antes”);
((A) this).F(); // (2)
Console.WriteLine(“Después”);
}
public static void Main()
{
B b = new B();
b.F();
}
Z
Pue5 MienN 5i ejecu7amo5 el código an7erior Qeremo5 Rue la aplicación nunca 7ermina de
ejecu7ar5e S e579 con57an7emen7e mo57rando el men5aje Antes por pan7alla% E57o 5e deMe
a Rue deMido al polimorOi5mo 5e Wa en7rado en un Mucle inOini7oL aunRue u5emo5 el
operador de conQer5ión para 7ra7ar el oMje7o como 5i Oue5e de 7ipo AN 5u Qerdadero 7ipo
5igue 5iendo BN por lo Rue la Qer5ión de F() a la Rue 5e llamar9 en (2) e5 a la de B de
nuevoN Rue QolQer9 a llamar5e a5V mi5ma una S o7ra Qe8 de manera indeOinida%
Para 5olucionar e57oN lo5 di5eXadore5 de C# Wan incluido una palaMra re5erQada llamada
base Rue deQuelQe una reOerencia al oMje7o ac7ual 5emejan7e a this pero con la
peculiaridad de Rue lo5 acce5o5 a ella 5on 7ra7ado5 como 5i el Qerdadero 7ipo Oue5e el de
5u cla5e Ma5e% "5ando baseN podrVamo5 reempla8ar el código de la redeOinición de F() de
ejemplo an7erior porL

public override void F()
{
Console.WriteLine(“Antes”);
base.F();
Console.WriteLine(“Después”);
}
Si aWora ejecu7amo5 el programa Qeremo5 Rue aWora 5V Rue la Qer5ión de F() en B llama a
la Qer5ión de F() en AN re5ul7ando la 5iguien7e 5alida por pan7allaL
Antes
A
Después
A la Wora de redeOinir m67odo5 aM57rac7o5 WaS Rue 7ener cuidado con una co5aL de5de el
m67odo redeOinidor no e5 po5iMle u5ar base para Wacer reOerencia a m67odo5 aM57rac7o5
de la cla5e padreN aunRue 5V para Wacer reOerencia a lo5 no aM57rac7o5% Por ejemploL
abstract class A
{
public abstract void F();
public void G()
{}
}
class B: A
El lenguaje de programación C# (ema ;L Cla5e5
{
public override void F()
{
base.G(); // Correcto
base.F(); // Error, base.F() es abstracto
}
}
Downcasting
#ado Rue una QariaMle de un de7erminado 7ipo puede e57ar en realidad almacenando un
oMje7o Rue 5ea de algTn 7ipo Wijo del 7ipo de la QariaMle S en e5e ca5o a 7raQ65 de la
QariaMle 5ólo puede acceder5e a aRuello5 miemMro5 del Qerdadero 7ipo del oMje7o Rue
5ean comune5 con miemMro5 del 7ipo de la QariaMle Rue reOerencia al oMje7oN mucWa5
Qece5 no5 Qa a in7ere5ar Rue una Qe8 Rue den7ro de un m67odo gen6rico WaSamo5
de7erminado cu9l e5 el Qerdadero 7ipo de un oMje7o Ipor ejemploN con el operador isK
podamo5 7ra7arlo como 7al% En e57o5 ca5o5 lo Rue WaS e5 Rue Wacer una conQer5ión del
7ipo padre al Qerdadero 7ipo del oMje7oN S a e57o 5e le llama 5.D269;372=
Para reali8ar un doYnca57ing una primera po5iMilidad e5 indicar preceder la eUpre5ión a
conQer7ir del 7ipo en el Rue 5e la de5ea conQer7ir indicado en7re par6n7e5i5% E5 decirN
5iguiendo la 5iguien7e 5in7aUi5L
(<tipoDestino>) <expresiónAConvertir>
El re5ul7ado de e57e 7ipo de eUpre5ión e5 el oMje7o re5ul7an7e de conQer7ir el re5ul7ado de
<expresiónAConvertir> a <tipoDestino>% En ca5o de Rue la conQer5ión no 5e pudie5e
reali8ar 5e lan8arVa una eUcepción del 7ipo predeOinido System.InvaIidCastException
7ra Oorma de reali8ar el doYnca57ing e5 u5ando el operador asN Rue 5e u5a a5VL
<expresiónAConvertir> as <tipoDestino>
La principal diOerencia de e57e operador con el an7erior e5 Rue 5i aWora la conQer5ión no
5e pudie5e reali8ar 5e deQolQerVa nuII en lugar de lan8ar5e una eUcepción% La o7ra
diOerencia e5 Rue as 5ólo e5 aplicaMle a 7ipo5 reOerencia S 5ólo a conQer5ione5 en7re 7ipo5
de una mi5ma jerarRuVa Ide padre5 a Wijo5 o QiceQer5aK
Lo5 errore5 al reali8ar conQer5ione5 de e57e 7ipo en m67odo5 gen6rico5 5e producen
cuando el Qalor pa5ado a la QariaMle gen6rica no e5 ni del 7ipo indicado en <tipoDestino>
ni eUi57e ninguna deOinición de cómo reali8ar la conQer5ión a e5e 7ipo Icómo deOinirla 5e
Qer9 en el Tema %%: 1ede0ini$i)n de o!eradoresK
CIases y métodos seIIados
"na 6-9;1 ;1--959 e5 una cla5e Rue no puede 7ener cla5e5 Wija5N S para deOinirla Ma57a
an7eponer el modiOicador seaIed a la deOinición de una cla5e normal% Por ejemploL
sealed class ClaseSellada
El lenguaje de programación C# (ema ;L Cla5e5
{
}
"na u7ilidad de deOinir una cla5e como 5ellada e5 Rue permi7e Rue la5 llamada5 a 5u5
m67odo5 Qir7uale5 Weredado5 5e realicen 7an eOicien7emen7e como 5i Oue5en no Qir7uale5N
pue5 al no poder eUi57ir cla5e5 Wija5 Rue lo5 redeOinan no puede WaMer polimorOi5mo S no
WaS Rue de7erminar cu9l e5 la Qer5ión correc7a del m67odo a la Rue 5e Wa de llamar%
Nó7e5e Rue 5e Wa dicWo m67odo5 Qir7uale5 Weredado5N pue5 lo Rue no 5e permi7e e5
deOinir miemMro5 Qir7uale5 den7ro de e57e 7ipo de cla5e5N Sa Rue al no poder5e Weredar5e
de ella5 e5 algo 5in 5en7ido en 7an7o Rue nunca podrVan redeOinir5e%
AWora MienN WaS Rue 7ener en cuen7a Rue 5ellar reduce enormemen7e 5u capacidad de
reu7ili8aciónN S e5o e5 algo Rue el aumen7o de eOiciencia oM7enido en la5 llamada5 a 5u5
m67odo5 Qir7uale5 no 5uele compen5ar% En realidad la principal cau5a de la inclu5ión de
e57a5 cla5e5 en C# e5 Rue permi7en a5egurar Rue cier7a5 cla5e5 crV7ica5 nunca podr9n
7ener cla5e5 Wija5 S 5u5 QariaMle5 5iempre almacenar9n oMje7o5 del mi5mo 7ipo% Por
ejemploN para 5impliOicar el Ouncionamien7o del CL) S lo5 compiladore5 5e Wa op7ado
por Wacer Rue 7odo5 lo5 7ipo5 de da7o5 M95ico5 eUcep7o System.Object e576n 5ellado5%
(6nga5e en cuen7a Rue e5 aM5urdo deOinir 5imul79neamen7e una cla5e como abstract S
seaIedN pue5 nunca podrVa acceder5e a la mi5ma al no poder5e crear cla5e5 Wija5 5uSa5
Rue deOinan 5u5 m67odo5 aM57rac7o5% Por e57a ra8ónN el compilador con5idera erróneo
deOinir una cla5e con amMo5 modiOicadore5 a la Qe8%
Apar7e de para 5ellar cla5e5N 7amMi6n 5e puede u5ar seaIed como modiOicador en la
redeOinición de un m67odo para con5eguir Rue la nueQa Qer5ión del mi5mo Rue 5e deOina
deje de 5er Qir7ual S 5e le puedan aplicar la5 op7imi8acione5 arriMa comen7ada5% "n
ejemplo de e57o e5 el 5iguien7eL
class A
{
public abstract F();
}
class B:A
{
public sealed override F() // F() deja de ser redefinible
{}
}
%cultación de miembros
HaS oca5ione5 en la5 Rue puede re5ul7ar in7ere5an7e u5ar la Werencia Tnicamen7e como
mecani5mo de reu7ili8ación de código pero no nece5ariamen7e para reu7ili8ar miemMro5%
E5 decirN puede Rue in7ere5e Weredar de una cla5e 5in Rue ello impliRue Rue 5u cla5e Wija
Werede 5u5 miemMro5 7al cuale5 5ino con ligera5 modiOicacione5%
E57o puede muS T7il al u5ar la Werencia para deOinir Qer5ione5 e5peciali8ada5 de cla5e5 de
u5o gen6rico% Por ejemploN lo5 oMje7o5 de la cla5e System.CoIIections.ArrayList incluida
en la BCL pueden almacenar cualRuier nTmero de oMje7o5 System.ObjectN Rue al 5er la
cla5e primigenia ello 5igniOica Rue pueden almacenar oMje7o5 de cualRuier 7ipo% Sin
El lenguaje de programación C# (ema ;L Cla5e5
emMargoN al recuperarlo5 de e57e almac6n gen6rico 5e 7iene el proMlema de Rue lo5
m67odo5 Rue para ello 5e oOrecen deQuelQen oMje7o5 System.ObjectN lo Rue implicar9 Rue
mucWa5 Qece5 WaSa luego Rue reconQer7irlo5 a 5u 7ipo original median7e doYnca57ing
para poder a5V u5ar 5u5 m67odo5 e5pecVOico5% En 5u lugarN 5i 5ólo 5e Qa a u5ar un
ArrayList para almacenar oMje7o5 de un cier7o 7ipo puede re5ul7ar m95 cómodo u5ar un
oMje7o de alguna cla5e deriQada de ArrayList cuSo m67odo eU7rac7or de oMje7o5 ocul7e al
Weredado de ArrayList S deQuelQa direc7amen7e oMje7o5 de e5e 7ipo%
Para Qer m95 claramen7e cómo Wacer la ocul7aciónN Qamo5 a 7omar el 5iguien7e ejemplo
donde 5e deriQa de una cla5e con un m67odo void F() pero 5e de5ea Rue en la cla5e Wija el
m67odo Rue 5e 7enga 5ea de la Oorma int F()L
class Padre
{
public void F()
{}
}
class Hija:Padre
{
public int F()
{return 1;}
}
Como en C# no 5e admi7e Rue en una mi5ma cla5e WaSan do5 m67odo5 Rue 5ólo 5e
diOerencien en 5u5 Qalore5 de re7ornoN puede pen5ar5e Rue el código an7erior producir9
un error de compilación% Sin emMargoN e57o no e5 a5V 5ino Rue el compilador lo Rue War9
5er9 Ruedar5e Tnicamen7e con la Qer5ión deOinida en la cla5e Wija S de5ecWar la Weredada
de la cla5e padre% A e57o 5e le conoce como .60-396782 51 ?71?C4. Sa Rue Wace
de5paracer en la cla5e Wija el miemMro WeredadoN S cuando al compilar 5e de7ec7e 5e
generar9 el 5iguien7e de aQi5o I5e 5upone Rue clases.cs almacena el código an7eriorKL
clases.cs(F#C5%+ ,arning CSCI+ TJe Key,ord ne, is reLuired on
MHi7a.G(%M -ecause it Jides inJerited mem-er M4adre.G(%M

Como generalmen7e cuando 5e Wereda in7ere5a Rue la cla5e Wija compar7a lo5 mi5mo5
miemMro5 Rue la cla5e padre IS 5i aca5o Rue aXada miemMro5 eU7raKN el compilador
emi7e el aQi5o an7erior para indicar Rue no 5e e579 Waciendo lo WaMi7ual% Si Rueremo5
eQi7arlo Wemo5 de preceder la deOinición del m67odo ocul7ador de la palaMra re5erQada
new para a5V indicar eUplVci7amen7e Rue Rueremo5 ocul7ar el F() WeredadoL
class Padre
{
public void F()
{}
}
class Hija:Padre
{
new public int F()
{return 1;}
}
En realidad la ocul7ación de miemMro5 no implica lo5 miemMro5 ocul7ado5 7engan Rue
5er m67odo5N 5ino Rue 7amMi6n pueden 5er campo5 o cualRuiera de lo5 dem95 7ipo5 de
El lenguaje de programación C# (ema ;L Cla5e5
miemMro Rue en 7ema5 po57eriore5 5e Qer9n% Por ejemploN puede Rue 5e de5ee Rue un
campo X de 7ipo int e576 di5poniMle en la cla5e Wija como 5i Oue5e de 7ipo string%
(ampoco implica Rue lo5 miemMro5 m67odo5 ocul7ado5 7engan Rue diOerenciar5e de lo5
m67odo5 ocul7adore5 en 5u 7ipo de re7ornoN 5ino Rue pueden 7ener eUac7amen7e 5u mi5mo
7ipo de re7ornoN par9me7ro5 S nomMre% Hacer e57o puede dar lugar a errore5 muS 5u7ile5
como el incluido en la 5iguien7e Qarian7e de la cla5e Trabajador donde en Qe8 de
redeOinir5e Cumpleaños() lo Rue 5e Wace e5 ocul7arlo al olQidar incluir el overrideL

using System;
class Persona
{
public string Nombre; // Campo de cada objeto Persona que almacena su nombre
public int Edad; // Campo de cada objeto Persona que almacena su edad
public string NÌF; // Campo de cada objeto Persona que almacena su NÌF
public virtual void Cumpleaños() // Ìncrementa en uno la edad del objeto Persona
{
Console.WriteLine(“Ìncrementada edad de persona”);
}
public Persona (string nombre, int edad, string nif) // Constructor de Persona
{
Nombre = nombre;
Edad = edad;
NÌF = nif;
}
}
class Trabajador: Persona
{
int Sueldo; // Campo de cada objeto Trabajador que almacena cuánto gana
Trabajador(string nombre, int edad, string nif, int sueldo): base(nombre, edad, nif)
{ // Ìnicializamos cada Trabajador en base al constructor de Persona
Sueldo = sueldo;
}

public Cumpleaños()
{
Edad++;
Console.WriteLine("Ìncrementada edad de trabajador");
}
public static void Main()
{
Persona p = new Trabajador("Josan", 22, "77588260-Z", 100000);
p.Cumpleaños();
// p.Sueldo++; //ERROR: Sueldo no es miembro de Persona
}
}
Al no incluir5e override 5e Wa perdido la capacidad de polimorOi5moN S ello puede Qer5e
en Rue la 5alida Rue aWora mo57rara por pan7alla el códigoL

El lenguaje de programación C# (ema ;L Cla5e5
;ncrementada edad de 5ersona
Errore5 de e57e 7ipo 5on muS 5u7ile5 S podrVan 5er diOVcile5 de de7ec7ar% Sin emMargoN en
C# e5 O9cil Wacerlo gracia5 a Rue el compilador emi7ir9 el men5aje de aQi5o Sa Qi57o por
WaMer WecWo la ocul7ación 5in new% Cuando el programador lo Qea podr9 aXadir new para
5uprimirlo 5i realmen7e lo Rue RuerVa Wacer era ocul7arN pero 5i e5a no era 5u in7ención
a5V 5aMr9 Rue 7iene Rue corregir el código Ipor ejemploN aXadiendo el override olQidadoK
Como 5u propio nomMre indicaN cuando 5e redeOine un m67odo 5e camMia 5u deOinición
original S por ello la5 llamada5 al mi5mo ejecu7aran dicWa Qer5ión aunRue 5e Wagan a
7raQ65 de QariaMle5 de la cla5e padre Rue almacenen oMje7o5 de la cla5e Wija donde 5e
redeOinió% Sin emMargoN cuando 5e ocul7a un m67odo no 5e camMia 5u deOinición en la
cla5e padre 5ino 5ólo en la cla5e WijaN por lo Rue la5 llamada5 al mi5mo reali8ada5 a
7raQ65 de QariaMle5 de la cla5e padre ejecu7ar9n la Qer5ión de dicWa cla5e padre S la5
reali8ada5 median7e QariaMle5 de la cla5e Wija ejecu7ar9n la Qer5ión de la cla5e Wija%
En realidad el polimorOi5mo S la ocul7ación no 5on concep7o5 7o7almen7e an7agónico5N S
aunRue no e5 Q9lido deOinir m67odo5 Rue 5imul79neamen7e 7engan lo5 modiOicadore5
override S new Sa Rue un m67odo ocul7ador e5 como 5i Oue5e la primera Qer5ión Rue 5e
Wace del mi5mo Iluego no puede redeOinir5e algo no deOinidoKN 5V Rue e5 po5iMle
comMinar new S virtual para deOinir m67odo5 ocul7adore5 redeOiniMle5% Por ejemploL
using System;
class A
{
public virtual void F() { Console.WriteLine("A.F"); }
}
class B: A
{
public override void F() { Console.WriteLine("B.F"); }
}
class C: B
{
new public virtual void F() { Console.WriteLine("C.F"); }
}
class D: C
{
public override void F() { Console.WriteLine("D.F"); }
}
class Ocultación
{
public static void Main()
{
A a = new D();
B b = new D();
C c = new D();
D d = new D();
a.F();
b.F();
c.F();
d.F();
}
}
El lenguaje de programación C# (ema ;L Cla5e5
La 5alida por pan7alla de e57e programa e5L
1.G
1.G
9.G
9.G
AunRue el Qerdadero 7ipo de lo5 oMje7o5 a cuSo m67odo 5e llama en Main() e5 DN en la5
do5 primera5 llamada5 5e llama al F() de B% E57o 5e deMe a Rue la redeOinición dada en B
camMia la Qer5ión de F() en A por la 5uSa propiaN pero la ocul7ación dada en C Wace Rue
para la redeOinición Rue po57eriormen7e 5e da en D 5e con5idere Rue la Qer5ión original
de F() e5 la dada en C S ello proQoca Rue no modiOiRue la Qer5ione5 de dicWo m67odo
dada5 en A S B IRueN por la redeOinición dada en BN en amMo5 ca5o5 5on la Qer5ión de BK

"n 7ruco mnemo76cnico Rue puede 5er T7il para de7erminar a Ru6 Qer5ión del m67odo 5e
llamar9 en ca5o5 complejo5 como el an7erior con5i57e en con5iderar Rue el mecani5mo
de polimorOi5mo Ounciona como 5i Mu5ca5e el Qerdadero 7ipo del oMje7o a cuSo m67odo
5e llama de5cendiendo en la jerarRuVa de 7ipo5 de5de el 7ipo de la QariaMle 5oMre la Rue
5e aplica el m67odo S de manera Rue 5i duran7e dicWo recorrido 5e llega a alguna Qer5ión
del m67odo con new 5e para la MT5Rueda S 5e Rueda con la Qer5ión del mi5mo incluida
en el 7ipo recorrido ju57o an7e5 del Rue 7enVa el m67odo ocul7ador%

HaS Rue 7ener en cuen7a Rue el grado de ocul7ación Rue proporcione new depende del
niQel de acce5iMilidad del m67odo ocul7adorN de modo Rue 5i e5 priQado 5ólo ocul7ar9
den7ro de la cla5e donde e576 deOinido% Por ejemploN dadoL
using System;
class A
{
public virtual void F() // F() es un método redefinible
{
Console.WriteLine(“F() de A”);
}
}
class B: A
{
new private void F() {} // Oculta la versión de F() de A sólo dentro de B
}
class C: B
{
public override void F() // Válido, pues aquí sólo se ve el F() de A
{
base.F();
Console.WriteLine(“F() de B”);
}
public static void Main()
{
C obj = new C();
obj.F();
}
}
El lenguaje de programación C# (ema ;L Cla5e5
La 5alida de e57e programa por pan7alla 5er9L
G(% de .
G(% de 1
Pe5e a 7odo lo comen7adoN WaS Rue re5al7ar Rue la principal u7ilidad de poder indicar
eUplVci7amen7e 5i 5e de5ea redeOinir u ocul7ar cada miemMro e5 Rue Oacili7a enormemen7e
la re5olución de proMlema5 de A14;7.295. 51 37<.; Rue puedan 5urgir 5i al deriQar una
nueQa cla5e de o7ra S aXadirle miemMro5 adicionale5N po57eriormen7e 5e la de5ea
ac7uali8ar con una nueQa Qer5ión de 5u cla5e padre pero 657a con7iene miemMro5 Rue
en7ran en conOlic7o5 con lo5 aXadido5 preQiamen7e a la cla5e Wija cuando aTn no eUi57Van
en la cla5e padre% En lenguaje5 donde implVci7amen7e 7odo5 lo5 miemMro5 5on Qir7uale5N
como 4aQaN e57o da lugar a proMlema5 muS graQe5 deMido5 5oMre 7odo aL
• Gue por 5u5 nomMre5 lo5 nueQo5 miemMro5 de la cla5e padre en7re en conOlic7o5 con
lo5 aXadido5 a la cla5e Wija cuando no eUi57Van% Por ejemploN 5i la Qer5ión inicial de
de la cla5e padre no con7iene ningTn m67odo de nomMre F()N a la cla5e Wija 5e le
aXade void F() S luego en la nueQa Qer5ión de la cla5e padre 5e incorporado int F()N 5e
producir9 un error por 7ener5e en la cla5e Wija do5 m67odo5 F()
En 4aQa para re5olQer e57e proMlema una po5iMilidad 5erVa pedir al creador de la cla5e
padre Rue camMia5e el nomMre o par9me7ro5 de 5u m67odoN lo cual no e5 5iempre
po5iMle ni conQenien7e en 7an7o Rue ello podrVa 7ra5ladar el proMlema a Rue WuMie5en
deriQado de dicWa cla5e an7e5 de QolQerla a modiOicar% 7ra po5iMilidad 5erVa
modiOicar el nomMre o par9me7ro5 del m67odo en la cla5e WijaN lo Rue nueQamen7e
puede lleQar a incompa7iMilidade5 5i 7amMi6n 5e WuMie5e deriQado de dicWa cla5e Wija%
• Gue lo5 nueQo5 miemMro5 7engan lo5 mi5mo5 nomMre5 S 7ipo5 de par9me7ro5 Rue lo5
incluido5 en la5 cla5e5 Wija5 S 5ea oMliga7orio Rue 7oda redeOinición Rue 5e Waga de
ello5 5iga un cier7o e5Ruema%
E57o e5 muS proMlem97ico en lenguaje5 como 4aQa donde 7oda deOinición de m67odo
con igual nomMre S par9me7ro5 Rue alguno de 5u cla5e padre e5 con5iderado
implVci7amen7e redeOinición de 657eN Sa Rue diOVcilmen7e en una cla5e Wija e5cri7a con
an7erioridad a la nueQa Qer5ión de la cla5e padre 5e WaMr9 5eguido el e5Ruema
nece5ario% Por elloN para re5olQerlo WaMr9 Rue ac7uali8ar la cla5e Wija para Rue lo 5iga
S de 7al manera Rue lo5 camMio5 Rue 5e le Wagan no aOec7en a 5u5 5uMcla5e5N lo Rue
ello puede 5er m95 o meno5 diOVcil 5egTn la5 carac7erV57ica5 del e5Ruema a 5eguir%
7ra po5iMilidad 5erVa 5ellar el m67odo en la cla5e WijaN pero ello recor7a la capacidad
de reu7ili8ación de dicWa cla5e S 5ólo 7iene 5en7ido 5i no Oue redeOinido en ninguna
5uMcla5e 5uSa%
En C# 7odo5 e57o5 proMlema5 5on de O9cil 5olución Sa Rue pueden re5olQer5e con 5ólo
ocul7ar lo5 nueQo5 miemMro5 en la cla5e Wija S 5eguir 7raMajando como 5i no eUi57ie5en%
Miembros de tipo
En realidadN den7ro la deOinición de un 7ipo de da7o no 7ienen porRu6 incluir5e 5ólo
deOinicione5 de miemMro5 comune5 a 7odo5 5u5 oMje7o5N 5ino 7amMi6n pueden deOinir5e
El lenguaje de programación C# (ema ;L Cla5e5
miemMro5 ligado5 al 7ipo como 7al S no a lo5 oMje7o5 del mi5mo% Para ello Ma57a preceder
la deOinición de e5e miemMro de la palaMra re5erQada staticN como mue57ra e57e ejemploL
class A
{
int x;
static int y;
}
Lo5 oMje7o5 de cla5e A 5ólo Qan a di5poner del campo xN mien7ra5 Rue el campo y Qa a
per7enecer a la cla5e A% Por e57a ra8ón 5e dice Rue lo5 miemMro5 con modiOicador static
5on ?71?C4.; 51 37<. S Rue lo5 no lo 7ienen 5on ?71?C4.; 51 .C>13.%
Para acceder a un miemMro de cla5e Sa no e5 Q9lida la 5in7aUi5 Wa57a aWora Qi57a de
<objeto>.<miembro>N pue5 al no e57ar e57o5 miemMro5 ligado5 a ningTn oMje7o no podrVa
poner5e nada en el campo <objeto>% La 5in7aUi5 a u5ar para acceder a e57o5 miemMro5
5er9 <nombreClase>.<miembro>N como mue57ra ejemplo donde 5e a5igna el Qalor & al
miemMro y de la cla5e A deOinida m95 arriMaL
A.y = 2;
Nó7e5e Rue la inclu5ión de miemMro5 de cla5e rompe con la aOirmación indicada al
principio del 7ema en la Rue 5e decVa Rue C# e5 un lenguaje orien7ado a oMje7o5 puro en
el Rue 7odo con lo Rue 5e 7raMaja 5on oMje7o5N Sa Rue a lo5 miemMro5 de 7ipo no 5e le5
accede a 7raQ65 de oMje7o5 5ino nomMre5 de 7ipo5%
E5 impor7an7e ma7i8ar Rue 5i deOinimo5 una Ounción como staticN en7once5 el código de
la mi5ma 5ólo podr9 acceder implVci7amen7e I5in 5in7aUi5 <objeto>.<miembro>K a o7ro5
miemMro5 static del 7ipo de da7o al Rue per7ene8ca% 5eaN no 5e podr9 acceder a ni a lo5
miemMro5 de oMje7o del 7ipo en Rue e576 deOinido ni 5e podr9 u5ar this Sa Rue el m67odo
no e579 a5ociado a ningTn oMje7o% 5eaN e57e código 5erVa inQ9lidoL
int x;
static void Ìncrementa()
{
x++; //ERROR: x es miembro de objeto e Ìncrementa() lo es de clase.
}
(amMi6n WaS Rue 5eXalar Rue lo5 m67odo5 e5797ico5 no en7ran den7ro del mecani5mo de
redeOinicione5 de5cri7o en e57e mi5mo 7ema% #icWo mecani5mo 5ólo e5 aplicaMle a
m67odo5 de oMje7o5N Rue 5on de Ruiene5 puede declarar5e QariaMle5 S por 7an7o puede
ac7uar el polimorOi5mo% Por elloN incluir lo5 modiOicadore5 virtuaIN override o abstract al
deOinir un m67odo static e5 con5iderado erróneo por el compilador% E5o no 5igniOica Rue
lo5 miemMro5 static no 5e WeredenN 5ino 7an 5ólo Rue no 7iene 5en7ido redeOinirlo5%
Encapsulación
2a Wemo5 Qi57o Rue la Werencia S el polimorOi5mo eran do5 de lo5 pilare5 Oundamen7ale5
en lo5 Rue e5 apoSa la programación orien7ada a oMje7o5% Pue5 MienN el 7ercero S Tl7imo
e5 la 1269<;0-96782N Rue e5 un mecani5mo Rue permi7e a lo5 di5eXadore5 de 7ipo5 de
El lenguaje de programación C# (ema ;L Cla5e5
da7o5 de7erminar Ru6 miemMro5 de lo5 7ipo5 creen pueden 5er u7ili8ado5 por o7ro5
programadore5 S cu9le5 no% La5 principale5 Qen7aja5 Rue ello apor7a 5onL
• Se Oacili7a a lo5 programadore5 Rue QaSa a u5ar el 7ipo de da7o Iprogramadore5
clien7e5K el aprendi8aje de cómo 7raMajar con 6lN pue5 5e le pueden ocul7ar 7odo5 lo5
de7alle5 rela7iQo5 a 5u implemen7ación in7erna S 5ólo dejarle Qi5iMle5 aRuello5 Rue
puedan u5ar con 5eguridad% Adem95N a5V 5e le5 eQi7a Rue come7an errore5 por
manipular inadecuadamen7e miemMro5 Rue no deMerVan 7ocar%
• Se Oacili7a al creador del 7ipo la po57erior modiOicación del mi5moN pue5 5i lo5
programadore5 clien7e5 no pueden acceder a lo5 miemMro5 no Qi5iMle5N 5u5
aplicacione5 no 5e Qer9n aOec7ada5 5i 657o5 camMian o 5e eliminan% 1racia5 a e57o e5
po5iMle crear inicialmen7e 7ipo5 de da7o5 con un di5eXo 5encillo aunRue poco
eOicien7eN S 5i po57eriormen7e e5 nece5ario modiOicarlo5 para aumen7ar 5u eOicienciaN
ello puede Wacer5e 5in aOec7ar al código e5cri7o en Ma5e a la no mejorada de 7ipo%
La encap5ulación 5e con5igue aXadiendo ?.57@7695.41; 51 9661;. en la5 deOinicione5
de miemMro5 S 7ipo5 de da7o5% E57o5 modiOicadore5 5on par7Vcula5 Rue 5e le5 colocan
delan7e para indicar de5de Ru6 código5 puede acceder5e a ello5N en7endi6ndo5e por
acceder el WecWo de u5ar 5u nomMre para cualRuier co5a Rue no 5ea deOinirloN como
llamarlo 5i e5 una OunciónN leer o e5criMir 5u Qalor 5i e5 un campoN crear oMje7o5 o
Weredar de 6l 5i e5 una cla5eN e7c%
Por deOec7o 5e con5idera Rue lo5 miemMro5 de un 7ipo de da7o 5ólo 5on acce5iMle5 de5de
código 5i7uado den7ro de la deOinición del mi5moN aunRue e57o puede camMiar5e
precedi6ndolo5 de uno lo5 5iguien7e5 modiOicadore5 IaunRue alguno5 de ello5 Sa 5e Wan
eUplicado a lo largo del 7emaN aRuV 5e recogen 7odo5 de manera de7alladaK al deOinirlo5L
public : Puede 5er accedido de5de cualRuier código%
protected : #e5de una cla5e 5ólo puede acceder5e a miemMro5 protected de
oMje7o5 de e5a mi5ma cla5e o de 5uMcla5e5 5uSa5% A5VN en el 5iguien7e código la5
in57ruccione5 comen7ada5 con ^^ Error no 5on Q9lida5 por lo e5cri7o jun7o a ella5L
public class A
{
protected int x;
static void F(A a, B b, C c)
{
a.x = 1; // Ok
b.x = 1; // Ok
c.x = 1; // OK
}
}
public class B: A
{
static void F(A a, B b, C c)
{
//a.x = 1; // Error, ha de accederse a traves de objetos tipo B o C
b.x = 1; // Ok
c.x = 1; // Ok
}
}
El lenguaje de programación C# (ema ;L Cla5e5
public class C: B
{
static void F(A a, B b, C c)
{
//a.x = 1; // Error, ha de accederse a traves de objetos tipo C
//b.x = 1; // Error, ha de accederse a traves de objetos tipo C
c.x = 1; // Ok
}
}
MQiamen7e 5iempre Rue 5e Werede de una cla5e 5e 7endr9 7o7al acce5o en la cla5e
Wija de implVci7amen7e 5in nece5idad de u5ar la 5in7aUi5 <objeto>.<miembro>- a lo5
miemMro5 Rue 657a Werede de 5u cla5e padreN como mue57ra el 5iguien7e ejemploL
using System;
class A
{
protected int x=5;
}
class B:A
{
B()
{
Console.WriteLine(“Heredado x={0} de clase A”, x);
}
public static void Main()
{
new B();
}
}
Como e5 de e5perarN la 5alida por pan7alla del programa de ejemplo 5er9L
Heredado $N5 de clase .
A lo Rue no 5e podr9 acceder de5de una cla5e Wija e5 a lo5 miemMro5 pro7egido5
de o7ro5 oMje7o5 de 5u cla5e padreN 5ino 5ólo a lo5 Weredado5% E5 decirL
using System;
class A
{
protected int x=5;
}
class B:A
{
B(A objeto)
{
Console.WriteLine(“Heredado x={0} de clase A”, x);
Console.WriteLine(objeto.x); // Error, no es el x heredado
}
public static void Main()
El lenguaje de programación C# (ema ;L Cla5e5
{
new B(new A());
}
}
private : Sólo puede 5er accedido de5de el código de la cla5e a la Rue per7enece%
E5 lo con5iderado por deOec7o%
internal : Sólo puede 5er accedido de5de código per7enecien7e al en5amMlado
en Rue 5e Wa deOinido%
protected internal : Sólo puede 5er accedido de5de código per7enecien7e al
en5amMlado en Rue 5e Wa deOinido o de5de cla5e5 Rue deriQen de la cla5e donde
5e Wa deOinido%
Si 5e duda 5oMre el modiOicador de Qi5iMilidad a poner a un miemMroN e5 mejor ponerle
inicialmen7e el Rue proporcione meno5 permi5o5 de acce5o5N Sa Rue 5i luego de7ec7a Rue
nece5i7a darle m95 permi5o5 5iempre podr9 camMi9r5elo por o7ro meno5 re57ringido% Sin
emMargoN 5i 5e le da uno m95 permi5iQo de lo nece5ario S luego 5e nece5i7a camMiar por
o7ro meno5 permi5iQoN lo5 código5 Rue e5cri7o en Ma5e a la Qer5ión m95 permi5iQa Rue
dependie5en de dicWo miemMro podrVan dejar de Ouncionar por Ruedar5e 5in acce5o a 6l%
E5 impor7an7e recordar Rue 7oda redeOinición de un m67odo Qir7ual o aM57rac7o Wa de
reali8ar5e man7eniendo lo5 mi5mo5 modiOicadore5 Rue 7uQie5e el m67odo original% E5
decirN no podemo5 redeOinir un m67odo pro7egido camMiando 5u acce5iMilidad por
pTMlicaN pue5 5i el creador de la cla5e Ma5e lo deOinió a5V por algo 5erVa%
)e5pec7o a lo5 7ipo5 de da7o5N por deOec7o 5e con5idera Rue 5on acce5iMle5 5ólo de5de el
mi5mo en5amMlado en Rue Wa 5ido deOinido5N aunRue 7amMi6n e5 po5iMle modiOicar e57a
con5ideración an7eponiendo uno de lo5 5iguien7e5 modiOicadore5 a 5u deOiniciónL
public : E5 po5iMle acceder a la cla5e de5de cualRuier en5amMlado%
internal : Sólo e5 po5iMle acceder a la cla5e de5de el en5amMlado donde 5e
declaró% E5 lo con5iderado por deOec7o%
(amMi6n pueden deOinir5e 7ipo5 den7ro de o7ro5 I37<.; 723142.;K En e5e ca5o 5er9n
con5iderado5 miemMro5 del 7ipo con7enedor den7ro de la Rue 5e WaSan deOinidoN por lo
Rue le5 5er9n aplicaMle5 7odo5 lo5 modiOicadore5 Q9lido5 para miemMro5 S por deOec7o 5e
con5iderar9 RueN como con cualRuier miemMroN 5on priQado5% Para acceder a e57o5 7ipo5
de5de código eU7erno a 5u 7ipo con7enedor ISa 5ea para Weredar de ello5N crear oMje7o5
5uSo5 o acceder a 5u5 miemMro5 e5797ico5KN adem95 de nece5i7ar5e lo5 permi5o5 de
acce5o nece5ario5 5egTn el modiOicador de acce5iMilidad al deOinirlo5N WaS Rue u5ar la
no7ación <nombreTipoContendor>.<nombreTipoÌnterno>N como mue57ra en e57e ejemploL
class A // No lleva modificador, luego se considera que es internal
{
public class AÌnterna {} // Si ahora no se pusiese public se consideraría private
}
class B:A.AÌnterna // B deriva de la clase interna AÌnterna definida dentro de A. Es
{} // válido porque A.AÌnterna es pública
Nó7e5e Rue dado Rue lo5 7ipo5 eU7erno5 e579n deOinido5 den7ro de 5u 7ipo eU7ernoN de5de
ello5 e5 po5iMle acceder a lo5 miemMro5 e5797ico5 priQado5 de 657e% Sin emMargoN WaS Rue
5eXalar Rue 2. <01512 9661514 9 -.; ?71?C4.; 2. 1;3M376.; 51 ;0 37<. 6.231215.4%
El lenguaje de programación C# (ema ;L Cla5e5
El lenguaje de programación C# (ema =L E5pacio5 de nomMre5
TEMA 6: Espacios de nombres
Concepto de espacio de nombres
#el mi5mo modo Rue lo5 OicWero5 5e organi8an en direc7orio5N lo5 7ipo5 de da7o5 5e
organi8an en 1;<967. 51 2.?C41;%
Por un ladoN e57o permi7e 7enerlo5 m95 organi8ado5 S Oacili7a 5u locali8ación% #e WecWoN
a5V e5 como 5e Walla organi8ada la BCLN de modo Rue 7oda5 la5 cla5e5 m95 comTnmen7e
u5ada5 en cualRuier aplicación 5e Wallan en el e5pacio de nomMre5 llamado SystemN la5
de acce5o a Ma5e5 de da7o5 en System.DataN la5 de reali8ación de operacione5 de
en7rada^5alida en System.ION e7c%
Por o7ro ladoN lo5 e5pacio5 de nomMre5 7amMi6n permi7en poder u5ar en un mi5mo
programa Qaria5 cla5e5 con igual nomMre 5i per7enecen a e5pacio5 diOeren7e5% La idea e5
Rue cada OaMrican7e deOina 5u5 7ipo5 den7ro de un e5pacio de nomMre5 propio para Rue
a5V no WaSa conOlic7o5 5i Qario5 OaMrican7e5 deOinen cla5e5 con el mi5mo nomMre S 5e
Ruieren u5ar a la Qe8 en un mi5mo programa% MQiamen7e para Rue e57o Ouncione no Wan
de coincidir lo5 nomMre5 lo5 e5pacio5 de cada OaMrican7eN S una Oorma de con5eguirlo e5
d9ndole5 el nomMre de la empre5a OaMrican7eN o 5u nomMre de dominio en In7erne7N e7c%
(efinición de espacios de nombres
Para deOinir un e5pacio de nomMre5 5e u7ili8a la 5iguien7e 5in7aUi5L
namespace <nombreEspacio>
{
<tipos>
}
Lo5 <tipos> a5V deOinido5 pa5ar9n a con5idera5e miemMro5 del e5pacio de nomMre5
llamado <nombreEspacio>% Como Qeremo5 m95 adelan7eN apar7e de cla5e5 e57o5 7ipo5
pueden 5er 7amMi6n in7erOace5N e57ruc7ura5N 7ipo5 enumerado5 S delegado5% A
con7inuación 5e mue57ra un ejemplo en el Rue deOinimo5 una cla5e de nomMre
ClaseEjemplo per7enecien7e a un e5pacio de nomMre5 llamado EspacioEjemploL
namespace EspacioEjemplo
{
class ClaseEjemplo
{}
}
El Qerdadero nomMre de una cla5eN al Rue 5e denomina 2.?C41 6.?<-139?1231
69-7@7695.N e5 el nomMre Rue le demo5 al declararla preOijado por la conca7enación de
7odo5 lo5 e5pacio5 de nomMre5 a lo5 Rue per7enece ordenado5 del m95 eU7erno al m95
in7erno S 5eguido cada uno de ello5 por un pun7o Icar9c7er .K Por ejemploN el Qerdadero
nomMre de la cla5e ClaseEjemplo an7e5 deOinida e5 EspacioEjemplo.ClaseEjemplo% Si no
deOinimo5 una cla5e den7ro de una deOinición de e5pacio de nomMre5 Dcomo 5e Wa WecWo
El lenguaje de programación C# (ema =L E5pacio5 de nomMre5
en lo5 ejemplo5 de 7ema5 preQio5D 5e con5idera Rue 657a per7enece al llamado 1;<967. 51
2.?C41; =-.C9- S 5u nomMre comple7amen7e caliOicado coincidir9 con el iden7iOicador
Rue 7ra5 la palaMra re5erQada cIass le demo5 en 5u deOinición I2.?C41 ;7?<-1K
Apar7e de deOinicione5 de 7ipoN 7amMi6n e5 po5iMle incluir como miemMro5 de un e5pacio
de nomMre5 a o7ro5 e5pacio5 de nomMre5% E5 decirN como 5e mue57ra el 5iguien7e ejemplo
e5 po5iMle anidar e5pacio5 de nomMre5L
namespace EspacioEjemplo
{
namespace EspacioEjemplo2
{
class ClaseEjemplo
{}
}
}
AWora ClaseEjemplo 7endr9 EspacioEjemplo.EspacioEjemplo2.ClaseEjemplo como nomMre
comple7amen7e caliOicado% En realidad e5 po5iMle compac7ar la5 deOinicione5 de e5pacio5
de nomMre5 anidado5 u5ando e57a 5in7aUi5 de caliOicación comple7a para dar el nomMre
del e5pacio de nomMre5 a deOinir% E5 decirN el Tl7imo ejemplo e5 eRuiQalen7e aL
namespace EspacioEjemplo.EspacioEjemplo2
{
class ClaseEjemplo
{}
}
En amMo5 ca5o5 lo Rue 5e Wa deOinido e5 una cla5e ClaseEjemplo per7enecien7e al e5pacio
de nomMre5 EspacioEjemplo2 RueN a 5u Qe8N per7enece al e5pacio EspacioEjemplo%
mportación de espacios de nombres
Sentencia using
En principioN 5i de5de código per7enecien7e a una cla5e deOinida en un cier7o e5pacio de
nomMre5 5e de5ea Wacer reOerencia a 7ipo5 deOinido5 en o7ro5 e5pacio5 de nomMre5N 5e Wa
de reOerir a lo5 mi5mo5 u5ando 5u nomMre comple7amen7e caliOicado% Por ejemploL
namespace EspacioEjemplo.EspacioEjemplo2
{
class ClaseEjemplo
{}
}
class Principal // Pertenece al espacio de nombres global
{
public static void Main ()
{
EspacioEjemplo.EspacioEjemplo2.ClaseEjemplo c = new
EspacioEjemplo.EspacioEjemplo2.ClaseEjemplo();
}
El lenguaje de programación C# (ema =L E5pacio5 de nomMre5
}
Como puede re5ul7ar muS pe5ado 7ener Rue e5criMir nomMre5 7an largo5 cada Qe8 Rue 5e
reOerencie a 7ipo5 a5V deOinido5N C# incluSe un mecani5mo de impor7ación de e5pacio5
de nomMre5 Rue 5impliOica la 7area S 5e Ma5a en una 5en7encia Rue u5a la 5iguien7e
5in7aUi5L
using <espacioNombres>;
E57a5 5en7encia5 5iempre Wan de aparecer en la deOinición de e5pacio de nomMre5 an7e5
Rue cualRuier deOinición de miemMro5 de la mi5ma% Permi7en indicar cu9le5 5er9n lo5
e5pacio5 de nomMre5 Rue 5e u5ar9n implVci7amen7e den7ro de e5e e5pacio de nomMre5% A
lo5 miemMro5 de lo5 e5pacio5 de nomMre5 a5V impor7ado5 5e le5 podr9 reOerenciar 5in
u5ar caliOicación comple7a% A5VN aplicando e57o al ejemplo an7erior RuedarVaL
using EspacioEjemplo.EspacioEjemplo2;
namespace EspacioEjemplo.EspacioEjemplo2
{
class ClaseEjemplo
{}
}
// (1)
class Principal // Pertenece al espacio de nombres global
{
public static void ()
{
// EspacioEjemplo.EspacioEjemplo2. está implícito
ClaseEjemplo c = new ClaseEjemplo();
}
}
Nó7e5e Rue la 5en7encia using no podrVa WaMer5e incluido en la 8ona marcada en el
código como (1) porRue en7once5 5e QiolarVa la regla de Rue 7odo using Wa aparecer en
un e5pacio de nomMre5 an7e5 Rue cualRuier deOinición de miemMro Ila deOinición del
e5pacio de nomMre5 EspacioEjemplo.EspacioEjemplo2 e5 un miemMro del e5pacio de
nomMre5 gloMalK Sin emMargoN el 5iguien7e código 5V Rue 5erVa Q9lidoL
namespace EspacioEjemplo.EspacioEjemplo2
{
class ClaseEjemplo
{}
}
namespace Principal
{
using EspacioEjemplo.EspacioEjemplo2;
class Principal // Pertenece al espacio de nombres global
{
public static void Main()
{
ClaseEjemplo c = new ClaseEjemplo();
}
}
El lenguaje de programación C# (ema =L E5pacio5 de nomMre5
}
En e57e ca5o el using aparece an7e5 Rue cualRuier o7ra deOinición de 7ipo5 den7ro del
e5pacio de nomMre5 en Rue 5e incluSe IPrincipalK Sin emMargoN aWora la impor7ación
WecWa con el using 5ólo 5er9 Q9lida den7ro de código incluido en e5e mi5mo e5pacio de
nomMre5N mien7ra5 Rue en el ca5o an7erior era Q9lida en 7odo el OicWero al e57ar incluida
en el e5pacio de nomMre5 gloMal%
#eMe 7ener5e en cuen7a Rue 5i una 5en7encia using impor7a miemMro5 de igual nomMre
Rue miemMro5 deOinido5 en el e5pacio de nomMre5 en Rue 5e incluSeN no 5e produce error
alguno pero 5e dar9 preOerencia a lo5 miemMro5 no impor7ado5% "n ejemploL
namespace N1.N2
{
class A {}
class B {}
}
namespace N3
{
using N1.N2;
class A {}
class C: A {}
}
ARuV C deriQa de N3.A en Qe8 de N1.N2.A% Si Rueremo5 lo con7rario 7endremo5 Rue
reOerenciar a N1.N2.A por 5u nomMre comple7o al deOinir C oN como 5e eUplica a
con7inuaciónN u5ar un 9-79;%
Especificación de aIias
ATn en el ca5o de Rue u5emo5 e5pacio5 de nomMre5 di57in7o5 para diOerenciar cla5e5 con
igual nomMre pero proceden7e5 de di57in7o5 OaMrican7e5N podrVan dar5e conOlic7o5 5i
u5amo5 5en7encia5 using para impor7ar lo5 e5pacio5 de nomMre5 de dicWo5 OaMrican7e5 Sa
Rue en7once5 al Wacer5e reOerencia a una de la5 cla5e5 comune5 con 7an 5olo 5u nomMre
5imple el compilador no podr9 de7erminar a cual de ella5 en concre7o no5 reOerimo5%
Por ejemploN 5i 7enemo5 una cla5e de nomMre comple7amen7e caliOicado A.ClaseN o7ra de
nomMre B.ClaseN S Wacemo5L
using A;
using B;
class EjemploConflicto: Clase {}
hCómo 5aMr9 el compilador 5i lo Rue Rueremo5 e5 deriQar de A.Clase o de B.ClaseJ Pue5
en realidad no podr9 de7erminarlo S producir9 un error inOormando de Rue eUi57e una
reOerencia amMigua a Clase en el código%
El lenguaje de programación C# (ema =L E5pacio5 de nomMre5
Para re5olQer amMigiedade5 de e57e 7ipo podrVa Wacer5e reOerencia a lo5 7ipo5 en
conOlic7o u5ando 5iempre 5u5 nomMre5 comple7amen7e caliOicado5N pero ello puede llegar
a 5er muS Oa7igo5o 5oMre 7odo 5i 5u5 nomMre5 5on muS largo5% Para 5olucionarlo 5in
e5criMir 7an7oN C# permi7e deOinir 9-79; para cualRuier 7ipo de da7oN Rue 5on 5inónimo5
Rue 5e le5 deOinen u7ili8ando la 5iguien7e 5in7aUi5L
using <alias> = <nombreCompletoTipo>;
Como cualRuier o7ro usingN la5 deOinicione5 de alia5 5ólo pueden incluir5e al principio
de la5 deOinicione5 de e5pacio5 de nomMre5 S 5ólo 7ienen Qalide8 den7ro de la5 mi5ma5%
#eOiniendo alia5 di57in7o5 para lo5 7ipo5 en conOlic7o5 5e re5uelQen lo5 proMlema5 de
amMigiedade5% Por ejemploN el proMlema del ejemplo an7erior podrVa re5olQer5e a5VL
using A;
using B;
using ClaseA = A.Clase;
class EjemploConflicto: ClaseA {} // Heredamos de A.Clase
Lo5 alia5 no 7ienen porRu6 5er 5ólo reOeren7e5 a 7ipo5N 5ino Rue 7amMi6n e5 po5iMle
e5criMir alia5 de e5pacio5 de nomMre5% Por ejemploL
namespace N1.N2
{
class A {}
}
namespace N3
{
using R1 = N1;
using R2 = N1.N2;
class B
{
N1.N2.A a; // Campo de nombre completamente calificado N1.N2.A
R1.N2.A b; // Campo de nombre completamente calificado N1.N2.A
R2.A c; // Campo de nombre completamente calificado N1.N2.A
}
}
Al deOinir alia5 WaS Rue 7ener cuidado con no deOinir en un mi5mo e5pacio de nomMre5
Qario5 con igual nomMre o cuSo5 nomMre5 coincidan con lo5 de miemMro5 de dicWo
e5pacio de nomMre5% (amMi6n WaS Rue 7ener en cuen7a Rue no 5e pueden deOinir uno5
alia5 en Ounción de o7roN por lo Rue código5 como el 5iguien7e 5on incorrec7o5L
namespace N1.N2 {}
namespace N3
{
using R1 = N1;
using R2 = N1.N2;
using R3 = R1.N2; // ERROR: No se puede definir R3 en función de R1
}
Espacio de nombres distribuidos
El lenguaje de programación C# (ema =L E5pacio5 de nomMre5
Si Wacemo5 Qaria5 deOinicione5 de un e5pacio de nomMre5 en un mi5mo o diOeren7e5
OicWero5 S 5e compilan 7oda5 jun7a5N el compilador la5 Ou5ionar9 en una 5ola deOinición
cuSo5 miemMro5 5er9n la conca7enación de lo5 de deOinición reali8ada% Por ejemploL
namespace A // (1)
{
class B1 {}
}
namespace A // (2)
{
class B2 {}
}
"na deOinición como la an7erior e5 7ra7ada por el compilador eUac7amen7e igual RueL
namespace A
{
class B1 {}
class B2 {}
}
2 lo mi5mo ocurrirVa 5i la5 deOinicione5 marcada5 como (1) S (2) 5e WuMie5en WecWo en
OicWero5 5eparado5 Rue 5e compila5en conjun7amen7e%
HaS Rue 7ener en cuen7a Rue la5 5en7encia5 usingN Sa 5ean de impor7ación de e5pacio5
de nomMre5 o de deOinición de alia5N no 5on con5iderada5 miemMro5 de lo5 e5pacio5 de
nomMre5 S por 7an7o no par7icipan en 5u5 Ou5ione5% A5VN el 5iguien7e código e5 inQ9lidoL
namespace A
{
class ClaseA {}
}
namespace B
{
using A;
}
namespace B
{
// using A;
class Principal: ClaseA {}
}
E57e código no e5 correc7o porRue aunRue 5e impor7a el e5pacio de nomMre5 A al
principio de una deOinición del e5pacio de nomMre5 donde 5e Wa deOinido PrincipalN no 5e
impor7a en la mi5ma deOinición donde 5e deriQa Principal de A.ClaseA% Para Rue el código
compila5e WaMrVa Rue de5comen7ar la lVnea comen7ada%
El lenguaje de programación C# (ema .L ,ariaMle5 S 7ipo5 de da7o5
TEMA 7: VariabIes y tipos de datos
(efinición de variables
"na A9479C-1 puede Qer5e 5implemen7e como un Wueco en el Rue 5e puede almacenar un
oMje7o de un de7erminado 7ipo al Rue 5e le da un cier7o nomMre% Para poderla u7ili8ar
5ólo WaS Rue deOinirla indicando cual 5er9 5u nomMre S cual 5er9 el 7ipo de da7o5 Rue
podr9 almacenarN lo Rue 5e Wace 5iguiendo la 5iguien7e 5in7aUi5L
<tipoVariable> <nombreVariable>;
"na QariaMle puede 5er deOinida den7ro de una deOinición de cla5eN en cuSo ca5o 5e
corre5ponderVa con el 7ipo de miemMro Rue Wa57a aWora Wemo5 denominado 69?<.%
(amMi6n puede deOinir5e como un A9479C-1 -.69- a un m67odoN Rue e5 una QariaMle
deOinida den7ro del código del m67odo a la Rue 5ólo puede acceder5e de5de den7ro de
dicWo código% 7ra po5iMilidad e5 deOinirla como <94M?134. de un m67odoN Rue 5on
QariaMle5 Rue almacenan lo5 Qalore5 de llamada al m67odo S RueN al igual Rue la5
QariaMle5 locale5N 5ólo puede 5er accedida5 de5de código uMicado den7ro del m67odo% El
5iguien7e ejemplo mue57ra como deOinir QariaMle5 de 7odo5 e57o5 ca5o5L
class A
{
int x, z;
int y;
void F(string a, string b)
{
Persona p;
}
}
En e57e ejemplo la5 QariaMle5 xN z e y 5on campo5 de 7ipo intN mien7ra5 Rue p e5 una
QariaMle local de 7ipo Persona S a S b 5on par9me7ro5 de 7ipo string% Como 5e mue57ra en
el ejemploN 5i un m67odo 7oma Qario5 par9me7ro5 la5 deOinicione5 de 657o5 5e 5eparan
median7e coma5 Icar9c7er ,KN S 5i Rueremo5 deOinir Qario5 campo5 o QariaMle5 locale5 Ino
Q9lido para par9me7ro5K de un mi5mo 7ipo podemo5 incluirlo5 en una mi5ma deOinición
incluSendo en <nombreVariable> 5u5 nomMre5 5eparado5 por coma5%
Con la 5in7aUi5 de deOinición de QariaMle5 an7eriormen7e dada 5implemen7e deOinimo5
QariaMle5 pero no almacenamo5 ningTn oMje7o inicial en ella5% El compilador dar9 un
Qalor por deOec7o a lo5 campo5 para lo5 Rue no 5e indiRue eUplVci7amen7e ningTn Qalor
5egTn 5e eUplica en el 5iguien7e apar7ado% Sin emMargoN a la QariaMle5 locale5 no le5 da
ningTn Qalor inicialN pero de7ec7a cualRuier in7en7o de leerla5 an7e5 de darle5 Qalor S
produce errore5 de compilación en e5o5 ca5o5%
2a Wemo5 Qi57o Rue para crear oMje7o5 5e u7ili8a el operador 21D% Por 7an7oN una Oorma
de a5ignar un Qalor a la QariaMle p del ejemplo an7erior 5erVa a5VL
Persona p;
p = new Persona(“José”, 22, “76543876-A “);
El lenguaje de programación C# (ema .L ,ariaMle5 S 7ipo5 de da7o5
Sin emMargoN C# 7amMi6n proporciona una 5in7aUi5 m95 5encilla con la Rue podremo5
a5ignar un oMje7o a una QariaMle en el mi5mo momen7o 5e deOine% Para ello 5e la Wa de
deOinir u5ando e57a o7ra no7aciónL
<tipoVariable> <nombreVariable> = <valorÌnicial>;
A5V por ejemploN la an7erior a5ignación de Qalor a la QariaMle p podrVa re5criMir5e de e57a
o7ra Oorma m95 compac7aL
Persona p = new Persona(“José”, 22, “76543876-A“);
La e5peciOicación de un Qalor inicial 7amMi6n comMinar5e con la deOinición de mTl7iple5
QariaMle5 5eparada5 por coma5 en una mi5ma lVnea% Por ejemploN la5 5iguien7e5
deOinicione5 5on Q9lida5L
Persona p1 = new Persona(“José”, 22, ”76543876-A“), p2 = new Persona(“Juan”, 21,
”87654212-S”);
2 5on 7ra7ada5 por el compilador de Oorma comple7amen7e eRuiQalen7e5 a WaMerla5
declarado comoL
Persona p1 = new Persona(“José”, 22, “76543876-A“);
Persona p2 = new Persona(“Juan”, 21, ”87654212-S”);
Tipos de datos b0sicos
Lo5 37<.; 51 593.; CM;76.; 5on cier7o5 7ipo5 de da7o5 7an comTnmen7e u7ili8ado5 en la
e5cri7ura de aplicacione5 Rue en C# 5e Wa incluido una 5in7aUi5 e5pecial para 7ra7arlo5%
Por ejemploN para repre5en7ar nTmero5 en7ero5 de *& Mi75 con 5igno 5e u7ili8a el 7ipo de
da7o System.Int32 deOinido en la BCLN aunRue a la Wora de crear un oMje7o a de e57e 7ipo
Rue repre5en7e el Qalor & 5e u5a la 5iguien7e 5in7aUi5L
System.Ìnt32 a = 2;
Como 5e QeN no 5e u7ili8a el operador new para crear oMje7o System.Int32N 5ino Rue
direc7amen7e 5e indica el li7eral Rue repre5en7a el Qalor a crearN con lo Rue la 5in7aUi5
nece5aria para crear en7ero de e57e 7ipo 5e reduce con5ideraMlemen7e% E5 m95N dado lo
Orecuen7e Rue e5 el u5o de e57e 7ipo 7amMi6n 5e Wa predeOinido en C# el alia5 int para el
mi5moN por lo Rue la deOinición de QariaMle an7erior Rueda a5V de compac7aL
int a = 2;
System.Int32 no e5 el Tnico 7ipo de da7o M95ico incluido en C#% En el e5pacio de
nomMre5 System 5e Wan incluido 7odo5 e57o5L
T7<. D1;647<6782 B73; R92=. 51 A9-.41; A-79;
SBS7e 3tes con 5igno ' eD:&'N :&.f 5MS7e
BS7e 3tes 5in 5igno ' e+N &;;f MS7e
In7:= En7ero5 cor7o5 con 5igno := eD*&%.='N *&%.=.f 5Wor7
"In7:= En7ero5 cor7o5 5in 5igno := e+N =;%;*;f u5Wor7
El lenguaje de programación C# (ema .L ,ariaMle5 S 7ipo5 de da7o5
In7*& En7ero5 normale5 *& eD&%:3.%3'*%=3'N &%:3.%3'*%=3.f in7
"In7*& En7ero5 normale5 5in 5igno *& e+N 3%&03%0=.%&0;f uin7
In7=3
En7ero5 largo5 =3
eD0%&&*%*.&%+*=%';3%..;%'+'N
0%&&*%*.&%+*=%';3%..;%'+.f
long
"In7=3 En7ero5 largo5 5in 5igno =3 e+D:'%33=%.33%+.*%.+0%;;:%=:;f ulong
Single )eale5 con . dVgi7o5 de preci5ión *& e:N;j:+
D3;
D *N3j:+
*'
f Oloa7
#ouMle )eale5 de :;D:= dVgi7o5 de preci5ión =3 e;N+j:+
D*&3
D :N.j:+
*+'
f douMle
#ecimal )eale5 de &'D&0 dVgi7o5 de preci5ión :&' e:N+j:+
D&'
D .N0j:+
&'
f decimal
Boolean ,alore5 lógico5 *& 3401N @9-;1 Mool
CWar Carac7ere5 "nicode := ekgu++++lN kgu////lf cWar
S7ring Cadena5 de carac7ere5 ,ariaMle El permi7ido por la memoria 57ring
Mjec7 CualRuier oMje7o ,ariaMle CualRuier oMje7o oMjec7
T9C-9 ) : (ipo5 de da7o5 M95ico5
Pe5e a 5u 5in7aUi5 e5pecialN en C# lo5 7ipo5 M95ico5 5on 7ipo5 del mi5mo niQel Rue
cualRuier o7ro 7ipo del lenguaje% E5 decirN Weredan de System.Object S pueden 5er
7ra7ado5 como oMje7o5 de dicWa cla5e por cualRuier m67odo Rue e5pere un
System.ObjectN lo Rue e5 muS T7il para el di5eXo de ru7ina5 gen6rica5 Rue admi7an
par9me7ro5 de cualRuier 7ipo S e5 una Qen7aja impor7an7e de C# Oren7e a lenguaje5
5imilare5 como 4aQa donde lo5 7ipo5 M95ico5 no 5on con5iderado5 oMje7o5%
El Qalor Rue por deOec7o 5e da a lo5 campo5 de 7ipo5 M95ico5 con5i57e en poner a cero
7odo el 9rea de memoria Rue ocupen% E57o 5e 7raduce en Rue lo5 campo5 de 7ipo5 M95ico5
num6rico5 5e iniciali8an por deOec7o con el Qalor +N lo5 de 7ipo booI lo Wacen con faIseN
lo5 de 7ipo char con '\u0000'N S lo5 de 7ipo string S object con nuII%
AWora Rue 5aMemo5 cu9le5 5on lo5 7ipo5 M95ico5N e5 el momen7o de comen7ar cu9le5 5on
lo5 5uOijo5 Rue admi7en lo5 li7erale5 num6rico5 para indicar al compilador cu9l e5 el 7ipo
Rue 5e Wa de con5iderar Rue 7iene% Por ejemploN 5i 7enemo5 en una cla5e lo5 m67odo5L
public static void F(int x)
{...}
public static void F(long x)
{...}
An7e una llamada como F(100)N ha cu9l de lo5 m67odo5 5e llamaraJ Pue5 MienN en
principio 5e con5idera Rue el 7ipo de un li7eral en7ero e5 el corre5pondien7e al primero de
e57o5 7ipo5 M95ico5 Rue permi7an almacenarloL intN uintN IongN uIongN por lo Rue en el ca5o
an7erior 5e llamarVa al primer F() Para llamar al o7ro podrVa aXadir5e el 5uOijo L al li7eral
S Wacer la llamada con F(100L) En la (aMla = 5e re5umen lo5 po5iMle5 5uOijo5 Q9lido5L
S0@7>. T7<. 51- -73149- 12314.
ninguno Primero deL int, uint, IongN uIong
L ó I
0
Primero deL Iong, uIong
U ó u Primero deL int, uint
UL, UI, uL, uI, LU, Lu, IU ó Iu
uIong
T9C-9 6: SuOijo5 de li7erale5 en7ero5
Por 5u par7eN en la (aMla . 5e indican lo5 5uOijo5 Rue admi7en lo5 li7erale5 reale5L
0
No 5e recomienda u5ar el 5uOijo IN pue5 5e parece mucWo al nTmero uno% #e WecWoN el compilador
produce un men5aje de aQi5o 5i 5e u5a S puede Rue en Qer5ione5 Ou7ura5 genere un error%
El lenguaje de programación C# (ema .L ,ariaMle5 S 7ipo5 de da7o5
S0@7>. T7<. 51- -73149- 419-
F ó f
fIoat
ningunoN D ó d
doubIe
M ó m decimaI
T9C-9 7: SuOijo5 de li7erale5 reale5
Tablas
TabIas unidimensionaIes
"na 39C-9 02757?12;7.29- o A163.4 e5 un 7ipo e5pecial de QariaMle Rue e5 capa8 de
almacenar en 5u in7erior S de manera ordenada uno o Qario5 da7o5 de un de7erminado
7ipo% Para declarar 7aMla5 5e u5a la 5iguien7e 5in7aUi5L
<tipoDatos>[] <nombreTabla>;
Por ejemploN una 7aMla Rue pueda almacenar oMje7o5 de 7ipo int 5e declara a5VL
int[] tabla;
Con e57o la 7aMla creada no almacenarVa ningTn oMje7oN 5ino Rue QaldrVa nuII% Si 5e de5ea
Rue Qerdaderamen7e almacene oMje7o5 WaS Rue indicar cu9l e5 el nTmero de oMje7o5 Rue
podr9 almacenarN lo Rue puede Wacer5e u5ando la 5iguien7e 5in7aUi5 al declararlaL
<tipoDatos>[] <nombreTabla> = new <tipoDatos>[<númeroDatos>];
Por ejemploN una 7aMla Rue pueda almacenar :++ oMje7o5 de 7ipo int 5e declara a5VL
int[] tabla = new int[100];
AunRue 7amMi6n 5erVa po5iMle deOinir el 7amaXo de la 7aMla de Oorma 5eparada a 5u
declaración de e57e modoL
int[] tabla;
tabla = new int[100];
Con e57a Tl7ima 5in7aUi5 e5 po5iMle camMiar din9micamen7e el nTmero de elemen7o5 de
una QariaMle 7aMla 5in m95 Rue irle a5ignando nueQa5 7aMla5% Ello no 5igniOica Rue una
7aMla 5e pueda redimen5ionar con5erQando lo5 elemen7o5 Rue 7uQie5e an7e5 del camMio
de 7amaXoN 5ino Rue ocurre 7odo lo con7rarioL cuando a una QariaMle 7aMla 5e le a5igna
una 7aMla de o7ro 7amaXoN 5u5 elemen7o5 an7iguo5 5on 5oMree5cri7o5 por lo5 nueQo5%
Si 5e crea una 7aMla con la 5in7aUi5 Wa57a aWora eUplicada 7odo5 5u5 elemen7o5 7endrVan el
Qalor por deOec7o de 5u 7ipo de da7o% Si Rueremo5 darle5 o7ro5 Qalore5 al declarar la
7aMlaN Wemo5 de indicarlo5 en7re llaQe5 u5ando e57a 5in7aUi5L
<tipoDatos>[] <nombreTabla> = new <tipoDatos>[] {<valores>};
Han de e5peciOicar5e 7an7o5 <valores> como nTmero de elemen7o5 5e de5ee Rue 7enga la
7aMlaN S 5i 5on m95 de uno 5e Wan de 5eparar en7re 5V median7e coma5 I,K Nó7e5e Rue
El lenguaje de programación C# (ema .L ,ariaMle5 S 7ipo5 de da7o5
aWora no e5 nece5ario indicar el nTmero de elemen7o5 de la 7aMla IaunRue puede Wacer5e
5i 5e de5eaKN pue5 el compilador puede deducirlo del nTmero de Qalore5 e5peciOicado5%
Por ejemploN para declarar una 7aMla de cua7ro elemen7o5 de 7ipo int con Qalore5 ;N:N3N+
5e podrVa Wacer lo 5iguien7eL
int[] tabla = new int[] {5,1,4,0};
Inclu5o 5e puede compac7ar aTn m95 la 5in7aUi5 declarando la 7aMla a5VL
int[] tabla = {5,1,4,0};
(amMi6n podemo5 crear 7aMla5 cuSo 7amaXo 5e pueda e57aMlecer din9micamen7e a par7ir
del Qalor de cualRuier eUpre5ión Rue produ8ca un Qalor de 7ipo en7ero% Por ejemploN para
crear una 7aMla cuSo 7amaXo 5ea el Qalor indicado por una QariaMle de 7ipo int Iluego 5u
Qalor 5er9 de 7ipo en7eroK 5e WarVaL

int i = 5;
...
int[] tablaDinámica = new int[i];
A la Wora de acceder a lo5 elemen7o5 almacenado5 en una 7aMla Ma57a indicar en7re
corcWe7e5N S a con7inuación de la reOerencia a la mi5maN la po5ición Rue ocupe en la 7aMla
el elemen7o al Rue acceder% Cuando 5e Waga WaS Rue 7ener en cuen7a Rue en C# la5 7aMla5
5e indeUan de5de +N lo Rue 5igniOica Rue el primer elemen7o de la 7aMla ocupar9 5u
po5ición +N el 5egundo ocupar9 la po5ición :N S a5V 5uce5iQamen7e para el re57o de
elemen7o5% Por ejemploN aunRue e5 m95 ineOicien7eN la 7aMla declarada en el Tl7imo
Oragmen7o de código de ejemplo 7amMi6n podrVa WaMer5e deOinido a5VL
int[] tabla = new int[4];
tabla[0] = 5;
tabla[1]++; // Por defecto se inicializó a 0, luego ahora el valor de tabla[1] pasa a ser 1
tabla[2] = tabla[0] ÷ tabla[1]; // tabla[2] pasa a valer 4, pues 5-4 = 1
// El contenido de la tabla será {5,1,4,0}, pues tabla[3] se inicializó por defecto a 0.
HaS Rue 7ener cuidado a la Wora de acceder a lo5 elemen7o5 de una 7aMla Sa Rue 5i 5e
e5peciOica una po5ición 5uperior al nTmero de elemen7o5 Rue pueda almacenar la 7aMla
5e producir9 una eUcepción de 7ipo System.OutOfBoundsException% En el Tema %2:
"nstr#$$iones 5e eUplica Ru6 5on la5 eUcepcione5N pero por aWora Ma57a con5iderar Rue
5on oMje7o5 Rue inOorman de 5i7uacione5 eUcepcionale5 Igeneralmen7e errore5K
producida5 duran7e la ejecución de una aplicación% Para eQi7ar e57e 7ipo de eUcepcione5
puede con5ul7ar el Qalor del campo
:+
de 5ólo lec7ura Length Rue e579 a5ociado a 7oda
7aMla S con7iene el nTmero de elemen7o5 de la mi5ma% Por ejemploN para a5ignar un . al
Tl7imo elemen7o de la 7aMla an7erior 5e WarVaL
tabla[tabla.Length ÷ 1] = 7; // Se resta 1 porque tabla.Length devuelve 4 pero el último
// elemento de la tabla es tabla[3]
:+
Length e5 en realidad una propiedadN pero por aWora podemo5 con5iderar Rue e5 campo%
El lenguaje de programación C# (ema .L ,ariaMle5 S 7ipo5 de da7o5
TabIas dentadas
"na 39C-9 5123959 no e5 m95 Rue una 7aMla cuSo5 elemen7o5 5on a 5u Qe8 7aMla5N
pudi6ndo5e a5V anidar cualRuier nTmero de 7aMla5% Para declarar 7aMla5 de e57e 7ipo 5e
u5a una 5in7aUi5 muS 5imilar a la eUplicada para la5 7aMla5 unidimen5ionale5N 5ólo Rue
aWora 5e indican 7an7o5 corcWe7e5 como niQel de anidación 5e de5ee% Por ejemploN para
crear una 7aMla de 7aMla5 de elemen7o5 de 7ipo int Oormada por do5 elemen7o5N uno de lo5
cuale5 Oue5e una 7aMla de elemen7o5 de 7ipo int Oormada por lo5 elemen7o5 de Qalore5 :N&
S el o7ro Oue5e una 7aMla de elemen7o5 de 7ipo int S Qalore5 *N3N;N 5e puede WacerL
int[][] tablaDentada = new int[2][] {new int[] {1,2}, new int[] {3,4,5}};
Como 5e indica eUplVci7amen7e cu9le5 5on lo5 elemen7o5 de la 7aMla declarada no Wace
Oal7a indicar el 7amaXo de la 7aMlaN por lo Rue la declaración an7erior e5 eRuiQalen7e aL
int[][] tablaDentada = new int[][] {new int[] {1,2}, new int[] {3,4,5}};
E5 m95N igual Rue como 5e Qió con la5 7aMla5 unidimen5ionale5 7amMi6n e5 Q9lido WacerL
int[][] tablaDentada = {new int[] {1,2}, new int[] {3,4,5}};
Si no Rui5i65emo5 indicar cu9le5 5on lo5 elemen7o5 de la5 7aMla5 componen7e5N en7once5
7endrVamo5 Rue indicar al meno5 cu9l e5 el nTmero de elemen7o5 Rue podr9n almacenar
I5e iniciali8ar9n con Qalore5 por deOec7oK RuedandoL

int[][] tablaDentada = {new int[2], new int[3]};
Si no Rueremo5 crear la5 7aMla5 componen7e5 en el momen7o de crear la 7aMla den7adaN
en7once5 7endremo5 Rue indicar por lo meno5 cu9l e5 el nTmero de 7aMla5 componen7e5
po5iMle5 Icada una QaldrVa nuIIKN con lo Rue RuedarVaL
int[][] tablaDentada = new int[2][];
E5 impor7an7e 5eXalar Rue no e5 po5iMle e5peciOicar 7oda5 la5 dimen5ione5 de una 7aMla
den7ada en 5u deOinición 5i no 5e indica eUplVci7amen7e el Qalor inicial de 657a5 en7re
llaQe5% E5 decirN e57a declaración e5 incorrec7aL
int[][] tablaDentada = new int[2][5];
E57o 5e deMe a Rue el 7amaXo de cada 7aMla componen7e puede 5er di57in7o S con la
5in7aUi5 an7erior no 5e puede decir cu9l e5 el 7amaXo de cada una% "na opción WuMie5e
5ido con5iderar Rue e5 ; para 7oda5 como 5e Wace en 4aQaN pero ello no 5e Wa
implemen7ado en C# S WaMrVa Rue declarar la 7aMla deN por ejemploN e57a maneraL
int[][] tablaDentada = {new int[5], new int[5]);

/inalmen7eN 5i 5ólo Rueremo5 declarar una QariaMle 7aMla den7ada pero no Rueremo5
indicar 5u nTmero de elemen7o5N Iluego la QariaMle QaldrVa nuIIKN en7once5 Ma57a ponerL
int[][] tablaDentada;
El lenguaje de programación C# (ema .L ,ariaMle5 S 7ipo5 de da7o5
HaS Rue preci5ar Rue aunRue en lo5 ejemplo5 Wa57a aWora pre5en7e5 5e Wan e5cri7o
ejemplo5 Ma5ado5 en 7aMla5 den7ada5 de 5ólo do5 niQele5 de anidaciónN 7amMi6n e5
po5iMle crear 7aMla5 den7ada5 de cualRuier nTmero de niQele5 de anidación% Por ejemploN
para una 7aMla de 7aMla5 de 7aMla5 de en7ero5 de & elemen7o5 en la Rue el primero Oue5e
una 7aMla den7ada Oormada por do5 7aMla5 de ; en7ero5 S el 5egundo elemen7o Oue5e una
7aMla den7ada Oormada por una 7aMla de 3 en7ero5 S o7ra de * 5e podrVa deOinir a5VL

int[][][] tablaDentada = new int[][][] { new int[][] {new int[5], new int[5]},
new int[][] {new int[4], new int[3]}};
A la Wora de acceder a lo5 elemen7o5 de una 7aMla den7ada lo Tnico Rue WaS Rue Wacer e5
indicar en7re corcWe7e5 cu9l e5 el elemen7o eUac7o de la5 7aMla5 componen7e5 al Rue 5e
de5ea accederN indic9ndo5e un elemen7o de cada niQel de anidación en7re uno5 corcWe7e5
diOeren7e5 pero coloc9ndo5e 7oda5 la5 pareja5 de corcWe7e5 jun7a5 S ordenada5 de la 7aMla
m95 eU7erna a la m95 in7erna% Por ejemploN para a5ignar el Qalor :+ al elemen7o cuar7o de
la 7aMla Rue e5 elemen7o primero de la 7aMla Rue e5 elemen7o 5egundo de la 7aMla den7ada
declarada en Tl7imo lugar 5e WarVaL
tablaDentada[1][0][3] = 10;
TabIas muItidimensionaIes
"na 39C-9 ?0-3757?12;7.29- o ?9347K e5 aRuella cuSo5 elemen7o5 5e encuen7ran
organi8ado5 en una e57ruc7ura de Qaria5 dimen5ione5% Para deOinirla5 5e u7ili8a una
5in7aUi5 5imilar a la u5ada para declarar 7aMla5 unidimen5ionale5 pero 5eparando la5
diOeren7e5 dimen5ione5 median7e coma5 I,K Por ejemploN una 7aMla mul7idimen5ional de
elemen7o5 de 7ipo int Rue con57e de :& elemen7o5 puede 7ener 5u5 elemen7o5 di57riMuido5
en do5 dimen5ione5 Oormando una e57ruc7ura *U3 5imilar a una ma7ri8 de la OormaL
: & * 3
; = . '
0 :+ :: :&
E57a 7aMla 5e podrVa declarar a5VL
int[,] tablaMultidimensional = new int[3,4] {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
En realidad no e5 nece5ario indicar el nTmero de elemen7o5 de cada dimen5ión de la
7aMla Sa Rue pueden deducir5e de lo5 Qalore5 eUplVci7amen7e indicado5 en7re llaQe5N por
lo Rue la deOinición an7erior e5 5imilar a e57aL
int[,] tablaMultidimensional = new int[,] {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
Inclu5o puede reducir5e aTn m95 la 5in7aUi5 nece5aria Ruedando 7an 5óloL
int[,] tablaMultidimensional = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
Si no Rueremo5 indicar eUplVci7amen7e lo5 elemen7o5 de la 7aMla al declararlaN podemo5
oMQiarlo5 pero aTn a5V indicar el 7amaXo de cada dimen5ión de la 7aMla Ia lo5 elemen7o5
5e le5 darVa el Qalor por deOec7o de 5u 7ipo de da7oK a5VL
El lenguaje de programación C# (ema .L ,ariaMle5 S 7ipo5 de da7o5
int[,] tablaMultidimensional = new int[3,4];
(amMi6n podemo5 no e5peciOicar ni 5iRuiera el nTmero de elemen7o5 de la 7aMla de e57a
Oorma ItablaMultidimensional con7endrVa aWora nuIIKL
int[,] tablaMultidimensional;
AunRue lo5 ejemplo5 de 7aMla5 mul7idimen5ionale5 Wa57a aWora mo57rado5 5on de 7aMla5
de do5 dimen5ione5N en general 7amMi6n e5 po5iMle crear 7aMla5 de cualRuier nTmero de
dimen5ione5% Por ejemploN una 7aMla Rue almacene &3 elemen7o5 de 7ipo int S Qalor + en
una e57ruc7ura 7ridimen5ional *U3U& 5e declararVa a5VL
int[,,] tablaMultidimensional = new int[3,4,2];
El acce5o a lo5 elemen7o5 de una 7aMla mul7idimen5ional e5 muS 5encilloL 5ólo WaS Rue
indicar lo5 Vndice5 de la po5ición Rue ocupe en la e57ruc7ura mul7idimen5ional el
elemen7o al Rue 5e de5ee acceder% Por ejemploN para incremen7ar en una unidad el
elemen7o Rue ocupe la po5ición I:N*N&K de la 7aMla an7erior 5e WarVa I5e indi8a de5de +KL
tablaMultidimensional[0,2,1]++;
Nó7e5e Rue 7an7o la5 7aMla5 den7ada5 como la5 7aMla5 mul7idimen5ionale5 pueden 5er
u7ili8ada5 7an7o para repre5en7ar e57ruc7ura5 ma7riciale5 como paraN en generalN
repre5en7ar cualRuier e57ruc7ura de Qaria5 dimen5ione5% La diOerencia en7re amMa5 5onL
• Como la5 7aMla5 den7ada5 5on 7aMla5 de 7aMla5N cada uno de 5u5 elemen7o5 puede
5er una 7aMla de un 7amaXo diOeren7e% A5VN con la5 7aMla5 den7ada5 podemo5
repre5en7ar ma7rice5 en la5 Rue cada columna 7enga un 7amaXo di57in7o Ipor el
a5pec7o _a5errado` de e57e 7ipo de ma7rice5 e5 por lo Rue 5e le5 llama 7aMla5
den7ada5KN mien7ra5 Rue u5ando 7aMla5 mul7idimen5ionale5 5ólo e5 po5iMle crear
ma7rice5 rec7angulare5 o cuadrada5% La5 e57ruc7ura5 a5errada5 pueden 5imular5e
u5ando ma7rice5 mul7idimen5ionale5 con 7oda5 5u5 columna5 del 7amaXo de la
columna m95 grande nece5ariaN aunRue ello implica de5perdiciar mucWa
memoria 5oMre 7odo 5i lo5 7amaXo5 de cada columna 5on muS diOeren7e5 S la
7aMla e5 grande% #e 7odo5 modo5N la5 e57ruc7ura5 m95 comune5 Rue 5e u5an en la
maSorVa de aplicacione5 5uelen 5er rec7angulare5 o cuadrada5%
• Lo5 7iempo5 Rue 5e 7ardan en crear S de57ruir 7aMla5 den7ada5 5on 5uperiore5 a
lo5 Rue 5e 7ardan en crear S de57ruir 7aMla5 mul7idimen5ionale5% E57o 5e deMe a
Rue la5 primera5 5on 7aMla5 de 7aMla5 mien7ra5 Rue la5 5egunda5 5on una Tnica
7aMlaN Por ejemploN para crear una 7aMla den7ada e:++fe:++f WaS Rue crear :+:
7aMla5 Ila 7aMla den7ada m95 la5 :++ 7aMla5 Rue con7ieneKN mien7ra5 Rue para
crear una crear una 7aMla Midimen5ional e:++N:++f WaS Rue crear una Tnica 7aMla%
• La5 7aMla5 den7ada5 no Oorman par7e del CLSN por lo Rue no 7odo5 lo5 lenguaje5
ge57ionado5 lo5 7ienen porRu6 admi7ir% Por ejemplo ,i5ual Ba5ic%NE( no la5
admi7eN por lo Rue al u5arla5 en miemMro5 pTMlico5 eRuiQale a perder
in7eroperaMilidad con e57o5 lenguaje5%
El lenguaje de programación C# (ema .L ,ariaMle5 S 7ipo5 de da7o5
TabIas mixtas
"na 39C-9 ?7I39 e5 5implemen7e una 7aMla Oormada por 7aMla5 mul7idimen5ionale5 S
den7ada5 comMinada5 en7re 5V de cualRuier manera% Para declarar una 7aMla de e57e 7ipo
Ma57a con 7an 5olo comMinar la5 no7acione5 Sa Qi57a5 para la5 mul7idimen5ionale5 S
den7ada5% Por ejemploN para declarar una 7aMla de 7aMla5 mul7idimen5ionale5 cuSo5
elemen7o5 5ean 7aMla5 unidimen5ionale5 de en7ero5 5e WarVa lo 5iguien7eL
int[][,][] tablaMixta;
Covarianza de tabIas
La 6.A94792K9 51 39C-9; e5 el re5ul7ado de lleQar el polimorOi5mo al mundo de la5
7aMla5% E5 decirN e5 la capacidad de 7oda 7aMla de poder almacenar elemen7o5 de cla5e5
Wija5 de la cla5e de elemen7o5 Rue pueda almacenar% Por ejemploN en 7an7o Rue 7oda5
cla5e5 5on Wija5 de System.ObjectN la 5iguien7e a5ignación e5 Q9lidaL
string[] tablaCadenas = {“Manolo”, “Paco”, “Pepe”};
object[] tablaObjetos = tablaCadenas;
HaS Rue 7ener en cuen7a Rue la coQarian8a de 7aMla5 5ólo 5e aplica a oMje7o5 de 7ipo5
reOerencia S no a oMje7o5 de 7ipo5 Qalor Por ejemploN la 5iguien7e a5ignación no 5erVa
Q9lida en 7an7o Rue int e5 un 7ipo por QalorL
int[] tablaEnteros = {1, 2, 3};
object[] tablaObjetos = tablaEnteros;
La cIase System.Array
En realidadN 7oda5 la5 7aMla5 Rue deOinamo5N 5ea cual 5ea el 7ipo de elemen7o5 Rue
con7enganN 5on oMje7o5 Rue deriQan de System.Array% E5 decirN Qan a di5poner de 7odo5
lo5 miemMro5 Rue 5e Wan deOinido para e57a cla5eN en7re lo5 Rue 5on de57acaMle5L
• LengthL Campo
::
de 5ólo lec7ura Rue inOorma del nTmero 7o7al de elemen7o5 Rue
con7iene la 7aMla% Si la 7aMla 7iene m95 de una dimen5ión o niQel de anidación
indica el nTmero de elemen7o5 de 7oda5 5u5 dimen5ione5 S niQele5% Por ejemploL
int[] tabla = {1,2,3,4};
int[][] tabla2 = {new int[] {1,2}, new int[] {3,4,5}};
int[,] tabla3 = {{1,2},{3,4,5,6}};
Console.WriteLine(tabla.Length); //Ìmprime 4
Console.WriteLine(tabla2.Length); //Ìmprime 5
Console.WriteLine(tabla3.Length); //Ìmprime 6
• RankL Campo de 5ólo lec7ura Rue almacena el nTmero de dimen5ione5 de la
7aMla% MQiamen7e 5i la 7aMla no e5 mul7idimen5ional Qaldr9 :% Por ejemploL
::
En realidad 7odo5 lo5 _campo5` de5cri7o5 en e57e apar7ado no 5on en realidad campo5N 5ino propiedade5%
AunRue 5on concep7o5 diOeren7e5N por aWora puede con5iderarlo5 como iguale5%
El lenguaje de programación C# (ema .L ,ariaMle5 S 7ipo5 de da7o5
int[] tabla = {1,2,3,4};
int[][] tabla2 = {new int[] {1,2}, new int[] {3,4,5}};
int[,] tabla3 = {{1,2},{3,4,5,6}};
Console.WriteLine(tabla.Rank); //Ìmprime 1
Console.WriteLine(tabla2.Rank); //Ìmprime 1
Console.WriteLine(tabla3.Rank); //Ìmprime 2
• int GetLength(int dimensión)L !67odo Rue deQuelQe el nTmero de elemen7o5 de
la dimen5ión e5peciOicada% La5 dimen5ione5 5e indican empe8ando a con7ar
de5de ceroN por lo Rue 5i Ruiere oM7ener5e el nTmero de elemen7o5 de la primera
dimen5ión WaMr9 Rue u5ar GetLength(0)N 5i 5e Ruiere oM7ener lo5 de la 5egunda
WaMr9 Rue u5ar GetLength(1)N e7c% Por ejemploL
int[,] tabla = {{1,2}, {3,4,5,6}};
Console.WriteLine(tabla.GetLength(0)); // Ìmprime 2
Console.WriteLine(<gtabla.GetLength(1)); // Ìmprime 4
• void CopyTo(Array destino, int posición)L Copia 7odo5 lo5 elemen7o5 de la 7aMla
5oMre la Rue 5e aplica en la 7aMla destino a par7ir de la posición de 657a indicada%
Por ejemploL
int[] tabla1 = {1,2,3,4};
int[] tabla2 = {5,6,7,8, 9};
tabla1.CopyTo(tabla2,0); // A partir de ahora, tabla2 contendrá {5,1,2,3,4}
AmMa5 7aMla5 deMen 5er unidimen5ionale5N la 7aMla de de57ino Wade 5er de un 7ipo
Rue pueda almacenar lo5 oMje7o5 de la 7aMla origenN el Vndice e5peciOicado Wa de
5er Q9lido ImaSor o igual Rue cero S menor Rue el 7amaXo de la 7aMla de de57inoK
S no Wa de Qaler nuII ninguna de la5 7aMla5% Si no Oue5e a5VN 5al7arVan eUcepcione5
de diQer5o5 7ipo5 inOormando del error come7ido Ien la documen7ación del S#A
puede Qer cu9le5 5on en concre7oK
Apar7e de lo5 miemMro5 aRuV 5eXalado5N System.Array 7amMi6n cuen7a con mucWo5 o7ro5
Rue Oacili7an reali8ar 7area5 7an Orecuen7e5 como MT5Rueda5 de elemen7o5N ordenacione5N
e7c% Para m95 inOormación 5oMre ello5 puede con5ul7ar5e la documen7ación del S#A%
Cadenas de te1to
"na 695129 51 31I3. no e5 m95 Rue una 5ecuencia de carac7ere5% %NE( la5 repre5en7a
in7ernamen7e en Oorma7o "nicodeN S C# la5 repre5en7an eU7ernamen7e como oMje7o5 de
un 7ipo de da7o stringN Rue no e5 m95 Rue un alia5 del 7ipo System.String de la BCL%
La5 cadena5 de 7eU7o 5uelen crear5e a par7ir li7erale5 de cadena o de o7ra5 cadena5
preQiamen7e creada5% Ejemplo5 de amMo5 ca5o5 5e mue57ran a con7inuaciónL
string cadena1 = “José Antonio”;
string cadena2 = cadena1;
El lenguaje de programación C# (ema .L ,ariaMle5 S 7ipo5 de da7o5
En el primer ca5o 5e Wa creado un oMje7o string Rue repre5en7a a la cadena Oormada por
la 5ecuencia de carac7ere5 OosP .ntonio indicada li7eralmen7e Inó7e5e Rue la5 comilla5
doMle5 en7re la5 Rue 5e encierran lo5 li7erale5 de cadena no Oorman par7e del con7enido
de la cadena Rue repre5en7an 5ino Rue 5ólo 5e u5an como delimi7adore5 de la mi5maK En
el 5egundo ca5o la QariaMle cadena2 creada 5e genera a par7ir de la QariaMle cadena: Sa
eUi57en7eN por lo Rue amMa5 QariaMle5 apun7ar9n al mi5mo oMje7o en memoria%
HaS Rue 7ener en cuen7a Rue el 7ipo string e5 un 7ipo reOerenciaN por lo Rue en principio
la comparación en7re oMje7o5 de e57e 7ipo deMerVa comparar 5u5 direccione5 de memoria
como pa5a con cualRuier 7ipo reOerencia% Sin emMargoN 5i ejecu7amo5 el 5iguien7e código
Qeremo5 Rue e57o no ocurre en el ca5o de la5 cadena5L
using System;
public class ÌgualdadCadenas
{
public static void Main()
{
string cadena1 = “José Antonio”;
string cadena2 = String.Copy(cadena1);
Console.WriteLine(cadena1==cadena2);
}
}
El m67odo Copy() de la cla5e String u5ado deQuelQe una copia del oMje7o Rue 5e le pa5a
como par9me7ro% Por 7an7oN al 5er oMje7o5 diOeren7e5 5e almacenar9n en po5icione5
di57in7a5 de memoria S al compararlo5 deMerVa deQolQer5e faIse como pa5a con cualRuier
7ipo reOerencia% Sin emMargoN 5i ejecu7a el programa Qer9 Rue lo Rue 5e oM7iene e5
preci5amen7e lo con7rarioL true% E57o 5e deMe a Rue para Wacer para Wacer m95 in7ui7iQo el
7raMajo con cadena5N en C# 5e Wa modiOicado el operador de igualdad para Rue cuando 5e
apliRue en7re cadena5 5e con5idere Rue 5u5 operando5 5on iguale5 5ólo 5i 5on
leUicogr9Oicamen7e eRuiQalen7e5 S no 5i reOerencian al mi5mo oMje7o en memoria%
Adem95N e57a comparación 5e Wace 7eniendo en cuen7a la capi7ali8ación u5adaN por lo
Rue “Hola”==”HOLA” ó “Hola”==”hola” deQolQer9n faIse Sa Rue con7ienen la5 mi5ma5 le7ra5
pero con di57in7a capi7ali8ación%
Si 5e Rui5ie5e comparar cadena5 por reOerencia WaMrVa Rue op7ar por una de e57a5 do5
opcione5L compararla5 con Object.ReferenceEquaIs() o conQer7irla5 en object5 S luego
compararla5 con == Por ejemploL

Console.WriteLine(Object.ReferecenceEquals(cadena1, cadena2));
Console.WriteLine( (object) cadena1 == (object) cadena2);
AWora 5V Rue lo Rue 5e comparan 5on la5 direccione5 de lo5 oMje7o5 Rue repre5en7an a la5
cadena5 en memoriaN por lo Rue la 5alida Rue 5e mo57rar9 por pan7alla e5L
Galse
Galse
HaS Rue 5eXalar una co5aN S e5 Rue aunRue en principio el 5iguien7e código deMerVa
mo57rar la mi5ma 5alida por pan7alla Rue el an7erior Sa Rue la5 cadena5 comparada5 5e
deMerVan corre5ponder a oMje7o5 Rue aunRue 5ean leUicogr9Oicamen7e eRuiQalen7e5 5e
almacenan en po5icione5 diOeren7e5 en memoriaL
El lenguaje de programación C# (ema .L ,ariaMle5 S 7ipo5 de da7o5
using System;
public class ÌgualdadCadenas2
{
public static void Main()
{
string cadena1 = “José Antonio”;
string cadena2 = “José Antonio”;
Console.WriteLine(Object.ReferenceEquals(cadena1, cadena2));
Console.WriteLine( ((object) cadena1) == ((object) cadena2));
}
}
Si lo ejecu7amo5 Qeremo5 Rue la 5alida oM7enida e5 ju57amen7e la con7rariaL
True
True
E57o 5e deMe a Rue el compilador Wa de7ec7ado Rue amMo5 li7erale5 de cadena 5on
leUicogr9Oicamen7e eRuiQalen7e5 S Wa decidido Rue para aWorra memoria lo mejor e5
almacenar en memoria una Tnica copia de la cadena Rue repre5en7an S Wacer Rue amMa5
QariaMle5 apun7en a e5a copia comTn% E57o Qa a aOec7ar a la Oorma en Rue e5 po5iMle
manipular la5 cadena5 como 5e eUplicar9 m95 adelan7e%
Al igual Rue el 5igniOicado del operador == Wa 5ido e5pecialmen7e modiOicado para
7raMajar con cadena5N lo mi5mo ocurre con el operador Minario +% En e57e ca5oN cuando 5e
aplica en7re do5 cadena5 o una cadena S un car9c7er lo Rue Wace e5 deQolQer una nueQa
cadena con el re5ul7ado de conca7enar 5u5 operando5% A5V por ejemploN en el 5iguien7e
código la5 do5 QariaMle5 creada5 almacenar9n la cadena Hola MundoL
public class Concatenación
{
public static void Main()
{
string cadena = “Hola” + “ Mundo”;
string cadena2 = “Hola Mund” + 'o';
}
}
Por o7ro ladoN el acce5o a la5 cadena5 5e Wace de manera 5imilar a como 5i de 7aMla5 de
carac7ere5 5e 7ra7a5eL 5u _campo` Length almacenar9 el nTmero de carac7ere5 Rue la
Oorman S para acceder a 5u5 elemen7o5 5e u7ili8a el operador []% Por ejemploN el 5iguien7e
código mue57ra por pan7alla cada car9c7er de la cadena Hola en una lVnea diOeren7eL
using System;
public class AccesoCadenas
{
public static void Main()
{
string cadena = “Hola”;
Console.WriteLine(cadena[0]);
Console.WriteLine(cadena[1]);
Console.WriteLine(cadena[2]);
El lenguaje de programación C# (ema .L ,ariaMle5 S 7ipo5 de da7o5
Console.WriteLine(cadena[3]);
}
}
Sin emMargoN WaS Rue 5eXalar una diOerencia impor7an7e re5pec7o a la Oorma en Rue 5e
accede a la5 7aMla5L la5 cadena5 5on inmu7aMle5N lo Rue 5igniOica Rue no e5 po5iMle
modiOicar lo5 carac7ere5 Rue la5 Oorman% E57o 5e deMe a Rue el compilador compar7e en
memoria la5 reOerencia5 a li7erale5 de cadena leUicogr9Oicamen7e eRuiQalen7e5 para a5V
aWorrar memoriaN S 5i 5e permi7ie5e modiOicarlo5 lo5 camMio5 Rue 5e Wicie5en a 7raQ65 de
una QariaMle a una cadena compar7ida aOec7arVan al re57o de QariaMle5 Rue la compar7anN
lo Rue podrVa cau5ar errore5 diOVcile5 de de7ec7ar% Por 7an7oN Wacer e57o e5 incorrec7oL
string cadena = “Hola”;
cadena[0]=”A”; //Error: No se pueden modificar las cadenas
Sin emMargoN el WecWo de Rue no 5e puedan modiOicar la5 cadena5 no 5igniOica Rue no 5e
puedan camMiar lo5 oMje7o5 almacenado5 en la5 QariaMle5 de 7ipo string%Por ejemploN el
5iguien7e código e5 Q9lidoL
String cad = “Hola”;
cad = “Adios”; // Correcto, pues no se modifica la cadena almacenada en cad
// sino que se hace que cad pase a almacenar otra cadena distinta..

Si 5e de5ea 7raMajar con cadena5 modiOicaMle5 puede u5ar5e Sytem.Text.StringBuiIderN
Rue Ounciona de manera 5imilar a string pero permi7e la modiOicación de 5u5 cadena5 en
7an7o Rue e57a5 no 5e compar7en en memoria% Para crear oMje7o5 de e57e 7ipo Ma57a pa5ar
como par9me7ro de 5u con57ruc7or el oMje7o string Rue con7iene la cadena a repre5en7ar
median7e un StringBuiIderN S para conQer7ir un StringBuiIder en String 5iempre puede
u5ar5e 5u m67odo ToString() Weredado de System.Object% Por ejemploL
using System.Text;
using System;
public class ModificaciónCadenas
{
public static void Main()
{
StringBuilder cadena = new StringBuilder(“Pelas”);
String cadenaÌnmutable;
cadena[0] = 'V';
Console.WriteLine(cadena); // Muestra Velas
cadenaÌnmutable = cadena.ToString();
Console.WriteLine(cadenaÌnmutable); // Muestra Velas
}
}
Apar7e de lo5 m67odo5 Sa Qi57o5N en la cla5e System.String 5e deOinen mucWo5 o7ro5
m67odo5 aplicaMle5 a cualRuier cadena S Rue permi7en manipularla% Lo5 principale5 5onL
• int IndexOf(string subcadena)L Indica cu9l e5 el Vndice de la primera aparición de la
subcadena indicada den7ro de la cadena 5oMre la Rue 5e aplica% La MT5Rueda de dicWa
5uMcadena 5e reali8a de5de el principio de la cadenaN pero e5 po5iMle indicar en un
5egundo par9me7ro opcional de 7ipo int cu9l e5 el Vndice de la mi5ma a par7ir del Rue
5e de5ea empe8ar a Mu5car% #el mi5mo modoN la MT5Rueda acaMa al llegar al Oinal de
El lenguaje de programación C# (ema .L ,ariaMle5 S 7ipo5 de da7o5
la cadena 5oMre la Rue 5e Mu5caN pero pa5ando un 7ercer par9me7ro opcional de 7ipo
int e5 po5iMle indicar algTn Vndice an7erior donde 7erminarla%
Nó7e5e Rue e5 un m67odo muS T7il para 5aMer 5i una cadena con7iene o no alguna
5uMcadena de7erminadaN pue5 5ólo 5i no la encuen7ra deQuelQe un -1%
• int LastIndexOf(string subcadena)L /unciona de Oorma 5imilar a IndexOf() 5ólo Rue
deQuelQe la po5ición de la Tl7ima aparición de la subcadena Mu5cada en lugar de
deQolQer la de la primera%
• string Insert(int posición, string subcadena)L #eQuelQe la cadena re5ul7an7e de
in5er7ar la subcadena indicada en la posición e5peciOicada de la cadena 5oMre la Rue
5e aplica%
• string Remove(int posición, int número)L #eQuelQe la cadena re5ul7an7e de eliminar
el número de carac7ere5 indicado Rue WuMie5e en la cadena 5oMre al Rue 5e aplica a
par7ir de la posición e5peciOicada%
• string RepIace(string aSustituir, string sustituta)L #eQuelQe la cadena re5ul7an7e de
5u57i7uir en la cadena 5oMre la Rue 5e aplica 7oda aparición de la cadena aSustituir
indicada por la cadena sustituta e5peciOicada como 5egundo par9me7ro%
• string Substring(int posición, int número)L #eQuelQe la 5uMcadena de la cadena 5oMre
la Rue 5e aplica Rue comien8a en la posición indicada S 7iene el número de carac7ere5
e5peciOicado5% Si no 5e indica dicWo nTmero 5e deQuelQe la 5uMcadena Rue Qa de5de
la po5ición indicada Wa57a el Oinal de la cadena%
• string ToUpper() S string ToLower()L #eQuelQenN re5pec7iQamen7eN la cadena Rue
re5ul7e de conQer7ir a maST5cula5 o minT5cula5 la cadena 5oMre la Rue 5e aplican%
E5 preci5o incidir en Rue aunRue WaSan m67odo5 de in5erciónN reempla8o o eliminación
de carac7ere5 Rue puedan dar la 5en5ación de Rue e5 po5iMle modiOicar el con7enido de
una cadenaN en realidad la5 cadena5 5on inmu7aMle5 S dicWo m67odo5 lo Rue Wacen e5
deQolQer una nueQa cadena con el con7enido corre5pondien7e a WaMer eOec7uado la5
operacione5 de modiOicación 5olici7ada5 5oMre la cadena a la Rue 5e aplican% Por elloN la5
cadena5 5oMre la5 Rue 5e aplican Ruedan in7ac7a5 como mue57ra el 5iguien7e ejemploL
using System;
public class EjemploÌnmutabilidad
{
public static void Main()
{
string cadena1=”Hola”;
string cadena2=cadena1.Remove(0,1);
Console.WriteLine(cadena1);
Console.WriteLine(cadena2);
}
}
La 5alida por pan7alla de e57e ejemplo demue57ra lo an7e5 dicWoN pue5 e5L
El lenguaje de programación C# (ema .L ,ariaMle5 S 7ipo5 de da7o5
Hola
ola
Como 5e QeN 7ra5 el Remove() la cadena1 permanece in7ac7a S el con7enido de cadena2 e5
el Rue deMerVa 7ener cadena1 5i 5e le WuMie5e eliminado 5u primer car9c7er%
Constantes
"na 6.2;39231 e5 una QariaMle cuSo Qalor puede de7erminar el compilador duran7e la
compilación S puede aplicar op7imi8acione5 deriQada5 de ello% Para Rue e57o 5ea po5iMle
5e Wa de cumplir Rue el Qalor de una con57an7e no pueda camMiar duran7e la ejecuciónN
por lo Rue el compilador inOormar9 con un error de 7odo in7en7o de modiOicar el Qalor
inicial de una con57an7e% La5 con57an7e5 5e deOinen como QariaMle5 normale5 pero
precediendo el nomMre de 5u 7ipo del modiOicador const S d9ndole5 5iempre un Qalor
inicial al declararla5% 5eaN con e57a 5in7aUi5L
const <tipoConstante> <nombreConstante> = <valor>;
A5VN ejemplo5 de deOinición de con57an7e5 e5 el 5iguien7eL
const int a = 123;
const int b = a + 125;
#ada5 e57a5 deOinicione5 de con57an7e5N lo Rue War9 el compilador 5er9 5u57i7uir en el
código generado 7oda5 la5 reOerencia5 a la5 con57an7e5 a S b por lo5 Qalore5 :&* S &3'
re5pec7iQamen7eN por lo Rue el código generado 5er9 m95 eOicien7e Sa Rue no incluir9 el
acce5o S c9lculo de lo5 Qalore5 de a S b% Nó7e5e Rue puede Wacer e57o porRue en el
código 5e indica eUplVci7amen7e cual e5 el Qalor Rue 5iempre 7endr9 a SN al 5er e57e un
Qalor OijoN puede deducir cu9l 5er9 el Qalor Rue 5iempre 7endr9 b% Para Rue el compilador
pueda Wacer e57o5 c9lculo5 5e Wa de cumplir Rue el Qalor Rue 5e a5igne a la5 con57an7e5
en 5u declaración 5ea una eUpre5ión con57an7e% Por ejemploN el 5iguien7e código no e5
Q9lido en 7an7o Rue el Qalor de x no e5 con57an7eL
int x = 123; // x es una variable normal, no una constante
const int y = x +123; // Error: x no tiene porqué tener valor constante (aunque aquí lo tenga)
#eMido a la nece5idad de Rue el Qalor dado a una con57an7e 5ea preci5amen7e con57an7eN
no 7iene mucWo 5en7ido crear con57an7e5 de 7ipo5 de da7o5 no M95ico5N pue5 a no 5er Rue
Qalgan nuII 5u5 Qalore5 no 5e pueden de7erminar duran7e la compilación 5ino Tnicamen7e
7ra5 la ejecución de 5u con57ruc7or% La Tnica eUcepción a e57a regla 5on lo5 7ipo5
enumerado5N cuSo5 Qalore5 5e pueden de7erminar al compilar como 5e eUplicar9 cuando
lo5 Qeamo5 en el Tema %*: En#mera$iones
(oda5 la5 con57an7e5 5on implVci7amen7e e5797ica5N por lo 5e con5idera erróneo incluir el
modiOicador static en 5u deOinición al no 7ener 5en7ido Wacerlo% #e WecWoN para leer 5u
Qalor de5de código5 eU7erno5 a la deOinición de la cla5e donde e576 deOinida la con57an7eN
WaMr9 Rue u5ar la 5in7aUi5 <nombreClase>.<nombreConstante> 7Vpica de lo5 campo5 static%
Por Tl7imoN WaS Rue 7ener en cuen7a Rue una QariaMle 5ólo puede 5er deOinida como
con57an7e 5i e5 una QariaMle local o un campoN pero no 5i e5 un par9me7ro%
El lenguaje de programación C# (ema .L ,ariaMle5 S 7ipo5 de da7o5
2ariables de sólo lectura
#ado Rue WaS cier7o5 ca5o5 en lo5 Rue re5ul7a in7ere5an7e di5poner de la capacidad de
5ólo lec7ura Rue 7ienen la5 con57an7e5 pero no e5 po5iMle u5arla5 deMido a la5
re57riccione5 Rue WaS impue57a5 5oMre 5u u5oN en C# 7amMi6n 5e da la po5iMilidad de
deOinir QariaMle5 Rue 5ólo puedan 5er leVda5% Para ello 5e u5a la 5iguien7e 5in7aUi5L
readonIy <tipoConstante> <nombreConstante> , <valor>;
E57a5 QariaMle5 5uperan la maSorVa de la5 limi7acione5 de la5 con57an7e5% Por ejemploL
• No e5 oMliga7orio darle5 un Qalor al deOinirla5N 5ino Rue puede d9r5ele5 en el
con57ruc7or% AWora MienN una Qe8 dado un Qalor a una QariaMle readonIy Sa no e5
po5iMle QolQerlo a modiOicar% Si no 5e le da ningTn Qalor ni en 5u con57ruc7or ni
en 5u deOinición 7omar9 el Qalor por deOec7o corre5pondien7e a 5u 7ipo de da7o%
• No 7ienen porRu6 almacenar Qalore5 con57an7e5N 5ino Rue el Qalor Rue almacenen
puede calcular5e duran7e la ejecución de la aplicación%
• No 7ienen porRu6 deOinir5e como e5797ica5N aunRue 5i 5e de5ea puede Wacer5e%
• Su Qalor 5e de7ermina duran7e la ejecución de la aplicaciónN lo Rue permi7e la
ac7uali8ación de código5 clien7e 5in nece5idad de recompilar% Por ejemploN dadoL
namespace Programa1
{
public class Utilidad
{
public static readonly int X = 1;
}
}
namespace Programa2
{
class Test
{
public static void Main() {
System.Console.WriteLine(Programa1.Utilidad.X);
}
}
}
En principioN la ejecución de e57e programa producir9 el Qalor :% Sin emMargoN 5i
cada e5pacio de nomMre5 5e compilan en módulo5 de código 5eparado5 Rue luego
5e enla8an din9micamen7e S camMiamo5 el Qalor de XN 5ólo 7endremo5 Rue
recompilar el módulo donde e576 deOinido Programa1.Utilidad S Programa2.Test
podr9 ejecu7ar5e u5ando el nueQo Qalor de X 5in nece5idad de recompilarlo%
Sin emMargoN pe5e a la5 Qen7aja5 Rue la5 QariaMle5 de 5ólo lec7ura oOrecen
re5pec7o a la5 con57an7e5N 7ienen do5 inconQenien7e5 re5pec7o a 657a5L 5ólo
El lenguaje de programación C# (ema .L ,ariaMle5 S 7ipo5 de da7o5
pueden deOinir5e como campo5 Ino como QariaMle5 locale5K S con ella5 no e5
po5iMle reali8ar la5 op7imi8acione5 de código comen7ada5 para la5 con57an7e5%
%rden de iniciali3ación de variables
Para deducir el orden en Rue 5e iniciali8ar9n la5 QariaMle5 de un 7ipo de da7o Ma57a 5aMer
cu9l e5 el momen7o en Rue 5e iniciali8a cada una S cuando 5e llama a lo5 con57ruc7ore5L
• Lo5 69?<.; 1;3M376.; 5ólo 5e iniciali8an la primera Qe8 Rue 5e accede al 7ipo al
Rue per7enecenN pero no en 5uce5iQo5 acce5o5% E57o5 acce5o5 pueden 5er 7an7o
para crear oMje7o5 de dicWo 7ipo como para acceder a 5u5 miemMro5 e5797ico5% La
iniciali8ación 5e Wace de modo Rue en primer lugar 5e d6 a cada QariaMle el Qalor
por deOec7o corre5pondien7e a 5u 7ipoN luego 5e d6 a cada una el Qalor inicial
e5peciOicado al deOinirla5N S por Tl7imo 5e llame al con57ruc7or del 7ipo% "n
con57ruc7or de 7ipo e5 5imilar a un con57ruc7or normal 5ólo Rue en 5u código
Tnicamen7e puede acceder5e a miemMro5 static I5e Qer9 en el Tema 8: MétodosK
• Lo5 69?<.; 2. 1;3M376.; 5e iniciali8an cada Qe8 Rue 5e crea un oMje7o del 7ipo
de da7o al Rue per7enecen% La iniciali8ación 5e Wace del mi5mo modo Rue en el
ca5o de lo5 campo5 e5797ico5N S una Qe8 7erminada 5e pa5a a ejecu7ar el código
del con57ruc7or e5peciOicado al crear el oMje7o% En ca5o de Rue la creación del
oMje7o 5ea el primer acce5o Rue 5e Waga al 7ipo de da7o del mi5moN en7once5
primero 5e iniciali8ar9n lo5 campo5 e5797ico5 S luego lo5 no e5797ico5%
• Lo5 <94M?134.; 5e iniciali8an en cada llamada al m67odo al Rue per7enecen con
lo5 Qalore5 e5peciOicado5 al llamarlo%
• La5 A9479C-1; -.69-1; 5e iniciali8an en cada llamada al m67odo al cual
per7enecen pero 7ra5 WaMer5e iniciali8ado lo5 par9me7ro5 deOinido5 para el
mi5mo% Si no 5e le5 da Qalor inicial no 7oman ninguno por deOec7oN
con5ider9ndo5e erróneo 7odo acce5o de lec7ura Rue 5e Waga a la5 mi5ma5
mien7ra5 no 5e le5 e5criMa algTn Qalor%
HaS Rue 7ener en cuen7a Rue al deOinir5e campo5 e5797ico5 pueden Wacer5e deOinicione5
cVclica5 en la5 Rue el Qalor de uno5 campo5 dependa del de o7ro5 S el Qalor de lo5
5egundo5 dependa del de lo5 primero5% Por ejemploL
class ReferenciasCruzadas
{
static int a = b + 1;
static int b = a + 1;
public static void Main()
{
System.Console.WriteLine("a = {0}, b = {1}", a, b);
}
}
El lenguaje de programación C# (ema .L ,ariaMle5 S 7ipo5 de da7o5
E57o 5ólo e5 po5iMle Wacerlo al deOinir campo5 e5797ico5 S no en7re campo5 no e5797ica5 o
QariaMle5 locale5N Sa Rue no 5e puede iniciali8ar campo5 no e5797ico5 en Ounción del
Qalor de o7ro5 miemMro5 no e5797ico5 del mi5mo oMje7o porRue el oMje7o aTn no e57arVa
iniciali8adoN S no 5e pueden iniciali8ar QariaMle5 locale5 en Ounción del Qalor de o7ra5
QariaMle5 locale5 deOinida5 m95 adelan7e porRue no 5e pueden leer QariaMle5 no
iniciali8ada5% Adem95N aunRue la5 con57an7e5 5ean implVci7amen7e e5797ica5 7ampoco
puede Wacer5e deOinicione5 cVclica5 en7re con57an7e5%
En primer lugarN WaS Rue 5eXalar Rue e5criMir un código como el del ejemplo an7erior no
e5 un Muen W9Mi7o de programación Sa Rue diOicul7a innece5ariamen7e la legiMilidad del
programa% ATn a5VN C# admi7e e57e 7ipo de código5 S para de7erminar el Qalor con Rue 5e
iniciali8ar9n Ma57a 7ener en cuen7a Rue 5iempre 5e iniciali8an primero 7odo5 lo5 campo5
con 5u5 Qalore5 por deOec7o S luego 5e iniciali8an aRuello5 Rue 7engan Qalore5 iniciale5
con dicWo5 Qalore5 iniciale5 S en el mi5mo orden en Rue apare8can en el código Ouen7e%
#e e57e modoN la 5alida del programa de ejemplo an7erior 5er9L
a N C# - N D
Nó7e5e Rue lo Rue 5e Wa WecWo e5 iniciali8ar primero a S b con 5u5 Qalore5 por deOec7o I+
en e57e ca5oKN luego calcular el Qalor Oinal de a S luego calcular el Qalor Oinal de b% Como
b Qale + cuando 5e calcula el Qalor Oinal de aN en7once5 el Qalor Oinal de a e5 :b S como a
Qale : cuando 5e calcula el Qalor Oinal de bN en7once5 el Qalor Oinal de b e5 &%
El lenguaje de programación C# (ema 'L !67odo5
TEMA 8: Métodos
Concepto de m.todo
"n ?N3.5. e5 un conjun7o de in57ruccione5 a la5 Rue 5e le5 da un de7erminado nomMre
de 7al manera Rue 5ea po5iMle ejecu7arla5 en cualRuier momen7o 5in 7enerla5 Rue
re5criMir 5ino u5ando 5ólo 5u nomMre% A e57a5 in57ruccione5 5e le5 denomina 6014<. del
m67odoN S a 5u ejecución a 7raQ65 de 5u nomMre 5e le denomina --9?959 al m67odo%
La ejecución de la5 in57ruccione5 de un m67odo puede producir como re5ul7ado un
oMje7o de cualRuier 7ipo% A e57e oMje7o 5e le llama A9-.4 51 413.42. del m67odo S e5
comple7amen7e opcionalN pudi6ndo5e e5criMir m67odo5 Rue no deQuelQan ninguno%
La ejecución de la5 in57ruccione5 de un m67odo puede depender del Qalor de una5
QariaMle5 e5peciale5 denominada5 <94M?134.; del m67odoN de manera Rue en Ounción
del Qalor Rue 5e d6 a e57a5 QariaMle5 en cada llamada la ejecución del m67odo 5e pueda
reali8ar de una u o7ra Oorma S podr9 producir uno u o7ro Qalor de re7orno%
Al conjun7o Oormado por el nomMre de un m67odo S el nTmero S 7ipo de 5u5 par9me7ro5
5e le conoce como ;7=293049 del m67odo% La 5igna7ura de un m67odo e5 lo Rue
Qerdaderamen7e lo iden7iOicaN de modo Rue e5 po5iMle deOinir en un mi5mo 7ipo Qario5
m67odo5 con id6n7ico nomMre 5iempre S cuando 7engan di57in7o5 par9me7ro5% Cuando
e57o ocurre 5e dice Rue el m67odo Rue 7iene e5e nomMre e579 ;.C41694=95.%
(efinición de m.todos
Para deOinir un m67odo WaS Rue indicar 7an7o cu9le5 5on la5 in57ruccione5 Rue Oorman 5u
cuerpo como cu9l e5 el nomMre Rue 5e le dar9N cu9l e5 el 7ipo de oMje7o Rue puede
deQolQer S cu9le5 5on lo5 par9me7ro5 Rue puede 7omar% E57o 5e indica deOini6ndolo a5VL
<tipoRetorno> <nombreMétodo>(<parámetros>)
{
<cuerpo>
}
En <tipoRetorno> 5e indica cu9l e5 el 7ipo de da7o del oMje7o Rue el m67odo deQuelQeN S 5i
no deQuelQe ninguno 5e Wa de e5criMir A.75 en 5u lugar%
Como nomMre del m67odo 5e puede poner en <nombreMétodo> cualRuier iden7iOicador
Q9lido% Como 5e Qer9 m95 adelan7e en el Tema %5: "nter0a$esN 7amMi6n e5 po5iMle incluir
en <nombreMétodo> inOormación de eUplici7ación de implemen7ación de in7erOa8N pero
por aWora podemo5 con5iderar Rue 5iempre 5er9 un iden7iOicador%
AunRue e5 po5iMle e5criMir m67odo5 Rue no 7omen par9me7ro5N 5i un m67odo lo5 7oma 5e
Wa de indicar en <parámetros> cu9l e5 el nomMre S 7ipo de cada unoN 5epar9ndolo5 con
coma5 5i 5on m95 de uno S 5iguiendo la 5in7aUi5 Rue m95 adelan7e 5e eUplica%
El lenguaje de programación C# (ema 'L !67odo5
El <cuerpo> del m67odo 7amMi6n e5 opcionalN pero 5i el m67odo re7orna algTn 7ipo de
oMje7o en7once5 Wa de incluir al meno5 una in57rucción return Rue indiRue cu9l oMje7o%
La 5in7aUi5 an7eriormen7e Qi57a no e5 la Rue 5e u5a para deOinir ?N3.5.; 9C;34963.;%
Como Sa 5e Qio en el Tema 5: ClasesN en e5o5 ca5o5 lo Rue 5e Wace e5 5u57i7uir el cuerpo
del m67odo S la5 llaQe5 Rue lo encierran por un 5imple pun7o S coma I;K !95 adelan7e en
e57e 7ema Qeremo5 Rue e5o e5 7amMi6n lo Rue 5e Wace para deOinir ?N3.5.; 1I3142.;%
A con7inuación 5e mue57ra un ejemplo de cómo deOinir un m67odo de nomMre Saluda
cuSo cuerpo con5i57a en e5criMir en la con5ola el men5aje “Hola Mundo" S Rue deQuelQa
un oMje7o int de Qalor :L
int Saluda()
{
Console.WriteLine(“Hola Mundo”);
return 1;
}
Llamada a m.todos
La Oorma en Rue 5e puede llamar a un m67odo depende del 7ipo de m67odo del Rue 5e
7ra7e% Si e5 un ?N3.5. 51 .C>13. Im67odo no e5797icoK 5e Wa de u5ar la no7aciónL
<objeto>.<nombreMétodo>(<valoresarámetros>)
El <objeto> indicado puede 5er direc7amen7e una QariaMle del 7ipo de da7o5 al Rue
per7ene8ca el m67odo o puede 5er una eUpre5ión Rue produ8ca como re5ul7ado una
QariaMle de e5e 7ipo Irecordemo5 RueN deMido a la WerenciaN el 7ipo del <objeto> puede 5er
un 5uM7ipo del 7ipo donde realmen7e 5e WaSa deOinido el m67odoKb pero 5i de5de código
de algTn m67odo de un oMje7o 5e de5ea llamar a o7ro m67odo de e5e mi5mo oMje7oN
en7once5 5e Wa de dar el Qalor this a <objeto>%
En ca5o de Rue 5ea un ?N3.5. 51 37<. Im67odo e5797icoKN en7one5 5e Wa de u5arL
<tipo>.<nombreMétodo>(<valoresParámetros>)
AWora en <tipo> Wa de indicar5e el 7ipo donde 5e WaSa deOinido el m67odo o algTn 5uM7ipo
5uSo% Sin emMargoN 5i el m67odo per7enece al mi5mo 7ipo Rue el código Rue lo llama
en7once5 5e puede u5ar la no7ación aMreQiadaL
<nombreMétodo>(<valoresParámetros>)

El Oorma7o en Rue 5e pa5en lo5 Qalore5 a cada par9me7ro en <valoresParámetros> a
aRuello5 m67odo5 Rue 7omen par9me7ro5 depende del 7ipo de par9me7ro Rue 5ea% E57o 5e
eUplica en el 5iguien7e apar7ado%
Tipos de par0metros. !inta1is de definición
El lenguaje de programación C# (ema 'L !67odo5
La Oorma en Rue 5e deOine cada par9me7ro de un m67odo depende del 7ipo de par9me7ro
del Rue 5e 7ra7e% En C# 5e admi7en cua7ro 7ipo5 de par9me7ro5L par9me7ro5 de en7radaN
par9me7ro5 de 5alidaN par9me7ro5 por reOerencia S par9me7ro5 de nTmero indeOinido%
Parámetros de entrada
"n <94M?134. 51 1234959 reciMe una copia del Qalor Rue almacenarVa una QariaMle del
7ipo del oMje7o Rue 5e le pa5e% Por 7an7oN 5i el oMje7o e5 de un 7ipo Qalor 5e le pa5ar9 una
copia del oMje7o S cualRuier modiOicación Rue 5e Waga al par9me7ro den7ro del cuerpo
del m67odo no aOec7ar9 al oMje7o original 5ino a 5u copiab mien7ra5 Rue 5i el oMje7o e5 de
un 7ipo reOerencia en7once5 5e le pa5ar9 una copia de la reOerencia al mi5mo S cualRuier
modiOicación Rue 5e Waga al par9me7ro den7ro del m67odo 7amMi6n aOec7ar9 al oMje7o
original Sa Rue en realidad el par9me7ro reOerencia a e5e mi5mo oMje7o original%
Para deOinir un par9me7ro de en7rada Ma57a indicar cu9l el nomMre Rue 5e le de5ea dar S
el cu9l e5 7ipo de da7o Rue podr9 almacenar% Para ello 5e 5igue la 5iguien7e 5in7aUi5L
<tipoParámetro> <nombreParámetro>
Por ejemploN el 5iguien7e código deOine un m67odo llamado Suma Rue 7oma do5
par9me7ro5 de en7rada de 7ipo int llamado5 par1 S par2 S deQuelQe un int con 5u 5umaL
int Suma(int par1, int par2)
{
return par1+par2;
}
Como 5e QeN 5e u5a la in57rucción return para indicar cu9l e5 el Qalor Rue Wa de deQolQer
el m67odo% E57e Qalor e5 el re5ul7ado de ejecu7ar la eUpre5ión par1+par2b e5 decirN e5 la
5uma de lo5 Qalore5 pa5ado5 a 5u5 par9me7ro5 par1 S par2 al llamarlo%
En la5 llamada5 a m67odo5 5e eUpre5an lo5 Qalore5 Rue 5e de5een dar a e57e 7ipo de
par9me7ro5 indicando 5implemen7e el Qalor de5eado% Por ejemploN para llamar al m67odo
an7erior con lo5 Qalore5 & S ; 5e WarVa <objeto>.Suma(2,5)N lo Rue deQolQerVa el Qalor .%
(odo e57o 5e re5ume con el 5iguien7e ejemploL
using System;
class ParámetrosEntrada
{
public int a = 1;
public static void F(ParametrosEntrada p)
{
p.a++;
}
public static void G(int p)
{
p++;
}
El lenguaje de programación C# (ema 'L !67odo5
public static void Main()
{
int obj1 = 0;
ParámetrosEntrada obj2 = new ParámetrosEntrada();
G(obj1);
F(obj2);
Console.WriteLine(“{0}, {1}”, obj1, obj2.a);
}
}
E57e programa mue57ra la 5iguien7e 5alida por pan7allaL
# D
Como 5e QeN la llamada al m67odo G() no modiOica el Qalor Rue 7enVa obj1 an7e5 de
llamarlo Sa Rue obj1 e5 de un 7ipo Qalor IintK Sin emMargoN como obj2 e5 de un 7ipo
reOerencia IParámetrosLlamadasK lo5 camMio5 Rue 5e le Wacen den7ro de F() al pa59r5elo
como par9me7ro 5V Rue le aOec7an%
Parámetros de saIida
"n <94M?134. 51 ;9-759 5e diOerencia de uno de en7rada en Rue 7odo camMio Rue 5e le
realice en el código del m67odo al Rue per7enece aOec7ar9 al oMje7o Rue 5e le pa5e al
llamar dicWo m67odo 7an7o 5i 657e e5 de un 7ipo por Qalor como 5i e5 de un 7ipo
reOerencia% E57o 5e deMe a Rue lo Rue a e57o5 par9me7ro5 5e le5 pa5a e5 5iempre una
reOerencia al Qalor Rue almacenarVa una QariaMle del 7ipo del oMje7o Rue 5e le5 pa5e%
CualRuier par9me7ro de 5alida de un m67odo 5iempre Wa de modiOicar5e den7ro del
cuerpo del m67odo S adem95 dicWa modiOicación Wa de Wacer5e an7e5 Rue cualRuier
lec7ura de 5u Qalor% Si e57o no 5e Wicie5e a5V el compilador lo de7ec7arVa e inOormarVa de
ello con un error% Por e57a ra8ón e5 po5iMle pa5ar par9me7ro5 de 5alida Rue 5ean
QariaMle5 no iniciali8ada5N pue5 5e garan7i8a Rue en el m67odo 5e iniciali8ar9n an7e5 de
leerla5% Adem95N 7ra5 la llamada a un m67odo 5e con5idera Rue la5 QariaMle5 Rue 5e le
pa5aron como par9me7ro5 de 5alida Sa e57ar9n iniciali8ada5N pue5 den7ro del m67odo
5eguro Rue 5e la5 iniciali8a%
Nó7e5e Rue e57e 7ipo de par9me7ro5 permi7en di5eXar m67odo5 Rue deQuelQan mTl7iple5
oMje7o5L un oMje7o 5e deQolQerVa como Qalor de re7orno S lo5 dem95 5e deQolQerVan
e5criMi6ndolo5 en lo5 par9me7ro5 de 5alida%
Lo5 par9me7ro5 de 5alida 5e deOinen de Oorma parecida a lo5 par9me7ro5 de en7rada pero
5e le5 Wa de aXadir la palaMra re5erQada out% 5eaN 5e deOinen a5VL
out <tipoParámetro> <nombreParámetro>
Al llamar a un m67odo Rue 7ome par9me7ro5 de e57e 7ipo 7amMi6n 5e Wa preceder el Qalor
e5peciOicado para e57o5 par9me7ro5 del modiOicador out% "na u7ilidad de e57o e5 Oacili7ar
la legiMilidad de la5 llamada5 a m67odo5% Por ejemploN dada una llamada de la OormaL
El lenguaje de programación C# (ema 'L !67odo5
a.f(x, out z)
E5 O9cil de7erminar Rue lo Rue 5e Wace e5 llamar al m67odo f() del oMje7o a pa59ndole x
como par9me7ro de en7rada S z como par9me7ro de 5alida% Adem95N 7amMi6n 5e puede
deducir Rue el Qalor de z camMiar9 7ra5 la llamada%
Sin emMargoN la Qerdadera u7ilidad de Oor8ar a eUplici7ar en la5 llamada5 el 7ipo de pa5o
de cada par9me7ro e5 Rue permi7e eQi7ar errore5 deriQado5 de Rue un programador pa5e
una QariaMle a un m67odo S no 5epa Rue el m67odo la puede modiOicar% (eni6ndola Rue
eUplici7ar 5e a5egura Rue el programador 5ea con5cien7e de lo Rue Wace%
Parámetros por referencia
"n <94M?134. <.4 41@1412679 e5 5imilar a un par9me7ro de 5alida 5ólo Rue no e5
oMliga7orio modiOicarlo den7ro del m67odo al Rue per7eneceN por lo Rue 5er9 oMliga7orio
pa5arle una QariaMle iniciali8ada Sa Rue no 5e garan7i8a 5u iniciali8ación en el m67odo%
Lo5 par9me7ro5 por reOerencia 5e deOinen igual Rue lo5 par9me7ro5 de 5alida pero
5u57i7uSendo el modiOicador out por el modiOicador ref% #el mi5mo modoN al pa5ar
Qalore5 a par9me7ro5 por reOerencia 7amMi6n WaS Rue precederlo5 del ref%
Parámetros de número indefinido
C# permi7e di5eXar m67odo5 Rue puedan 7omar cualRuier nTmero de par9me7ro5% Para
ello WaS Rue indicar como Tl7imo par9me7ro del m67odo un par9me7ro de algTn 7ipo de
7aMla unidimen5ional o den7ada precedido de la palaMra re5erQada params% Por ejemploL

static void F(int x, params object[] extras)
{}
(odo5 lo5 par9me7ro5 de nTmero indeOinido Rue 5e pa5an al m67odo al llamarlo Wan de
5er del mi5mo 7ipo Rue la 7aMla% Nó7e5e Rue en el ejemplo e5e 7ipo e5 la cla5e primigenia
objectN con lo Rue 5e con5igue Rue gracia5 al polimorOi5mo el m67odo pueda 7omar
cualRuier nTmero de par9me7ro5 de cualRuier 7ipo% Ejemplo5 de llamada5 Q9lida5 5erVanL
F(4); // Pueden pasarse 0 parámetros indefinidos
F(3,2);
F(1, 2, “Hola”, 3.0, new Persona());
F(1, new object[] {2,”Hola”, 3.0, new Persona});
El primer ejemplo demue57ra Rue el nTmero de par9me7ro5 indeOinido5 Rue 5e pa5en
7amMi6n puede 5er +% Por 5u par7eN lo5 do5 Tl7imo5 ejemplo5 5on 7o7almen7e eRuiQalen7e5N
pue5 preci5amen7e la u7ilidad de palaMra re5erQada params e5 indicar Rue 5e de5ea Rue la
creación de la 7aMla object[] 5e Waga implVci7amen7e%
E5 impor7an7e 5eXalar Rue la prioridad de un m67odo Rue incluSa el params e5 inOerior a
la de cualRuier o7ra 5oMrecarga del mi5mo% E5 decirN 5i 5e WuMie5e deOinido una
5oMrecarga del m67odo an7erior como la 5iguien7eL
El lenguaje de programación C# (ema 'L !67odo5
static void F(int x, int y)
{}
Cuando 5e Wicie5e una llamada como F(3,2) 5e llamarVa a e57a Tl7ima Qer5ión del m67odoN
Sa Rue aunRue la del params e5 7amMi6n aplicaMleN 5e con5idera Rue e5 meno5 priori7aria%
Sobrecarga de tipos de parámetros
En realidad lo5 modiOicadore5 ref S out de lo5 par9me7ro5 de un m67odo 7amMi6n Oorman
par7e de lo Rue 5e conoce como 5igna7ura del m67odoN por lo Rue e57a cla5e e5 Q9lidaL
class Sobrecarga
{
public void f(int x)
{}
public void f(out int x)
{}
}
Nó7e5e Rue e57a cla5e e5 correc7a porRue cada uno de 5u5 m67odo5 7iene una 5igna7ura
di57in7aL el par9me7ro e5 de en7rada en el primero S de 5alida en el 5egundo%
Sin emMargoN WaS una re57ricciónL no puede ocurrir Rue la Tnica diOerencia en7re la
5igna7ura de do5 m67odo5 5ea Rue en uno un de7erminado par9me7ro lleQe el modiOicador
ref S en el o7ro lleQe el modiOicador out% Por ejemploN no e5 Q9lidoL
class SobrecargaÌnválida
{
public void f(ref int x)
{}
public void f(out int x)
{}
}
M.todos e1ternos
"n ?N3.5. 1I3142. e5 aRu6l cuSa implemen7ación no 5e da en el OicWero Ouen7e en Rue
e5 declarado% E57o5 m67odo5 5e declaran precediendo 5u declaración del modiOicador
extern% Como 5u código 5e da eU7ernamen7eN en el Ouen7e 5e 5u57i7uSen la5 llaQe5 donde
deMerVa e5criMir5e 5u cuerpo por un pun7o S coma I;KN Ruedando una 5in7aUi5 de la OormaL
extern <nombreMétodo>(<parámetros>);
La Oorma en Rue 5e a5ocie el código eU7erno al m67odo no e579 deOinida en la
e5peciOicación de C# 5ino Rue depende de la implemen7ación Rue 5e Waga del lenguaje%
El Tnico reRui5i7o e5 Rue no pueda deOinir5e un m67odo como aM57rac7o S eU7erno a la
Qe8N pero por 7odo lo dem95 puede comMinar5e con lo5 dem95 modiOicadore5N inclu5o
pudi6ndo5e deOinir m67odo5 Qir7uale5 eU7erno5%
El lenguaje de programación C# (ema 'L !67odo5
La Oorma m95 WaMi7ual de a5ociar código eU7erno con5i57e en preceder la declaración del
m67odo de un 9347C03. de 7ipo System.Runtime.InteropServices.DIIImport Rue indiRue
en cu9l liMrerVa de enlace din9mico I#LLK 5e Wa implemen7ado% E57e a7riMu7o reRuiere
Rue el m67odo eU7erno Rue le 5iga 5ea e5797icoN S un ejemplo de 5u u5o e5L
using System.Runtime.ÌnteropServices; // Aquí está definido DllÌmport
public class Externo
{
[DllÌmport(“kernel32”)]
public static extern void CopyFile(string fuente, string destino);
public static void Main()
{
CopyFile(“fuente.dat”, “destino.dat”);
}
}
El concep7o de a7riMu7o 5e eUplica de7alladamen7e en el Tema %*:.trib#tos% Por aWora
Ma57a 5aMer Rue lo5 a7riMu7o5 5e u5an de Oorman 5imilar a lo5 m67odo5 5ólo Rue no e579n
a5ociado5 a ningTn oMje7o ni 7ipo S 5e indican en7re corcWe7e5 I[]K an7e5 de declaracione5
de elemen7o5 del lenguaje% En el ca5o concre7o de DIIImport lo Rue indica el par9me7ro
Rue 5e le pa5a e5 cu9l e5 el OicWero Ipor deOec7o 5e con5idera Rue 5u eU7en5ión e5 .dllK
donde 5e encuen7ra la implemen7ación del m67odo eU7erno a con7inuación deOinido%
Lo Rue el código del ejemplo an7erior Wace e5 5implemen7e deOinir un m67odo de
nomMre CopyFile() cuSo código 5e corre5ponda con el de la Ounción CopyFiIe() del
OicWero Kernel(D.dll del API B72$% E57e m67odo e5 llamado en Main() para copiar el
OicWero de nomMre <uente.dat en o7ro de nomMre destino.dat% Nó7e5e Rue dado Rue
CopyFile() 5e Wa declarado como static S 5e le llama de5de la mi5ma cla5e donde 5e Wa
declaradoN no e5 nece5ario precederlo de la no7ación <nombreClase>. para llamarlo%
Como 5e QeN la u7ilidad principal de lo5 m67odo5 eU7erno5 e5 permi7ir Wacer --9?959; 9
6857=. 2937A. de5de código ge57ionadoN lo Rue puede 5er T7il por ra8one5 de eOiciencia o
para reu7ili8ar código an7iguamen7e e5cri7o pero reduce la por7aMilidad de la aplicación%
Constructores
Concepto de constructores
Lo5 6.2;34063.41; de un 7ipo de da7o5 5on m67odo5 e5peciale5 Rue 5e deOinen como
miemMro5 de 657e S Rue con7ienen código a ejecu7ar cada Qe8 Rue 5e cree un oMje7o de
e5e 7ipo% >57e código 5uele u5ar5e para laMore5 de iniciali8ación de lo5 campo5 del oMje7o
a crearN 5oMre 7odo cuando el Qalor de 657o5 no e5 con57an7e o incluSe accione5 m95 all9
de una a5ignación de Qalor Iaper7ura5 de OicWero5N acce5o5 a rede5N e7c%K
HaS Rue 7ener en cuen7a Rue la ejecución del con57ruc7or 5iempre 5e reali8a de5pu65 de
WaMer5e iniciali8ado 7odo5 lo5 campo5 del oMje7oN Sa 5ea con lo5 Qalore5 iniciale5 Rue 5e
WuMie5en e5peciOicado en 5u deOinición o dej9ndolo5 con el Qalor por deOec7o de 5u 7ipo%
Apar7e de 5u e5pecial 5in7aUi5 de deOiniciónN lo5 con57ruc7ore5 S lo5 m67odo5 normale5
7ienen una diOerencia muS impor7an7eL -.; 6.2;34063.41; 2. ;1 J141592%
El lenguaje de programación C# (ema 'L !67odo5
Definición de constructores
La 5in7aUi5 M95ica de deOinición de con57ruc7ore5 con5i57e en deOinirlo5 como cualRuier
o7ro m67odo pero d9ndole5 el mi5mo nomMre Rue el 7ipo de da7o al Rue per7enecen S no
indicando el 7ipo de Qalor de re7orno deMido a Rue nunca pueden deQolQer nada% E5
decirN 5e u5a la 5in7aUi5L
<modificadores> <nombreTipo>(<parámetros>)
{
<código>
}
"n con57ruc7or nunca puede deQolQer ningTn 7ipo de oMje7o porRueN como Sa 5e Wa
Qi57oN 5ólo 5e u5a jun7o al operador newN Rue deQuelQe una reOerencia al oMje7o reci6n
creado% Por elloN e5 aM5urdo Rue deQuelQa algTn Qalor Sa Rue nunca podrVa 5er cap7urado
en 7an7o Rue new nunca lo deQolQerVa% Por e57a ra8ón el compilador con5idera erróneo
indicar algTn 7ipo de re7orno en 5u deOiniciónN inclu5o aunRue 5e indiRue void%
LIamada aI constructor
Al con57ruc7or de una cla5e 5e le llama en el momen7o en Rue 5e crea algTn oMje7o de la
mi5ma u5ando el operador new% #e WecWoN la Oorma de u5o de e57e operador e5L
new <llamadaConstructor>
Por ejemploN el 5iguien7e programa demue57ra cómo al crear5e un oMje7o 5e ejecu7an la5
in57ruccione5 de 5u con57ruc7orL
class Prueba
{
Prueba(int x)
{
System.Console.Write(“Creado objeto Prueba con x={0}”,x);
}
public static void Main()
{
Prueba p = new Prueba(5);
}
}
La 5alida por pan7alla de e57e programa demue57ra Rue 5e Wa llamado al con57ruc7or del
oMje7o de cla5e Prueba creado en Main()N pue5 e5L
Creado objeto Prueba con x=5;
LIamadas entre constructores
El lenguaje de programación C# (ema 'L !67odo5
Al igual Rue ocurre con cualRuier o7ro m67odoN 7amMi6n e5 po5iMle 5oMrecargar lo5
con57ruc7ore5% E5 decirN 5e pueden deOinir Qario5 con57ruc7ore5 5iempre S cuando 657o5
7omen diOeren7e5 nTmero5 o 7ipo5 de par9me7ro5% Adem95N de5de el código de un
con57ruc7or puede llamar5e a o7ro5 con57ruc7ore5 del mi5mo 7ipo de da7o an7e5 de
ejecu7ar la5 in57ruccione5 del cuerpo del primero% Para ello 5e aXade un 727679-7K95.4
3J7; al con57ruc7orN Rue e5 e57ruc7ura Rue precede a la llaQe de aper7ura de 5u cuerpo 7al
S como 5e mue57ra en el 5iguien7e ejemploL

class A
{
int total;
A(int valor): this(valor, 2); // (1)
{
}
A(int valor, int peso) // (2)
{
total = valor*peso;
}
}
El this incluido Wace Rue la llamada al con57ruc7or (1) de la cla5e A proQoRue una
llamada al con57ruc7or (2) de e5a mi5ma cla5e en la Rue 5e le pa5e como primer
par9me7ro el Qalor originalmen7e pa5ado al con57ruc7or (1) S como 5egundo par9me7ro el
Qalor &% E5 impor7an7e 5eXalar Rue la llamada al con57ruc7or (2) en (1) 5e Wace an7e5 de
ejecu7ar cualRuier in57rucción de (1)
Nó7e5e Rue la 5oMrecarga de con57ruc7ore5 DS de cualRuier m67odo en generalD e5 un
Muen modo de deOinir Qer5ione5 m95 compac7a5 de m67odo5 de u5o Orecuen7e en la5 Rue
5e 7omen Qalore5 por deOec7o para par9me7ro5 de o7ra5 Qer5ione5 meno5 compac7a5 del
mi5mo m67odo% La implemen7ación de e57a5 Qer5ione5 compac7a5 con5i57irVa en Wacer
una llamada a la Qer5ión meno5 compac7a del m67odo en la Rue 5e le pa5en e5o5 Qalore5
por deOec7o Ia 7raQ65 del this en el ca5o de lo5 con57ruc7ore5K S 5i aca5o luego IS^o an7e5N
5i no e5 un con57ruc7orK 5e Wagan laMore5 e5pecVOica5 en el cuerpo del m67odo compac7o%
#el mi5mo modo Rue en la deOinición de un con57ruc7or de un 7ipo de da7o5 e5 po5iMle
llamar a o7ro5 con57ruc7ore5 del mi5mo 7ipo de da7o5N 7amMi6n e5 po5iMle Wacer llamada5
a con57ruc7ore5 de 5u 7ipo padre 5u57i7uSendo en 5u iniciali8ador la palaMra re5erQada
this por base% Por ejemploL
class A
{
int total;

A(int valor, int peso)
{
total = valor*peso;
}
}
class B:A
{
B(int valor):base(valor,2)
{}
El lenguaje de programación C# (ema 'L !67odo5
}
En amMo5 ca5o5N lo5 Qalore5 pa5ado5 como par9me7ro5 en el iniciali8ador no pueden
con7ener reOerencia5 a campo5 del oMje7o Rue 5e e576 creandoN Sa Rue 5e con5idera Rue
un oMje7o no e579 creado Wa57a Rue no 5e ejecu7e 5u con57ruc7or SN por 7an7oN al llamar al
iniciali8ador aTn no e579 creado% Sin emMargoN lo Rue 5V pueden incluir 5on reOerencia5 a
lo5 par9me7ro5 con lo5 Rue 5e llamó al con57ruc7or% Por ejemploN 5erVa Q9lido WacerL
A(int x, int y): this(x+y)
{}
Constructor por defecto
(odo 7ipo de da7o5 Wa de di5poner de al meno5 un con57ruc7or% Cuando 5e deOine un 7ipo
5in e5peciOicar ninguno el compilador con5idera Rue implVci7amen7e 5e Wa deOinido uno
5in cuerpo ni par9me7ro5 de la 5iguien7e OormaL
public <nombreClase>(): base()
{}
En el ca5o de Rue el 7ipo 5ea una cla5e aM57rac7aN en7once5 el con57ruc7or por deOec7o
in7roducido e5 el Rue 5e mue57ra a con7inuaciónN Sa Rue el an7erior no 5erVa Q9lido
porRue permi7irVa crear oMje7o5 de la cla5e a la Rue per7eneceL
protected <nombreClase>(): base()
{}
En el momen7o en 5e deOina eUplVci7amen7e algTn con57ruc7or el compilador dejar9 de
in7roducir implVci7amen7e el an7erior% HaS Rue 7ener e5pecial cuidado con la llamada Rue
e57e con57ruc7or por deOec7o reali8a en 5u iniciali8adorN pue5 pueden producir5e errore5
como el del 5iguien7e ejemploL
class A
{
public A(int x)
{}
}
class B:A
{
public static void Main()
{
B b = new B(); // Error: No hay constructor base
}
}
En e57e ca5oN la creación del oMje7o de cla5e B en Main() no e5 po5iMle deMido a Rue el
con57ruc7or Rue por deOec7o el compilador crea para la cla5e B llama al con57ruc7or 5in
par9me7ro5 de 5u cla5e Ma5e AN pero A carece de dicWo con57ruc7or porRue no 5e le Wa
deOinido eUplVci7amen7e ninguno con e5a5 carac7erV57ica5 pero 5e le Wa deOinido o7ro Rue
Wa WecWo Rue el compilador no le deOina implVci7amen7e el primero%
El lenguaje de programación C# (ema 'L !67odo5
7ro error Rue podrVa dar5e con5i57irVa en Rue aunRue el 7ipo padre 7uQie5e un
con57ruc7or 5in par9me7ro5N 657e Oue5e priQado S por 7an7o inacce5iMle para el 7ipo Wijo%
(amMi6n e5 impor7an7e 5eXalar Rue aTn en el ca5o de Rue deOinamo5 nue57ra5 propio5
con57ruc7ore5N 5i no e5peciOicamo5 un iniciali8ador el compilador in7roducir9 por
no5o7ro5 uno de la Oorma :base() Por 7an7oN en e57o5 ca5o5 7amMi6n WaS Rue a5egurar5e de
Rue el 7ipo donde 5e WaSa deOinido el con57ruc7or Werede de o7ro Rue 7enga un
con57ruc7or 5in par9me7ro5 no priQado%
LIamadas poIimórficas en constructores
E5 conQenien7e eQi7ar en la medida de lo po5iMle la reali8ación de llamada5 a m67odo5
Qir7uale5 den7ro de lo5 con57ruc7ore5N Sa Rue ello puede proQocar errore5 muS diOVcile5
de de7ec7ar deMido a Rue 5e ejecu7en m67odo5 cuando la par7e del oMje7o Rue manipulan
aTn no 5e Wa 5ido iniciali8ado% "n ejemplo de e57o e5 el 5iguien7eL
using System;
public class Base
{
public Base()
{
Console.WriteLine("Constructor de Base");
this.F();
}
public virtual void F()
{
Console.WriteLine("Base.F");
}
}
public class Derivada:Base
{
Derivada()
{
Console.WriteLine("Constructor de Derivada");
}
public override void F()
{
Console.WriteLine("Derivada.F()");
}
public static void Main()
{
Base b = new Derivada();
}
}
La 5alida por pan7alla mo57rada por e57e programa al ejecu7ar5e e5 la 5iguien7eL
Constructor de 1ase
9eri2ada.G(%
El lenguaje de programación C# (ema 'L !67odo5
Constructor de 9eri2ada
Lo Rue Wa ocurrido e5 lo 5iguien7eL Al crear5e el oMje7o Derivada 5e Wa llamado a 5u
con57ruc7or 5in par9me7ro5N Rue como no 7iene iniciali8ador implVci7amen7e llama al
con57ruc7or 5in par9me7ro5 de 5u cla5e Ma5e% El con57ruc7or de Base reali8a una llamada
al m67odo Qir7ual F()N S como el Qerdadero 7ipo del oMje7o Rue 5e e579 con57ruSendo e5
DerivadaN en7once5 la Qer5ión del m67odo Qir7ual ejecu7ada e5 la redeOinición del mi5mo
incluida en dicWa cla5e% Por Tl7imoN 5e 7ermina llamando al con57ruc7or de Derivada S
Oinali8a la con57rucción del oMje7o%
Nó7e5e Rue 5e Wa ejecu7ado el m67odo F() de Derivada an7e5 Rue el código del con57ruc7or
de dicWa cla5eN por lo Rue 5i e5e m67odo manipula5e campo5 deOinido5 en Derivada Rue
5e iniciali8a5en a 7raQ65 de con57ruc7orN 5e WaMrVa accedido a ello5 an7e5 de iniciali8arlo5
S ello 5eguramen7e proQocarVa errore5 de cau5a5 diOVcile5 de aQeriguar%
Constructor de tipo
(odo 7ipo puede 7ener opcionalmen7e un 6.2;34063.4 51 37<.N Rue e5 un m67odo
e5pecial Rue Ounciona de Oorma 5imilar a lo5 con57ruc7ore5 ordinario5 5ólo Rue para lo
Rue 5e u5a e5 para iniciali8ar lo5 campo5 static del 7ipo donde 5e Wa deOinido%
Cada 7ipo de da7o 5ólo puede 7ener un con57ruc7or de 7ipo% >57e con57ruc7or e5 llamado
au7om97icamen7e por el compilador la primera Qe8 Rue 5e accede al 7ipoN Sa 5ea para
crear oMje7o5 del mi5mo o para acceder a 5u5 campo5 e5797ico5% E57a llamada 5e Wace
ju57o de5pu65 de iniciali8ar lo5 campo5 e5797ico5 del 7ipo con lo5 Qalore5 iniciale5
e5peciOicado5 al deOinirlo5 IoN en 5u au5enciaN con lo5 Qalore5 por deOec7o de 5u5 7ipo5 de
da7oKN por lo Rue el programador no 7iene Oorma de con7rolar la Oorma en Rue 5e le llama
SN por 7an7oN no puede pa5arle par9me7ro5 Rue condicionen 5u ejecución%
Como cada 7ipo 5ólo puede 7ener un con57ruc7or de 7ipo no 7iene 5en7ido poder u5ar this
en 5u iniciali8ador para llamar a o7ro% 2 adem95N 7ampoco 7iene 5en7ido u5ar base
deMido a Rue 657e 5iempre War9 reOerencia al con57ruc7or de 7ipo 5in par9me7ro5 de 5u
cla5e Ma5e% 5eaN 02 6.2;34063.4 51 37<. 2. <0151 31214 727679-7K95.4%
Adem95N no 7iene 5en7ido darle modiOicadore5 de acce5o Sa Rue el programador nunca lo
podr9 llamar 5ino Rue 5ólo 5er9 llamado au7om97icamen7e S 5ólo al acceder5e al 7ipo por
primera Qe8% Como e5 aM5urdoN el compilador con5idera un error d9r5elo5%
La Oorma en Rue 5e deOine el con57ruc7or de 7ipo e5 5imilar a la de lo5 con57ruc7ore5
normale5N 5ólo Rue aWora la deOinición Wa de ir preOijada del modiOicador static S no
puede con7ar con par9me7ro5 ni iniciali8ador% 5eaN 5e deOine de la 5iguien7e maneraL
static <nombreTipo>()
{
<código>
}
En la e5peciOicación de C# no 5e Wa recogido cu9l Wa de 5er el orden eUac7o de la5
llamada5 a lo5 con57ruc7ore5 de 7ipo5 cuando 5e comMinan con WerenciaN aunRue lo Rue 5V
El lenguaje de programación C# (ema 'L !67odo5
5e indica e5 Rue 5e Wa de a5egurar de Rue no 5e accede a un campo e5797ico 5in WaMer5e
ejecu7ado an7e5 5u con57ruc7or de 7ipo% (odo e57o puede Qer5e m95 claro con un ejemploL

using System;
class A
{
public static X;
static A()
{
Console.WriteLine(“Constructor de A”);
X=1;
}
}
class B:A
{
static B()
{
Console.WriteLine(“Constructor de B”);
X=2;
}
public static void Main()
{
B b = new B();
Console.WriteLine(B.X);
}
}
La 5alida Rue mue57ra por pan7alla la ejecución de e57e programa e5 la 5iguien7eL
;nicialiEada clase 1
;nicialiEada clase .
D
En principio la 5alida de e57e programa puede re5ul7ar conOu5a deMido a Rue lo5
primero5 do5 men5aje5 parecen dar la 5en5ación de Rue la creación del oMje7o b proQocó
Rue 5e ejecu7a5e el con57ruc7or de la cla5e Wija an7e5 Rue al de la cla5e padreN pero el
Tl7imo men5aje 5e corre5ponde con una ejecución en el orden opue57o% Pue5 MienN lo Rue
Wa ocurrido e5 lo 5iguien7eL como el orden de llamada a con57ruc7ore5 de 7ipo no e579
e57aMlecidoN el compilador de !icro5oO7 Wa llamado an7e5 al de la cla5e Wija S por ello el
primer men5aje mo57rado e5 ;nicialiEada clase 1% Sin emMargoN cuando en e57e
con57ruc7or 5e Qa a acceder al campo X 5e de7ec7a Rue la cla5e donde 5e deOinió aTn no
e579 iniciali8ada S en7once5 5e llama a 5u con57ruc7or de 7ipoN lo Rue Wace Rue 5e mue57re
el men5aje ;ncialiEada clase .% (ra5 e57a llamada 5e macWaca el Qalor Rue el
con57ruc7or de A dió a X IQalor :K por el Qalor Rue el con57ruc7or de B le da IQalor &K
/inalmen7eN el Tl7imo WriteLine() mue57ra un DN Rue e5 el Tl7imo Qalor e5cri7o en X%

(estructores
Al igual Rue e5 po5iMle deOinir m67odo5 con57ruc7ore5 Rue incluSan código Rue ge57ione
la creación de oMje7o5 de un 7ipo de da7oN 7amMi6n e5 po5iMle deOinir un 51;34063.4 Rue
ge57ione cómo 5e de57ruSen lo5 oMje7o5 de e5e 7ipo de da7o% E57e m67odo 5uele 5er T7il
El lenguaje de programación C# (ema 'L !67odo5
para liMerar recur5o5 7ale5 como lo5 OicWero5 o la5 coneUione5 de rede5 aMier7a5 Rue el
oMje7o a de57ruir e57uQie5e acaparando en el momen7o en Rue 5e Oue5e a de57ruir%
La de57rucción de un oMje7o e5 reali8ada por el recolec7or de Ma5ura cuando reali8a una
recolección de Ma5ura S de7ec7a Rue no eUi57en reOerencia5 a e5e oMje7o ni en pilaN ni en
regi57ro5 ni de5de o7ro5 oMje7o5 5V reOerenciado5% La5 recoleccione5 5e inician
au7om97icamen7e cuando el recolec7or de7ec7a Rue Rueda poca memoria liMre o Rue 5e Qa
a Oinali8ar la ejecución de la aplicaciónN aunRue 7amMi6n puede Oor8ar5e llamando al
m67odo CoIIect() de la cla5e System.GC
La 5in7aUi5 Rue 5e u5a para deOinir un de57ruc7or e5 la 5iguien7eL
~<nombreTipo>()
{
<código>
}
(ra5 la ejecución del de57ruc7or de un oMje7o de un de7erminado 7ipo 5iempre 5e llama al
de57ruc7or de 5u 7ipo padreN Oorm9ndo5e a5V una cadena de llamada5 a de57ruc7ore5 Rue
acaMa al llegar5e al de57ruc7or de object% >57e Tl7imo de57ruc7or no con7iene código
algunoN S dado Rue object no 7iene padreN 7ampoco llama a ningTn o7ro de57ruc7or%
Lo5 de57ruc7ore5 no 5e Weredan% Sin emMargoN para a5egurar Rue la cadena de llamada5 a
de57ruc7ore5 Ouncione correc7amen7e 5i no incluimo5 ninguna deOinición de de57ruc7or en
un 7ipoN el compilador in7roducir9 en e5o5 ca5o5 una por no5o7ro5 de la 5iguien7e OormaL
~<nombreTipo>()
{}
El 5iguien7e ejemplo mue57ra como 5e deOinen de57ruc7ore5 S cómo Ounciona la cadena
de llamada a de57ruc7ore5L
using System;
class A
{
~A()
{
Console.WriteLine(“Destruido objeto de clase A”);
}
}
class B:A
{
~B()
{
Console.WriteLine(“Destruido objeto de clase B”);
}
public static void Main()
{
new B();
}
}
El lenguaje de programación C# (ema 'L !67odo5
El código del m67odo Main() de e57e programa crea un oMje7o de cla5e B pero no
almacena ninguna reOerencia al mi5mo% Luego Oinali8a la ejecución del programaN lo Rue
proQoca la ac7uación del recolec7or de Ma5ura S la de57rucción del oMje7o creado
llamando an7e5 a 5u de57ruc7or% La 5alida Rue oOrece por pan7alla el programa demue57ra
Rue 7ra5 llamar al de57ruc7or de B 5e llama al de 5u cla5e padreN Sa Rue e5L
9estruido o-7eto de clase 1
9estruido o-7eto de clase .
Nó7e5e Rue aunRue no 5e WaSa guardado ninguna reOerencia al oMje7o de 7ipo B creado S
por 7an7o 5ea inacce5iMle para el programadorN al recolec7or de Ma5ura no le pa5a lo
mi5mo S 5iempre 7iene acce5o a lo5 oMje7o5N aunRue 5ean inT7ile5 para el programador%
E5 impor7an7e recalcar Rue no e5 Q9lido incluir ningTn modiOicador en la deOinición de
un de57ruc7orN ni 5iRuiera modiOicadore5 de acce5oN Sa Rue como nunca 5e le puede
llamar eUplVci7amen7e no 7iene ningTn niQel de acce5o para el programador% Sin
emMargoN ello no implica Rue cuando 5e le5 llame no 5e 7enga en cuen7a el Qerdadero
7ipo de lo5 oMje7o5 a de57ruirN como demue57ra el 5iguien7e ejemploL
using System;
public class Base
{
public virtual void F()
{
Console.WriteLine("Base.F");
}
~Base()
{
Console.WriteLine("Destructor de Base");
this.F();
}
}
public class Derivada:Base
{
~Derivada()
{
Console.WriteLine("Destructor de Derivada");
}
public override void F()
{
Console.WriteLine("Derivada.F()");
}
public static void Main()
{
Base b = new Derivada();
}
}
La 5alida mo57rada Rue mue57ra por pan7alla e57e programa al ejecu7arlo e5L
9estructor de 9eri2ada
9estructor de 1ase
El lenguaje de programación C# (ema 'L !67odo5
9eri2ada.G(%
Como 5e QeN aunRue el oMje7o creado 5e almacene en una QariaMle de 7ipo BaseN 5u
Qerdadero 7ipo e5 Derivada S por ello 5e llama al de57ruc7or de e57a cla5e al de57ruirlo%
(ra5 ejecu7ar5e dicWo de57ruc7or 5e llama al de57ruc7or de 5u cla5e padre 5igui6ndo5e la
cadena de llamada5 a de57ruc7ore5% En e57e con57ruc7or padre WaS una llamada al m67odo
Qir7ual F()N Rue como nueQamen7e el oMje7o Rue 5e e579 de57ruSendo e5 de 7ipo DerivadaN
la Qer5ión de F() a la Rue 5e llamar9 e5 a la de la dicWa cla5e%
Nó7e5e Rue una llamada a un m67odo Qir7ual den7ro de un de57ruc7or como la Rue 5e
Wace en el ejemplo an7erior puede dar lugar a errore5 diOVcile5 de de7ec7arN pue5 cuando
5e llama al m67odo Qir7ual Sa 5e Wa de57ruido la par7e del oMje7o corre5pondien7e al 7ipo
donde 5e deOinió el m67odo ejecu7ado% A5VN en el ejemplo an7erior 5e Wa ejecu7ado
Derivada.F() 7ra5 Derivada.~F()N por lo Rue 5i en Derivada.F() 5e u5a5e algTn campo
de57ruido en Derivada.~F() podrVan producir5e errore5 diOVcile5 de de7ec7ar%
El lenguaje de programación C# (ema 0L Propiedade5
TEMA 9: Propiedades
Concepto de propiedad
"na <4.<71595 e5 una me8cla en7re el concep7o de campo S el concep7o de m67odo%
EU7ernamen7e e5 accedida como 5i de un campo normal 5e 7ra7a5eN pero in7ernamen7e e5
po5iMle a5ociar código a ejecu7ar en cada a5ignación o lec7ura de 5u Qalor% >57e código
puede u5ar5e para comproMar Rue no 5e a5ignen Qalore5 inQ9lido5N para calcular 5u Qalor
5ólo al 5olici7ar 5u lec7uraN e7c%
"na propiedad no almacena da7o5N 5ino 5ólo 5e u7ili8a como 5i lo5 almacena5e% En la
pr9c7ica lo Rue 5e 5uele Wacer e5criMir como código a ejecu7ar cuando 5e le a5igne un
QalorN código Rue con7role Rue e5e Qalor 5ea correc7o S Rue lo almacene en un campo
priQado 5i lo e5b S como código a ejecu7ar cuando 5e lea 5u QalorN código Rue deQuelQa
el Qalor almacenado en e5e campo pTMlico% A5V 5e 5imula Rue 5e 7iene un campo pTMlico
5in lo5 inconQenien7e5 Rue e57o5 pre5en7an por no poder5e con7rolar el acce5o a ello5%
(efinición de propiedades
Para deOinir una propiedad 5e u5a la 5iguien7e 5in7aUi5L
<tipoPropiedad> <nombrePropiedad>
{
set
{
<códigoEscritura>
}
get
{
<códigoLectura>
}
}
"na propiedad a5V deOinida 5erVa accedida como 5i de un campo de 7ipo <tipoPropiedad>
5e 7ra7a5eN pero en cada lec7ura de 5u Qalor 5e ejecu7arVa el <códigoLectura> S en cada
e5cri7ura de un Qalor en ella 5e ejecu7arVa <códigoEscritura>
Al e5criMir lo5 MloRue5 de código get S set WaS Rue 7ener en cuen7a Rue den7ro del
código set 5e puede Wacer reOerencia al Qalor Rue 5e 5olici7a a5ignar a 7raQ65 de un
par9me7ro e5pecial del mi5mo 7ipo de da7o Rue la propiedad llamado vaIue Iluego
no5o7ro5 no podemo5 deOinir uno con e5e nomMre en <códigoEscritura>Kb S Rue den7ro del
código get 5e Wa de deQolQer 5iempre un oMje7o del 7ipo de da7o de la propiedad%
En realidad el orden en Rue apare8can lo5 MloRue5 de código set S get e5 irreleQan7e%
Adem95N e5 po5iMle deOinir propiedade5 Rue 5ólo 7engan el MloRue get I<4.<715951; 51
;8-. -163049K o Rue 5ólo 7engan el MloRue set I<4.<715951; 51 ;8-. 1;6473049K Lo Rue
no e5 Q9lido e5 deOinir propiedade5 Rue no incluSan ninguno de lo5 do5 MloRue5%
El lenguaje de programación C# (ema 0L Propiedade5
La5 propiedade5 par7icipan del mecani5mo de polimorOi5mo igual Rue lo5 m67odo5N
5iendo inclu5o po5iMle deOinir propiedade5 cuSo5 MloRue5 de código get o set 5ean
aM57rac7o5% E57o 5e WarVa preOijando el MloRue apropiado con un modiOicador abstract S
5u57i7uSendo la deOinición de 5u código por un pun7o S coma% Por ejemploL
using System;
abstract class A
{
public abstract int PropiedadEjemplo
{
set;
get;
}
}
class B:A
{
private int valor;
public override int PropiedadEjemplo
{
get
{
Console.WriteLine(“Leído {0} de PropiedadEjemplo”, valor);
return valor;
}
set
{
valor = value;
Console.WriteLine(“Escrito {0} en PropiedadEjemplo”, valor);
}
}
}
En e57e ejemplo 5e Qe cómo 5e deOinen S redeOinen propiedade5 aM57rac7a5% Al igual Rue
abstract S overrideN 7amMi6n e5 po5iMle u5ar cualRuiera de lo5 modiOicadore5 rela7iQo5 a
Werencia S polimorOi5mo Sa Qi57o5L virtuaIN new S seaIed%
Nó7e5e Rue aunRue en el ejemplo 5e Wa op7ado por a5ociar un campo priQado valor a la
propiedad PropiedadEjemploN en realidad nada oMliga a Rue ello 5e Waga S e5 po5iMle
deOinir propiedade5 Rue no 7engan campo5 a5ociado5% E5 decirN una propiedad no 5e
7iene porRu6 corre5ponder con un almac6n de da7o5%
4cceso a propiedades
La Oorma de acceder a una propiedadN Sa 5ea para lec7ura o e5cri7uraN e5 eUac7amen7e la
mi5ma Rue la Rue 5e u5arVa para acceder a un campo de 5u mi5mo 7ipo% Por ejemploN 5e
podrVa acceder a la propiedad de un oMje7o de la cla5e B del ejemplo an7erior conL
B obj = new B();
obj.PropiedadEjemplo++;
El lenguaje de programación C# (ema 0L Propiedade5
El re5ul7ado Rue por pan7alla 5e mo57rarVa al Wacer una a5ignación como la an7erior 5erVaL
LeQdo de 4ro5iedad@7em5lo&
@scrito C en 4ro5iedad@7em5lo&
Nó7e5e Rue en el primer men5aje 5e mue57ra Rue el Qalor leVdo e5 + porRue lo Rue
deQuelQe el MloRue get de la propiedad e5 el Qalor por deOec7o del campo priQado valorN
Rue como e5 de 7ipo int 7iene como Qalor por deOec7o +%
mplementación interna de propiedades
En realidad la deOinición de una propiedad con la 5in7aUi5 an7e5 Qi57a e5 conQer7ida por
el compilador en la deOinición de un par de m67odo5 de la 5iguien7e OormaL
<tipoPropiedad> get_<nombrePropiedad>()
{ // Método en que se convierte en bloque get
<códigoLectura>
}
void set_<nombrePropiedad> (<tipoPropiedad> vaIue)
{ // Método en que se convierte en bloque set
<códigoEscritura>
}
E57o 5e Wace para Rue de5de lenguaje5 Rue no 5opor7en la5 propiedade5 5e pueda acceder
7amMi6n a ella5% Si una propiedad e5 de 5ólo lec7ura 5ólo 5e generar9 el m67odo get_X()N S
5i e5 de 5ólo e5cri7ura 5ólo 5e generar9 el set_X() AWora MienN en cualRuier ca5o WaS Rue
7ener cuidado con no deOinir en un mi5mo 7ipo de da7o m67odo5 con 5igna7ura5 como
e57a5 5i 5e Qan a generar in7ernamen7e deMido a la deOinición de una propiedadN Sa Rue
ello proQocarVa un error de deOinición mTl7iple de m67odo%
(eniendo en cuen7a la implemen7ación in7erna de la5 propiedade5N e5 O9cil Qer Rue el
Tl7imo ejemplo de acce5o a propiedad e5 eRuiQalen7e aL
B b = new B();
obj.set_PropiedadEjemplo(obj.get_Propiedad_Ejemplo()++);
Como 5e QeN gracia5 a la5 propiedade5 5e 7iene una 5in7aUi5 mucWo m95 compac7a S clara
para acceder a campo5 de manera con7rolada% Se podrVa pen5ar Rue la con7rapar7ida de
e57o e5 Rue el 7iempo de acce5o al campo aumen7a con5ideraMlemen7e por perder5e
7iempo en Wacer la5 llamada a m67odo5 set^get% Pue5 MienN e57o no 7iene porRu6 5er a5V Sa
Rue el compilador de C# elimina llamada5 Waciendo 72-7272= I5u57i7ución de la llamada
por 5u cuerpoK en lo5 acce5o5 a MloRue5 get^set no Qir7uale5 S de código5 peRueXo5N Rue
5on lo5 m95 WaMi7uale5%

Nó7e5e Rue de la Oorma en Rue 5e deOinen lo5 m67odo5 generado5 por el compilador 5e
puede deducir el porRu6 del WecWo de Rue en el MloRue set 5e pueda acceder a 7raQ65 de
vaIue al Qalor a5ignado S de Rue el oMje7o deQuel7o por el código de un MloRue get 7enga
Rue 5er del mi5mo 7ipo de da7o Rue la propiedad a la Rue per7enece%
El lenguaje de programación C# (ema 0L Propiedade5
El lenguaje de programación C# (ema :+L Indi8adore5
TEMA 10: Indizadores
Concepto de indi3ador
"n 7257K95.4 e5 una deOinición de cómo 5e puede aplicar el operador de acce5o a 7aMla5
I[ ]K a lo5 oMje7o5 de un 7ipo de da7o% E57o e5 e5pecialmen7e T7il para Wacer m95 clara la
5in7aUi5 de acce5o a elemen7o5 de oMje7o5 Rue puedan con7ener coleccione5 de
elemen7o5N pue5 permi7e 7ra7arlo5 como 5i Oue5en 7aMla5 normale5%
Lo5 indi8adore5 permi7en deOinir código a ejecu7ar cada Qe8 Rue 5e acceda a un oMje7o
del 7ipo del Rue 5on miemMro5 u5ando la 5in7aUi5 propia de la5 7aMla5N Sa 5ea para leer o
e5criMir% A diOerencia de la5 7aMla5N lo5 Vndice5 Rue 5e le5 pa5e en7re corcWe7e5 no 7iene
porRu6 5er en7ero5N pudi6ndo5e deOinir Qario5 indi8adore5 en un mi5mo 7ipo 5iempre S
cuando cada uno 7ome un nTmero o 7ipo de Vndice5 diOeren7e%
(efinición de indi3ador
A la Wora de deOinir un indi8ador 5e u5a una 5in7aUi5 parecida a la de la5 propiedade5L
<tipoÌndizador> this[<índices>]
{
set
{
<códigoEscritura>
}
get
{
<códigoLectura>
}
}
La5 Tnica5 diOerencia5 en7re e57a 5in7aUi5 S la de la5 propiedade5 5onL
• El nomMre dado a un indi8ador 5iempre Wa de 5er thisN pue5 carece de 5en7ido
poder darle cualRuiera en 7an7o Rue a un indi8ador no 5e accede por 5u nomMre
5ino aplicando el operador [ ] a un oMje7o% Por elloN lo Rue diOerenciar9 a uno5
indi8adore5 de o7ro5 5er9 el nTmero S 7ipo de 5u5 <índices>%
• En <índices> 5e indica cu9le5 5on lo5 Vndice5 Rue 5e pueden u5ar al acceder al
indi8ador% Para ello la 5in7aUi5 u5ada e5 ca5i la mi5ma Rue la Rue 5e u5a para
e5peciOicar lo5 par9me7ro5 de un m67odoN 5ólo Rue no 5e admi7e la inclu5ión de
modiOicadore5 refN out o params S Rue 5iempre Wa de deOinir5e al meno5 un
par9me7ro% MQiamen7eN el nomMre Rue 5e d6 a cada Vndice 5er9 el nomMre con el
Rue luego 5e podr9 acceder al mi5mo en lo5 MloRue5 set^get%
• No 5e pueden deOinir indi8adore5 e5797ico5N 5ino 5ólo indi8adore5 de oMje7o5%
El lenguaje de programación C# (ema :+L Indi8adore5
Por 7odo lo dem95N la 5in7aUi5 de deOinición de lo5 indi8adore5 e5 la mi5ma Rue la de la5
propiedade5L pueden 5er de 5ólo lec7ura o de 5ólo e5cri7uraN da igual el orden en Rue 5e
deOinan 5u5 MloRue5 set^getN den7ro del MloRue set 5e puede acceder al Qalor a e5criMir a
7raQ65 del par9me7ro e5pecial vaIue del 7ipo del indi8adorN el código del MloRue get Wa de
deQolQer un oMje7o de dicWo 7ipoN e7c%
A con7inuación 5e mue57ra un ejemplo de deOinición de una cla5e Rue con57a de do5
indi8adore5L amMo5 permi7en almacenar elemen7o5 de 7ipo en7eroN pero uno 7oma como
Vndice un en7ero S el o7ro 7oma do5 cadena5L
using System;
public class A
{
public int this[int índice]
{
set
{
Console.WriteLine(“Escrito {0} en posición {1}”, value, índice);
}
get
{
Console.WriteLine(“Leído 1 de posición {0}”, índice);
return 1;
}
}
public int this[string cad1, string cad2]
{
set
{
Console.WriteLine(“Escrito {0} en posición ({1},{2})”, value, cad1, cad2);
}
get
{
Console.WriteLine(“Leído 2 de posición ({0},{1})”, cad1, cad2);
return 2;
}
}
}
4cceso a indi3adores
Para acceder a un indi8ador 5e u7ili8a eUac7amen7e la mi5ma 5in7aUi5 Rue para acceder a
una 7aMlaN 5ólo Rue lo5 Vndice5 no 7ienen porRu6 5er en7ero5 5ino Rue pueden 5er de
cualRuier 7ipo de da7o Rue 5e WaSa e5peciOicado en 5u deOinición% Por ejemploN acce5o5
Q9lido5 a lo5 indi8adore5 de un oMje7o de la cla5e A deOinida en el epVgraOe an7erior 5onL
A obj = new A();
obj[100] = obj[“barco”, “coche”];
La ejecución de la a5ignación de e57e ejemplo producir9 e57a 5alida por pan7allaL
Leído 2 de posición (barco, coche)
Escrito 2 en posición 100
El lenguaje de programación C# (ema :+L Indi8adore5
mplementación interna de indi3adores
Al igual Rue la5 propiedade5N para Oacili7ar la in7eroperaMilidad en7re lenguaje5 lo5
indi8adore5 5on 7amMi6n conQer7ido5 por el compilador en llamada5 a m67odo5 cuSa
deOinición 5e deduce de la deOinición del indi8ador% AWora lo5 m67odo5 5on de la OormaL
<tipoÌndizador> get_Item(<índices>)
{
<códigoLectura>
}
void set_Item(<índices>, <tipoÌndizador> value)
{
<códigoEscritura>
}
NueQamen7eN WaS Rue 7ener cuidado con la 5igna7ura de lo5 m67odo5 Rue 5e deOinan en
una cla5e Sa Rue como la de alguno coincida con la generada au7om97icamen7e por el
compilador para lo5 indi8adore5 5e producir9 un error de amMigiedad%
El lenguaje de programación C# (ema ::L )edeOinición de operadore5
TEMA 11: Redefinición de operadores
Concepto de redefinición de operador
"n .<1495.4 en C# no e5 m95 Rue un 5VmMolo Oormado por uno o m95 carac7ere5 Rue
permi7e reali8ar una de7erminada operación en7re uno o m95 da7o5 S produce un
re5ul7ado% En el Tema *: .s!e$tos +é/i$os Sa Wemo5 Qi57o Rue C# cuen7a con un Muen
nTmero de operadore5 Rue permi7en reali8ar con una 5in7aUi5 clara e in7ui7iQa la5
operacione5 comune5 a la maSorVa de lenguaje5 Iari7m67icaN lógicaN e7c%K a5V como o7ra5
operacione5 m95 par7iculare5 de C# Ioperador isN operador stackaIIocN e7c%K
En C# Qiene predeOinido el compor7amien7o de 5u5 operadore5 cuando 5e aplican a
cier7o5 7ipo5 de da7o5% Por ejemploN 5i 5e aplica el operador + en7re do5 oMje7o5 int
deQuelQe 5u 5umaN S 5i 5e aplica en7re do5 oMje7o5 string deQuelQe 5u conca7enación% Sin
emMargoN 7amMi6n 5e permi7e Rue el programador pueda deOinir el 5igniOicado la maSorVa
de e57o5 operadore5 cuando 5e apliRuen a oMje7o5 de 7ipo5 Rue 6l WaSa deOinidoN S e57o e5
a lo Rue 5e le conoce como 4151@7276782 51 .<1495.4%
Nó7e5e Rue en realidad la po5iMilidad de redeOinir un operador no apor7a ninguna nueQa
Ouncionalidad al lenguaje S 5ólo 5e Wa incluido en C# para Oacili7ar la legiMilidad del
código% Por ejemploN 5i 7enemo5 una cla5e Complejo Rue repre5en7a nTmero5 complejo5
podrVamo5 deOinir una Ounción Sumar() para 5u5 oMje7o5 de modo Rue a 7raQ65 de ella 5e
pudie5e con5eguir la 5uma de do5 oMje7o5 de e57a cla5e como mue57ra e57e ejemploL
Complejo c1 = new Complejo(3,2); // c1 = 3 + 2i
Complejo c2 = new Complejo(5,2); // c2 = 5 + 2i
Complejo c3 = c1.Sumar(c2); // c3 = 8 + 4i
Sin emMargoN el código 5erVa mucWo m95 legiMle e in7ui7iQo 5i en Qe8 de 7ener5e Rue u5ar
el m67odo Sumar() se redeOinie5e el 5igniOicado del operador + para Rue al aplicarlo en7re
oMje7o5 Complejo deQolQie5e 5u 5uma% Con elloN el código an7erior RuedarVa a5VL
Complejo c1 = new Complejo(3,2); // c1 = 3 + 2i
Complejo c2 = new Complejo(5,2); // c2 = 5 + 2i
Complejo c3 = c1 + c2; // c3 = 8 + 4i
>57a e5 preci5amen7e la u7ilidad de la redeOinición de operadore5L Wacer m95 claro S
legiMle el códigoN no Wacerlo m95 cor7o% Por 7an7oN cuando 5e redeOina un operador e5
impor7an7e Rue 5e le d6 un 5igniOicado in7ui7iQo Sa Rue 5i no 5e irVa con7ra de la Oilo5oOVa
de la redeOinición de operadore5% Por ejemploN aunRue 5erVa po5iMle redeOinir el operador
* para Rue cuando 5e aplica5e en7re oMje7o5 de 7ipo Complejo deQuelQa 5u 5uma o
imprimie5e lo5 Qalore5 de 5u5 operando5 en la Qen7ana de con5olaN 5erVa aM5urdo Wacerlo
Sa Rue m95 Rue clariOicar el código lo Rue WarVa 5erVa diOicul7ar 5u compren5ión%
#e 7oda5 Oorma5N 5uele 5er Muena idea Rue cada Qe8 Rue 5e redeOina un operador en un
7ipo de da7o 7amMi6n 5e d6 una deOinición de un m67odo Rue Ouncione de Oorma
eRuiQalen7e al operador% A5V de5de lenguaje5 Rue no 5opor7en la redeOinición de
operadore5 7amMi6n podr9 reali8ar5e la operación S el 7ipo 5er9 m95 reu7ili8aMle%
El lenguaje de programación C# (ema ::L )edeOinición de operadore5
(efinición de redefiniciones de operadores
Sintaxis generaI de redefinición de operador
La Oorma en Rue 5e redeOine un operador depende del 7ipo de operador del Rue 5e 7ra7eN
Sa Rue no e5 lo mi5mo deOinir un operador unario Rue uno Minario% Sin emMargoN como
regla general podemo5 con5iderar Rue 5e Wace deOiniendo un m67odo pTMlico S e5797ico
cuSo nomMre 5ea el 5VmMolo del operador a redeOinir S Qenga precedido de la palaMra
re5erQada operator% E5 decirN 5e 5igue una 5in7aUi5 de la OormaL

pubIic static <tipoDevuelto> operator <símbolo>(<operandos>)
{
<cuerpo>
}
Lo5 modiOicadore5 pubIic S static pueden permu7ar5e 5i 5e de5eaN lo Rue e5 impor7an7e e5
Rue 5iempre apare8can en 7oda redeOinición de operador% Se pueden redeOinir 7an7o
operadore5 unario5 como Minario5N S en <operandos> 5e Wa de incluir 7an7o5 par9me7ro5
como operando5 pueda 7omar el operador a redeOinirN Sa Rue cada uno repre5en7ar9 a
uno de 5u5 operando5% Por Tl7imoN en <cuerpo> 5e Wan de e5criMir la5 in57ruccione5 a
ejecu7ar cada Qe8 Rue 5e apliRue la operación cuSo operador e5 <símbolo> a operando5
de lo5 7ipo5 indicado5 en <operandos>%
<tipoDevuelto> no puede 5er voidN pue5 por deOinición 7oda operación 7iene un re5ul7adoN
por lo Rue 7odo operador Wa de deQolQer algo% Adem95N permi7irlo complicarVa
innece5ariamen7e el compilador S 657e 7endrVa Rue admi7ir in57ruccione5 poco in7ui7iQa5
Icomo a+b; 5i el + e57uQie5e redeOinido con Qalor de re7orno void para lo5 7ipo5 de a S bK

Adem95N lo5 operadore5 no pueden redeOinir5e con 7o7al liMer7ad Sa Rue ello 7amMi6n
diOicul7arVa 5in nece5idad la legiMilidad del códigoN por lo Rue 5e Wan in7roducido la5
5iguien7e5 re57riccione5 al redeOinirlo5L
• Al meno5 uno de lo5 operando5 Wa de 5er del mi5mo 7ipo de da7o del Rue 5ea
miemMro la redeOinición del operador% Como puede deducir5eN ello implica Rue
aunRue puedan 5oMrecargar5e lo5 operadore5 Minario5 nunca podr9 Wacer5e lo mi5mo
con lo5 unario5 Sa Rue 5u Tnico par9me7ro 5ólo puede 5er de un Tnico 7ipo Iel 7ipo
den7ro del Rue 5e deOinaK Adem95N ello 7amMi6n proQoca Rue no pueden redeOinir5e
la5 conQer5ione5 Sa incluida5 en la BCL porRue al meno5 uno de lo5 operando5
5iempre WaMr9 de 5er de algTn nueQo 7ipo deOinido por el u5uario%
• No puede al7erar5e 5u5 regla5 de precedenciaN a5ocia7iQidadN uMicación S nTmero de
operando5N pue5 5i Sa de por 5V e5 diOVcil para mucWo5 recordarla5 cuando 5on Oija5N
mucWo m95 lo 5erVa 5i pudie5en modiOicar5e 5egTn lo5 7ipo5 de 5u5 operando5%
• No puede deOinir5e nueQo5 operadore5 ni comMinacione5 de lo5 Sa eUi57en7e5 con
nueQo5 5igniOicado5 Ipor ejemplo ** para repre5en7ar eUponenciaciónKN pue5 ello
complicarVa innece5ariamen7e el compiladorN el lenguaje S la legiMilidad del código
cuando en realidad e5 algo Rue puede 5imular5e deOiniendo m67odo5%
El lenguaje de programación C# (ema ::L )edeOinición de operadore5
• No 7odo5 lo5 operadore5 incluido5 en el lenguaje pueden redeOinir5eN pue5 mucWo5
de ello5 Icomo .N newN =N e7c%K 5on M95ico5 para el lenguaje S 5u redeOinición e5
inQiaMleN poco T7il o diOicul7arVa innece5ariamen7e la legiMilidad del código% Adem95N
no 7odo5 lo5 redeOiniMle5 5e redeOinen u5ando la 5in7aUi5 general Wa57a aWora Qi57aN
aunRue en 5u momen7o 5e ir9n eUplicando cu9le5 5on lo5 redeOiniMle5 S cu9le5 5on
la5 peculiaridade5 de aRuello5 Rue reRuieran una redeOinición e5pecial%
A con7inuación 5e mue57ra cómo 5e redeOinirVa el 5igniOicado del operador + para lo5
oMje7o5 Complejo del ejemplo an7eriorL
class Complejo;
{
public float ParteReal;
public float ParteÌmaginaria;
public Complejo (float parteReal, float parteÌmaginaria)
{
this.ParteReal = parteReal;
this.ParteÌmaginaria = parteÌmaginaria;
}
public static Complejo operator +(Complejo op1, Complejo op2)
{
Complejo resultado = new Complejo();
resultado.ParteReal = op1.ParteReal + op2.ParteReal;
resultado.ParteÌmaginaria = op1.ParteÌmaginaria + op2.ParteÌmaginaria;
return resultado;
}
}
E5 O9cil Qer Rue lo Rue en el ejemplo 5e Wa redeOinido e5 el 5igniOicado del operador +
para Rue cuando 5e apliRue en7re do5 oMje7o5 de cla5e Complejo deQuelQa un nueQo
oMje7o Complejo cuSa5 par7e5 real e imaginaria 5ea la 5uma de la5 de 5u5 operando5%
Se con5idera erróneo incluir la palaMra re5erQada new en la redeOinición de un operadorN
Sa Rue no pueden ocul7ar5e redeOinicione5 de operadore5 en 7an7o Rue e57o5 no 5e
aplican u7ili8ando el nomMre del 7ipo en Rue e576n deOinido5% La5 Tnica5 po5iMle5
coincidencia5 5e darVan en 5i7uacione5 como la del 5iguien7e ejemploL
using System;
class A
{
public static int operator +(A obj1, B obj2)
{
Console.WriteLine(“Aplicado + de A”);
return 1;
}
}
class B:A
{
public static int operator +(A obj1, B obj2)
{
Console.WriteLine(“Aplicado + de B”);
El lenguaje de programación C# (ema ::L )edeOinición de operadore5
return 1;
}
public static void Main()
{
A o1 = new A();
B o2 = new B();
Console.WriteLine(“o1+o2={0}”, o1+o2);
}
}
Sin emMargoN m95 Rue una ocul7ación de operadore5 lo Rue 5e 7iene e5 un proMlema de
amMigiedad en la deOinición del operador + en7re oMje7o5 de 7ipo5 A S B, de la Rue 5e
inOormar9 al compilar Sa Rue el compilador no 5aMr9 cu9l Qer5ión del operador deMe
u5ar para 7raducir o1+o2 a código Minario%
Redefinición de operadores unarios
Lo5 Tnico5 operadore5 unario5 redeOiniMle5 5onL !, +, -, ~, ++, --, true y faIseN S 7oda
redeOinición de un operador unario Wa de 7omar un Tnico par9me7ro Rue Wa de 5er del
mi5mo 7ipo Rue el 7ipo de da7o al Rue per7ene8ca la redeOinición%
Lo5 operadore5 ++ S -- 5iempre Wa de redeOinir5e de manera Rue el 7ipo de da7o del
oMje7o deQuel7o 5ea el mi5mo Rue el 7ipo de da7o donde 5e deOinen% Cuando 5e u5en de
Oorma preOija 5e deQolQer9 e5e oMje7oN S cuando 5e u5en de Oorma po57iOja el compilador
lo Rue War9 5er9 deQolQer el oMje7o original Rue 5e le5 pa5ó como par9me7ro en lugar del
indicado en el return% Por ello e5 impor7an7e no modiOicar dicWo par9me7ro 5i e5 de un
7ipo reOerencia S Rueremo5 Rue e57o5 operadore5 7engan 5u 5igniOicado 7radicional% "n
ejemplo de cómo Wacerlo e5 la 5iguien7e redeOinición de ++ para el 7ipo ComplejoL

public static Complejo operator ++ (Complejo op)
{
Complejo resultado = new Complejo(op.ParteReal + 1, op.ParteÌmaginaria);
return resultado;
}
Nó7e5e Rue 5i WuMi65emo5 redeOinido el ++ de e57a o7ra OormaL
public static Complejo operator ++ (Complejo op)
{
op.ParteReal++;
return op;
}
En7once5 el re5ul7ado deQuel7o al aplic9r5elo a un oMje7o 5iempre 5erVa el mi5mo 7an7o 5i
Oue aplicado de Oorma preOija como 5i lo Oue de Oorma po57iOijaN Sa Rue en amMo5 ca5o5
el oMje7o deQuel7o 5erVa el mi5mo% Sin emMargoN e5o no ocurrirVa 5i Complejo Oue5e una
e57ruc7uraN Sa Rue en7once5 op no 5erVa el oMje7o original 5ino una copia de 657e S lo5
camMio5 Rue 5e le Wicie5en en el cuerpo de la redeOinición de ++ no aOec7arVan al oMje7o
originalN Rue e5 el Rue 5e deQuelQe cuando 5e u5a ++ de manera po57Oija%
El lenguaje de programación C# (ema ::L )edeOinición de operadore5
)e5pec7o a lo5 operadore5 true S faIseN e57o5 indican re5pec7iQamen7eN cuando 5e Wa de
con5iderar Rue un oMje7o repre5en7a el Qalor lógico cier7o S cuando 5e Wa de con5iderar
Rue repre5en7a el Qalor lógico Oal5oN por lo Rue 5u5 redeOinicione5 5iempre Wan de
deQolQer un oMje7o de 7ipo booI Rue indiRue dicWa 5i7uación% Adem95N 5i 5e redeOine uno
e5 oMliga7orio redeOinir 7amMi6n el o7roN pue5 5iempre e5 po5iMle u5ar indi57in7amen7e
uno u o7ro para de7erminar el Qalor lógico Rue un oMje7o de e5e 7ipo repre5en7e%
En realidad lo5 operadore5 true S faIse no pueden u5ar5e direc7amen7e en el código
Ouen7eN 5ino Rue redeOinirlo5 para un 7ipo de da7o e5 T7il porRue permi7en u7ili8ar oMje7o5
de e5e 7ipo en eUpre5ione5 condicionale5 7al S como 5i de un Qalor lógico 5e 7ra7a5e% Por
ejemploN podemo5 redeOinir e57o5 operadore5 en el 7ipo Complejo de modo Rue
con5ideren cier7o a 7odo complejo di57in7o de + P +i S Oal5o a + P +iL
public static bool operator true(Complejo op)
{
return (op.ParteReal != 0 || op.ParteÌmaginaria != 0);
}
public static bool operator false(Complejo op)
{
return (op.ParteReal == 0 && op.ParteÌmaginaria == 0);
}
Con e57a5 redeOinicione5N un código como el Rue 5igue mo57rarVa por pan7alla el men5aje
@s ciertoL
Complejo c1 = new Complejo(1, 0); // c1 = 1 + 0i
if (c1)
System.Console.WriteLine(“Es cierto”);
Redefinición de operadores binarios
Lo5 operadore5 Minario5 redeOiniMle5 5on +N -N *N /N %N &N |N ^N <<N >>N ==N !=N >N <N >= S <=
(oda redeOinición Rue 5e Waga de ello5 Wa de 7omar do5 par9me7ro5 7ale5 Rue al meno5
uno 5ea del mi5mo 7ipo Rue el 7ipo de da7o del Rue e5 miemMro la redeOinición%
HaS Rue 7ener en cuen7a Rue aRuello5 de e57o5 operadore5 Rue 7engan complemen7ario
5iempre Wan de redeOinir5e jun7o con 657e% E5 decirN 5iempre Rue 5e redeOina en un 7ipo el
operador > 7amMi6n Wa de redeOinir5e en 6l el operador <N 5iempre Rue 5e redeOina >= Wa
de redeOinir5e <=N S 5iempre Rue 5e redeOina == Wa de redeOinir5e !=%
(amMi6n WaS Rue 5eXalar RueN como puede deducir5e de la li57a de operadore5 Minario5
redeOiniMle5 dadaN no e5 redeOinir direc7amen7e ni el operador de a5ignación c ni lo5
operadore5 compue57o5 I+=N -=N e7c%K Sin emMargoN en el ca5o de e57o5 Tl7imo5 dicWa
redeOinición ocurre de manera au7om97ica al redeOinir 5u par7e _no =` E5 decirN al
redeOinir + Ruedar9 redeOinido con5ecuen7emen7e +=N al redeOinir * lo War9 *=N e7c%
Por o7ra par7eN 7amMi6n caMe 5eXalar Rue no e5 po5iMle redeOinir direc7amen7e lo5
operadore5 && S ||% E57o 5e deMe a Rue el compilador lo5 7ra7a de una manera e5pecial
Rue con5i57e en eQaluarlo5 pere8o5amen7e% Sin emMargoN e5 po5iMle 5imular 5u
El lenguaje de programación C# (ema ::L )edeOinición de operadore5
redeOinición redeOiniendo lo5 operadore5 unario5 true S faIseN lo5 operadore5 Minario5 &
S | S 7eniendo en cuen7a Rue && S || 5e eQalTan a5VL
• &&L Si 7enemo5 una eUpre5ión de la Oorma x && yN 5e aplica primero el operador
faIse a x% Si deQuelQe faIseN en7once5 x && y deQuelQe el re5ul7ado de eQaluar xb S
5i noN en7once5 deQuelQe el re5ul7ado de eQaluar x & y
• ||L Si 7enemo5 una eUpre5ión de la Oorma x || yN 5e aplica primero el operador true
a x% Si deQuelQe trueN 5e deQuelQe el re5ul7ado de eQaluar xb S 5i noN 5e deQuelQe
el de eQaluar x | y%
Redefiniciones de operadores de conversión
En el Tema *: .s!e$tos +é/i$os Sa Qimo5 Rue para conQer7ir oMje7o5 de un 7ipo de da7o
en o7ro 5e puede u5ar un operador de conQer5ión Rue 7iene la 5iguien7e 5in7aUi5L
(<tipoDestino>) <expresión>
Lo Rue e57e operador Wace e5 deQolQer el oMje7o re5ul7an7e de conQer7ir al 7ipo de da7o de
nomMre <tipoDestino> el oMje7o re5ul7an7e de eQaluar <expresión> Para Rue la conQer5ión
pueda aplicar5e e5 preci5o Rue eUi57a alguna deOinición de cómo 5e Wa de conQer7ir a
<tipoDestino> lo5 oMje7o5 del 7ipo re5ul7an7e de eQaluar <expresión> E57o puede indicar5e
in7roduciendo como miemMro del 7ipo de e5o5 oMje7o5 o del 7ipo <tipoDestino> una
redeOinición del operador de conQer5ión Rue indiRue cómo Wacer la conQer5ión del 7ipo
del re5ul7ado de eQaluar <expresión> a <tipoDestino>
La5 redeOinicione5 de operadore5 de conQer5ión pueden 5er de do5 7ipo5L
• EI<-L6739;: La conQer5ión 5ólo 5e reali8a cuando 5e u5en eUplVci7amen7e lo5
operadore5 de conQer5ión an7e5 comen7ado%
• I?<-L6739;: La conQer5ión 7amMi6n 5e reali8a au7om97icamen7e cada Qe8 Rue 5e
a5igne un oMje7o de e5e 7ipo de da7o a un oMje7o del 7ipo <tipoDestino>% E57a5
conQer5ione5 5on m95 cómoda5 Rue la5 eUplVci7a5 pero 7amMi6n m95 peligro5a5
Sa Rue pueden ocurrir 5in Rue el programador 5e d6 cuen7a% Por elloN 5ólo
deMerVan deOinir5e como implVci7a5 la5 conQer5ione5 5egura5 en la5 Rue no 5e
puedan producir eUcepcione5 ni perder5e inOormación al reali8arla5%
En un mi5mo 7ipo de da7o pueden deOinir5e mTl7iple5 conQer5ione5 5iempre S cuando el
7ipo origen de la5 mi5ma5 5ea diOeren7e% Por 7an7oN no e5 Q9lido deOinir a la Qe8 en un
mi5mo 7ipo una Qer5ión implVci7a de una cier7a conQer5ión S o7ra eUplVci7a%
La 5in7aUi5 Rue 5e u5a para Wacer redeOinir una operador de conQer5ión e5 parecida a la
u5ada para cualRuier o7ro operador 5ólo Rue no WaS Rue darle nomMreN 7oma un Tnico
par9me7ro S WaS Rue preceder la palaMra re5erQada operator con la5 palaMra5 re5erQada5
expIicit o impIicit 5egTn 5e deOina la conQer5ión como eUplVci7a o implVci7a% Por ejemploN
para deOinir una conQer5ión implVci7a de Complejo a fIoat podrVa Wacer5eL
public static implicit operator float(Complejo op)
El lenguaje de programación C# (ema ::L )edeOinición de operadore5
{
return op.ParteReal;
}
Nó7e5e Rue el 7ipo del par9me7ro u5ado al deOinir la conQer5ión 5e corre5ponde con el
7ipo de da7o del oMje7o al Rue 5e puede aplicar la conQer5ión I37<. .47=12KN mien7ra5 Rue
el 7ipo del Qalor deQuel7o 5er9 el 7ipo al Rue 5e realice la conQer5ión I37<. 51;372.K Con
e57a deOinición podrVan e5criMir5e código5 como el 5iguien7eL
Complejo c1 = new Complejo(5,2); // c1 = 5 + 2i
float f = c1; // f = 5
Nó7e5e Rue en la conQer5ión de Complejo a fIoat 5e pierde inOormación Ila par7e
imaginariaKN por lo Rue 5erVa mejor deOinir la conQer5ión como eUplVci7a 5u57i7uSendo en
5u deOinición la palaMra re5erQada impIicit por expIicit% En e5e ca5oN el código an7erior
WaMrVa de camMiar5e porL
Complejo c1 = new Complejo(5,2); // c1 = 5 + 2i
float f = (float) c1; // f = 5
Por o7ro ladoN 5i lo Rue Wacemo5 e5 redeOinir la conQer5ión de fIoat a Complejo conL
public static implicit operator Complejo(float op)
{
return (new Complejo(op, 0));
}
En7once5 5e podrVa crear oMje7o5 Complejo a5VL
Complejo c2 = 5; // c2 = 5 + 0i
,6a5e Rue en e57e ca5o nunca 5e perder9 inOormación S la conQer5ión nunca Oallar9N por
lo Rue e5 perOec7amen7e Q9lido deOinirla como implVci7a% Adem95N nó7e5e como
redeOiniendo conQer5ione5 implVci7a5 puede con5eguir5e Rue lo5 7ipo5 deOinido5 por el
u5uario puedan iniciali8ar5e direc7amen7e a par7ir de Qalore5 li7erale5 7al S como 5i
Oue5en 7ipo5 M95ico5 del lenguaje%
En realidadN cuando 5e deOinan conQer5ione5 no 7iene porRu65 5iempre ocurrir Rue el
7ipo de57ino indicado 5ea el 7ipo del Rue 5ea miemMro la redeOiniciónN 5ino Rue 5ólo Wa
de cumplir5e Rue o el 7ipo de57ino o el 7ipo origen 5ean de dicWo 7ipo% 5eaN den7ro de
un 7ipo de da7o 5ólo pueden deOinir5e conQer5ione5 de e5e 7ipo a o7ro o de o7ro 7ipo a e5e%
Sin emMargoN al permi7ir5e conQer5ione5 en amMo5 5en7ido5 WaS Rue 7ener cuidado
porRue ello puede producir proMlema5 5i 5e 5olici7an conQer5ione5 para la5 Rue eUi57a
una deOinición de cómo reali8arla5 en el 7ipo Ouen7e S o7ra en el 7ipo de57ino% Por
ejemploN el 5iguien7e código proQoca un error al compilar deMido a elloL
class A
{
static void Main(string[] args)
{
A obj = new B(); // Error: Conversión de B en A ambigua
}
public static implicit operator A(B obj)
El lenguaje de programación C# (ema ::L )edeOinición de operadore5
{
return new A();
}
}
class B
{
public static implicit operator A(B obj)
{
return new A();
}
}
El proMlema de e57e 7ipo de errore5 e5 Rue puede re5ul7a diOVcil de5cuMrir 5u5 cau5a5 en
7an7o Rue el men5aje Rue el compilador emi7e indica Rue no 5e pueden conQer7ir lo5
oMje7o5 A en oMje7o5 B pero no aclara Rue ello 5e deMa a una amMigiedad%
7ro error con el Rue WaS Rue 7ener cuidado e5 con el WecWo de Rue puede ocurrir Rue al
me8clar redeOinicione5 implVci7a5 con m67odo5 5oMrecargado5 puedan WaMer
amMigiedade5 al de7erminar a Ru6 Qer5ión del m67odo 5e Wa de llamar% Por ejemploN
dado el códigoL
using System;
class A
{
public static implicit operator A(B obj)
{
return new A();
}
public static void MétodoSobrecargado(A o)
{
Console.WriteLine("Versión que toma A");
}
public static void MétodoSobrecargado(C o)
{
Console.WriteLine("Versión que toma C");
}
static void Main(string[] args)
{
MétodoSobrecargado(new B());
}
}
class B
{
public static implicit operator C(B obj)
{
return new C();
}
}
class C
{}
El lenguaje de programación C# (ema ::L )edeOinición de operadore5
Al compilarlo 5e producir9 un error deMido a Rue en la llamada a MétodoSobrecargado()
el compilador no puede deducir a Ru6 Qer5ión del m67odo 5e de5ea llamar Sa Rue eUi57en
conQer5ione5 implVci7a5 de oMje7o5 de 7ipo B en cualRuiera de lo5 7ipo5 admi7ido5 por 5u5
di57in7a5 Qer5ione5% Para re5olQerlo lo mejor e5peciOicar eUplVci7amen7e en la llamada la
conQer5ión a aplicar u5ando el operador () Por ejemploN para u5ar u5ar la Qer5ión del
m67odo Rue 7oma como par9me7ro un oMje7o de 7ipo A 5e podrVa WacerL
MétodoSobrecargado ( (A) new B());
Sin emMargoN WaS Rue 7ener cuidado Sa Rue 5i en Qe8 del código an7erior 5e 7uQie5eL
class A
{
public static implicit operator A(B obj)
{
return new A();
}
public static void MétodoSobrecargado(A o)
{
Console.WriteLine("Versión que toma A");
}
public static void MétodoSobrecargado(C o)
{
Console.WriteLine("Versión que toma C");
}
static void Main(string[] args)
{
MétodoSobrecargado(new B());
}
}
class B
{
public static implicit operator A(B obj)
{
return new A();
}
public static implicit operator C(B obj)
{
return new C();
}
}
class C
{}
En7once5 el Ouen7e compilarVa con normalidad S al ejecu7arlo 5e mo57rarVa el 5iguien7e
men5aje Rue demue57ra Rue 5e Wa u5ado la Qer5ión del m67odo Rue 7oma un oMje7o C%
/inalmen7eN WaS Rue 5eXalar Rue no e5 po5iMle deOinir cualRuier 7ipo de conQer5iónN 5ino
Rue aRuella5 para la5 Rue Sa eUi57a un mecani5mo predeOinido en el lenguaje no 5on
El lenguaje de programación C# (ema ::L )edeOinición de operadore5
Q9lida5% E5 decirN no pueden deOinir5e conQer5ione5 en7re un 7ipo S 5u5 an7ece5ore5 Ipor
el polimorOi5mo Sa eUi57enKN ni en7re un 7ipo S 6l mi5moN ni en7re 7ipo5 e in7erOace5 por
ello5 implemen7ada5 Ila5 in7erOace5 5e eUplicar9n en el Tema %5: "nter0a$esK
El lenguaje de programación C# (ema :&L #elegado5 S eQen7o5
TEMA 12: DeIegados y eventos
Concepto de delegado
"n 51-1=95. e5 un 7ipo e5pecial de cla5e cuSo5 oMje7o5 pueden almacenar reOerencia5 a
uno o m95 m67odo5 de 7al manera Rue a 7raQ65 del oMje7o 5ea po5iMle 5olici7ar la
ejecución en cadena de 7odo5 ello5%
Lo5 delegado5 5on muS T7ile5 Sa Rue permi7en di5poner de oMje7o5 cuSo5 m67odo5
puedan 5er modiOicado5 din9micamen7e duran7e la ejecución de un programa% #e WecWoN
5on el mecani5mo M95ico en el Rue 5e Ma5a la e5cri7ura de aplicacione5 de Qen7ana5 en la
pla7aOorma %NE(% Por ejemploN 5i en lo5 oMje7o5 de una cla5e Button Rue repre5en7e a lo5
Mo7one5 e579ndar de <indoY5 deOinimo5 un campo de 7ipo delegadoN podemo5
con5eguir Rue cada Mo7ón Rue 5e cree ejecu7e un código diOeren7e al 5er pul5ado 5in m95
Rue almacenar el código a ejecu7ar por cada Mo7ón en 5u campo de 7ipo delegado S luego
5olici7ar la ejecución 7odo e57e código almacenado cada Qe8 Rue 5e pul5e el Mo7ón%
Sin emMargoN 7amMi6n 5on T7ile5 para mucWV5ima5 o7ra5 co5a5 7ale5 como a5ociación de
código a la carga S de5carga de en5amMlado5N a camMio5 en Ma5e5 de da7o5N a camMio5 en
el 5i57ema de arcWiQo5N a la Oinali8ación de operacione5 a5Vncrona5N la ordenación de
conjun7o5 de elemen7o5N e7c% En generalN 5on T7ile5 en 7odo5 aRuello5 ca5o5 en Rue
in7ere5e pa5ar m67odo5 como par9me7ro5 de o7ro5 m67odo5%
Adem95N lo5 delegado5 proporcionan un mecani5mo median7e el cual uno5 oMje7o5
pueden 5olici7ar a o7ro5 Rue 5e le5 no7iOiRue cuando ocurran cier7o5 5uce5o5% Para elloN
Ma57arVa 5eguir el pa7rón con5i57en7e en Wacer Rue lo5 oMje7o5 no7iOicadore5 di5pongan de
algTn campo de 7ipo delegado S Wacer Rue lo5 oMje7o5 in7ere5ado5 almacenen m67odo5
5uSo5 en dicWo5 campo5 de modo Rue cuando ocurra el 5uce5o apropiado el oMje7o
no7iOicador 5imule la no7iOicación ejecu7ando 7odo5 lo5 m67odo5 a5V a5ociado5 a 6l%
(efinición de delegados
"n delegado no e5 m95 Rue un 7ipo e5pecial de 5uMcla5e System.MuIticastDeIegate% Sin
emMargoN para deOinir e57a5 cla5e5 no 5e puede u7ili8ar el mecani5mo de Werencia normal
5ino Rue Wa de 5eguir5e la 5iguien7e 5in7aUi5 e5pecialL
<modi!icadores> deIegate <tipoRetorno> <nombreDelegado> (<parámetros>);
<nombreDelegado> 5er9 el nomMre de la cla5e delegado Rue 5e deOineN mien7ra5 Rue
<tipoRetorno> S <parámetros> 5e corre5ponder9nN re5pec7iQamen7eN con el 7ipo del Qalor
de re7orno S la li57a de par9me7ro5 de lo5 m67odo5 cuSo5 código5 puede almacenar en 5u
in7erior lo5 oMje7o5 de e5e 7ipo delegado I.C>13.; 51-1=95.;K
"n ejemplo de cómo deOinir un delegado de nomMre Deleg cuSo5 oMje7o5 puedan
almacenar m67odo5 Rue deQuelQan un string S 7omen como par9me7ro un int e5L
delegate void Deleg(int valor);
El lenguaje de programación C# (ema :&L #elegado5 S eQen7o5
CualRuier in7en7o de almacenar en e57e delegado m67odo5 Rue no 7omen 5ólo un int
como par9me7ro o no deQuelQan un string producir9 un error de compilación oN 5i no
pudie5e de7ec7ar5e al compilarN una eUcepción de 7ipo System.ArgumentNuIIException
en 7iempo de ejecución% E57o puede Qer5e con el 5iguien7e programa de ejemploL
using System;
using System.Reflection;
public delegate void D();
public class ComprobaciónDelegados
{
public static void Main()
{
Type t = typeof(ComprobaciónDelegados);
MethodÌnfo m = t.GetMethod(“Método1”);
D obj = (D) Delegate.CreateDelegate(typeof(D), m);
obj();
}
public static void Método1()
{ Console.WriteLine(“Ejecutado Método1”); }
public static void Método2(string s)
{ Console.WriteLine(“Ejecutado Método2”); }
}
Lo Rue 5e Wace en el m67odo Main() de e57e programa e5 crear a par7ir del oMje7o Type
Rue repre5en7a al 7ipo ComprobaciónDelegados un oMje7o System.RefIection.MethodInfo
Rue repre5en7a a 5u m67odo Método1% Como 5e QeN para crear el oMje7o Type 5e u7ili8a el
operador typeof Sa e57udiadoN S para oM7ener el oMje7o MethodInfo 5e u5a 5u m67odo
GetMethod() Rue 7oma como par9me7ro una cadena con el nomMre del m67odo cuSo
MethodInfo de5ee oM7ener5e% "na Qe8 con5eguidoN 5e crea un oMje7o delegado de 7ipo D
Rue almacene una reOerencia al m67odo por 6l repre5en7ado a 7raQ65 del m67odo
CreateDeIegate() de la cla5e DeIegate S 5e llama dicWo oMje7oN lo Rue mue57ra el men5ajeL
@7ecutado MPtodoC
AunRue en Qe8 de oM7ener el MethodInfo Rue repre5en7a al Método1 5e WuMie5e oM7enido
el Rue repre5en7a al Método2 el compilador no de7ec7arVa nada raro al compilar Sa Rue no
e5 lo Ma57an7e in7eligen7e como para 5aMer Rue dicWo oMje7o no repre5en7a a un m67odo
almacenaMle en oMje7o5 delegado5 de 7ipo D% Sin emMargoN al ejecu7ar5e la aplicación el
CL) 5V Rue lo de7ec7arVa S ello proQocarVa una ArgumentNuIIException
E57o e5 un diOerencia impor7an7e de lo5 delegado5 re5pec7o a lo5 pun7ero5 a Ounción de
C^CPP IRue 7amMi6n pueden almacenar reOerencia5 a m67odo5KN Sa Rue con e57o5 Tl7imo5
no 5e reali8an dicWa5 comproMacione5 en 7iempo de ejecución S puede 7erminar
ocurriendo Rue un pun7ero a Ounción apun7e a un m67odo cuSa 5igna7ura o Qalor de
re7orno no 5e corre5pondan con lo5 indicado5 en 5u deOiniciónN lo Rue puede oca5ionar
Rue el programa Oalle por cau5a5 diOVcile5 de de7ec7ar%
La5 deOinicione5 de delegado5 7amMi6n pueden incluir cualRuiera de lo5 modiOicadore5
de acce5iMilidad Q9lido5 para una cla5eN Sa Rue al Oin S al caMo lo5 delegado5 5on cla5e5%
El lenguaje de programación C# (ema :&L #elegado5 S eQen7o5
E5 decirN 7odo5 pueden incluir lo5 modiOicadore5 pubIic e internaIN S lo5 5e deOinan
den7ro de o7ro 7ipo 7amMi6n pueden incluir protectedP private S protected internaI%
Manipulación de ob&etos delegados
"n oMje7o de un 7ipo delegado 5e crea eUac7amen7e igual Rue un oMje7o de cualRuier
cla5e 5ólo Rue en 5u con57ruc7or Wa de pa59r5ele el nomMre del m67odo cuSo código
almacenar9% E57e m67odo puede 7an7o 5er un m67odo e5797ico como uno no e5797ico% En
el primer ca5o 5e indicarVa 5u nomMre con la 5in7aUi5 <nombreTipo>.<nombreMétodo>, S
en el 5egundo 5e indicarVa con <objeto>.<nombreMétodo>
Para llamar al código almacenado en el delegado 5e u5a una 5in7aUi5 5imilar a la de la5
llamada5 a m67odo5N 5ólo Rue no WaS Rue preOijar el oMje7o delegado de ningTn nomMre
de 7ipo o de oMje7o S 5e u5a 5implemen7e <objetoDelegado>(<valoresParámetros>)
El 5iguien7e ejemplo mue57ra cómo crear un oMje7o delegado de 7ipo DN a5ociarle el
código de un m67odo llamado F S ejecu7ar dicWo código a 7raQ65 del oMje7o delegadoL
using System;
delegate void D(int valor);
class EjemploDelegado
{
public static void Main()
{
D objDelegado = new D(F);
objDelegado(3);
}
public static void F(int x)
{
Console.WriteLine( “Pasado valor {0} a F()”, x);
}
}
La ejecución de e57e programa producir9 la 5iguien7e 5alida por pan7allaL
4asado 2alor ( a G(%
Nó7e5e Rue para a5ociar el código de F() al delegado no 5e Wa indicado el nomMre de e57e
m67odo e5797ico con la 5in7aUi5 <nombreTipo>.<nombreMétodo> an7e5 comen7ada% E57o 5e
deMe a Rue no e5 nece5ario incluir el <nombreTipo>% cuando el m67odo a a5ociar a un
delegado e5 e5797ico S e579 deOinido en el mi5mo 7ipo Rue el código donde e5 a5ociado
En realidad un oMje7o delegado puede almacenar código5 de mTl7iple5 m67odo5 7an7o
e5797ico5 como no e5797ico5 de manera Rue una llamada a 7raQ65 5uSa produ8ca la
ejecución en cadena de 7odo5 ello5 en el mi5mo orden en Rue 5e almacenaron en 6l%
Nó7e5e Rue 5i lo5 m67odo5 deQuelQen algTn QalorN 7ra5 la ejecución de la cadena de
llamada5 5ólo 5e deQolQer9 el Qalor de re7orno de la Tl7ima llamada%
Adem95N cuando 5e reali8a una llamada a 7raQ65 de un oMje7o delegado no 5e 7ienen en
cuen7a lo5 modiOicadore5 de Qi5iMilidad de lo5 m67odo5 Rue 5e ejecu7ar9nN lo Rue permi7e
El lenguaje de programación C# (ema :&L #elegado5 S eQen7o5
llamar de5de un 7ipo a m67odo5 priQado5 de o7ro5 7ipo5 Rue e576n almacenado5 en un
delegado por acce5iMle de5de el primero 7al S como mue57ra el 5iguien7e ejemploL
using System;
public delegate void D();
class A
{
public static D obj;
public static void Main()
{
B.AlmacenaPrivado();
obj();
}
}
class B
{
private static void Privado()
{ Console.WriteLine(“Llamado a método privado”); }
public static void AlmacenaPrivado()
{ A.obj += new D(Privado); }
}
La llamada a AlmacenaPrivado en el m67odo Main() de la cla5e A proQoca Rue en el campo
delegado obj de dicWa cla5e 5e almacene una reOerencia al m67odo priQado Privado() de la
cla5e BN S la in57rucción 5iguien7e proQoca la llamada a dicWo m67odo priQado de5de una
cla5e eU7erna a la de 5u deOinición como demue57ra la 5alida del programaL
Llamado a mPtodo 5ri2ado
Para aXadir nueQo5 m67odo5 a un oMje7o delegado 5e le aplica el operador += pa59ndole
como operando derecWo un oMje7o delegado de 5u mi5mo 7ipo Ino Qale de o7ro aunRue
admi7a lo5 mi5mo5 7ipo5 de par9me7ro5 S Qalor de re7ornoK Rue con7enga lo5 m67odo5 a
aXadirleN S para Rui79r5elo5 5e Wace lo mi5mo pero con el operador -=% Por ejemploN el
5iguien7e código mue57ra lo5 eOec7o5 de amMo5 operadore5L
using System;
delegate void D(int valor);
class EjemploDelegado
{
public string Nombre;
EjemploDelegado(string nombre)
{
Nombre = nombre;
}
public static void Main()
{
EjemploDelegado obj1 += new EjemploDelegado(“obj1”);
D objDelegado = new D(f);
El lenguaje de programación C# (ema :&L #elegado5 S eQen7o5
objDelegado += new D(obj1.g);
objDelegado(3);
objDelegado -= new D(obj1.g);
objDelegado(5);
}
public void g(int x)
{
Console.WriteLine(“Pasado valor {0} a g() en objeto {1}”, x, Nombre);
}
public static void f(int x)
{
Console.WriteLine( “Pasado valor {0} a f()”, x);
}
}

La 5alida producida por pan7alla por e57e programa 5er9L
4asado 2alor ( a <(%
4asado 2alor ( a g(% en o-7eto o-7C
4asado 2alor 5 a <(%
Como 5e QeN cuando aWora 5e Wace la llamada objDelegado(3) 5e ejecu7an lo5 código5 de
lo5 do5 m67odo5 almacenado5 en objDelegadoN S al Rui79r5ele luego uno de e57o5 código5
la 5iguien7e llamada 5ólo ejecu7a el código del Rue Rueda% Nó7e5e adem95 en el ejemplo
como la redeOinición de + reali8ada para lo5 delegado5 permi7e Rue 5e pueda iniciali8ar
objDelegado u5ando += en Qe8 de =% E5 decirN 5i uno de lo5 operando5 de + Qale nuII no
5e produce ninguna eUcepciónN 5ino Rue 7an 5ólo no 5e aXade ningTn m67odo al o7ro%

HaS Rue 5eXalar Rue un oMje7o delegado Qale nuII 5i no 7iene ningTn m67odo a5ociadoN
Sa 5ea porRue no 5e Wa llamado aTn a 5u con57ruc7or o porRue lo5 Rue 7uQie5e a5ociado
5e le WaSan Rui7ado con -=% A5VN 5i al Main() del ejemplo an7erior le aXadimo5 al OinalL
objDelegado -= new D(f);
objDelegado(6);
Se producir9 al ejecu7arlo una eUcepción de 7ipo System.NuIIReferenceException
indicando Rue 5e Wa in7en7ado acceder a una reOerencia nula%
(amMi6n WaS Rue 5eXalar Rue para Rue el operador -= Ouncione 5e le Wa de pa5ar como
operador derecWo un oMje7o delegado Rue almacene algTn m67odo eUac7amen7e igual al
m67odo Rue 5e le Ruiera Rui7ar al oMje7o delegado de 5u lado i8Ruierdo% Por ejemploN 5i
5e le Ruiere Rui7ar un m67odo de un cier7o oMje7oN 5e le Wa de pa5ar un oMje7o delegado
Rue almacene e5e m67odo de e5e mi5mo oMje7oN S no Qale Rue almacene e5e m67odo pero
de o7ro oMje7o de 5u mi5mo 7ipo% Por ejemploN 5i al Main() an7erior le aXadimo5 al OinalL
objDelegado -= new g(obj1.g);
objDelegado(6);
En7once5 no 5e producir9 ninguna eUcepción Sa Rue el -= no eliminar9 ningTn m67odo
de objDelegado deMido a Rue e5e oMje7o delegado no con7iene ningTn m67odo g()
proceden7e del oMje7o obj1% E5 m95N la 5alida Rue 5e producir9 por pan7alla 5er9L

4asado 2alor ( a <(%
El lenguaje de programación C# (ema :&L #elegado5 S eQen7o5
4asado 2alor ( a g(% en o-7eto o-7C
4asado 2alor 5 a <(%
4asado 2alor R a <(%
La clase !$stem.Multicast(elegate
2a 5e Wa dicWo Rue la 5in7aUi5 e5pecial de deOinición de delegado5 no e5 m95 Rue una
Oorma e5pecial deOinir 5uMcla5e5 de System.MuIticastDeIegate% E57a cla5e a 5u Qe8 deriQa
de System.DeIegateN Rue repre5en7a a oMje7o5 delegado5 Rue 5ólo puede almacenar un
Tnico m67odo% Por 7an7oN 7odo5 lo5 oMje7o5 delegado Rue 5e deOinan con7ar9n con lo5
5iguien7e5 miemMro5 comune5 Weredado5 de e57a5 cla5e5L

• object TargetL Propiedad de 5ólo lec7ura Rue almacena el oMje7o al Rue per7enece
el Tl7imo m67odo aXadido al oMje7o delegado% Si e5 un m67odo de cla5e Qale nuII%
• MethodInfo MethodL Propiedad de 5ólo lec7ura Rue almacena un oMje7o
System.RefIection.MethodInfo con inOormación 5oMre el Tl7imo m67odo aXadido
al oMje7o InomMreN modiOicadore5N e7c%K Para 5aMer cómo acceder a e57o5 da7o5
puede con5ul7ar la documen7ación incluida en el S#A 5oMre la cla5e MethodInfo

• DeIegate[] getInvocationList()L Permi7e acceder a 7odo5 lo5 m67odo5 almacenado5
en un delegadoN Sa Rue deQuelQe una 7aMla cuSo5 elemen7o5 5on delegado5 cada
uno de lo5 cuale5 almacenan unoN S 5ólo unoN de lo5 m67odo5 del original% E57o5
delegado5 5e encuen7ran ordenado5 en la 7aMla en el mi5mo orden en Rue 5u5
m67odo5 Oueron Oue almacenado5 en el oMje7o delegado original%
E57e m67odo e5 e5pecialmen7e T7il porRue a 7raQ65 de la 7aMla Rue re7orna 5e
pueden Wacer co5a5 7ale5 como ejecu7ar lo5 m67odo5 del delegado en un orden
diOeren7e al de 5u almacenamien7oN proce5ar lo5 Qalore5 de re7orno de 7oda5 la5
llamada5 a lo5 m67odo5 del delegado originalN eQi7ar Rue una eUcepción en la
ejecución de uno de lo5 m67odo5 impida la ejecución de lo5 dem95N e7c%
Apar7e de e57o5 m67odo5 de oMje7oN la cla5e System.MuIticastDeIegate 7amMi6n cuen7a
con lo5 5iguien7e5 m67odo5 de 7ipo de u5o Orecuen7eL
• static DeIegate Combine(DeIegate fuente, DeIegate destino)L #eQuelQe un nueQo
oMje7o delegado Rue almacena la conca7enación de lo5 m67odo5 de fuente con lo5
de destino% Por 7an7oN nó7e5e Rue e57a5 7re5 in57ruccione5 5on eRuiQalen7e5L
objDelegado += new D(obj1.g);
objDelegado = objDelegado + new D(obj1.g);
objDelegado = (D) MulticastDelegate.Combine(objDelegado, new D(obj1.g);
E5 m95N en realidad el compilador de C# lo Rue Wace e5 conQer7ir 7oda aplicación
del operador + en7re delegado5 en una llamada a Combine() como la mo57rada%
HaS Rue 7ener cuidado con lo5 7ipo5 de lo5 delegado5 a comMinar Sa Rue Wan de
5er eUac7amen7e lo5 mi5mo5 o 5i no 5e lan8a una System.ArgumentExceptionN S
ello ocurre aTn en el ca5o de Rue dicWo5 5ólo 5e diOerencien en 5u nomMre S no
en 5u5 7ipo5 de par9me7ro5 S Qalor de re7orno%
El lenguaje de programación C# (ema :&L #elegado5 S eQen7o5
• static DeIegate Combine(DeIegate[] tabIa)L #eQuelQe un nueQo delegado cuSo5
m67odo5 almacenado5 5on la conca7enación de 7odo5 lo5 de la li57a Rue 5e le pa5a
como par9me7ro S en el orden en Rue aparecie5en en ella% E5 una Muena Oorma de
crear delegado5 con mucWo5 m67odo5 5in 7ener Rue aplicar += Qaria5 Qece5%
(odo5 lo5 oMje7o5 delegado5 de la tabla Wan de 5er del mi5mo 7ipoN pue5 5i no 5e
producirVa una System.ArgumentException%
• static DeIegate Remove(DeIegate originaI, DeIegate aBorrar)L #eQuelQe un nueQo
delegado cuSo5 m67odo5 almacenado5 5on el re5ul7ado de eliminar de original lo5
Rue 7uQie5e aBorrar% Por 7an7oN e57a5 in57ruccione5 5on eRuiQalen7e5L
objDelegado -= new D(obj1.g);
objDelegado - objDelegado - new D(obj1.g);
objDelegado = (D) MulticastDelegate.Remove(objDelegado, new D(obj1.g);
NueQamen7eN lo Rue Wace el compilador de C# e5 conQer7ir 7oda aplicación del
operador - en7re delegado5 en una llamada a Remove() como la mo57rada% Por
7an7oN al igual Rue con -=N para Morrar m67odo5 de oMje7o 5e Wa de e5peciOicar en
aBorrar un oMje7o delegado Rue con7enga reOerencia5 a m67odo5 a5ociado5 a
eUac7amen7e lo5 mi5mo5 oMje7o5 Rue lo5 almacenado5 en original%
• static DeIegate CreateDeIegate (Type tipo, MehodInfo método)L 2a 5e u5ó
e57e m67odo en el ejemplo de comproMación de 7ipo5 del epVgraOe 4De0ini$i)n de
dele(ados5 de e57e mi5mo 7ema% Como recordar9 permi7e crear din9micamen7e
oMje7o5 delegado5N Sa Rue deQuelQe un oMje7o delegado del tipo indicado Rue
almacena una reOerencia al método repre5en7ado por 5u 5egundo par9me7ro%
Llamadas as"ncronas
La Oorma de llamar a m67odo5 Rue Wa57a aWora 5e Wa eUplicado reali8a la llamada de
manera ;L264.29N lo Rue 5igniOica Rue la in57rucción 5iguien7e a la llamada no 5e ejecu7a
Wa57a Rue no Oinalice el m67odo llamado% Sin emMargoN a 7odo m67odo almacenado en un
oMje7o delegado 7amMi6n e5 po5iMle llamar de manera 9;L264.29 a 7raQ65 de lo5 m67odo5
del mi5moN lo Rue con5i57e en Rue no 5e e5pera a Rue acaMe de ejecu7ar5e para pa5ar a la
in57rucción 5iguien7e a 5u llamada 5ino Rue 5u ejecución 5e deja en mano5 de un Wilo
apar7e Rue 5e ir9 ejecu79ndolo en paralelo con el Wilo llaman7e%

Por 7an7o lo5 delegado5 proporcionan un cómodo mecani5mo para ejecu7ar cualRuier
m67odo a5Vncronamen7eN pue5 para ello Ma57a in7roducirlo en un oMje7o delegado del 7ipo
apropiado% Sin emMargoN e57e mecani5mo de llamada a5Vncrona 7iene una limi7aciónN S e5
Rue 5ólo e5 Q9lido para oMje7o5 delegado5 Rue almacenen un Tnico m67odo%
Para Wacer po5iMle la reali8ación de llamada5 a5Vncrona5N apar7e de lo5 m67odo5
Weredado5 de System.MuIticastDeIegate 7odo delegado cuen7a con e57o5 o7ro5 do5 Rue el
compilador deOine a 5u medida en la cla5e en Rue 7raduce la deOinición de 5u 7ipoL

IAsyncResuIt BeginInvoke(<parámetros>, AsyncCaIIback cb, Object o)
<tipoRetorno> EndInvoke(<parámetros"e!#ut>, IASyncResuIt ar)
El lenguaje de programación C# (ema :&L #elegado5 S eQen7o5
BeginInvoke() crea un Wilo Rue ejecu7ar9 lo5 m67odo5 almacenado5 en el oMje7o delegado
5oMre el Rue 5e aplica con lo5 par9me7ro5 indicado5 en <parámetros> S deQuelQe un
oMje7o IAsyncResuIt Rue almacenar9 inOormación rela7iQa a e5e Wilo Ipor ejemploN a
7raQ65 de 5u propiedad de 5ólo lec7ura booI IsCompIete puede con5ul7ar5e 5i Wa
7erminado 5u laMorK Sólo 7iene 5en7ido llamarlo 5i el oMje7o delegado 5oMre el Rue 5e
aplica almacena un Tnico m67odoN pue5 5i no 5e lan8a una System.ArgumentException%
El par9me7ro cb de BeginInvoke() e5 un oMje7o de 7ipo delegado Rue puede almacenar
m67odo5 a ejecu7ar cuando el Wilo an7e5 comen7ado Oinalice 5u 7raMajo% A e57o5 m67odo5
el CL) le5 pa5ar9 au7om97icamen7e como par9me7ro el IAsyncResuIt deQuel7o por
BeginInvoke()N e57ando a5V deOinido el delegado de57inado a almacenarlo5L
public delegate void ASyncCallback(ÌASyncResult obj);
Por 5u par7eN el par9me7ro o de BeginInvoke puede u5ar5e para almacenar cualRuier
inOormación adicional Rue 5e con5idere opor7una% E5 po5iMle acceder a 6l a 7raQ65 de la
propiedad object AsyncState del oMje7o IAsyncResuIt deQuel7o por BeginInvoke()
En ca5o de Rue no 5e de5ee ejecu7ar ningTn código e5pecial al Oinali8ar el Wilo de
ejecución a5Vncrona o no de5ee u5ar inOormación adicionalN puede dar5e 5in ningTn 7ipo
de proMlema el Qalor nuII a lo5 Tl7imo5 par9me7ro5 de BeginInvoke() 5egTn corre5ponda%
/inalmen7eN EndInvoke() 5e u5a para recoger lo5 re5ul7ado5 de la ejecución a5Vncrona de
lo5 m67odo5 iniciada a 7raQ65 BeginInvoke() Por elloN 5u Qalor de re7orno e5 del mi5mo
7ipo Rue lo5 m67odo5 almacenaMle5 en el oMje7o delegado al Rue per7enece S en
<parámetrosRefOut> 5e indican lo5 par9me7ro5 de 5alida S por reOerencia de dicWo5
m67odo5% Su 7ercer par9me7ro e5 el IAsyncResuIt deQuel7o por el BeginInvoke() Rue creó
el Wilo cuSo5 re5ul7ado5 5e 5olici7a recoger S 5e u5a preci5amen7e para iden7iOicarlo% Si
e5e Wilo no WuMie5e 7erminado aTn de reali8ar la5 llamada5N 5e e5perar9 a Rue lo Waga%
Para ilu57rar mejor el concep7o de llamada5 a5Vncrona5N el 5iguien7e ejemplo mue57ra
cómo encap5ular en un oMje7o delegado un m67odo F() para ejecu7arlo a5Vncronamen7eL
D objDelegado = new D (F);
ÌAsyncResult hilo = objDelegado.BeginÌnvoke(3, new AsyncCallback(M), “prueba”);
// ... Hacer cosas
objDelegado.EndÌnvoke(hilo);
#onde el m67odo M Wa 5ido deOinido en la mi5ma cla5e Rue e57e código a5VL
public static void M(ÌAsyncResult obj)
{
Console.WriteLine(“Llamado a M() con {0}”, obj.AsyncState);
}
Si en7re el BeginInvoke() S el EndInvoke() no WuMie5e WaMido ninguna e5cri7ura en
pan7allaN la 5alida del Oragmen7o de código an7erior 5erVaL
4asado 2alor ( a G(%
Llamado a M(% con 5rue-a
La llamada a BeginInvoke() lan8ar9 un Wilo Rue ejecu7ar9 el m67odo F() almacenado en
objDelegadoN pero mien7ra5 7an7o 7amMi6n 5eguir9 ejecu79ndo5e el código del Wilo de5de
El lenguaje de programación C# (ema :&L #elegado5 S eQen7o5
donde 5e llamó a BeginInvoke() Sólo 7ra5 llamar a EndInvoke() 5e puede a5egurar Rue 5e
WaMr9 ejecu7ado el código de F()N pue5 mien7ra5 7an7o la eQolución de amMo5 Wilo5 e5
pr9c7icamen7e inde7erminaMle Sa Rue depende del cómo ac7Te el planiOicador de Wilo5%
ATn 5i el Wilo llamador modiOica el Qalor de alguno de lo5 par9me7ro5 de 5alida o por
reOerencia de 7ipo5 QalorN el Qalor ac7uali8ado de 657o5 no 5er9 Qi5iMle para el Wilo
llaman7e Wa57a no llamar a EndInvoke() Sin emMargoN el Qalor de lo5 par9me7ro5 de 7ipo5
reOerencia 5V Rue podrVa 5erlo% Por ejemploN dado un código comoL
int x=0;
Persona p = new Persona(“Josan”, “7361928-E”, 22);
ÌAsyncResult res = objetoDelegado.BeginÌnvoke(ref x, p, null, null);
// Hacer cosas...
objetoDelegado.EndÌnvoke(ref x, res);
Si en un pun7o del código comen7ado con // Hacer cosas...N donde el Wilo a5Vncrono Sa
WuMie5e modiOicado lo5 con7enido5 de x S pN 5e in7en7a5e leer lo5 Qalore5 de e57a5
QariaMle5N 5ólo 5e leerVa el Qalor ac7uali8ado de p% El de x no 5e QerVa Wa57a de5pu65 de la
llamada a EndInvoke()
Por o7ro ladoN WaS Rue 5eXalar Rue 5i duran7e la ejecución a5Vncrona de un m67odo 5e
produce alguna eUcepciónN 657a no 5erVa no7iOicada pero proQocarVa Rue el Wilo a5Vncrono
aMor7a5e% Si po57eriormen7e 5e llama5e a EndInvoke() con el IAsyncResuIt a5ociado a
dicWo WiloN 5e relan8arVa la eUcepción Rue produjo el aMor7o S en7once5 podrVa 7ra7ar5e%
Para op7imi8ar la5 llamada5 a5Vncrona5 e5 recomendaMle marcar con el a7riMu7o OneWay
deOinido en System.Runtime.Remoting.Messaging lo5 m67odo5 cuSo Qalor de re7orno S
Qalore5 de par9me7ro5 de 5alida no no5 impor7enN pue5 ello indica a la inOrae57ruc7ura
encargada de Wacer la5 llamada5 a5Vncrona5 Rue no Wa de con5iderar% Por ejemploL
S/neWayT 5u-lic 2oid MPtodo(%
{!
AWora MienN WaS Rue 7ener en cuen7a Rue Wacer e57o implica perder 7oda po5iMilidad de
7ra7ar la5 eUcepcione5 Rue pudie5e producir5e al ejecu7ar a5Vncronamen7e el m67odo
a7riMuidoN pue5 con ello llamar a EndInvoke() dejarVa de relan8ar la eUcepción producida%
Por Tl7imoN a modo de re5umen a con7inuación 5e indican cu9le5 5on lo5 pa7rone5 Rue
pueden 5eguir5e para recoger lo5 re5ul7ado5 de una llamada a5VncronaL
:% #e7ec7ar 5i la llamada a5Vncrona Wa Oinali8ado mirando el Qalor de la
propiedad IsCompIete del oMje7o IAsyncResuIt deQuel7o por BeginInvoke()
Cuando 5ea a5VN con EndInvoke() puede recoger5e 5u5 re5ul7ado5%
&% Pa5ar un oMje7o delegado en el penTl7imo par9me7ro de BeginInvoke() con
el m67odo a ejecu7ar cuando Oinalice el Wilo a5VncronoN lo Rue liMerarVa al Wilo
llaman7e de la 7area de 7ener Rue andar mirando 5i Wa Oinali8ado o no%
Si de5de dicWo m67odo 5e nece5i7a5e acceder a lo5 re5ul7ado5 del m67odo llamado
podrVa acceder5e a ello5 a 7raQ65 de la propiedad AsyncDeIegate del oMje7o
IAsyncResuIt Rue reciMe% E57a propiedad con7iene el oMje7o delegado al Rue 5e
El lenguaje de programación C# (ema :&L #elegado5 S eQen7o5
llamóN aunRue 5e mue57ra a con7inuación an7e5 de acceder a ella WaS Rue
conQer7ir el par9me7ro IAsyncResuIt de e5e m67odo en un AsyncResuItL
public static void M(ÌAsyncResult iar)
{
D objetoDelegado = (D) ((AsyncResult iar)).AsyncDelegate;
// A partir de aquí podría llamarse a EndÌnvoke() a través de objetoDelegado
}
mplementación interna de los delegados
Cuando Wacemo5 una deOinición de delegado de la OormaL
<modificadores> deIegate <tipoRetorno> <nombre>(<parámetros>);
El compilador in7ernamen7e la 7ran5Oorma en una deOinición de cla5e de la OormaL
<modificadores> cIass <nombre>:System.MuIticastDeIegate
{
private object _target;
private int _methodPtr;
private MuIticastDeIegate _prev;
pubIic <nombre>(object objetivo, int punteroMétodo)
{...}
pubIic virtuaI <tipoRetorno> Invoke(<parámetros>)
{...}

pubIic virtuaI IAsyncResuIt BeginInvoke(<parámetros>, AsyncCaIIback cb, Object o)
Q%%%R
pubIic virtuaI <tipoRetorno> EndInvoke(<parámetros"e!#ut>, IASyncResuIt ar)
{...}
}
Lo primero Rue llama la a7ención al leer la deOinición de e57a cla5e e5 Rue 5u con57ruc7or
no 5e parece en aM5olu7o al Rue Wemo5 e57ado u5ando Wa57a aWora para crear oMje7o5
delegado% E57o 5e deMe a Rue en realidadN a par7ir de lo5 da7o5 e5peciOicado5 en la Oorma
de u5ar el con57ruc7or Rue el programador u7ili8aN el compilador e5 capa8 de de7erminar
lo5 Qalore5 apropiado5 para lo5 par9me7ro5 del Qerdadero con57ruc7orN Rue 5onL
• object objetivo con7iene el oMje7o al cual per7enece el m67odo e5peciOicadoN S 5u
Qalor 5e guarda en el campo _target% Si e5 un m67odo e5797ico almacena nuII%
• int punteroMétodo con7iene un en7ero Rue permi7e al compilador de7erminar cu9l
e5 el m67odo del oMje7o al Rue 5e de5ea llamarN S 5u Qalor 5e guarda en el campo
S?13J.5P34% SegTn donde 5e WaSa deOinido dicWo m67odoN el Qalor de e57e
par9me7ro proceder9 de la5 7aMla5 MethodDef o MethodRef de lo5 me7ada7o5%
El campo priQado _prev de un delegado almacena una reOerencia al delegado preQio al
mi5mo en la cadena de m67odo5% En realidadN en un oMje7o delegado con mTl7iple5
El lenguaje de programación C# (ema :&L #elegado5 S eQen7o5
m67odo5 lo Rue 5e 7iene e5 una cadena de oMje7o5 delegado5 cada uno de lo5 cuale5
con7iene uno de lo5 m67odo5 S una reOerencia Ien _prevK a o7ro oMje7o delegado Rue
con7endr9 o7ro de lo5 m67odo5 de la cadena%
Cuando 5e crea un oMje7o delegado con new 5e da el Qalor nuII a 5u campo _prev para a5V
indicar Rue no per7enece a una cadena 5ino Rue 5ólo con7iene un m67odo% Cuando 5e
comMinen do5 oMje7o5 delegado5 Icon + o DeIegate.Combine()K el campo _prev del nueQo
oMje7o delegado creado enla8ar9 a lo5 do5 originale5b S cuando 5e eliminen m67odo5 de
la cadena Icon - o DeIegate.Remove()K 5e ac7uali8ar9n lo5 campo5 _prev de la cadena
para Rue 5al7en a lo5 oMje7o5 delegado5 Rue con7enVan lo5 m67odo5 eliminado5%
Cuando 5e 5olici7a la ejecución de lo5 m67odo5 almacenado5 en un delegado de manera
a5Vncrona lo Rue 5e Wace e5 llamar al m67odo Invoke() del mi5mo% Por ejemploN una
llamada como e57aL
objDelegado(49);
E5 conQer7ida por el compilador enL
objDelegado.Ìnvoke(49);
AunRue Invoke() e5 un m67odo pTMlicoN C# no permi7e Rue el programador lo llame
eUplVci7amen7e% Sin emMargoN o7ro5 lenguaje5 ge57ionado5 5V Rue podrVan permi7irlo%
El m67odo Invoke() 5e 5irQe de la inOormación almacenada en _targetN _methodPtr S
_prevN para de7erminar a cu9l m67odo 5e Wa de llamar S en Ru6 orden 5e le Wa de llamar%
A5VN la implemen7ación de Invoke() 5er9 de la OormaL
pubIic virtuaI <tipoRetorno> Invoke(<parámetros>)
{
if (_prev!=nuII)
_prev.Invoke(<parámetros>);
return _target._methodPtr(<parámetros>);
}
MQiamen7e la 5in7aUi5 S394=13.S?13J.5P34 no e5 Q9lida en C#N Sa Rue S?13J.5P34 no
e5 un m67odo 5ino un campo% Sin emMargoN 5e Wa e5cri7o a5V para poner de maniOie57o
Rue lo Rue el compilador Wace e5 generar el código apropiado para llamar al m67odo
per7enecien7e al oMje7o indicado en _target e iden7iOicado con el Qalor de _methodPtr
Nó7e5e Rue la in57rucción if incluida 5e u5a para a5egurar Rue la5 llamada5 a lo5 m67odo5
de la cadena 5e Wagan en ordenL 5i el oMje7o delegado no e5 el Tl7imo de la cadena%
IS<41ATU20--K 5e llamar9 an7e5 al m67odo I2A.E1() de 5u predece5or%
Por Tl7imoN 5ólo 5eXalar RueN como e5 lógicoN en ca5o de Rue lo5 m67odo5 Rue el oMje7o
delegado pueda almacenar no 7engan Qalor de re7orno I657e 5ea voidKN el cuerpo de
Invoke() 5ólo QarVa en Rue la palaMra re5erQada return e5 eliminada del mi5mo%
El lenguaje de programación C# (ema :&L #elegado5 S eQen7o5
Eventos
Concepto de evento
"n 1A123. e5 una Qarian7e de la5 propiedade5 para lo5 campo5 cuSo5 7ipo5 5ean
delegado5% E5 decirN permi7en con7rolar la Oorman en Rue 5e accede a lo5 campo5
delegado5 S dan la po5iMilidad de a5ociar código a ejecu7ar cada Qe8 Rue 5e aXada o
elimine un m67odo de un campo delegado%
Sintaxis básica de definición de eventos
La 5in7aUi5 M95ica de deOinición de un eQen7o con5i57e en deOinirlo como cualRuier o7ro
campo con la Tnica peculiaridad de Rue 5e le Wa de an7eponer la palaMra re5erQada event
al nomMre de 5u 7ipo IRue 5er9 un delegadoK 5eaN 5e 5igue la 5in7aUi5L
<modificadores> event <tipoDelegado> <nombreEvento>;
Por ejemploN para deOinir un eQen7o de nomMre PrueMa S 7ipo delegado # 5e WarVaL
public event D Pruebab
(amMi6n pueden deOinir5e mTl7iple5 eQen7o5 en una mi5ma lVnea 5eparando 5u5 nomMre5
median7e coma5% Por ejemploL
public event D Prueba1, Prueba2;
#e5de código uMicado den7ro del mi5mo 7ipo de da7o donde 5e WaSa deOinido el eQen7o
5e puede u5ar el eQen7o 7al S como 5i de un campo delegado normal 5e 7ra7a5e% Sin
emMargoN de5de código uMicado eU7ernamen7e 5e imponen una 5erie de re57riccione5 Rue
permi7en con7rolar la Oorma en Rue 5e accede al mi5moL
• No 5e le puede aplicar lo5 m67odo5 Weredado5 de System.MuIticastDeIegate%
• Sólo 5e le puede aplicar do5 operacione5L aXadido de m67odo5 con += S
eliminación de m67odo5 con -=% #e e57e modo 5e eQi7a Rue 5e u5e 5in Ruerer = en
Qe8 de += ó -= S 5e 5u57i7uSan 7odo5 lo5 m67odo5 de la li57a de m67odo5 del
campo delegado por o7ro Rue en realidad 5e le RuerVa aXadir o Rui7ar I5i e5e o7ro
Qalie5e nuIIN ello inclu5o podrVa proQocar una System.NuIIReferenceException)
• No e5 po5iMle llamar a lo5 m67odo5 almacenado5 en un campo delegado a 7raQ65
del mi5mo% E57o permi7e con7rolar la Oorma en Rue 5e le5 llamaN Sa Rue oMliga a
Rue la llamada 7enga Rue Wacer5e a 7raQ65 de algTn m67odo pTMlico deOinido en
la deOinición del 7ipo de da7o donde el eQen7o Oue deOinido%
Sintaxis compIeta de definición de eventos
El lenguaje de programación C# (ema :&L #elegado5 S eQen7o5
La Qerdadera u7ilidad de un eQen7o e5 Rue permi7e con7rolar la Oorma en Rue 5e a5ocian S
Rui7an m67odo5 de lo5 oMje7o5 delegado5 con += S -=% Para ello 5e Wan de deOinir con la
5iguien7e 5in7aUi5 aQan8adaL
<modificadores> event <tipoDelegado> <nombreEvento>
{
add
{
<códigoAdd>
}
remove
{
<códigoRemove>
}
}
Con e57a 5in7aUi5 no pueden deOinir5e Qario5 eQen7o5 en una mi5ma lVnea como ocurrVa
con la M95ica% Su 5igniOicado e5 el 5iguien7eL cuando 5e a5ocie un m67odo con += al
eQen7o 5e ejecu7ar9 el <códigoAdd>N S cuando 5e le Rui7e alguno con -= 5e ejecu7ar9 el
<códigoRemove>% E57a 5in7aUi5 e5 5imilar a la de lo5 MloRue5 setVget de la5 propiedade5
pero con una impor7an7e diOerenciaL aunRue pueden permu7ar5e la5 5eccione5 add S
removeN e5 oMliga7orio incluir 5iempre a amMa5%
La 5in7aUi5 M95ica e5 en realidad una Oorma aMreQiada de u5ar la aQan8ada% A5VN la
deOinición public event D Prueba(int valor); la in7erpre7arVa el compilador comoL

private D prueba
public event D Prueba
{
[MethodÌmpl(MethodÌmlOptions.Synchronized)]
add
{
prueba = (D) Delegate.Combine(prueba, value);
}
[MethodÌmpl(MethodÌmlOptions.Synchronized)]
remove
{
prueba = (D) Delegate.Remove(prueba, value);
}
}
E5 decirN el compilador deOinir9 un campo delegado priQado S código5 para add S
remove Rue Wagan Rue el u5o de += S -= 5oMre el eQen7o 7enga el eOec7o Rue normalmen7e
7endrVan 5i 5e aplica5en direc7amen7e 5oMre el campo priQado% Como 5e QeN den7ro de
e57o5 m67odo5 5e puede u5ar vaIue para Wacer reOerencia al operando derecWo de lo5
operadore5 += S -=% El a7riMu7o System.Runtime.InteropServices.MethodImpI Rue precede
a lo5 MloRue5 add S remove 5ólo 5e incluSe para a5egurar Rue un camMio de Wilo no
pueda in7errumpir la ejecución de 5u5 código5 a5ociado5%
La5 re57riccione5 de u5o de eQen7o5 de5de código5 eU7erno5 al 7ipo donde 5e Wan
deOinido 5e deMen a Rue en realidad 657o5 no 5on oMje7o5 delegado5 5ino Rue el oMje7o
delegado e5 el campo priQado Rue in7ernamen7e deOine el compilador% El compilador
El lenguaje de programación C# (ema :&L #elegado5 S eQen7o5
7raduce 7oda llamada al eQen7o en una llamada al campo delegado% Como e57e e5
priQadoN por e5o 5ólo pueda acceder5e a 6l de5de código de 5u propio 7ipo de da7o%
En realidadN el compilador in7ernamen7e 7raduce la5 5eccione5 add S remove de la
deOinición de un eQen7o en m67odo5 de la OormaL
void add_<nombreEvento>(<tipoDelegado> vaIue)
void remove_<nombreEvento>(<tipoDelegado> vaIue)
(oda aplicación de += S -= a un eQen7o no e5 conQer7ida en una llamada al campo
priQado 5ino en una llamada al m67odo add^remove apropiadoN como 5e puede oM5erQar
anali8ando el !SIL de cualRuier Ouen7e donde 5e u5en += S -= 5oMre eQen7o5% Adem95N
como e57o5 m67odo5 deQuelQen void 65e 5er9 el 7ipo del Qalor deQuel7o al aplicar += ó -=
IS no el oMje7o a5ignadoKN lo Rue eQi7ar9 Rue código eU7erno al 7ipo donde 5e WaSa
deOinido el eQen7o pueda acceder direc7amen7e al campo delegado priQado%
Si en Qe8 de la 5in7aUi5 M95ica u5amo5 la comple7a no 5e deOinir9 au7om97icamen7e un
campo delegado por cada eQen7o Rue 5e deOinaN por lo Rue 7ampoco 5er9 po5iMle Wacer
reOerencia al mi5mo de5de código uMicado en la mi5ma cla5e donde 5e Wa deOinido% Sin
emMargo ello permi7e Rue el programador pueda de7erminarN a 7raQ65 de 5eccione5 add S
removeN cómo 5e almacenar9n lo5 m67odo5% Por ejemploN para aWorrar memoria 5e puede
op7ar por u5ar un diccionario donde almacenar lo5 m67odo5 a5ociado5 a Qario5 eQen7o5
de un mi5mo oMje7o en lugar de u5ar un oMje7o delegado por cada uno%
#ado Rue la5 5eccione5 add S remove 5e 7raducen como m67odo5N lo5 eQen7o5 7amMi6n
podr9n par7icipar en el mecani5mo de Werencia S redeOinicione5 7Vpico de lo5 m67odo5%
E5 decirN en <modificadores> apar7e de modiOicadore5 de acce5o S el modiOicador staticN
7amMi6n 5e podr9n incluir lo5 modiOicadore5 rela7iQo5 a Werencia% En e57e 5en7ido WaS
Rue preci5ar algoL un eQen7o deOinido como abstract Wa de deOinir5e 5iempre con la
5in7aUi5 M95ica Ino incluir9 5eccione5 add o removeK
El lenguaje de programación C# (ema :*L E57ruc7ura5
TEMA 13: Estructuras
Concepto de estructura
"na 1;34063049 e5 un 7ipo e5pecial de cla5e pen5ada para repre5en7ar oMje7o5 ligero5% E5
decirN Rue ocupen poca memoria S deMan 5er manipulado5 con QelocidadN como oMje7o5
Rue repre5en7en pun7o5N OecWa5N e7c% Ejemplo5 de e57ruc7ura5 incluida5 en la BCL 5on la
maSorVa de lo5 7ipo5 M95ico5 IeUcep7o string S objectKN S de WecWo la5 e57ruc7ura5 jun7o
con la redeOinición de operadore5 5on la Oorma ideal de deOinir nueQo5 7ipo5 M95ico5 a
lo5 Rue 5e apliRuen la5 mi5ma5 op7imi8acione5 Rue a lo5 predeOinido5%
(iferencias entre clases $ estructuras
A diOerencia de una cla5e S Oiel a 5u e5pVri7u de _ligere8a`N una e57ruc7ura no puede
deriQar de ningTn 7ipo S ningTn 7ipo puede deriQar de ella% Por e57a5 ra8one5 5u5
miemMro5 no pueden incluir modiOicadore5 rela7iQo5 a WerenciaN aunRue con una
eUcepciónL pueden incluir override para redeOinir lo5 miemMro5 de System.Object%
7ra diOerencia en7re la5 e57ruc7ura5 S la5 cla5e5 e5 Rue 5u5 QariaMle5 no almacenan
reOerencia5 a 8ona5 de memoria din9mica donde 5e encuen7ran almacenado5 oMje7o5 5ino
direc7amen7e reOerencian a oMje7o5% Por ello 5e dice Rue la5 cla5e5 5on 37<.; 41@1412679 S
la5 e57ruc7ura5 5on 37<.; A9-.4N 5iendo po5iMle 7an7o encon7rar oMje7o5 de e57ruc7ura5 en
pila Ino 5on campo5 de cla5e5K como en memoria din9mica I5on campo5 de cla5e5K
"na primera con5ecuencia de e57o e5 Rue lo5 acce5o5 a miemMro5 de oMje7o5 de 7ipo5
Qalor 5on mucWo m95 r9pido5 Rue lo5 acce5o5 a miemMro5 de pila5N Sa Rue e5 nece5ario
pa5ar por una reOerencia meno5 a la Wora de acceder a ello5% Adem95N el 7iempo de
creación S de57rucción de e57ruc7ura5 7amMi6n e5 inOerior% #e WecWoN la de57rucción de
lo5 oMje7o5 almacenado5 en pila e5 pr9c7icamen7e inapreciaMle Sa Rue 5e reali8a con un
5imple decremen7o del pun7ero de pila S no in7erQiene en ella el recolec7or de Ma5ura%
7ra con5ecuencia de lo an7erior e5 Rue cuando 5e realicen a5ignacione5 en7re QariaMle5
de 7ipo5 QalorN lo Rue 5e Qa a copiar en la QariaMle de57ino e5 el oMje7o almacenado por la
QariaMle Ouen7e S no la dirección de memoria din9mica a la Rue apun7aMa 657a% Por
ejemploN dado el 5iguien7e 7ipo Inó7e5e Rue la5 e57ruc7ura5 5e deOinen igual Rue la5 cla5e5
pero u5ando la palaMra re5erQada struct en Qe8 de cIassKL
struct Point
{
public int x, y;
public Point(int x, int y)
{
this.x = x;
this.y = y;
}
Z
El lenguaje de programación C# (ema :*L E57ruc7ura5
Si u5amo5 e57e 7ipo en un código como el 5iguien7eL
Punto p = new Punto(10,10);
Punto p2 = p;
p2.x = 100;
Console.WriteLine(p.x);
Lo Rue 5e mo57rar9 por pan7alla 5er9 C% E57o 5e deMe a Rue el Qalor de x modiOicado e5
el de p2N Rue como e5 una copia de p lo5 camMio5 Rue 5e le Wagan no aOec7ar9n a p% Sin
emMargoN 5i Punto WuMie5e 5ido deOinido como una cla5e en7once5 5V Rue 5e WuMie5e
mo57rado por pan7alla CN Sa Rue en e5e ca5o lo Rue 5e WaMrVa copiado en p2 WaMrVa 5ido
una reOerencia a la mi5ma dirección de memoria din9mica reOerenciada por pN por lo Rue
cualRuier camMio Rue 5e Waga en e5a 8ona a 7raQ65 de p2 7amMi6n aOec7ar9 a p%
#e lo an7erior 5e deduce Rue la a5ignación en7re oMje7o5 de 7ipo5 e57ruc7ura5 e5 mucWo
m95 len7a Rue la a5ignación en7re oMje7o5 de cla5e5N Sa Rue 5e Wa de copiar un oMje7o
comple7o S no 5olo una reOerencia% Para aliQiar e57o al pa5ar oMje7o5 de 7ipo5 e57ruc7ura
como par9me7ro5N 5e da la po5iMilidad de pa5arlo5 como par9me7ro5 por reOerencia
ImodiOicador refK o par9me7ro5 de 5alida IoutK en Qe8 de como par9me7ro5 de en7rada%
(oda5 la5 e57ruc7ura5 deriQan implVci7amen7e del 7ipo System.VaIueTypeN Rue a 5u Qe8
deriQa de la cla5e primigenia System.Object% VaIueType 7iene lo5 mi5mo5 miemMro5 Rue
5u padreN S la Tnica diOerencia 5eXalaMle en7re amMo5 e5 Rue en VaIueType 5e Wa
redeOinido EquaIs() de modo Rue deQuelQa true 5i lo5 oMje7o5 comparado5 7ienen el
mi5mo Qalor en 7odo5 5u5 campo5 S faIse 5i no% E5 decirN la comparación en7re
e57ruc7ura5 con EquaIs() 5e reali8a por Qalor%
)e5pec7o a la implemen7ación de la igualdad en lo5 7ipo5 deOinido5 como e57ruc7ura5N
7amMi6n e5 impor7an7e 7ener muS en cuen7a Rue el operador == no e5 en principio
aplicaMle a la5 e57ruc7ura5 Rue deOina el programador% Si 5e de5ea Rue lo 7enga Wa de
d9r5ele eUplVci7amen7e una redeOinición al deOinir dicWa5 e57ruc7ura5%
#o1ing $ unbo1ing
#ado Rue 7oda e57ruc7ura deriQa de System.ObjectN Wa de 5er po5iMle a 7raQ65 del
polimorOi5mo almacenar oMje7o5 de e57o5 7ipo5 en oMje7o5 object% Sin emMargoN e57o no
puede Wacer5e direc7amen7e deMido a la5 diOerencia5 5em9n7ica5 S de almacenamien7o
Rue eUi57en en7re cla5e5 S e57ruc7ura5L un object 5iempre Wa de almacenar una reOerencia
a un oMje7o en memoria din9mica S una e57ruc7ura no 7iene porRu6 e57arlo% Por ello Wa de
reali89r5ele an7e5 al oMje7o de 7ipo Qalor una conQer5ión conocida como C.I72=%
)ecVprocamen7eN al proce5o de conQer5ión de un object Rue con7enga un oMje7o de un
7ipo Qalor al 7ipo Qalor original 5e le denomina 02C.I72=%
El proce5o de MoUing e5 muS 5encillo% Con5i57e en enQolQer el oMje7o de 7ipo Qalor en un
oMje7o de un 7ipo reOerencia creado e5pecVOicamen7e para ello% Por ejemploN para un
oMje7o de un 7ipo Qalor TN el 7ipo reOerencia creado 5erVa de la OormaL
class T_Box
{
T value;
El lenguaje de programación C# (ema :*L E57ruc7ura5
T_Box(T t)
{
value = t;
}
}
En realidad 7odo e57o ocurre de Oorma 7ran5paren7e al programadorN el cual 5implemen7e
a5igna el oMje7o de 7ipo Qalor a un oMje7o de 7ipo reOerencia como 5i de cualRuier
a5ignación polimórOica 5e 7ra7a5e% Por ejemploL
int p = new Punto(10,10);
object o = p; // boxing. Es equivalente a object o = new Punto_Box(p);
En realidad la cla5e enQol7orio arriMa e5cri7a no 5e crea nuncaN pero concep7ualmen7e e5
como 5i 5e crea5e% E57o 5e puede comproMar Qiendo a 7raQ65 del 5iguien7e código Rue el
Qerdadero 7ipo del oMje7o o del ejemplo an7erior 5igue 5iendo Punto IS no Punto_BoxKL
Console.WriteLine((p is Punto));
La 5alida por pan7alla de e57e código e5 TrueN lo Rue conOirma Rue 5e 5igue
con5iderando Rue en realidad p almacena un Punto Irecu6rde5e Rue el operador is 5ólo
deQuelQe true 5i el oMje7o Rue 5e le pa5a como operando i8Ruierdo e5 del 7ipo Rue 5e le
indica como operando derecWoK
El proce5o de unMoUing e5 7amMi6n 7ran5paren7e al programador% Por ejemploN para
recuperar como Punto el Qalor de 7ipo Punto almacenado en el oMje7o o an7erior 5e WarVaL
p = (Punto) o; // Es equivalente a ((Punto_Box) o).value
MQiamen7e duran7e el unMoUing 5e War9 una comproMación de 7ipo para a5egurar Rue el
oMje7o almacenado en o e5 realmen7e de 7ipo Punto% E57a comproMación e5 7an e57ric7a
Rue 5e Wa de cumplir Rue el 7ipo e5peciOicado 5ea eUac7amen7e el mi5mo Rue el 7ipo
original del oMje7oN no Qale Rue 5ea un compa7iMle% Por 7an7oN e57e código e5 inQ9lidoL
int i = 123;
object o = i;
long l = (long) o // Error: o contiene un int, no un long
Sin emMargoN lo Rue 5i 5erVa Q9lido e5 WacerL
long l = (long) (int) o;
Como 5e puede apreciar en el con57ruc7or del 7ipo enQol7orio creadoN duran7e el MoUing
el enQol7orio Rue 5e crea reciMe una copia del Qalor del oMje7o a conQer7irN por lo Rue lo5
camMio5 Rue 5e le Wagan no aOec7ar9n al oMje7o original% Por elloN la 5alida del 5iguien7e
código 5er9 :+L
Punto p = new Punto(10,10);
object o = p; // boxing
p.X = 100;
Console.WriteLine( ((Punto) o).X); // unboxing
El lenguaje de programación C# (ema :*L E57ruc7ura5
Sin emMargoN 5i Pun7o 5e WuMie5e deOinido como una cla5e en7once5 5V Rue 5e mo57rarVa
por pan7alla un :++ Sa Rue en7once5 no 5e WarVa MoUing en la a5ignación de p a o 5ino
Rue 5e aplicarVa el mecani5mo de polimorOi5mo normalN Rue con5i57e en 7ra7ar p a 7raQ65
de o como 5i Oue5e de 7ipo oMjec7 pero 5in reali8ar5e ninguna conQer5ión%
El proMlema del MoUing S el unMoUing e5 Rue 5on proce5o5 len7o5N Sa Rue implican la
creación S de57rucción de oMje7o5 enQol7orio% Por ello puede in7ere5ar eQi7arlo5 en
aRuella5 5i7uacione5 donde la Qelocidad de ejecución de la aplicación 5ea crV7icaN S para
ello 5e proponen Qaria5 76cnica5L
• Si el proMlema 5e deMe al pa5o de e57ruc7ura5 como par9me7ro5 de m67odo5
gen6rico5 Rue 7omen par9me7ro5 de 7ipo objectN puede conQenir deOinir
5oMrecarga5 de e5o5 m67odo5 Rue en lugar de 7omar object5 7omen oMje7o5 de lo5
7ipo5 e57ruc7ura Rue en concre7o la aplicación u7ili8a
A par7ir de la Qer5ión &%+ de C#N 5e pueden u7ili8ar la5 denominada5 <-9237--9; o
=12N476.;N Rue no 5on m95 Rue deOinicione5 de 7ipo5 de da7o5 en la5 Rue no 5e
indica cu9l e5 el 7ipo eUac7o de cier7a5 QariaMle5 5ino Rue 5e deja en Ounción de
par9me7ro5 a lo5 Rue puede d9r5ele5 di57in7o5 Qalore5 al crear cada oMje7o de e5e
7ipo% A5VN en Qe8 de crear5e oMje7o5 con m67odo5 Rue 7omen par9me7ro5 objectN 5e
podrVan ir creando diOeren7e5 Qer5ione5 del 7ipo 5egTn la e57ruc7ura con la 5e QaSa
a 7raMajar% El Tema 6%: No'edades de C7 6.+ eUplica e57o m95 de7alladamen7e%
• !ucWa5 Qece5 conQiene Wacer unMoUing para poder acceder a miemMro5
e5pecVOico5 de cier7a5 e57ruc7ura5 almacenada5 en object5N aunRue a con7inuación
QuelQa a nece5i7ar5e realmacenar la e57ruc7ura en un object% Para eQi7ar e57o una
po5iMilidad 5erVa almacenar en el oMjec7o no direc7amen7e la e57ruc7ura 5ino un
oMje7o de una cla5e enQolQen7e creada a medida por el programador S Rue
incluSa lo5 miemMro5 nece5ario5 para Wacer la5 operacione5 an7eriore5% A5V 5e
eQi7arVa 7ener Rue Wacer unMoUingN pue5 5e conQer7irVa de object a e5a cla5eN Rue
no e5 un 7ipo Qalor S por 7an7o no implica unMoUing%
• Con la mi5ma ideaN o7ra po5iMilidad 5erVa Rue el 7ipo e57ruc7ura implemen7a5e
cier7a5 in7erOace5 median7e la5 Rue 5e pudie5e Wacer la5 operacione5 an7e5
comen7ada5% AunRue la5 in7erOace5 no 5e 7ra7ar9n Wa57a el Tema %5: "nter0a$esN
por aWora Ma57a 5aMer Rue la5 in7erOace5 5on 7amMi6n 7ipo5 reOerencia S por 7an7o
conQer7ir de object a un 7ipo in7erOa8 no implica unMoUing%
Constructores
Lo5 con57ruc7ore5 de la5 e57ruc7ura5 5e compor7an de una Oorma di57in7a a lo5 de la5
cla5e5% Por un ladoN no pueden incluir ningTn iniciali8ador Ma5e deMido a Rue como no
puede WaMer Werencia el compilador 5iempre 5aMe Rue Wa de llamar al con57ruc7or 5in
par9me7ro5 de System.VaIueType% Por o7roN den7ro de 5u cuerpo no 5e puede acceder a
5u5 miemMro5 Wa57a iniciali8arlo5N pue5 para aWorrar 7iempo no 5e le5 da ningTn Qalor
inicial an7e5 de llamar al con57ruc7or%
Sin emMargoN la diOerencia m95 impor7an7e en7re lo5 con57ruc7ore5 de amMo5 7ipo5 5e
encuen7ra en la implemen7ación del con57ruc7or 5in par9me7ro5L como lo5 oMje7o5
El lenguaje de programación C# (ema :*L E57ruc7ura5
e57ruc7ura no pueden almacenar el Qalor por deOec7o nuII cuando 5e declaran 5in u5ar
con57ruc7or Sa Rue e5e Qalor indica reOerencia a po5ición de memoria din9mica
inde7erminada S lo5 oMje7o5 e57ruc7ura no almacenan reOerencia5N 7oda e57ruc7ura
5iempre 7iene deOinido un con57ruc7or 5in par9me7ro5 Rue lo Rue Wace e5 darle en e5o5
ca5o5 un Qalor por deOec7o a lo5 oMje7o5 declarado5% E5e Qalor con5i57e en poner a cero
7oda la memoria ocupada por el oMje7oN lo Rue 7iene el eOec7o de dar como Qalor a cada
campo el cero de 5u 7ipo
:&
% Por ejemploN el 5iguien7e código imprime un + en pan7allaL

Punto p = new Punto();
Console.WriteLine(p.X);
2 el 5iguien7e 7amMi6nL
using System;
struct Punto
{
public int X,Y;
}
class EjemploConstructorDefecto
{
Punto p;
public static void Main()
{
Console.WriteLine(p.X);
}
}
Sin emMargoN el WecWo de Rue e57e con57ruc7or por deOec7o 5e apliRue no implica Rue 5e
pueda acceder a la5 QariaMle5 locale5 5in an7e5 iniciali8arla5 con o7ro Qalor% Por ejemploN
el 5iguien7e Oragmen7o de código de un m67odo 5erVa incorrec7oL
Punto p;
Console.WriteLine(p.X); // X no inicializada
Sin emMragoN como a la5 e57ruc7ura5 declarada5 5in con57ruc7or no 5e le5 da el Qalor por
deOec7o nuIIN 5V Rue 5erVa Q9lidoL

Punto p;
p.X = 2;
Console.WriteLine(p.X);
Para a5egurar un Qalor por deOec7o comTn a 7odo5 lo5 oMje7o5 e57ruc7uraN 5e proWiMe a lo5
programadore5 darle5 5u propia deOinición del con57ruc7or 5in par9me7ro5% !ien7ra5 Rue
en la5 cla5e5 e5 opcional implemen7arlo S 5i no 5e Wace el compilador in7roduce uno por
deOec7oN en la5 e57ruc7ura5 no e5 Q9lido Wacerlo% Adem95N aTn en el ca5o de Rue 5e
deOinan o7ro5 con57ruc7ore5N el con57ruc7or 5in par9me7ro5 5eguir9 5iendo in7roducido
au7om97icamen7e por el compilador a diOerencia de cómo ocurrVa con la5 cla5e5 donde
en e5e ca5o el compilador no lo in7roducVa%
:&
5eaN cero para lo5 campo5 de 7ipo5 num6rico5N '\u0000' para lo5 de 7ipo charN faIse para lo5 de 7ipo booI
S nuII para lo5 de 7ipo5 reOerencia%
El lenguaje de programación C# (ema :*L E57ruc7ura5
Por o7ro ladoN para con5eguir Rue el Qalor por deOec7o de 7odo5 lo5 oMje7o5 e57ruc7ura5
5ea el mi5moN 5e proWVMe darle5 una Qalor inicial a 5u5 campo5 en el momen7o de
declararlo5N pue5 5i no el con57ruc7or por deOec7o WaMrVa de 7enerlo5 en cuen7a S 5u
ejecución 5erVa m95 ineOicien7e% Por e57a ra8ónN lo5 con57ruc7ore5 deOinido5 por el
programador para una e57ruc7ura Wan de iniciali8ar 7odo5 5u5 miemMro5 no e5797ico5 en
7an7o Rue an7e5 de llamarlo5 no 5e le5 da ningTn Qalor inicial%
Nó7e5e Rue deMido a la eUi57encia de un con57ruc7or por deOec7o cuSa implemen7ación
e5capa de mano5 del programadorN el código de lo5 m67odo5 de una e57ruc7ura puede
7ener Rue con5iderar la po5iMilidad de Rue 5e acceda a ello5 con lo5 Qalore5 re5ul7an7e5
de una iniciali8ación con e5e con57ruc7or% Por ejemploN dadoL
struct A
{
public readonly string S;
public A(string s)
{
if (s==null)
throw (new ArgumentNullException());
this.S = s;
}
}
Nada a5egura Rue en e57e código lo5 oMje7o5 de cla5e A 5iempre 5e inicialicen con un
Qalor di57in7o de nuII en 5u campo SN pue5 aunRue el con57ruc7or deOinido para A
comprueMa Rue e5o no ocurra lan8ando una eUcepción en ca5o de Rue 5e le pa5e una
cadena Rue Qalga nuIIN 5i el programador u5a el con57ruc7or por deOec7o crear9 un oMje7o
en el Rue S Qalga nuII% Adem95N ni 5iRuiera e5 Q9lido e5peciOicar un Qalor inicial a S en
5u deOiniciónN Sa Rue para iniciali8ar r9pidamen7e la5 e57ruc7ura5 5u5 campo5 no
e5797ico5 no pueden 7ener Qalore5 iniciale5%
El lenguaje de programación C# (ema :3L Enumeracione5
TEMA 14: Enumeraciones
Concepto de enumeración
"na 120?1496782 o 37<. 120?1495. e5 un 7ipo e5pecial de e57ruc7ura en la Rue lo5
li7erale5 de lo5 Qalore5 Rue pueden 7omar 5u5 oMje7o5 5e indican eUplVci7amen7e al
deOinirla% Por ejemploN una enumeración de nomMre Tamaño cuSo5 oMje7o5 pudie5en
7omar lo5 Qalore5 li7erale5 PequeñoN Mediano o Grande 5e deOinirVa a5VL
enum Tamaño
{
Pequeño,
Mediano,
Grande
}
Para en7ender Mien la principal u7ilidad de la5 enumeracione5 Qamo5 a Qer an7e5 un
proMlema muS 7Vpico en programaciónL 5i Rueremo5 deOinir un m67odo Rue pueda
imprimir por pan7alla un cier7o 7eU7o con diOeren7e5 7amaXo5N una primera po5iMilidad
5erVa do7arlo de un par9me7ro de algTn 7ipo en7ero Rue indiRue el 7amaXo con el Rue 5e
de5ea mo57rar el 7eU7o% A e57o5 nTmero5 Rue lo5 m67odo5 in7erpre7an con 5igniOicado5
e5pecVOico5 5e le5 5uele denominar 2O?14.; ?M=76.;N S 5u u7ili8ación 7iene lo5
inconQenien7e5 de Rue diOicul7a la legiMilidad del código IWaS Rue recordar Ru6 5igniOica
para el m67odo cada Qalor del nTmeroK S 5u e5cri7ura IWaS Rue recordar Ru6 nTmero Wa
pa59r5ele al m67odo para Rue Ouncione de una cier7a OormaK
"na al7erna7iQa mejor para el m67odo an7erior con5i57e en deOinirlo de modo Rue 7ome
un par9me7ro de 7ipo Tamaño para Rue a5V el programador u5uario no 7enga Rue recordar
la corre5pondencia en7re 7amaXo5 S nTmero5% ,6a5e a5V como la llamada (2) del ejemplo
Rue 5igue e5 mucWo m95 legiMle Rue la (1)L
obj.MuestraTexto(2); // (1)
obj.MuestraTexto(Tamaño.Mediano); // (2)
Adem95N e57o5 li7erale5 no 5ólo Oacili7an la e5cri7ura S lec7ura del código 5ino Rue
7amMi6n pueden 5er u5ado5 por Werramien7a5 de documen7aciónN depuradore5 u o7ra5
aplicacione5 para 5u57i7uir nTmero5 m9gico5 S mo57rar 7eU7o5 mucWo5 m95 legiMle5%
Por o7ro ladoN u5ar enumeracione5 7amMi6n Oacili7a el man7enimien7o del código% Por
ejemploN 5i el m67odo (1) an7erior 5e WuMie5e deOinido de Oorma Rue : 5igniOica5e 7amaXo
peRueXoN & mediano S * grandeN cuando 5e Rui5ie5e incluir un nueQo 7amaXo in7ermedio
en7re peRueXo S mediano WaMrVa Rue darle un Qalor 5uperior a * o inOerior a : Sa Rue lo5
dem95 e57arVan cogido5N lo Rue romperVa el orden de menor a maSor en7re nTmero5 S
7amaXo5 a5ociado5% Sin emMargoN u5ando una enumeración no impor7arVa man7ener el
orden rela7iQo S Ma57arVa aXadirle un nueQo li7eral%
7ra Qen7aja de u5ar enumeracione5 Oren7e a nTmero5 m9gico5 e5 Rue 657a5 par7icipan en
el mecani5mo de comproMación de 7ipo5 de C# S el CL)% A5VN 5i un m67odo e5pera un
oMje7o Tamaño S 5e le pa5a uno de o7ro 7ipo enumerado 5e producir9N 5egTn cuando 5e
El lenguaje de programación C# (ema :3L Enumeracione5
de7ec7e la incoWerenciaN un error en compilación o una eUcepción en ejecución% Sin
emMargoN 5i 5e WuMie5en u5ado nTmero5 m9gico5 del mi5mo 7ipo en Qe8 de
enumeracione5 no 5e WaMrVa de7ec7ado nadaN pue5 en amMo5 ca5o5 para el compilador S
el CL) 5erVan 5imple5 nTmero5 5in ningTn 5igniOicado e5pecial a5ociado%
(efinición de enumeraciones
2a Wemo5 Qi57o un ejemplo de cómo deOinir una enumeración% Sin emMargoN la 5in7aUi5
comple7a Rue 5e puede u5ar para deOinirla5 e5L
enum <nombreEnumeración> : <tipoBase>
{
<literales>
}
En realidad una enumeración e5 un 7ipo e5pecial de e57ruc7ura Iluego System.VaIueType
5er9 7ipo padre de ellaK Rue 5ólo puede 7ener como miemMro5 campo5 pTMlico5
con57an7e5 S e5797ico5% E5o5 campo5 5e indican en <literales>N S como 5u5 modiOicadore5
5on 5iempre lo5 mi5mo5 no WaS Rue e5peciOicarlo5 Ide WecWoN e5 erróneo WacerloK
El 7ipo por deOec7o de la5 con57an7e5 Rue Oorman una enumeración e5 intN aunRue puede
d9r5ele5 cualRuier o7ro 7ipo M95ico en7ero IbyteN sbyteN shortN ushortN uintN intN Iong o
uIongK indic9ndolo en <tipoBase>% Cuando 5e Waga e57o WaS Rue 7ener muS pre5en7e Rue
el compilador de C# 5ólo admi7e Rue 5e indiRuen a5V lo5 alia5 de e57o5 7ipo5 M95ico5N
pero no 5u5 nomMre5 reale5 ISystem.ByteN System.SByteN e7c%K
Si no 5e e5peciOica Qalor inicial para cada con57an7eN el compilador le5 dar9 por deOec7o
Qalore5 Rue empiecen de5de + S 5e incremen7en en una unidad para cada con57an7e
5egTn 5u orden de aparición en la deOinición de la enumeración% A5VN el ejemplo del
principio del 7ema e5 eRuiQalen7e aL
enum Tamaño:int
{
Pequeño = 0,
Mediano = 1,
Grande = 2
}
E5 po5iMle al7erar lo5 Qalore5 iniciale5 de cada con57an7e indic9ndolo5 eUplVci7amen7e
como en el código reci6n mo57rado% 7ra po5iMilidad e5 al7erar el Qalor Ma5e a par7ir del
cual 5e Qa calculando el Qalor de la5 5iguien7e5 con57an7e5 como en e57e o7ro ejemploL
enum Tamaño
{
Pequeño,
Mediano = 5,
Grande
}
En e57e Tl7imo ejemplo el Qalor a5ociado a Pequeño 5er9 +N el a5ociado a Mediano 5er9 ;N
S el a5ociado a Grande 5er9 = Sa Rue como no 5e le indica eUplVci7amen7e ningTn o7ro 5e
con5idera Rue e57e Qalor e5 el de la con57an7e an7erior m95 :%
El lenguaje de programación C# (ema :3L Enumeracione5
MQiamen7eN el nomMre Rue 5e de a cada con57an7e Wa de 5er diOeren7e al de la5 dem95 de
5u mi5ma enumeración S el Qalor Rue 5e de a cada una Wa de e57ar incluido en el rango
de Qalore5 admi7ido5 por 5u 7ipo Ma5e% Sin emMargoN nada oMliga a Rue el Qalor Rue 5e de
a cada con57an7e 7enga Rue 5er diOeren7e al de la5 dem95N S de WecWo puede e5peciOicar5e
el Qalor de una con57an7e en Ounción del Qalor de o7ra como mue57ra e57e ejemploL
enum Tamaño
{
Pequeño,
Mediano = Pequeño,
Grande = Pequeño + Mediano
}
En realidadN lo Tnico Rue impor7a e5 Rue el Qalor Rue 5e d6 a cada li7eralN 5i e5 Rue 5e le
da alguno eUplVci7amen7eN 5ea una eUpre5ión con57an7e cuSo re5ul7ado 5e encuen7re en el
rango admi7ido por el 7ipo Ma5e de la enumeración S no proQoRue deOinicione5
circulare5% Por ejemploN la 5iguien7e deOinición de enumeración e5 incorrec7a Sa Rue en
ella lo5 li7erale5 Pequeño S Mediano 5e Wan deOinido circularmen7eL
enum TamañoMal
{
Pequeño = Mediano,
Mediano = Pequeño,
Grande
}
Nó7e5e Rue 7amMi6n la 5iguien7e deOinición de enumeración 7amMi6n 5erVa incorrec7a Sa
Rue en ella el Qalor de B depende del de A implVci7amen7e I5erVa el de A m95 :KL
enum EnumMal
{
A = B,
B
}
5so de enumeraciones
La5 QariaMle5 de 7ipo5 enumerado5 5e deOinen como cualRuier o7ra QariaMle I5in7aUi5
<nombreTipo> <nombreVariable>K Por ejemploL
Tamaño t;
El Qalor por deOec7o para un oMje7o de una enumeración e5 +N Rue puede o no
corre5ponder5e con alguno de lo5 li7erale5 deOinido5 para 657a% A5VN 5i la t del ejemplo
Oue5e un campo 5u Qalor 5erVa Tamaño.Pequeño% (amMi6n puede d9r5ele o7ro Qalor al
deOinirlaN como mue57ra el 5iguien7e ejemplo donde 5e le da el Qalor Tamaño.GrandeL
Tamaño t = Tamaño.Grande; // Ahora t vale Tamaño.Grande
Nó7e5e Rue a la Wora de Wacer reOerencia a lo5 li7erale5 de una enumeración 5e u5a la
5in7aUi5 <nombreEnumeración>.<nombreLiteral>N como e5 lógico 5i 7enemo5 en cuen7a Rue
El lenguaje de programación C# (ema :3L Enumeracione5
en realidad lo5 li7erale5 de una enumeración 5on con57an7e5 puMlica5 S e5797ica5N pue5 e5
la 5in7aUi5 Rue 5e u5a para acceder a e5e 7ipo de miemMro5% El Tnico 5i7io donde no e5
nece5ario preceder el nomMre del li7eral de <nombreEnumeración>. e5 en la propia
deOinición de la enumeraciónN como 7amMi6n ocurre con cualRuier con57an7e e5797ica%
En realidad lo5 li7erale5 de una enumeración 5on con57an7e5 de 7ipo5 en7ero5 S la5
QariaMle5 de 7ipo enumerado 5on QariaMle5 del 7ipo en7ero Ma5e de la enumeración% Por
e5o e5 po5iMle almacenar Qalore5 de enumeracione5 en QariaMle5 de 7ipo5 en7ero5 S
Qalore5 de 7ipo5 en7ero5 en QariaMle5 de enumeracione5% Por ejemploL
int i = Tamaño.Pequeño; // Ahora i vale 0
Tamaño t = (Tamaño) 0; //Ahora t vale Tamaño.Pequeño (=0)
t = (Tamaño) 100; // Ahora t vale 100, que no se corresponde con ningún literal
Como 5e Qe en el Tl7imo ejemploN 7amMi6n e5 po5iMle darle a una enumeración Qalore5
en7ero5 Rue no 5e corre5pondan con ninguno de 5u5 li7erale5%
#ado Rue lo5 Qalore5 de una enumeración 5on en7ero5N e5 po5iMle aplicarle5 mucWa5 de
la5 operacione5 Rue 5e pueden aplicar a lo5 mi5mo5L ==N !=N <N >N <=N >=N +N -N ^N &N |N ~N +
+N -- S sizeof% Sin emMargoN WaS Rue concre7ar Rue lo5 operadore5 Minario5 + S - no
pueden aplicar5e en7re do5 operando5 de enumeracione5N 5ino Rue al meno5 uno de ello5
Wa de 5er un 7ipo en7erob S Rue WN X S Y 5ólo pueden aplicar5e en7re enumeracione5%
La clase !$stem.Enum
(odo5 lo5 7ipo5 enumerado5 deriQan de System.EnumN Rue deriQa de System.VaIueType
S 657a a 5u Qe8 deriQa de la cla5e primigenia System.Object% Apar7e de lo5 m67odo5
Weredado5 de e57a5 cla5e5 padre5 Sa e57udiado5N 7oda enumeración 7amMi6n di5pone de
o7ro5 m67odo5 Weredado5 de System.EnumN lo5 principale5 de lo5 cuale5 5onL
• static Type getUnderIyingType(Type enum)L #eQuelQe un oMje7o System.Type
con inOormación 5oMre el 7ipo Ma5e de la enumeración repre5en7ada por el oMje7o
System.Type Rue 5e le pa5a como par9me7ro
:*
%
• string ToString(string formato)L Cuando a un oMje7o de un 7ipo enumerado 5e le
aplica el m67odo ToString() Weredado de objectN lo Rue 5e mue57ra e5 una cadena
con el nomMre del li7eral almacenado en e5e oMje7o% Por ejemplo Inó7e5e Rue
WriteLine() llama au7om97icamen7e al ToString() de 5u5 argumen7o5 no stringKL
Tamaño t = Color.Pequeño;
Console.WriteLine(t); // Muestra por pantalla la cadena "Pequeño"
Como 7amMi6n puede re5ul7ar in7era5an7e oM7ener el Qalor num6rico del li7eralN 5e
Wa 5oMrecargado System.Enum el m67odo an7erior para Rue 7ome como
par9me7ro una cadena Rue indica cómo 5e de5ea mo57rar el li7eral almacenado en
el oMje7o% Si e57a cadena e5 nulaN QacVa o Qale "G" mue57ra el li7eral como 5i del
m67odo ToString() e579ndar 5e 7ra7a5eN pero 5i Qale "D" o "X" lo Rue mue57ra e5 5u
Qalor num6rico Ien decimal 5i Qale "D" S en WeUadecimal 5i Qale "X"K Por ejemploL
:*
)ecu6rde5e Rue para oM7ener el System.Type de un 7ipo de da7o Ma57a u5ar el operador typeof pa59ndole
como par9me7ro5 el nomMre del 7ipo cuSo System.Type 5e de5ea oM7ener% Por ejemploN typeof(int)
El lenguaje de programación C# (ema :3L Enumeracione5
Console.WriteLine(t.ToString("X")); // Muestra 0
Console.WriteLine(t.ToString("G")); // Muestra Pequeño
En realidadN lo5 Qalore5 de formato 5on in5en5iMle5 a la capi7ali8ación S da igual 5i
en Qe8 de "G" 5e u5a "g" o 5i en Qe8 de "X" 5e u5a "x"%
• static string Format(Type enum, object vaIorLiteraI, string formato)L /unciona de
Oorma parecida a la 5oMrecarga de ToString() recien Qi57aN 5ólo Rue aWora no e5
nece5ario di5poner de ningTn oMje7o del 7ipo enumerado cuSa repre5en7ación de
li7eral 5e de5ea oM7ener 5ino Rue Ma57a indicar el oMje7o Type Rue lo repre5en7a S
el nTmero del li7eral a oM7ener% Por ejemploL
Console.Write(Enum.Format(typeof(Tamaño), 0, "G"); // Muestra Pequeño
Si el valorLiteral indicado no e57uQie5e a5ociado a ningTn li7eral del 7ipo
enumerador repre5en7ado por enumN 5e deQolQerVa una cadena con dicWo nTmero%
Por el con7rarioN 5i WuMie5en Qario5 li7erale5 en la enumeración con el mi5mo
Qalor num6rico a5ociadoN lo Rue 5e deQolQerVa 5erVa el nomMre del declarado en
Tl7imo lugar al deOinir la enumeración%
• static object Parse(Type enum, string nombre6 bool ma$usculas7): Crea
un oMje7o de un 7ipo enumerado cuSo Qalor e5 el corre5pondien7e al li7eral de
nomMre a5ociado nombre% Si la enumeración no 7uQie5e ningTn li7eral con e5e
nomMre 5e lan8arVa una ArgumentExceptionN S para de7erminar cómo 5e Wa de
Mu5car el nomMre en7re lo5 li7erale5 de la enumeración 5e u7ili8a el 7ercer
par9me7ro Ie5 opcional S por deOec7o Qale faIseK Rue indica 5i 5e Wa de ignorar la
capi7ali8ación al Mu5carlo% "n ejemplo del u5o de e57e m67odo e5L
Tamaño t = (Tamaño) Enum.Parse(typeof(Tamaño), "Pequeño");
Console.WriteLine(t) // Muestra Pequeño
Apar7e de crear oMje7o5 a par7ir del nomMre del li7eral Rue almacenar9nN Parse()
7amMi6n permi7e crearlo5 a par7ir del Qalor num6rico del mi5mo% Por ejemploL
Tamaño t = (Tamaño) Enum.Parse(typeof(Tamaño), "0");
Console.WriteLine(t) // Muestra Pequeño
En e57e ca5oN 5i el Qalor indicado no 5e corre5pondie5e con el de ninguno de lo5
li7erale5 de la enumeración no 5al7arVa ninguna eUcepciónN pero el oMje7o creado
no almacenarVa ningTn li7eral Q9lido% Por ejemploL
Tamaño t = (Tamaño) Enum.Parse(typeof(Tamaño), "255");
Console.WriteLine(t) // Muestra 255
• static object[] GetVaIues(Type enum)L #eQuelQe una 7aMla con lo5 Qalore5 de
7odo5 lo5 li7erale5 de la enumeración repre5en7ada por el oMje7o System.Type Rue
5e le pa5a como par9me7ro% Por ejemploL
object[] tabla = Enum.GetValues(typeof(Tamaño));
Console.WriteLine(tabla[0]); // Muestra 0, pues Pequeño = 0
Console.WriteLine(tabla[1]); // Muestra 1, pues Mediano = 1
Console.WriteLine(tabla[2]); // Muestra 1, pues Grande = Pequeño+Mediano
El lenguaje de programación C# (ema :3L Enumeracione5
• static string GetName(Type enum, object vaIor)L #eQuelQe una cadena con el
nomMre del li7eral de la enumeración repre5en7ada por enum Rue 7enga el Qalor
e5peciOicado en valor% Por ejemploN e57e código mue57ra Pequeño por pan7allaL
Console.WriteLine(Enum.GetName(typeof(Tamaño), 0)); //Ìmprime Pequeño
Si la enumeración no con7iene ningTn li7eral con e5e Qalor deQuelQe nuIIN S 5i
7uQie5e Qario5 con e5e mi5mo Qalor deQolQerVa 5ólo el nomMre del Tl7imo% Si 5e
Ruiere oM7ener el de 7odo5 e5 mejor u5ar GetNames()N Rue 5e u5a como GetName()
pero deQuelQe un string[] con lo5 nomMre5 de 7odo5 lo5 li7erale5 Rue 7engan el
Qalor indicado ordenado5 5egTn 5u orden de deOinición en la enumeración%
• static booI isDefined (Type enum, object vaIor)L #eQuelQe un Mooleano Rue indica
5i algTn li7eral de la enumeración indicada 7iene el Qalor indicado%
Enumeraciones de flags
!ucWa5 Qece5 in7ere5a dar como Qalore5 de lo5 li7erale5 de una enumeración Tnicamen7e
Qalore5 Rue 5ean po7encia5 de do5N pue5 ello permi7e Rue median7e operacione5 de Mi75 &
S | 5e puede 7ra7ar lo5 oMje7o5 del 7ipo enumerado como 5i almacena5en 5imul79neamen7e
Qario5 li7erale5 de 5u 7ipo% A e57e 7ipo de enumeracione5 la5 llamaremo5 120?14967.21;
51 @-9=;N S un ejemplo de ella5 e5 el 5iguien7eL
enum ModificadorArchivo
{
Lectura = 1,
Escritura = 2,
Oculto = 4,
Sistema = 8
}
Si Rueremo5 crear un oMje7o de e57e 7ipo Rue repre5en7e lo5 modiOicadore5 de un arcWiQo
de lec7uraDe5cri7ura podrVamo5 WacerL
ModificadorArchivo obj = ModificadorArchivo.Lectura | ModificadorArchivo.Escritura
El Qalor del 7ipo Ma5e de la enumeración Rue 5e WaMr9 almacenado en obj e5 *N Rue e5 el
re5ul7ado de Wacer la operación ) en7re lo5 Mi75 de lo5 Qalore5 de lo5 li7erale5 Lectura S
Escritura% Al 5er lo5 li7erale5 de ModificadorArchivo po7encia5 de do5 5ólo 7endr9n un Tnico
Mi7 a : S dicWo Mi7 5er9 diOeren7e en cada uno de ello5N por lo Rue la Tnica Oorma de
generar un * ITl7imo5 do5 Mi75 a :K comMinando li7erale5 de ModificadorArchivo e5
comMinando lo5 li7erale5 Lectura ITl7imo Mi7 a :K S Escritura IpenTl7imo Mi7 a :K Por 7an7oN
el Qalor de obj iden7iOicar9 unVQocamen7e la comMinación de dicWo5 li7erale5%
#eMido a e57a comMinaMilidad no 5e deMe de7erminar el Qalor li7eral de lo5 oMje7o5
ModificadorArchivo 7al S como 5i 5ólo pudie5en almacenar un Tnico li7eralN pue5 5u Qalor
num6rico no 7endrVa porRu6 corre5ponder5e con el de ningTn li7eral de la enumeración
Por ejemploL
bool permisoLectura = (obj == ModificadorArchivo.Lectura); // Almacena false
El lenguaje de programación C# (ema :3L Enumeracione5
AunRue lo5 permi5o5 repre5en7ado5 por obj incluVan permi5o de lec7uraN 5e deQuelQe
faIse porRue el Qalor num6rico de obj e5 * S el del ModificadorArchivo.Lectura e5 :% Si lo
Rue Rueremo5 e5 comproMar 5i obj con7iene permi5o de lec7uraN en7once5 WaMr9 Rue u5ar
el operador de Mi75 & para ai5larlo del re57o de li7erale5 comMinado5 Rue con7ieneL

bool permisoLectura = (ModificadorArchivo.Lectura ==
(obj & ModificadorArchivo.Lectura)); // Almacena true
N lo Rue e5 lo mi5moL
bool permisoLectura = ( (obj & ModificadorArchivo.Lectura) != 0); // Almacena true
A5imi5moN 5i direc7amen7e 5e in7en7a mo57rar por pan7alla el Qalor de un oMje7o de una
enumeración Rue almacene un Qalor Rue 5ea comMinación de li7erale5N no 5e oM7endr9 el
re5ul7ado e5perado InomMre del li7eral corre5pondien7e a 5u QalorK Por ejemploN dadoL
Console.Write(obj); // Muestra 3
Se mo57rar9 un * por pan7alla Sa Rue en realidad ningTn li7eral de ModificadorArchivo
7iene a5ociado dicWo Qalor% Como lo na7ural 5erVa Rue 5e de5ea5e oM7ener un men5aje de
la Oorma Lectura# @scrituraN lo5 m67odo5 ToString() S Format() de la5 enumeracione5
Sa Qi57o5 admi7en un cuar7o Qalor "F" para 5u par9me7ro Oorma7o I5u nomMre Qiene de
Olag5K con el Rue 5e con5igue lo an7erior% Por 7an7oL
Console.Write(obj.ToString("F")); // Muestra Lectura, Escritura
E57o 5e deMe a Rue cuando Format() de7ec7a e57e indicador IToString() 7amMi6nN pue5 para
generar la cadena llama in7ernamen7e a Format()K S el li7eral almacenado en el oMje7o no
5e corre5ponde con ninguno de lo5 de 5u 7ipo enumeradoN en7once5 lo Rue Wace e5 mirar
uno por uno lo5 Mi75 a uno del Qalor num6rico a5ociado de dicWo li7eral S aXadirle a la
cadena a deQolQer el nomMre de cada li7eral de la enumeración cuSo Qalor a5ociado 5ólo
7enga e5e Mi7 a unoN u59ndo como 5eparador en7re nomMre5 un car9c7er de coma%
Nó7e5e Rue nada oMliga a Rue lo5 li7erale5 del 7ipo enumerado 7engan porRu6 WaMer5e
deOinido como po7encia5 de do5N aunRue e5 lo m95 conQenien7e para Rue "F" 5ea T7ilN
pue5 5i la enumeración 7uQie5e algTn li7eral con el Qalor del oMje7o de 7ipo enumerado no
5e reali8arVa el proce5o an7erior S 5e deQolQerVa 5ólo el nomMre de e5e li7eral%
Por o7ro ladoN 5i alguno de lo5 Mi75 a : del Qalor num6rico del oMje7o no 7uQie5e el
corre5pondien7e li7eral con 5ólo e5e Mi7 a : en la enumeración no 5e reali8arVa 7ampoco el
proce5o an7erior S 5e deQolQerVa una cadena con dicWo Qalor num6rico%
"na po5iMilidad m95 cómoda para oM7ener el mi5mo eOec7o Rue con "F" e5 marcar la
deOinición de la enumeración con el a7riMu7o FIagsN con lo Rue ni 5iRuiera 5erVa nece5ario
indicar Oorma7o al llamar a ToString() 5eaN 5i 5e deOine ModificadorArchivo a5VL
[Flags]
enum ModificadorArchivo
{
Lectura = 1,
Escritura = 2,
Oculto = 4,
El lenguaje de programación C# (ema :3L Enumeracione5
Sistema = 8
}
En7once5 la 5iguien7e llamada producir9 como 5alida Lectura# @scrituraL
Console.Write(obj); // Muestra Lectura, Escritura
E57o 5e deMe a Rue en au5encia del modiOicador "F", Format() mira den7ro de lo5
me7ada7o5 del 7ipo enumerado al Rue per7enece el Qalor num6rico a mo57rar 5i 657e
di5pone del a7riMu7o FIags% Si e5 a5V Ounciona como 5i 5e le WuMie5e pa5ado "F"%
(amMi6n caMe de57acar RueN para crear oMje7o5 de enumeracione5 cuSo Qalor 5ea una
comMinación de Qalore5 de li7erale5 de 5u 7ipo enumeradoN el m67odo m67odo Parse() de
Enum permi7e Rue la cadena Rue 5e le e5peciOica como 5egundo par9me7ro cuen7e con
mTl7iple5 li7erale5 5eparado5 por coma5% Por ejemploN un oMje7o ModificadorArchivo Rue
repre5en7e modiOicadore5 de lec7ura S ocul7ación puede crear5e conL
ModificadorArchivo obj =
(ModificadorArchivo) Enum.Parse(typeof(ModificadorArchivo),"Lectura,Oculto"));
HaS Rue 5eXalar Rue e57a capacidad de crear oMje7o5 de enumeracione5 cuSo Qalor
almacenado 5ea una comMinación de lo5 li7erale5 deOinido5 en dicWa enumeración e5
7o7almen7e independien7e de 5i al deOinirla 5e u7ili8ó el a7riMu7o FIags o no%
El lenguaje de programación C# (ema :;L In7erOace5
TEMA 15: Interfaces
Concepto de interfa3
"na 72314@9K e5 la deOinición de un conjun7o de m67odo5 para lo5 Rue no 5e da
implemen7aciónN 5ino Rue 5e le5 deOine de manera 5imilar a como 5e deOinen lo5
m67odo5 aM57rac7o5% E5 m95N una in7erOa8 puede Qer5e como una Oorma e5pecial de
deOinir cla5e5 aM57rac7a5 Rue 7an 5ólo con7engan miemMro5 aM57rac7o5%
Como la5 cla5e5 aM57rac7a5N la5 in7erOace5 5on 7ipo5 reOerenciaN no puede crear5e oMje7o5
de ella5 5ino 5ólo de 7ipo5 Rue deriQen de ella5N S par7icipan del polimorOi5mo% Sin
emMargoN 7amMi6n 7ienen numero5a5 diOerencia5 con 657a5L
• E; <.;7C-1 51@7274 37<.; /01 5147A12 51 ?M; 51 029 72314@9K% E57o 5e deMe a
Rue lo5 proMlema5 Rue 5e podrVan pre5en7ar al crear 7ipo5 Rue Wereden de Qario5
padre5 5e deMen a la diOVcil re5olución de lo5 conOlic7o5 deriQado5 de la Werencia
de Qaria5 implemen7acione5 diOeren7e5 de un mi5mo m67odo% Sin emMargoN como
con la5 in7erOace5 e57o nunca podr9 ocurrir en 7an7o Rue no incluSen códigoN 5e
permi7e la Werencia mTl7iple de la5 mi5ma5%
• La5 e57ruc7ura5 no pueden Weredar de cla5e5 pero 5V de in7erOace5N S la5 in7erOace5
no pueden deriQar de cla5e5N pero 5V de o7ra5 in7erOace5%
• (odo 7ipo Rue deriQe de una in7erOa8 Wa de dar una implemen7ación de 7odo5 lo5
miemMro5 Rue Wereda de e57aN S no como ocurre con la5 cla5e5 aM57rac7a5 donde
e5 po5iMle no darla 5i 5e deOine como aM57rac7a 7amMi6n la cla5e Wija% #e e57a
manera Rueda deOinido un con7ra7o en la cla5e Rue la Wereda Rue Qa a permi7ir
poder u5arla con 5eguridad en 5i7uacione5 polimórOica5L 7oda cla5e Rue Werede
una in7erOa8 implemen7ar9 7odo5 lo5 m67odo5 de la mi5ma% Por e57a ra8ón 5e
5uele denominar 7?<-1?12394 una in7erOa8 al WecWo de Weredar de ella%

Nó7e5e Rue deMido a e57oN no 5uele conQenir ampliar in7erOace5 Sa deOinida5 e
implemen7ada5N pue57o Rue cualRuier aXadido inQalidar9 5u5 implemen7acione5
Wa57a Rue 5e deOina en la5 mi5ma5 un implemen7ación para dicWo aXadido% Sin
emMargoN 5i 5e Wereda de una cla5e aM57rac7a e57e proMlema no 5e 7endr9 5iempre
Rue el miemMro aXadido a la cla5e aM57rac7a no 5ea aM57rac7o%
• La5 in7erOace5 5ólo pueden 7ener como miemMro5 m67odo5 normale5N eQen7o5N
propiedade5 e indi8adore5b pero no pueden incluir deOinicione5 de campo5N
operadore5N con57ruc7ore5N de57ruc7ore5 o miemMro5 e5797ico5% Adem95N 7odo5 lo5
miemMro5 de la5 in7erOace5 5on implVci7amen7e pTMlico5 S no 5e le5 puede dar
ningTn modiOicador de acce5o Ini 5iRuiera pubIicN pue5 5e 5uponeK
(efinición de interfaces
La 5in7aUi5 general Rue 5e 5igue a la Wora de deOinir una in7erOa8 e5L
El lenguaje de programación C# (ema :;L In7erOace5
<modificadores> interface <nombre>/<inter!aces$ase>
{
<miembros>
}
Lo5 <modificadores> admi7ido5 por la5 in7erOace5 5on lo5 mi5mo5 Rue lo5 de la5 cla5e5 E5
decirN pubIicN internaI, privateN protectedN protected internaI o new Ie igualmen7eN lo5
cua7ro Tl7imo5 5ólo 5on aplicaMle5 a in7erOace5 deOinida5 den7ro de o7ro5 7ipo5K
El <nombre> de una in7erOa8 puede 5er cualRuier iden7iOicador Q9lidoN aunRue por
conQenio 5e 5uele u5ar Ì como primer car9c7er del mi5mo IÌComparableN ÌAN e7cK
Lo5 <miembros> de la5 in7erOace5 pueden 5er deOinicione5 de m67odo5N propiedade5N
indi8adore5 o eQen7o5N pero no campo5N operadore5N con57ruc7ore5 o de57ruc7ore5% La
5in7aUi5 Rue 5e 5igue para deOinir cada 7ipo de miemMro e5 la mi5ma Rue para deOinirlo5
como aM57rac7o5 en una cla5e pero 5in incluir abstract por 5uponer5e implVci7amen7eL

• MN3.5.;: <tipoRetorno> <nombreMétodo>(<parámetros>);
• P4.<715951;: <tipo> <nombrePropiedad> {set8 get8}
Lo5 MloRue5 get S set pueden in7ercamMiar5e S puede no incluir5e uno de ello5
Ipropiedad de 5ólo lec7ura o de 5ólo e5cri7ura 5egTn el ca5oKN pero no lo5 do5%
• I257K95.41;: <tipo> this[<índices>] {set8 get8}
Al igual Rue la5 propiedade5N lo5 MloRue5 set S get pueden in7ercamMiar5e S
oMQiar5e uno de ello5 al deOinirlo5%
• EA123.;: event <delegado> <nombreEvento>;
Nó7e5e Rue a diOerencia de la5 propiedade5 e indi8adore5N no e5 nece5ario indicar
nada 5oMre 5u5 MloRue5 add S remove% E57o 5e deMe a Rue 5iempre 5e Wan de
implemen7ar amMo5N aunRue 5i 5e u5a la 5in7aUi5 M95ica el compilador le5 da una
implemen7ación por deOec7o au7om97icamen7e%
CualRuier deOinición de un miemMro de una in7erOa8 puede incluir el modiOicador new
para indicar Rue pre7ende ocul7ar o7ra Weredada de alguna in7erOa8 padre% Sin emMargoN
el re57o de modiOicadore5 no 5on Q9lido5 Sa Rue implVci7amen7e 5iempre 5e con5idera
Rue 5on pubIic S abstract% Adem95N una in7erOa8 7ampoco puede incluir miemMro5 de
7ipoN por lo Rue e5 incorrec7o incluir el modiOicador static al deOinir 5u5 miemMro5%

Cada in7erOa8 puede Weredar de Qaria5 in7erOace5N Rue 5e indicarVan en <interfacesBase>
5eparada5 por coma5% E57a li57a 5ólo puede incluir in7erOace5N pero no cla5e5 o
e57ruc7ura5b S a con7inuación 5e mue57ra un ejemplo de cómo deOinir una in7erOa8 ÌC Rue
Wereda de o7ra5 do5 in7erOace5 ÌA S ÌBL
public delegate void D (int x);
interface ÌA
El lenguaje de programación C# (ema :;L In7erOace5
{
int PropiedadA{get;}
void Común(int x);
}
interface ÌB
{
int this [int índice] {get; set;}
void Común(int x);
}
interface ÌC: ÌA, ÌB
{
event D EventoC;
}
Nó7e5e Rue aunRue la5 in7erOace5 padre5 de ÌC con7ienen un m67odo comTn no WaS
proMlema alguno a la Wora de deOinirla5% En el 5iguien7e epVgraOe Qeremo5 cómo 5e
re5uelQen la5 amMigiedade5 Rue por e57o pudie5en dar5e al implemen7ar ÌC%
mplementación de interfaces
Para deOinir una cla5e o e57ruc7ura Rue implemen7e una o m95 in7erOace5 Ma57a incluir lo5
nomMre5 de la5 mi5ma5 como 5i de una cla5e Ma5e 5e 7ra7a5e D5epar9ndola5 con coma5 5i
5on Qaria5 o 5i la cla5e deOinida Wereda de o7ra cla5eD S a5egurar Rue la cla5e cuen7e con
deOinicione5 para 7odo5 lo5 miemMro5 de la5 in7erOace5 de la5 Rue Wereda Dlo Rue 5e
puede con5eguir deOini6ndolo5 en ella o Wered9ndolo5 de 5u cla5e padre%

La5 deOinicione5 Rue 5e den de miemMro5 de in7erOace5 Wan de 5er 5iempre pTMlica5 S no
pueden incluir overrideN pue5 como 5u5 miemMro5 5on implVci7amen7e abstract 5e
5oMreen7iende% Sin emMargoN 5V pueden d9r5ele lo5 modiOicadore5 como virtuaI ó abstract
S u5ar override en redeOinicione5 Rue 5e le5 den en cla5e5 Wija5 de la cla5e Rue
implemen7e la in7erOa8%
Cuando una cla5e deriQa de m95 de una in7erOa8 Rue incluSe un mi5mo miemMroN la
implemen7ación Rue 5e le d6 5erQir9 para 7oda5 la5 in7erOace5 Rue cuen7en con e5e
miemMro% Sin emMargoN 7amMi6n e5 po5iMle dar una implemen7ación diOeren7e para cada
una u5ando una 7?<-1?12396782 1I<-L6739N lo Rue con5i57e en implemen7ar el miemMro
5in el modiOicador pubIic S an7eponiendo a 5u nomMre el nomMre de la in7erOa8 a la Rue
per7enece 5eguido de un pun7o Icar9c7er .K
Cuando un miemMro 5e implemen7a eUplVci7amen7eN no 5e le pueden dar modiOicadore5
como en la5 implemen7acione5 implVci7a5N ni 5iRuiera virtuaI o abstract% "na Oorma de
5imular lo5 modiOicadore5 Rue 5e nece5i7en con5i57e en darle5 un cuerpo Rue lo Rue Waga
5ea llamar a o7ra Ounción Rue 5V cuen7e con e5o5 modiOicadore5%
El 5iguien7e ejemplo mue57ra cómo deOinir una cla5e CL Rue implemen7e la in7erOa8 ÌCL
class CL:ÌC
{
public int PropiedadA
{
El lenguaje de programación C# (ema :;L In7erOace5
get {return 5;}
set {Console.WriteLine(“Asignado{0} a PropiedadA”, value);}
}
void ÌA.Común(int x)
{
Console.WriteLine(“Ejecutado Común() de ÌA”);
}
public int this[int índice]
{
get { return 1;}
set { Console.WriteLine(“Asignado {0} a indizador”, value); }
}
void ÌB.Común(int x)
{
Console.WriteLine(“Ejecutado Común() de ÌB”);
}
public event D EventoC;
}
Como 5e QeN para implemen7ar la in7erOa8 ÌC Wa 5ido nece5ario implemen7ar 7odo5 5u5
miemMro5N inclu5o lo5 Weredado5 de ÌA S ÌBN de la 5iguien7e maneraL
• Al EventoC 5e le Wa dado la implemen7ación por deOec7oN aunRue 5i 5e Rui5ie5e 5e
podrVa WaMer dado una implemen7ación e5pecVOica a 5u5 MloRue5 add S remove%
• Al m67odo Común() 5e le Wa dado una implemen7ación para cada Qer5ión
Weredada de una de la5 cla5e5 padre de ÌCN u59ndo5e para ello la 5in7aUi5 de
implemen7ación eUplVci7a an7e5 comen7ada% Nó7e5e Rue no 5e Wa incluido el
modiOicador pubIic en la implemen7ación de e57o5 miemMro5%
• A la PropiedadA 5e le Wa dado una implemen7ación con un MloRue 5e7 Rue no
aparecVa en la deOinición de PropiedadA en la in7erOa8 ÌA% E57o e5 Q9lido Wacerlo
5iempre S cuando la propiedad no 5e WaSa implemen7ado eUplVci7amen7eN S lo
mi5mo ocurre con lo5 indi8adore5 S en lo5 ca5o5 en Rue en Qe8 de set 5ea get el
MloRue eU7ra implemen7ado%
7ra u7ilidad de la5 implemen7acione5 eUplVci7a5 e5 Rue 5on la Tnica manera de
con5eguir poder dar implemen7ación a m67odo5 ocul7ado5 en la5 deOinicione5 de
in7erOace5% Por ejemploN 5i 7enemo5L
interface ÌPadre
{
int P{get;}
}
interface ÌHija:Padre
{
new int P();
}
La Tnica Oorma de poder deOinir una cla5e donde 5e d6 una implemen7ación 7an7o para el
m67odo P() como para la propiedad PN e5 u5ando implemen7ación eUplVci7a a5VL
El lenguaje de programación C# (ema :;L In7erOace5
class C: ÌHija
{
void ÌPadre.P {}
public int P() {.}
}
a5VL
class C: ÌHija
{
public void P () {}
int ÌHija.P() {}
}
a5VL
class C: ÌHija
{
void ÌPadre.P() {}
int ÌHija.P() {}
}
Pero como no 5e puede implemen7ar e5 5in ninguna implemen7ación eUplVci7aN pue5 5e
producirVa un error al 7ener amMo5 miemMro5 la5 mi5ma 5igna7ura% E5 decirN la 5iguien7e
deOinición no e5 correc7aL
class C: ÌHija
{
public int P() {} // ERROR: Ambos miembros tienen la misma signatura
public void P() {}
}
E5 po5iMle reimplemen7ar en una cla5e Wija la5 deOinicione5 Rue 5u cla5e padre die5e para
lo5 m67odo5 Rue Weredó de una in7erOa8% Para Wacer e5o Ma57a Wacer Rue la cla5e Wija
7amMi6n Werede de e5a in7erOa8 S dar en ella la5 deOinicione5 eUplVci7a5 de miemMro5 de
la in7erOa8 Rue 5e e57imen conQenien7e5N con5ider9ndo5e Rue la5 implemen7acione5 para
lo5 dem95 5er9n la5 Weredada5 de 5u cla5e padre% Por ejemploL
using System;
interface ÌA
{
void F();
}
class C1: ÌA
{
public void F()
{
Console.WriteLine("El F() de C1");
}
}
class C2: C1, ÌA
{
void ÌA.F() // Sin implementación explícita no redefiniría, sino ocultaría
{
El lenguaje de programación C# (ema :;L In7erOace5
Console.WriteLine("El F() de C2");
}
public static void Main()
{
ÌA obj = new C1();
ÌA obj2 = new C2();
obj.F();
obj2.F();
}
}
)eimplemen7ar un miemMro de una in7erOa8 de e57a manera e5 parecido a redeOinir lo5
miemMro5 reimplemen7ado5N 5ólo Rue aWora la redeOinición 5erVa 5olamen7e acce5iMle a
7raQ65 de QariaMle5 del 7ipo de la in7erOa8% A5VN la 5alida del ejemplo an7erior 5erVaL
El F() de C1
El F() de C2
HaS Rue 7ener en cuen7a Rue de e57a manera 5ólo pueden Wacer5e reimplemen7acione5 de
miemMro5 5i la cla5e donde 5e reimplemen7a Wereda direc7amen7e de la in7erOa8
implemen7ada eUplVci7amen7e o de alguna in7erOa8 deriQada de 657a% A5VN en el ejemplo
an7erior 5erVa incorrec7o WaMer WecWoL

class C2:C1 //La lista de herencias e interfaces implementadas por C2 sólo incluye a C1
{
void ÌA.f(); // ERROR: Aunque C1 herede de ÌA, ÌA no se incluye directamente
// en la lista de interfaces implementadas por C2
}
E5 impor7an7e 5eXalar Rue el nomMre de in7erOa8 e5peciOicado en una implemen7ación
eUplVci7a Wa de 5er eUac7amen7e el nomMre de la in7erOa8 donde 5e deOinió el miemMro
implemen7adoN no el de alguna 5uMcla5e de la mi5ma% Por ejemploL
interface Ì1
{
void F()
}
interface Ì2:Ì1
{}
class C1:Ì2
{
public void Ì2.F(); //ERROR: habría que usar Ì1.F()
}
En el ejemplo an7eriorN la lVnea comen7ada con7iene un error deMido a Rue /() 5e deOinió
den7ro de la in7erOa8 Ì1N S aunRue 7amMi6n per7ene8ca a Ì2 porRue 657a lo Wereda de Ì1N a
la Wora de implemen7arlo eUplVci7amen7e WaS Rue preOijar 5u nomMre de Ì1N no de Ì2%
4cceso a miembros de una interfa3
El lenguaje de programación C# (ema :;L In7erOace5
Se puede acceder a lo5 miemMro5 de una in7erOa8 implemen7ado5 en una cla5e de manera
no eUplVci7a a 7raQ65 de QariaMle5 de e5a cla5e como 5i de miemMro5 normale5 de la
mi5ma 5e 7ra7a5e% Por ejemploN e57e código mo57rarVa un cinco por pan7allaL
CL c = new CL();
Console.WriteLine(c.PropiedadA);
Sin emMargoN 7amMi6n e5 po5iMle deOinir QariaMle5 cuSo 7ipo 5ea una in7erOa8% AunRue no
eUi57en con57ruc7ore5 de in7erOace5N e57a5 QariaMle5 pueden iniciali8ar5e gracia5 al
polimorOi5mo a5ign9ndole5 oMje7o5 de cla5e5 Rue implemen7en e5a in7erOa8% A5VN el
5iguien7e código 7amMi6n mo57rarVa un cinco por pan7allaL
ÌA a = new CL();
Console.WriteLine(a.PropiedadA);
Nó7e5e Rue a 7raQ65 de una QariaMle de un 7ipo in7erOa8 5ólo 5e puede acceder a
miemMro5 del oMje7o almacenado en ella Rue e576n deOinido5 en e5a in7erOa8% E5 decirN
lo5 Tnico5 miemMro5 Q9lido5 para el oMje7o a an7erior 5erVan PropiedadA S Común()
En ca5o de Rue el miemMro al Rue 5e pre7enda acceder WaSa 5ido implemen7ado
eUplVci7amen7eN 5ólo puede acceder5e a 6l a 7raQ65 de QariaMle5 del 7ipo in7erOa8 al Rue
per7enece S no a 7raQ65 de QariaMle5 de 7ipo5 Rue Wereden de ellaN Sa Rue la deOinición de
e57o5 miemMro5 e5 priQada al no lleQar modiOicador de acce5o% Por ejemploL
CL cl = new CL();
ÌA a = cl;
ÌB b = cl;
// Console.WriteLine(cl.Común()); // Error: Común() fue implementado explícitamente
Console.WriteLine(a.Común());
Console.WriteLine(b.Común());
Console.WriteLine(((ÌA) cl).Común());
Console.WriteLine(((ÌB) cl).Común());
Cada Qe8 Rue 5e llame a un m67odo implemen7ado eUplVci7amen7e 5e llamar9 a la Qer5ión
del mi5mo deOinida para la in7erOa8 a 7raQ65 de la Rue 5e accede% Por elloN la 5alida del
código an7erior 5er9L
@7ecutado ComUn(% de ;.
@7ecutado ComUn(% de ;1
@7ecutado ComUn(% de ;.
@7ecutado ComUn(% de ;1
Se puede dar 7an7o una implemen7ación implVci7a como una eUplVci7a de cada miemMro
de una in7erOa8% La eUplVci7a 5e u5ar9 cuando 5e acceda a un oMje7o Rue implemen7e e5a
in7erOa8 a 7raQ65 de una reOerencia a la in7erOa8N mien7ra5 Rue la implVci7a 5e u5ar9
cuando el acce5o 5e Waga a 7raQ65 de una reOerencia del 7ipo Rue implemen7a la in7erOa8%
Por ejemploN dado el 5iguien7e códigoL

interface Ì
{
object Clone();
}
class Clase:Ì
{
El lenguaje de programación C# (ema :;L In7erOace5
public object Clone()
{
Console.WriteLine(“Ìmplementación implícita”);
}
public object ÌClonable.Clone()
{
Console.WriteLine(“Ìmplementación explícita”);
}
public static void Main()
{
Clase obj = new Clase();
((Ì) obj).Clone();
obj.Clone();
}
}
El re5ul7ado Rue por pan7alla 5e mo57rar9 7ra5 ejecu7arlo e5L
;m5lementaciBn e$5lQcita
;m5lementaciBn im5lQcita
Acceso a miembros de interfaces y boxing
E5 impor7an7e 5eXalar Rue aunRue la5 e57ruc7ura5 puedan implemen7ar in7erOace5 7al S
como lo Wacen la5 cla5e5N el llamarla5 a 7raQ65 de reOerencia5 a la in7erOa8 5upone una
gran p6rdida de rendimien7oN Sa Rue como la5 in7erOace5 5on 7ipo5 reOerencia ello
implicarVa la reali8ación del Sa Qi57o proce5o de MoUing% Por ejemploN en el códigoL
using System;
interface ÌÌncrementable
{ void Ìncrementar();}
struct Estructura:ÌÌncrementable
{
public int Valor;
public void Ìncrementar()
{
Valor++;
}
static void Main()
{
Estructura o = new Estructura();
Console.WriteLine(o.Valor);
((ÌÌncrementable) o).Ìncrementar();
Console.WriteLine(o.Valor);
o.Ìncrementar();
Console.WriteLine(o.Valor);
}
}
La 5alida oM7enida 5er9L

El lenguaje de programación C# (ema :;L In7erOace5
C
#onde nó7e5e Rue el re5ul7ado 7ra5 la primera llamada a Ìncrementar() 5igue 5iendo el
mi5mo Sa Rue como 5e le Wa WecWo a 7raQ65 de un reOerencia a la in7erOa8N WaMr9 5ido
aplicado 5oMre la copia de la e57ruc7ura re5ul7an7e del MoUing S no 5oMre la e57ruc7ura
original% Sin emMargoN la 5egunda llamada 5V Rue 5e aplica a la e57ruc7ura Sa Rue 5e
reali8a direc7amen7e 5oMre el oMje7o originalN S por 7an7o incremen7a 5u campo Valor%
El lenguaje de programación C# (ema :=L In57ruccione5
TEMA 16: Instrucciones
Concepto de instrucción
(oda acción Rue 5e pueda reali8ar en el cuerpo de un m67odoN como deOinir QariaMle5
locale5N llamar a m67odo5N a5ignacione5 S mucWa5 co5a5 m95 Rue Qeremo5 a lo largo de
e57e 7emaN 5on 72;340667.21;%
La5 in57ruccione5 5e agrupan Oormando C-./01; 51 72;340667.21;N Rue 5on li57a5 de
in57ruccione5 encerrada5 en7re llaQe5 Rue 5e ejecu7an una 7ra5 o7ra% E5 decirN la 5in7aUi5
Rue 5e 5igue para deOinir un MloRue de in57ruccione5 e5L
{
<listaÌnstrucciones>
}
(oda QariaMle Rue 5e deOina den7ro de un MloRue de in57ruccione5 5ólo eUi57ir9 den7ro de
dicWo MloRue% (ra5 6l 5er9 inacce5iMle S podr9 5er de57ruida por el recolec7or de Ma5ura%
Por ejemploN e57e código no e5 Q9lidoL
public void f();
{
{ int b; }
b = 1; // ERROR: b no existe fuera del bloque donde se declaró
}
Lo5 MloRue5 de in57ruccione5 pueden anidar5eN aunRue 5i den7ro de un MloRue in7erno
deOinimo5 una QariaMle con el mi5mo nomMre Rue o7ra deOinida en un MloRue eU7erno 5e
con5iderar9 Rue 5e Wa producido un errorN Sa Rue no 5e podr9 de7erminar a cu9l de la5
do5 5e e57ar9 Waciendo reOerencia cada Qe8 Rue 5e u7ilice 5u nomMre en el MloRue in7erno%
nstrucciones b0sicas
Definiciones de variabIes IocaIes
En el Tema 7: Variables ti!os de datos 5e Qio Rue la5 A9479C-1; -.69-1; 5on QariaMle5
Rue 5e deOinen en el cuerpo de lo5 m67odo5 S 5ólo 5on acce5iMle5 de5de dicWo5 cuerpo5%
)ecu6rde5e Rue la 5in7aUi5 eUplicada para deOinirla5 era la 5iguien7eL

<modi!icadores> <tipoVariable> <nombreVariable> , <valor>;
(amMi6n Sa en7once5 5e Qio Rue podVan deOinir5e Qaria5 QariaMle5 en una mi5ma
in57rucción 5eparando 5u5 pare5 nomMreDQalor median7e coma5N como en por ejemploL
int a=5, b, c=-1;
Asignaciones
El lenguaje de programación C# (ema :=L In57ruccione5
"na 9;7=296782 e5 5implemen7e una in57rucción median7e la Rue 5e indica un Qalor a
almacenar en un da7o% La 5in7aUi5 u5ada para ello e5L
<destino> = <origen>;
En 7ema5 preQio5 Sa 5e Wan dado numero5o5 ejemplo5 de cómo Wacer e57oN por lo Rue no
e5 nece5ario Wacer aWora maSor Wincapi6 en ello%
LIamadas a métodos
En el Tema 8: Métodos Sa 5e eUplicó Rue una --9?959 9 02 ?N3.5. con5i57e en
5olici7ar la ejecución de 5u5 in57ruccione5 a5ociada5 dando a 5u5 par9me7ro5 cier7o5
Qalore5% Si el m67odo a llamar e5 un m67odo de oMje7oN la 5in7aUi5 u5ada para ello e5L
<objeto>.<nombreMétodo>(<valoresarámetros>);
2 5i el m67odo a llamar e5 un m67odo de 7ipoN en7once5 la llamada 5e reali8a conL
<nombre%ipo>.<nombreMétodo>(<valoresarámetros>);
)ecu6rde5e Rue 5i la llamada al m67odo de 7ipo 5e Wace den7ro de la mi5ma deOinición de
7ipo donde el m67odo Oue deOinidoN la 5ección 8nombreTi!o9. de la 5in7aUi5 e5 opcional%
Instrucción nuIa
La 72;34066782 20-9 e5 una in57rucción Rue no reali8a nada en aM5olu7o% Su 5in7aUi5
con5i57e en e5criMir un 5imple pun7o S coma para repre5en7arla% 5eaN e5L
;
Suele u5ar5e cuando 5e de5ea indicar eUplVci7amen7e Rue no 5e de5ea ejecu7ar nadaN lo
Rue e5 T7il para Oacili7ar la legiMilidad del código oN como Qeremo5 m95 adelan7e en el
7emaN porRue o7ra5 in57ruccione5 la nece5i7an para indicar cu9ndo en alguno5 de 5u5
MloRue5 de in57ruccione5 componen7e5 no 5e Wa de reali8ar ninguna acción%
nstrucciones condicionales
La5 72;340667.21; 6.25767.29-1; 5on in57ruccione5 Rue permi7en ejecu7ar MloRue5 de
in57ruccione5 5ólo 5i 5e da una de7erminada condición% En lo5 5iguien7e5 5uMapar7ado5 de
e57e epVgraOe 5e de5criMen cu9le5 5on la5 in57ruccione5 condicionale5 di5poniMle5 en C#
Instrucción if
La 72;34066782 if permi7e ejecu7ar cier7a5 in57ruccione5 5ólo 5i de da una de7erminada
condición% Su 5in7aUi5 de u5o e5 la 5in7aUi5L
if (<condición>)
El lenguaje de programación C# (ema :=L In57ruccione5
<instruccionesÌf>
else
<instruccionesElse>
El 5igniOicado de e57a in57rucción e5 el 5iguien7eL 5e eQalTa la eUpre5ión <condición>N Rue
Wa de deQolQer un Qalor lógico% Si e5 cier7a IdeQuelQe trueK 5e ejecu7an la5
<instruccionesÌf>, S 5i e5 Oal5a IfaIseK 5e ejecu7an la5 <instruccionesElse> La rama eIse e5
opcionalN S 5i 5e omi7e S la condición e5 Oal5a 5e 5eguirVa ejecu7ando a par7ir de la
in57rucción 5iguien7e al if% En realidadN 7an7o <instruccionesÌf> como <instruccionesElse>
pueden 5er una Tnica in57rucción o un MloRue de in57ruccione5%
"n ejemplo de aplicación de e57a in57rucción e5 e57a Qarian7e del Hola!undoL
using System;
class HolaMundoÌf
{
public static void Main(String[] args)
{
if (args.Length > 0)
Console.WriteLine(“Hola {0}!”, args[0]);
else
Console.WriteLine(“Hola mundo!”);
}
}
Si ejecu7amo5 e57e programa 5in ningTn argumen7o Qeremo5 Rue el men5aje Rue 5e
mue57ra e5 ¡Hola Mundo!N mien7ra5 Rue 5i lo ejecu7amo5 con algTn argumen7o 5e
mo57rar9 un men5aje de MienQenida per5onali8ado con el primer argumen7o indicado%
Instrucción switch
La 72;34066782 switch permi7e ejecu7ar uno5 u o7ro5 MloRue5 de in57ruccione5 5egTn el
Qalor de una cier7a eUpre5ión% Su e57ruc7ura e5L
switch (<expresión>)
{
case <valor&>/ <blo'ue&>
<siguiente(cción>
case <valor2>/ <blo'ue2>
<siguiente(cción>
...
default/ <blo'ueDe!ault>
<siguiente(cción>
}
El 5igniOicado de e57a in57rucción e5 el 5iguien7eL 5e eQalTa <expresión>% Si 5u Qalor e5
<valor1> 5e ejecu7a el <bloque1>N 5i e5 <valor2> 5e ejecu7a <bloque2>N S a5V para el re57o de
Qalore5 e5peciOicado5% Si no e5 igual a ninguno de e5o5 Qalore5 S 5e incluSe la rama
defauItN 5e ejecu7a el <bloqueDefault>b pero 5i no 5e incluSe 5e pa5a direc7amen7e a
ejecu7ar la in57rucción 5iguien7e al switch%
El lenguaje de programación C# (ema :=L In57ruccione5
Lo5 Qalore5 indicado5 en cada rama del switch Wan de 5er eUpre5ione5 con57an7e5 Rue
produ8can Qalore5 de algTn 7ipo M95ico en7eroN de una enumeraciónN de 7ipo char o de
7ipo string% Adem95N no puede WaMer m95 de una rama con el mi5mo Qalor%

En realidadN aunRue 7oda5 la5 rama5 de un switch 5on opcionale5 5iempre 5e Wa de
incluir al meno5 una% Adem95N la rama defauIt no 7iene porRu6 aparecer la Tl7ima 5i 5e
u5aN aunRue e5 recomendaMle Rue lo Waga para Oacili7ar la legiMilidad del código%
El elemen7o marcado como <siguienteAcción> colocado 7ra5 cada MloRue de in57ruccione5
indica Ru6 e5 lo Rue Wa de Wacer5e 7ra5 ejecu7ar la5 in57ruccione5 del MloRue Rue lo
preceden% Puede 5er uno de e57o5 7re5 7ipo5 de in57ruccione5L
goto case <valori>;
goto defauIt;
break;

Si e5 un goto case indica Rue 5e Wa de 5eguir ejecu7ando el MloRue de in57ruccione5
a5ociado en el switch a la rama del <valori> indicadoN 5i e5 un goto defauIt indica Rue 5e
Wa de 5eguir ejecu7ando el MloRue de in57ruccione5 de la rama defauItN S 5i e5 un break
indica Rue 5e Wa de 5eguir ejecu7ando la in57rucción 5iguien7e al 5Yi7cW%
El 5iguien7e ejemplo mue57ra cómo 5e u7ili8a switchL
using System;
class HolaMundoSwitch
{
public static void Main(String[] args)
{
if (args.Length > 0)
switch(args[0])
{
case “José”: Console.WriteLine(“Hola José. Buenos días”);
break;
case “Paco”: Console.WriteLine(“Hola Paco. Me alegro de verte”);
break;
default: Console.WriteLine(“Hola {0}”, args[0]);
break;
}
else
Console.WriteLine(“Hola Mundo”);
}
}
E57e programa reconoce cier7o5 nomMre5 de per5ona5 Rue 5e le pueden pa5ar como
argumen7o5 al lan8arlo S le5 5aluda de Oorma e5pecial% La rama defauIt 5e incluSe para
dar un 5aludo por deOec7o a la5 per5ona5 no reconocida5%
Para lo5 programadore5 WaMi7uado5 a lenguaje5 como CPP e5 impor7an7e re5al7arle5 el
WecWo de RueN a diOerencia de dicWo5 lenguaje5N C# oMliga a incluir una 5en7encia break o
una 5en7encia goto 69;1 al Oinal de cada rama del switch para eQi7ar errore5 comune5 S
diOVcile5 de de7ec7ar cau5ado5 por olQidar incluir break; al Oinal de alguno de e57o5
MloRue5 S ello proQocar Rue 7ra5 ejecu7ar5e e5e MloRue 5e ejecu7e 7amMi6n el 5iguien7e%
El lenguaje de programación C# (ema :=L In57ruccione5
nstrucciones iterativas
La5 72;340667.21; 7314937A9; 5on in57ruccione5 Rue permi7en ejecu7ar repe7ida5 Qece5
una in57rucción o un MloRue de in57ruccione5 mien7ra5 5e cumpla una condición% E5
decirN permi7en deOinir Mucle5 donde cier7a5 in57ruccione5 5e ejecu7en Qaria5 Qece5% A
con7inuación 5e de5criMen cu9le5 5on la5 in57ruccione5 de e57e 7ipo incluida5 en C#%
Instrucción whiIe
La 72;34066782 whiIe permi7e ejecu7ar un MloRue de in57ruccione5 mien7ra5 5e de una
cier7a in57rucción% Su 5in7aUi5 de u5o e5L
whiIe (<condición>)
<instrucciones>
Su 5igniOicado e5 el 5iguien7eL Se eQalTa la <condición> indicadaN Rue Wa de producir un
Qalor lógico% Si e5 cier7a IQalor lógico trueK 5e ejecu7an la5 <instrucciones> S 5e repi7e el
proce5o de eQaluación de <condición> S ejecución de <instrucciones> Wa57a Rue deje de
5erlo% Cuando 5ea Oal5a IfaIseK 5e pa5ar9 a ejecu7ar la in57rucción 5iguien7e al whiIe% En
realidad <instrucciones> puede 5er una Tnica in57rucción o un MloRue de in57ruccione5%
"n ejemplo cómo u7ili8ar e57a in57rucción e5 el 5iguien7eL
using System;
class HolaMundoWhile
{
public static void Main(String[] args)
{
int actual = 0;
if (args.Length > 0)
while (actual < args.Length)
{
Console.WriteLine(“¡Hola {0}!”, args[actual]);
actual = actual + 1;
}
else
Console.WriteLine(“¡Hola mundo!”);
}
}
En e57e ca5oN 5i 5e indica m95 de un argumen7o al llamar al programa 5e mo57rar9 por
pan7alla un men5aje de 5aludo para cada uno de ello5% Para ello 5e u5a una QariaMle
actual Rue almacena cu9l e5 el nTmero de argumen7o a mo57rar en cada ejecución del
whiIe% Para man7enerla 5iempre ac7uali8ada lo Rue 5e Wace e5 aumen7ar en una unidad 5u
Qalor 7ra5 cada ejecución de la5 <instrucciones> del Mucle%
Por o7ro ladoN den7ro de la5 <instrucciones> de un whiIe pueden u7ili8ar5e la5 5iguien7e5
do5 in57ruccione5 e5peciale5L
• break;L Indica Rue 5e Wa de aMor7ar la ejecución del Mucle S con7inuar5e
ejecu7ando por la in57rucción 5iguien7e al whiIe%
El lenguaje de programación C# (ema :=L In57ruccione5
• continue;L Indica Rue 5e Wa de aMor7ar la ejecución de la5 <instrucciones> S
reeQaluar5e la <condición> del MucleN QolQi6ndo5e a ejecu7ar la5 <instrucciones> 5i
e5 cier7a o pa59ndo5e a ejecu7ar la in57rucción 5iguien7e al whiIe 5i e5 Oal5a%
Instrucción do...whiIe
La in57rucción do...whiIe e5 una Qarian7e del whiIe Rue 5e u5a a5VL
do
<instrucciones>
whiIe(<condición>);
La Tnica diOerencia del 5igniOicado de do...whiIe re5pec7o al de whiIe e5 Rue en Qe8 de
eQaluar primero la condición S ejecu7ar <instrucciones> 5ólo 5i e5 cier7aN do...whiIe
primero ejecu7a la5 <instrucciones> S luego mira la <condición> para Qer 5i 5e Wa de repe7ir
la ejecución de la5 mi5ma5% Por lo dem95 amMa5 in57ruccione5 5on iguale5N e inclu5o
7amMi6n puede incluir5e break; S continue; en7re la5 <instrucciones> del do...whiIe%
5. ... DJ7-1 e579 e5pecialmen7e de57inado para lo5 ca5o5 en lo5 Rue WaSa Rue ejecu7ar la5
<instrucciones> al meno5 una Qe8 aTn cuando la condición 5ea Oal5a de5de el principioN
como ocurre en el 5iguien7e ejemploL
using System;
class HolaMundoDoWhile
{
public static void Main()
{
String leído;
do
{
Console.WriteLine(“Clave: “);
leído = Console.ReadLine();
}
while (leído != “José”);
Console.WriteLine(“Hola José”);
}
}
E57e programa pregun7a al u5uario una claQe S mien7ra5 no in7rodu8ca la correc7a I4o56K
no con7inuar9 ejecu79ndo5e% "na Qe8 Rue in7roducida correc7amen7e dar9 un men5aje de
MienQenida al u5uario%
Instrucción for
La 72;34066782 for e5 una Qarian7e de whiIe Rue permi7e reducir el código nece5ario para
e5criMir lo5 7ipo5 de Mucle5 m95 comTnmen7e u5ado5 en programación% Su 5in7aUi5 e5L
for (<inicialización>; <condición>; <modificación>)
<instrucciones>
El lenguaje de programación C# (ema :=L In57ruccione5
El 5igniOicado de e57a in57rucción e5 el 5iguien7eL 5e ejecu7an la5 in57ruccione5 de
<inicialización>N Rue 5uelen u5ar5e para deOinir e iniciali8ar QariaMle5 Rue luego 5e u5ar9n
en <instrucciones>% Luego 5e eQalTa <condición>N S 5i e5 Oal5a 5e con7inTa ejecu7ando por
la in57rucción 5iguien7e al forb mien7ra5 Rue 5i e5 cier7a 5e ejecu7an la5 <instrucciones>
indicada5N luego 5e ejecu7an la5 in57ruccione5 de <modificación> DRue como 5u nomMre
indica 5uelen u5ar5e para modiOicar lo5 Qalore5 de QariaMle5 Rue 5e u5en en
<instrucciones>D S luego 5e reeQalTa <condición> repi7i6ndo5e el proce5o Wa57a Rue 657a
Tl7ima deje de 5er cier7a%
En <inicialización> puede en realidad incluir5e cualRuier nTmero de in57ruccione5 Rue no
7ienen porRu6 5er rela7iQa5 a iniciali8ar QariaMle5 o modiOicarla5N aunRue lo an7erior 5ea
5u u5o m95 WaMi7ual% En ca5o de 5er Qaria5 5e Wan de 5eparar median7e coma5 I,KN Sa Rue
el car9c7er de pun7o S coma I;K WaMi7ualmen7e u5ado para e57o5 mene57ere5 5e u5a en el
for para 5eparar lo5 MloRue5 de <inicialización>, <condición> S <modificación> Adem95N la
in57rucción nula no 5e puede u5ar en e57e ca5o S 7ampoco pueden comMinar5e
deOinicione5 de QariaMle5 con in57ruccione5 de o7ro5 7ipo5%

Con <modificación> pa5a algo 5imilarN Sa Rue puede incluir5e código Rue nada 7enga Rue
Qer con modiOicacione5 pero en e57e ca5o no 5e pueden incluir deOinicione5 de QariaMle5%
Como en el re57o de in57ruccione5 Wa57a aWora Qi57a5N en <instrucciones> puede 5er 7an7o
una Tnica in57rucción como un MloRue de in57ruccione5% Adem95N la5 QariaMle5 Rue 5e
deOinan en <inicialización> 5er9n Qi5iMle5 5ólo den7ro de e5a5 <instrucciones>%
La 5iguien7e cla5e e5 eRuiQalen7e a la cla5e HolaMundoWhile Sa Qi57a 5olo Rue Wace u5o
del for para compac7ar m95 5u códigoL
using System;
class HolaMundoFor
{
public static void Main(String[] args)
{
if (args.Length > 0)
for (int actual = 0; actual < args.Length; actual++)
Console.WriteLine(“¡Hola {0}!”, args[actual]);
else
Console.WriteLine(“¡Hola mundo!”);
}
}
Al igual Rue con whiIeN den7ro de la5 <instrucciones> del for 7amMi6n pueden incluir5e
in57ruccione5 continue; S break; Rue puedan al7erar el Ouncionamien7o normal del Mucle%
Instrucción foreach
La 72;34066782 foreach e5 una Qarian7e del for pen5ada e5pecialmen7e para compac7ar la
e5cri7ura de código5 donde 5e realice algTn 7ra7amien7o a 7odo5 lo5 elemen7o5 de una
colecciónN Rue 5uele un u5o muS WaMi7ual de for en lo5 lenguaje5 de programación Rue lo
incluSen% La 5in7aUi5 Rue 5e 5igue a la Wora de e5criMir e57a in57rucción foreach e5L
El lenguaje de programación C# (ema :=L In57ruccione5
foreach (<tipoElemento> <elemento> in <colección>)
<instrucciones>
El 5igniOicado de e57a in57rucción e5 muS 5encilloL 5e ejecu7an <instrucciones> para cada
uno de lo5 elemen7o5 de la <colección> indicada% <elemento> e5 una QariaMle de 5ólo
lec7ura de 7ipo <tipoElemento> Rue almacenar9 en cada momen7o el elemen7o de la
colección Rue 5e e576 proce5ando S Rue podr9 5er accedida de5de <instrucciones>%
E5 impor7an7e 5eXalar Rue <colección> no puede Qaler nuII porRue en7once5 5al7arVa una
eUcepción de 7ipo System.NuIIReferenceException, S Rue <tipoElemento> Wa de 5er un
7ipo cuSo5 oMje7o5 puedan almacenar lo5 Qalore5 de lo5 elemen7o5 de <colección>
En 7an7o Rue una 7aMla 5e con5idera Rue e5 una colecciónN el 5iguien7e código mue57ra
cómo u5ar for para compac7ar aTn m95 el código de la cla5e HolaMundoFor an7eriorL
using System;
class HolaMundoForeach
{
public static void Main(String[] args)
{
if (args.Length > 0)
foreach(String arg in args)
Console.WriteLine(“¡Hola {0}!”, arg);
else
Console.WriteLine(“¡Hola mundo!”);
}
}
La5 7aMla5 mul7idimen5ionale5 7amMi6n pueden recorrer5e median7e el foreachN el cual
pa5ar9 por 5u5 elemen7o5 en orden 7al S como mue57ra el 5iguien7e Oragmen7o de códigoL
int[,] tabla = { {1,2}, {3,4} };
foreach (int elemento in tabla)
Console.WriteLine(elemento);
CuSa 5alida por pan7alla e5L
C
D
(
V
En generalN 5e con5idera Rue una colección e5 7odo aRuel oMje7o Rue implemen7e la5
in7erOace5 IEnumerabIe o IEnumerator del e5pacio de nomMre5 System.CoIIections de la
BCLN Rue e579n deOinida5 como 5igueL
interface IEnumerabIe
{
IEnumerator GetEnumerator();
}
interface IEnumerator
{
El lenguaje de programación C# (ema :=L In57ruccione5
object Current {get;}
booI MoveNext();
void Reset();
}
El m67odo Reset() Wa de implemen7ar5e de modo Rue deQuelQa el enumerador reiniciado
a un e57ado inicial donde aTn no reOerencie ni 5iRuiera al primer elemen7o de la
colección 5ino Rue 5ea nece5ario llamar a MoveNext() para Rue lo Waga%
El m67odo MoveNext() 5e Wa de implemen7ar de modo Rue Waga Rue el enumerador pa5e
a apun7ar al 5iguien7e elemen7o de la colección S deQuelQa un Mooleano Rue indiRue 5i
7ra5 aQan8ar 5e Wa alcan8ado el Oinal de la colección%
La propiedad Current 5e Wa de implemen7ar de modo Rue deQuelQa 5iempre el elemen7o
de la colección al Rue el enumerador e576 reOerenciando% Si 5e in7en7a leer Current
WaMi6ndo5e Sa recorrido 7oda la colección o WaMi6ndo5e reiniciado la colección S no
WaMi6ndo5e colocado en 5u primer elemen7o con MoveNext()N 5e Wa de producir una
eUcepción de 7ipo System.Exception.SystemException.InvaIidOperationException
7ra Oorma de con5eguir Rue foreach con5idere Rue un oMje7o e5 una colección Q9lida
con5i57e en Wacer Rue dicWo oMje7o 5iga el <93482 51 6.-166782% E57e pa7rón con5i57e en
deOinir el 7ipo del oMje7o de modo Rue 5u5 oMje7o5 cuen7en con un m67odo pTMlico
GetEnumerator() Rue deQuelQa un oMje7o no nulo Rue cuen7e con una propiedad pTMlica
llamada Current Rue permi7a leer el elemen7o ac7ual S con un m67odo pTMlico booI
MoveNext() Rue permi7a camMiar el elemen7o ac7ual por el 5iguien7e S deQuelQa faIse
5ólo cuando 5e WaSa llegado al Oinal de la colección%
El 5iguien7e ejemplo mue57ra amMo5 7ipo5 de implemen7acione5L
using System;
using System.Collections;
class Patron
{
private int actual = -1;
public Patron GetEnumerator()
{
return this;
}
public int Current
{
get {return actual;}
}
public bool MoveNext()
{
bool resultado = true;
actual++;
if (actual==10)
resultado = false;
return resultado;
El lenguaje de programación C# (ema :=L In57ruccione5
}
}
class Ìnterfaz:ÌEnumerable,ÌEnumerator
{
private int actual = -1;
public object Current
{
get {return actual;}
}
public bool MoveNext()
{
bool resultado = true;
actual++;
if (actual==10)
resultado = false;
return resultado;
}
public ÌEnumerator GetEnumerator()
{
return this;
}
public void Reset()
{
actual = -1;
}
}
class Principal
{
public static void Main()
{
Patron obj = new Patron();
Ìnterfaz obj2 = new Ìnterfaz();
foreach (int elem in obj)
Console.WriteLine(elem);
foreach (int elem in obj2)
Console.WriteLine(elem);
}
}
Nó7e5e Rue en realidad en e57e ejemplo no WarVa Oal7a implemen7ar IEnumerabIeN pue57o
Rue la cla5e Ìnterfaz Sa implemen7a IEnumerator S ello e5 5uOicien7e para Rue pueda 5er
recorrida median7e foreach%
La u7ilidad de implemen7ar el pa7rón colección en lugar de la in7erOa8 IEnumerabIe e5
Rue a5V no e5 nece5ario Rue Current deQuelQa 5iempre un objectN 5ino Rue puede
deQolQer oMje7o5 de 7ipo5 m95 concre7o5 S gracia5 a ello puede de7ec7ar5e al compilar 5i
el <tipoElemento> indicado puede o no almacenar lo5 oMje7o5 de la colección%
El lenguaje de programación C# (ema :=L In57ruccione5
Por ejemploN 5i en el ejemplo an7erior 5u57i7uimo5 en el Tl7imo foreach el <tipoElemento>
indicado por PatrónN el código 5eguir9 compilando pero al ejecu7arlo 5al7ar9 una
eUcepción System.InvaIidCastException% Sin emMargoN 5i la 5u57i7ución 5e WuMie5e WecWo
en el penTl7imo foreachN en7once5 el código direc7amen7e no compilarVa S 5e no5
inOormarVa de un error deMido a Rue lo5 oMje7o5 int no 5on conQer7iMle5 en oMje7o5 Patrón%
(amMi6n WaS Rue 7ener en cuen7a Rue la comproMación de 7ipo5 Rue 5e reali8a en 7iempo
de ejecución 5i el oMje7o 5ólo implemen7ó la in7erOa8 IEnumerabIe e5 muS e57ric7aN en el
5en7ido de Rue 5i en el ejemplo an7erior 5u57i7uimo5 el <tipoElemento> del Tl7imo foreach
por byte 7amMi6n 5e lan8ar9 la eUcepción al no 5er lo5 oMje7o5 de 7ipo int implVci7amen7e
conQer7iMle5 en byte5 5ino 5ólo a 7raQ65 del operador () Sin emMargoN cuando 5e 5igue el
pa7rón de colección la5 comproMacione5 de 7ipo no 5on 7an e57ric7a5 S en7once5 5V Rue
5erVa Q9lido 5u57i7uir int por byte en <tipoElemento>%
El proMlema de 5ólo implemen7ar el pa7rón colección e5 Rue e57e e5 una carac7erV57ica
propia de C# S con la5 in57ruccione5 foreach Io eRuiQalen7e5K de lenguaje5 Rue no lo
5opor7en no 5e podrVa recorrer coleccione5 Rue 5ólo 5iguie5en e57e pa7rón% "na 5olución
en e57o5 ca5o5 puede 5er Wacer Rue el 7ipo del oMje7o colección implemen7e 7an7o la
in7erOa8 IEnumerabIe como el pa7rón colección% MQiamen7e e57a in7erOa8 deMerVa
implemen7ar5e eUplVci7amen7e para eQi7ar5e conOlic7o5 deriQado5 de Rue 5u5 miemMro5
7engan 5igna7ura5 coinciden7e5 con la5 de lo5 miemMro5 propio5 del pa7rón colección%
Si un oMje7o de un 7ipo colección implemen7a 7an7o la in7erOa8 IEnumerabIe como el
pa7rón de colecciónN en7once5 en C# foreach u5ar9 el pa7rón colección para recorrerlo%
nstrucciones de e1cepciones
Concepto de excepción.
La5 1I61<67.21; 5on el mecani5mo recomendado en la pla7aOorma %NE( para propagar
lo5 Rue 5e produ8can duran7e la ejecución de la5 aplicacione5 IdiQi5ione5 por ceroN
lec7ura de arcWiQo5 no di5poniMle5N e7c%K B95icamen7eN 5on oMje7o5 deriQado5 de la cla5e
System.Exception Rue 5e generan cuando en 7iempo de ejecución 5e produce algTn error
S Rue con7ienen inOormación 5oMre el mi5mo% E57o e5 una diOerencia re5pec7o a 5u
implemen7ación en el CPP 7radicional Rue le5 proporciona una cier7a WomogeneidadN
con5i57encia S 5encille8N pue5 en 657e podVan 5er Qalore5 de cualRuier 7ipo%

(radicionalmen7eN el 5i57ema Rue en o7ro5 lenguaje5 S pla7aOorma5 5e Wa Qenido u5ando
para inOormar e57o5 errore5 con5i57Va 5implemen7e en Wacer Rue lo5 m67odo5 en cuSa
ejecución pudie5en producir5e deQolQieran código5 Rue inOorma5en 5oMre 5i 5e Wan
ejecu7ado correc7amen7e oN en ca5o con7rarioN 5oMre cu9l Oue el error producido% Sin
emMargoN la5 eUcepcione5 proporcionan la5 5iguien7e5 Qen7aja5 Oren7e a dicWo 5i57emaL
• C-947595: El u5o de código5 e5peciale5 para inOormar de error 5uele diOicul7ar la
legiMilidad del Ouen7e en 7an7o Rue 5e me8clan la5 in57ruccione5 propia5 de la lógica
del mi5mo con la5 in57ruccione5 propia5 del 7ra7amien7o de lo5 errore5 Rue pudie5en
producir5e duran7e 5u ejecución% Por ejemploL
int resultado = obj.Método();
El lenguaje de programación C# (ema :=L In57ruccione5
if (resultado == 0) // Sin errores al ejecutar obj.Método();
{...}
else if (resultado == 1) // Tratamiento de error de código 1
{...}
else if (resultado == 2) // Tratamiento de error de código 2
...
Como 5e Qer9N u7ili8ando eUcepcione5 e5 po5iMle e5criMir el código como 5i nunca 5e
Oue5en a producir errore5 S dejar en una 8ona apar7e 7odo el código de 7ra7amien7o
de errore5N lo Rue con7riMuSe a Oacili7ar la legiMilidad de lo5 Ouen7e5%
• MM; 72@.4?96782: A par7ir del Qalor de un código de error puede 5er diOVcil deducir
la5 cau5a5 del mi5mo S con5eguirlo mucWa5 Qece5 implica 7ener5e Rue con5ul7ar la
documen7ación Rue proporcionada 5oMre el m67odo Rue lo proQocóN Rue puede
inclu5o Rue no e5peciOiRue claramen7e 5u cau5a%
Por el con7rarioN una eUcepción e5 un oMje7o Rue cuen7a con campo5 Rue de5criMen
la5 cau5a5 del error S a cuSo 7ipo 5uele d9r5ele un nomMre Rue re5uma claramen7e 5u
cau5a% Por ejemploN para inOormar errore5 de diQi5ión por cero 5e 5uele u7ili8ar una
eUcepción predeOinida de 7ipo DivideByZeroException en cuSo campo Message 5e
de7allan la5 cau5a5 del error producido
• T4939?7123. 9;1=0495.: Cuando 5e u7ili8an código5 de error nada oMliga a 7ra7arlo5
en cada llamada al m67odo Rue lo5 pueda producirN e ignorarlo5 puede proQocar m95
adelan7e en el código compor7amien7o5 ine5perado5 de cau5a5 diOVcile5 de de5cuMrir%
Cuando 5e u5an eUcepcione5 5iempre 5e a5egura Rue el programador 7ra7e 7oda
eUcepción Rue pueda producir5e o RueN 5i no lo WaceN 5e aMor7e la ejecución de la
aplicación mo57r9ndo5e un men5aje indicando dónde 5e Wa producido el error%
AWora MienN 7radicionalmen7e en lenguaje5 como CPP el u5o de eUcepcione5 5iempre Wa
7enido la5 de5Qen7aja5 re5pec7o al u5o de código5 de error de complicar el compilador S
dar lugar a código5 m95 len7o5 S diOVcile5 de op7imi8ar en lo5 Rue 7ra5 cada in57rucción
Rue pudie5e producir eUcepcione5 el compilador deMe in7roducir la5 comproMacione5
nece5aria5 para de7ec7arla5 S 7ra7arla5 a5V como para comproMar Rue lo5 oMje7o5 creado5
5ean correc7amen7e de57ruido5 5i 5e producen%
Sin emMargoN en la pla7aOorma %NE( de5aparecen lo5 proMlema5 de complicar el
compilador S diOicul7ar la5 op7imi8acione5 Sa Rue e5 el CL) Ruien 5e encarga de
de7ec7ar S 7ra7ar la5 eUcepcione5 S e5 5u recolec7or de Ma5ura Ruien 5e encarga a5egurar
la correc7a de57rucción de lo5 oMje7o5% MQiamen7e el código 5eguir9 5iendo algo m95
len7oN pero e5 un peRueXo 5acriOicio Rue merece la pena Wacer en 7an7o Rue ello a5egura
Rue nunca 5e producir9n proMlema5 diOVcile5 de de7ec7ar deriQado5 de errore5 ignorado5%
La cIase System.Exception
Como Sa 5e Wa dicWoN 7oda5 la5 eUcepcione5 deriQan de un 7ipo predeOinido en la BCL
llamado System.Exception% Lo5 principale5 miemMro5 Rue Weredan de 657e 5onL

• string Message {virtuaI get;}L Con7iene un men5aje de5crip7iQo de la5 cau5a5 de la
eUcepción% Por deOec7o e57e men5aje e5 una cadena QacVa I""K
El lenguaje de programación C# (ema :=L In57ruccione5
• Exception InnerException {virtuaI get;}L Si una eUcepción Oue cau5ada como
con5ecuencia de o7raN e57a propiedad con7iene el oMje7o System.Exception Rue
repre5en7a a la eUcepción Rue la cau5ó% A5V 5e pueden Oormar cadena5 de
eUcepcione5 de cualRuier longi7ud% Si 5e de5ea oM7ener la Tl7ima eUcepción de la
cadena e5 mejor u5ar el m67odo virtuaI Exception GetBaseException()
• string StackTrace {virtuaI get;}: Con7iene la pila de llamada5 a m67odo5 Rue 5e
7enVa en el momen7o en Rue 5e produjo la eUcepción% E57a pila e5 una cadena con
inOormación 5oMre cu9l e5 el m67odo en Rue 5e produjo la eUcepciónN cu9l e5 el
m67odo Rue llamó a e57eN cu9l e5 el Rue llamó a e5e o7roN e7c%
• string Source {virtuaI get; virtuaI set;}L Almacena inOormación 5oMre cu9l Oue la
aplicación u oMje7o Rue cau5ó la eUcepción%
• MethodBase TargetSite {virtuaI get;}L Almacena cu9l Oue el m67odo donde 5e
produjo la eUcepción en Oorma de oMje7o System.RefIection.MethodBase% Puede
con5ul7ar la documen7ación del S#A 5i de5ea cómo oM7ener inOormación 5oMre
la5 carac7erV57ica5 del m67odo a 7raQ65 del oMje7o MethodBase%
• string HeIpLink {virtuaI get;}: Con7iene una cadena con inOormación 5oMre cu9l e5
la ")I donde 5e puede encon7rar inOormación 5oMre la eUcepción% El Qalor de
e57a cadena puede e57aMlecer5e con virtuaI Exception SetHeIpLink (string URI)N
Rue deQuelQe la eUcepción 5oMre la Rue 5e aplica pero con la ")I Sa ac7uali8ada%
Para crear oMje7o5 de cla5e System.Exception 5e puede u5ar lo5 con57ruc7ore5L
Exception()
Exception(string msg)
Exception(string msg, Exception causante)
El primer con57ruc7or crea una eUcepción cuSo Qalor para Message 5er9 "" S no cau5ada
por ninguna o7ra eUcepción IInnerException Qaldr9 nuIIK El 5egundo la crea con el Qalor
indicado para MessageN S el Tl7imo la crea con adem95 la eUcepción cau5an7e indicada%
En la pr9c7icaN cuando 5e crean nueQo5 7ipo5 deriQado5 de System.Exception no 5e 5uele
redeOinir 5u5 miemMro5 ni aXadirle5 nueQo5N 5ino Rue 5ólo 5e Wace la deriQación para
di57inguir una eUcepción de o7ra por el nomMre del 7ipo al Rue per7enecen% AWora MienN
e5 conQenien7e re5pe7ar el conQenio de darle5 un nomMre acaMado en Exception S
redeOinir lo5 7re5 con57ruc7ore5 an7e5 comen7ado5%
Excepciones predefinidas comunes
En el e5pacio de nomMre5 System de la BCL WaS predeOinida5 mTl7iple5 eUcepcione5
deriQada5 de System.Exception Rue 5e corre5ponden con lo5 errore5 m95 comune5 Rue
pueden 5urgir duran7e la ejecución de una aplicación% En la (aMla ' 5e recogen alguna5L
T7<. 51 -9 1I61<6782 C90;9 51 /01 ;1 <4.50K69 -9 1I61<6782
ArgumentException
Pa5ado argumen7o no Q9lido IMa5e de eUcepcione5 de
El lenguaje de programación C# (ema :=L In57ruccione5
argumen7o5K
ArgumentNuIIException
Pa5ado argumen7o nulo
ArgumentOutOfRangeException
Pa5ado argumen7o Ouera de rango
ArrayTypeMistmatchException
A5ignación a 7aMla de elemen7o Rue no e5 de 5u 7ipo
COMException
EUcepción de oMje7o C!
DivideByZeroException
#iQi5ión por cero
IndexOutOfRangeException
Índice de acce5o a elemen7o de 7aMla Ouera del rango
Q9lido Imenor Rue cero o maSor Rue el 7amaXo de la
7aMlaK
InvaIidCastException
ConQer5ión eUplVci7a en7re 7ipo5 no Q9lida
InvaIidOperationException
peración inQ9lida en e57ado ac7ual del oMje7o
InteropException
Ba5e de eUcepcione5 producida5 en comunicación con
código in5eguro
NuIIReferenceException
Acce5o a miemMro de oMje7o Rue Qale nuII
OverfIowException
#e5Mordamien7o den7ro de con7eU7o donde 5e Wa de
comproMar lo5 de5Mordamien7o5 IeUpre5ión con57an7eN
in57rucción checkedN operación checked u opción del
compilador /c*ec<edK
OutOfMemoryException
/al7a de memoria para crear un oMje7o con new
SEHException
EUcepción SHE del API <in*&
StackOverfIowException
#e5Mordamien7o de la pilaN generalmen7e deMido a un
eUce5iQo nTmero de llamada5 recurren7e5%
TypeIniziaIizationException
Ha ocurrido alguna eUcepción al iniciali8ar lo5
campo5 e5797ico5 o el con57ruc7or e5797ico de un 7ipo%
En InnerException 5e indica cu9l e5%
T9C-9 8: EUcepcione5 predeOinida5 de u5o Orecuen7e

MQiamen7eN e5 conQenien7e Rue 5i la5 aplicacione5 Rue e5criMamo5 nece5i7en lan8ar
eUcepcione5 rela7iQa5 a errore5 de lo5 7ipo5 e5peciOicado5 en la T9C-9 8N lancen
preci5amen7e la5 eUcepcione5 indicada5 en e5a 7aMla S no cualRuier o7ra dSa 5ea deOinida
por no5o7ro5 mi5mo5 o predeOinida en la BCL con o7ro 5igniOicado%

Lanzamiento de excepciones. Instrucción throw
Para inOormar de un error no Ma57a con crear un oMje7o del 7ipo de eUcepción apropiadoN
5ino Rue 7amMi6n WaS pa59r5elo al mecani5mo de propagación de eUcepcione5 del CL)%
A e57o 5e le llama -92K94 -9 1I61<6782N S para Wacerlo 5e u5a la 5iguien7e in57rucciónL
throw <objetoExcepciónALanzar>;
Por ejemploN para lan8ar una eUcepción de 7ipo DivideByZeroException 5e podrVa WacerL
throw new DivideByZeroException();
Si el oMje7o a lan8ar Qale nuIIN en7once5 5e producir9 una NuIIReferenceException Rue
5er9 lan8ada en Qe8 de la eUcepción indicada en la in57rucción throw%
El lenguaje de programación C# (ema :=L In57ruccione5
Captura de excepciones. Instrucción try
"na Qe8 lan8ada una eUcepción e5 po5iMle e5criMir código Rue e5 encargue de 7ra7arla%
Por deOec7oN 5i e57e código no 5e e5criMe la eUcepción proQoca Rue la aplicación aMor7e
mo57rando un men5aje de error en el Rue 5e de5criMe la eUcepción producida
IinOormación de 5u propiedad MessageK S dónde 5e Wa producido IinOormación de 5u
propiedad StackTraceK A5VN dado el 5iguien7e código Ouen7e de ejemploL
using System;
class PruebaExcepciones
{
static void Main()
{
A obj1 = new A();
obj1.F();
}
}
class A
{
public void F()
{
G();
}
static public void G()
{
int c = 0;
int d = 2/c;
}
}
Al compilarlo no 5e de7ec7ar9 ningTn error Sa Rue al compilador no le merece la pena
calcular el Qalor de c en 7an7o Rue e5 una QariaMleN por lo Rue no de7ec7ar9 Rue diQidir 2/c
no e5 Q9lido% Sin emMargoN al ejecu7arlo 5e in7en7ar9 diQidir por cero en e5a in57rucción S
ello proQocar9 Rue aMor7e la aplicación mo57rando el 5iguien7e men5ajeL

?nJandled @$ce5tion+ System.9i2ide1yAero@$ce5tion+ .ttem5ted to di2ide
-y Eero.
at 4rue-a@$ce5ciones.Main(%
Como 5e QeN en e57e men5aje 5e indica Rue no 5e Wa 7ra7ado una eUcepción de diQi5ión
por cero I7ipo DivideByZeroExceptionK den7ro del código del m67odo Main() del 7ipo
PruebaExcepciones% Si al compilar el Ouen7e WuMi65emo5 u7ili8ado la opción /debugN el
compilador WaMrVa creado un OicWero .pdb con inOormación eU7ra 5oMre la5
in57ruccione5 del ejecu7aMle generado Rue permi7irVa Rue al ejecu7arlo 5e mo57ra5e un
men5aje mucWo m95 de7allado con inOormación 5oMre la in57rucción eUac7a Rue proQocó
la eUcepciónN la cadena de llamada5 a m67odo5 Rue lleQaron a 5u ejecución S el nTmero
de lVnea Rue cada una ocupa en el Ouen7eL
?nJandled @$ce5tion+ System.9i2ide1yAero@$ce5tion+ .ttem5ted to di2ide
-y Eero.
at ..W(% in @+8c68@78e7.cs+line DD
at ..G(% in @+8c68@78e7.cs+line CR
at 4rue-a@$ce5ciones.Main(% in @+8c68@78e7.cs+line I
El lenguaje de programación C# (ema :=L In57ruccione5
Si 5e de5ea 7ra7ar la eUcepción WaS Rue encerrar la diQi5ión den7ro de una 72;34066782 try
con la 5iguien7e 5in7aUi5L
try
<instrucciones>
catc9 (<e)cepción&>)
<tratamiento&>
catc9 (<e)cepción2>)
<tratamiento2>
...
finall$
<instruccionesFinall*>
El 5igniOicado de try e5 el 5iguien7eL 5i duran7e la ejecución de la5 <instrucciones> 5e
lan8a una eUcepción de 7ipo <excepción1> Io alguna 5uMcla5e 5uSaK 5e ejecu7an la5
in57ruccione5 <tratamiento1>N 5i Oue5e de 7ipo <excepción2> 5e ejecu7arVa <tratamiento2>N S
a5V Wa57a Rue 5e encuen7re una cl9u5ula catch Rue pueda 7ra7ar la eUcepción producida%
Si no 5e encon7ra5e ninguna S la in57rucción try e57uQie5e anidada den7ro de o7raN 5e
mirarVa en lo5 catch de 5u try padre S 5e repe7irVa el proce5o% Si al Oinal 5e recorren 7odo5
lo5 try padre5 S no 5e encuen7ra ningTn catch compa7iMleN en7once5 5e Mu5carVa en el
código de5de el Rue 5e llamó al m67odo Rue produjo la eUcepción% Si a5V 5e 7ermina
llegando al m67odo Rue inició el Wilo donde 5e produjo la eUcepción S 7ampoco allV 5e
encuen7ra un 7ra7amien7o apropiado 5e aMor7a dicWo Wilob S 5i e5e Wilo e5 el principal Iel
Rue con7iene el pun7o de en7radaK 5e aMor7a el programa S 5e mue57ra el men5aje de error
con inOormación 5oMre la eUcepción lan8ada Sa Qi57o%
A5VN para 7ra7ar la eUcepción del ejemplo an7erior de modo Rue una diQi5ión por cero
proQoRue Rue a d 5e le a5igne el Qalor +N 5e podrVa re5criMir G() de e57a o7ra OormaL
static public void G()
{
try
{
int c = 0;
int d = 2/c;
}
catch (DivideByZeroException)
{ d=0; }
}
Para 5impliOicar 7an7o el compilador como el código generado S OaQorecer la legiMilidad
del Ouen7eN en lo5 catch5 5e Mu5ca 5iempre orden de aparición 7eU7ualN por lo Rue para
eQi7ar catch5 aM5urdo5 no 5e permi7e deOinir catch5 Rue puedan cap7urar eUcepcione5
cap7uraMle5 por catch5 po57eriore5 a ello5 en 5u mi5ma in57rucción try%
(amMi6n WaS Rue 5eXalar Rue cuando en <instrucciones> 5e lance una eUcepción Rue 5ea
7ra7ada por un catch de algTn try DSa 5ea de la Rue con7iene la5 <instrucciones>N de algTn
try padre 5uSo o de alguno de lo5 m67odo5 Rue proQocaron la llamada al Rue produjo la
eUcepciónD 5e 5eguir9 ejecu7ando a par7ir de la5 in57ruccione5 5iguien7e5 a e5e try%
El MloRue finaIIy e5 opcionalN S 5i 5e incluSe Wa de Wacerlo 7ra5 7oda5 lo5 MloRue5 catch%
La5 <instruccionesFinally> de e57e MloRue 5e ejecu7ar9n 7an7o 5i 5e producen eUcepcione5
en <instrucciones> como 5i no% En el 5egundo ca5o 5u5 in57ruccione5 5e ejecu7ar9n 7ra5 la5
El lenguaje de programación C# (ema :=L In57ruccione5
<instrucciones>N mien7ra5 Rue en el primero lo War9n de5pu65 de 7ra7ar la eUcepción pero
an7e5 de 5eguir5e ejecu7ando por la in57rucción 5iguien7e al try Rue la 7ra7ó% Si en un try
no 5e encuen7ra un catch compa7iMleN an7e5 de pa5ar a Mu5car en 5u try padre o en 5u
m67odo llaman7e padre 5e ejecu7ar9n la5 <instruccionesFinally>%
Sólo 5i den7ro de un MloRue finaIIy 5e lan8a5e una eUcepción 5e aMor7a la ejecución del
mi5mo% #icWa eUcepción 5erVa propagada al try padre o al m67odo llaman7e padre del try
Rue con7uQie5e el finaIIy%
AunRue lo5 MloRue5 catch S finaIIy 5on opcionale5N 7oda in57rucción try Wa de incluir al
meno5 un MloRue catch o un MloRue finaIIy%
El 5iguien7e ejemplo re5ume cómo Ounciona la propagación de eUcepcione5L
using System;
class MiException:Exception {}
class Excepciones
{
public static void Main()
{
try
{
Console.WriteLine(“En el try de Main()”);
Método();
Console.WriteLine(“Al final del try de Main()”);
}
catch (MiException)
{
Console.WriteLine(“En el catch de Main()”);
}
finally
{
Console.WriteLine(“finally de Main()”);
}
}
public static void Método()
{
try
{
Console.WriteLine(“En el try de Método()”);
Método2();
Console.WriteLine(“Al final del try de Método()”);
}
catch (OverflowException)
{
Console.WriteLine(“En el catch de Método()”);
}
finally
{
Console.WriteLine(“finally de Método()”);
}
}
public static void Método2()
{
El lenguaje de programación C# (ema :=L In57ruccione5
try
{
Console.WriteLine(“En el try de Método2()”);
throw new MiException();
Console.WriteLine(“Al final del try de Método2()”);
}
catch (DivideByZeroException)
{ Console.WriteLine(“En el catch de Método2()”); }
finally
{ Console.WriteLine(“finally de Método2()”); }
}
}
Nó7e5e Rue en e57e código lo Tnico Rue 5e Wace e5 deOinir un 7ipo nueQo de eUcepción
llamado MiException S llamar5e en el Main() a un m67odo llamado Método() Rue llama a
o7ro de nomMre Método2() Rue lan8a una eUcepción de e5e 7ipo% ,iendo la 5alida de e57e
código e5 O9cil Qer el recorrido 5eguido duran7e la propagación de la eUcepciónL
@n try de Main(%
@n try de MPtodo(%
@n try de MPtodoD(%
<inally de MPtodoD
<inally de MPtodo
@n catcJ de Main(%
<inally de Main(%
Como 5e puede oM5erQarN WaS mucWo5 WriteLine() Rue nunca 5e ejecu7an Sa Rue en
cuan7o 5e lan8a una eUcepción 5e 5igue ejecu7ando 7ra5 la in57rucción 5iguien7e al try Rue
la 7ra7ó IaunRue ejecu7ando an7e5 lo5 finaIIy pendien7e5N como 5e deduce de la 5alida del
ejemploK #e WecWoN el compilador 5e dar9 cuen7a Rue la in57rucción 5iguien7e al throw
nunca 5e ejecu7ar9 e inOormar9 de ello con un men5aje de aQi5o%
La idea 7ra5 e57e mecani5mo de eUcepcione5 e5 eQi7ar me8clar código normal con código
de 7ra7amien7o de errore5% En <instrucciones> 5e e5criMirVa el código como 5i no pudie5en
producir5e errore5N en la5 cl9u5ula5 catch 5e 7ra7arVan lo5 po5iMle5 errore5N S en el finaIIy
5e incluirVa el código a ejecu7ar 7an7o 5i producen errore5 como 5i no I5uele u5ar5e para
liMerar recur5o5 ocupado5N como OicWero5 o coneUione5 de red aMier7a5K
En realidadN 7amMi6n e5 po5iMle e5criMir cada cl9u5ula catch deOiniendo una QariaMle Rue
5e podr9 u5ar den7ro del código de 7ra7amien7o de la mi5ma para Wacer reOerencia a la
eUcepción cap7urada% E57o 5e Wace con la 5in7aUi5L
catch (<tipoExcepción> <nombreVariable>)
{
<tratamiento>
}
Nó7e5e Rue en 7an7o Rue 7oda5 la5 eUcepcione5 deriQan de System.ExceptionN para
deOinir una cl9u5ula catch Rue pueda cap7urar cualRuier 7ipo de eUcepción Ma57a u5arL
catch(System.Exception <nombre#b+eto>)
{
<tratamiento>
}
El lenguaje de programación C# (ema :=L In57ruccione5
En realidad la 5in7aUi5 an7erior 5ólo permi7e cap7urar la5 eUcepcione5 propia5 de la
pla7aOorma %NE(N Rue deriQan de System.Exception% Sin emMargoN lenguaje5 como CPP
permi7en lan8ar eUcepcione5 no deriQada5 de dicWa cla5eN S para e5o5 ca5o5 5e Wa
incluido en C# una Qarian7e de catch Rue 5V Rue realmen7e puede cap7urar eUcepcione5
de cualRuier 7ipoN 7an7o 5i deriQan de System.Exception como 5i no% Su 5in7aUi5 e5L
catch
{
<tratamiento>
}
Como puede deducir5e de 5u 5in7aUi5N el proMlema Rue pre5en7a e57a Tl7ima Qarian7e de
catch e5 Rue no proporciona inOormación 5oMre cu9l e5 la eUcepción cap7uradaN por lo
Rue a Qece5 puede re5ul7ar poco T7il S 5i 5ólo 5e de5ea cap7urar cualRuier eUcepción
deriQada de System.Exception e5 mejor u5ar la 5in7aUi5 preQiamen7e eUplicada%
En cualRuier ca5oN amMo5 7ipo5 de cl9u5ula5 catch 5ólo pueden 5er e5cri7a5 como la
Tl7ima cl9u5ula catch del tryN Sa Rue 5i no la5 cl9u5ula5 catch Rue le 5iguie5en nunca
llegarVan a ejecu7ar5e deMido a Rue la5 primera5 cap7urarVan an7e5 cualRuier eUcepción
deriQada de System.Exception%
)e5pec7o al u5o de throwN WaS Rue 5eXalar Rue WaS una Oorma eU7ra de u5arlo Rue 5ólo e5
Q9lida den7ro de código5 de 7ra7amien7o de eUcepcione5 Icódigo5 <tratamientoi> de la5
cl9u5ula5 catchK E57a Oorma de u5o con5i57e en 5eguir 5implemen7e e57a 5in7aUi5L
throw;
En e57e ca5o lo Rue 5e Wace e5 relan8ar la mi5ma eUcepción Rue 5e cap7uró en el MloRue
catch den7ro de cuSo de código de 7ra7amien7o 5e u5a el throw; HaS Rue preci5ar Rue la
eUcepción relan8ada e5 preci5amen7e la cap7uradaN S aunRue en el MloRue catch 5e la
modiOiRue a 7raQ65 de la QariaMle Rue la repre5en7aN la Qer5ión relan8ada 5er9 la Qer5ión
original de la mi5ma S no la modiOicada%
Adem95N cuando 5e relance una eUcepción en un try con cl9u5ula finaIIyN an7e5 de pa5ar a
reproce5ar la eUcepción en el try padre del Rue la relan8ó 5e ejecu7ar9 dicWa cl9u5ula%

nstrucciones de salto
La5 72;340667.21; 51 ;9-3. permi7en Qariar el orden normal en Rue 5e ejecu7an la5
in57ruccione5 de un programaN Rue con5i57e en ejecu7arla5 una 7ra5 o7ra en el mi5mo
orden en Rue 5e WuMie5en e5cri7o en el Ouen7e% En lo5 5uMapar7ado5 de e57e epVgraOe 5e
de5criMir9n cu9le5 5on la5 in57ruccione5 de 5al7o incluida5 en C#L
Instrucción break
2a 5e Wa Qi57o Rue la 72;34066782 break 5ólo puede incluir5e den7ro de MloRue5 de
in57ruccione5 a5ociado5 a in57ruccione5 i7era7iQa5 o in57ruccione5 switch e indica Rue 5e
de5ea aMor7ar la ejecución de la5 mi5ma5 S 5eguir ejecu7ando a par7ir de la in57rucción
5iguien7e a ella5% Se u5a a5VL
El lenguaje de programación C# (ema :=L In57ruccione5
break;
Cuando e57a 5en7encia 5e u5a den7ro de un try con cl9u5ula finaIIyN an7e5 de aMor7ar5e la
ejecución de la in57rucción i7era7iQa o del switch Rue la con7iene S 5eguir5e ejecu7ando
por la in57rucción Rue le 5igaN 5e ejecu7ar9n la5 in57ruccione5 de la cl9u5ula finaIIy del
try% E57o 5e Wace para a5egurar Rue el MloRue finaIIy 5e ejecu7e aTn en ca5o de 5al7o%
Adem95N 5i den7ro una cl9u5ula finaIIy incluida en de un switch o de una in57rucción
i7era7iQa 5e u5a breakN no 5e permi7e Rue como re5ul7ado del break 5e 5alga del finaIIy%
Instrucción continue
2a 5e Wa Qi57o Rue la 72;34066782 continue 5ólo puede u5ar5e den7ro del MloRue de
in57ruccione5 de una in57rucción i7era7iQa e indica Rue 5e de5ea pa5ar a reeQaluar
direc7amen7e la condición de la mi5ma 5in ejecu7ar el re57o de in57ruccione5 Rue
con7uQie5e% La eQaluación de la condición 5e WarVa de la Oorma WaMi7ualL 5i e5 cier7a 5e
repi7e el Mucle S 5i e5 Oal5a 5e con7inTa ejecu7ando por la in57rucción Rue le 5igue% Su
5in7aUi5 de u5o e5 a5V de 5encillaL
continue;
En cuan7o a 5u5 u5o5 den7ro de 5en7encia5 tryN 7iene la5 mi5ma5 re57riccione5 Rue breakL
an7e5 de 5alir de un try 5e ejecu7ar9 5iempre 5u MloRue finaIIy S no e5 po5iMle 5alir de un
finaIIy incluido den7ro de una in57rucción i7era7iQa como con5ecuencia de un continue%
Instrucción return
E57a in57rucción 5e u5a para indicar cu9l e5 el oMje7o Rue Wa de deQolQer un m67odo% Su
5in7aUi5 e5 la 5iguien7eL
return <objetoRetorno>;
La ejecución de e57a in57rucción proQoca Rue 5e aMor7e la ejecución del m67odo den7ro
del Rue aparece S Rue 5e deQuelQa el <objetoRetorno> al m67odo Rue lo llamó% Como e5
lógicoN e57e oMje7o Wa de 5er del 7ipo de re7orno del m67odo en Rue aparece el return o de
alguno compa7iMle con 6lN por lo Rue e57a in57rucción 5ólo podr9 incluir5e en m67odo5
cuSo 7ipo de re7orno no 5ea voidN o en lo5 MloRue5 get de la5 propiedade5 o indi8adore5%
#e WecWoN e5 oMliga7orio Rue 7odo m67odo con 7ipo de re7orno 7ermine por un return%
Lo5 m67odo5 Rue deQuelQan void pueden 7ener un return con una 5in7aUi5 e5pacial en la
Rue no 5e indica ningTn Qalor a deQolQer 5ino Rue 5implemen7e 5e u5a return para
indicar Rue 5e de5ea 7erminar la ejecución del m67odoL
return;
NueQamen7eN como con el re57o de in57ruccione5 de 5al7o Wa57a aWora Qi57a5N 5i 5e
incluSe5e un return den7ro de un MloRue try con cl9u5ula finaIIyN an7e5 de deQolQer5e el
oMje7o e5peciOicado 5e ejecu7arVan la5 in57ruccione5 de la cl9u5ula finaIIy% Si WuMie5en
Qario5 MloRue5 finaIIy anidado5N la5 in57ruccione5 de cada uno e5 ejecu7arVan de manera
El lenguaje de programación C# (ema :=L In57ruccione5
ordenada Io 5eaN del m95 in7erno al m95 eU7ernoK AWora MienN lo Rue no e5 po5iMle e5
incluir un return den7ro de una cl9u5ula finaIIy%
Instrucción goto
La 72;34066782 goto permi7e pa5ar a ejecu7ar el código a par7ir de una in57rucción cuSa
e7iRue7a 5e indica en el goto% La 5in7aUi5 de u5o de e57a in57rucción e5L
goto <etiqueta>;
Como en la maSorVa de lo5 lenguaje5N goto e5 una 72;34066782 ?9-5739 cuSo u5o no 5e
recomienda porRue diOicul7a innece5ariamen7e la legiMilidad del código S 5uele 5er O9cil
5imularla u5ando in57ruccione5 i7era7iQa5 S 5elec7iQa5 con la5 condicione5 apropiada5%
Sin emMargoN en C# 5e incluSe porRue puede 5er eOicien7e u5arla 5i 5e anidan mucWa5
in57ruccione5 S para reducir 5u5 eOec7o5 nega7iQo5 5e le Wan impue57o una5 re57riccione5L
• Sólo 5e pueden e7iRue7ar in57ruccione5N S no direc7iQa5 preproce5adoN direc7iQa5
using o deOinicione5 de miemMro5N 7ipo5 o e5pacio5 de nomMre5%
• La e7iRue7a indicada no pueda per7enecer a un MloRue de in57ruccione5 anidado
den7ro del MloRue de5de el Rue 5e u5a el goto ni Rue e7iRue7e a in57ruccione5 de o7ro
m67odo diOeren7e a aRu6l en el cual 5e encuen7ra el goto Rue la reOerencia%
Para e7iRue7ar una in57rucción de modo Rue pueda 5er de57ino de un 5al7o con goto Ma57a
precederla del nomMre con el Rue 5e la Ruiera e7iRue7ar 5eguido de do5 pun7o5 I:K Por
ejemploN el 5iguien7e código demue57ra cómo u5ar goto S deOinir una e7iRue7aL
using System;
class HolaMundoGoto
{
public static void Main(string[] args)
{
for (int i=0; i<args.Length; i++)
{
if (args[i] != “salir”)
Console.WriteLine(args[i]);
else
goto fin:
}
fin: ;
}
}
E57e programa de ejemplo lo Rue Wace e5 mo57rar por pan7alla 7odo5 lo5 argumen7o5 Rue
5e le pa5en como par9me7ro5N aunRue 5i alguno de Oue5e salir en7once5 5e dejarVa de
mo57rar argumen7o5 S 5e aMor7a la ejecución de la aplicación% ,6a5e adem95 Rue e57e
ejemplo pone de maniOie57o una de la5 u7ilidade5 de la in57rucción nulaN Sa Rue 5i no 5e
WuMie5e e5cri7o 7ra5 la e7iRue7a fin el programa no compilarVa en 7an7o Rue 7oda e7iRue7a
Wa de preceder a alguna in57rucción IaunRue 5ea la in57rucción nulaK
El lenguaje de programación C# (ema :=L In57ruccione5
Nó7e5e Rue al Oin S al caMo lo5 u5o5 de goto den7ro de in57ruccione5 switch Rue 5e Qieron
al e57udiar dicWa in57rucción no 5on m95 Rue Qarian7e5 del u5o general de gotoN Sa Rue
defauIt: no e5 m95 Rue una e7iRue7a S case <valor>: puede Qer5e como una e7iRue7a un
7an7o e5pecial cuSo nomMre e5 case 5eguido de e5pacio5 en Mlanco S un Qalor% En amMo5
ca5o5N la e7iRue7a indicada Wa de per7enecer al mi5mo switch Rue el goto u5ado S no Qale
Rue 657e no la con7enga pero la con7enga algTn switch Rue con7enga al switch del goto%
El u5o de goto den7ro de 5en7encia5 tryN 7iene la5 mi5ma5 re57riccione5 Rue breakN
continue S returnL an7e5 de 5alir con un goto de un try 5e ejecu7ar9 5iempre 5u MloRue
finaIIy S no e5 po5iMle Oor8ar a 5al7ar Ouera de un finaIIy%
Instrucción throw
La instrucción throw Sa 5e Wa Qi57o Rue 5e u5a para lan8ar eUcepcione5 de e57e modoL
throw <ob+etoE)cepción(,an-ar>;
En ca5o de Rue no 5e indiRue ningTn <objetoExcepciónALanzar> 5e relan8ar9 el Rue 5e
e57uQie5e 7ra7ando en e5e momen7oN aunRue e57o 5ólo e5 po5iMle 5i el throw 5e Wa e5cri7o
den7ro del código de 7ra7amien7o a5ociado a alguna cl9u5ula catch%
Como e57a in57rucción Sa Wa 5ido eUplicada a Oondo en e57e mi5mo 7emaN para m95
inOormación 5oMre ella puede con5ul7ar5e el epVgraOe E/$e!$iones del mi5mo%
%tras instrucciones
La5 in57ruccione5 Qi57a5 Wa57a aWora 5on comune5 a mucWo5 lenguaje5 de programación%
Sin emMargoN en C# 7amMi6n 5e Wa incluido un Muen nTmero de nueQa5 in57ruccione5
propia5 de e57e lenguaje% E57a5 in57ruccione5 5e de5criMen en lo5 5iguien7e5 apar7ado5L
Instrucciones checked y unchecked
La5 in57ruccione5 checked S unchecked permi7en con7rolar la Oorma en Rue 7ra7ar9n lo5
de5Mordamien7o5 Rue ocurran duran7e la reali8ación de operacione5 ari7m67ica5 con 7ipo5
M95ico en7ero5% /uncionan de Oorma 5imilar a lo5 operadore5 checked S unchecked Sa
Qi57o5 en el Tema *: .s!e$tos lé/i$osN aunRue a diOerencia de 657o5 5on aplicaMle5 a
MloRue5 en7ero5 de in57ruccione5 S no a una Tnica eUpre5ión% A5VN la instrucción checked
5e u5a de e57e modoL
checked
<instrucciones>
(odo de5Mordamien7o Rue 5e produ8ca al reali8ar operacione5 ari7m67ica5 con en7ero5 en
<instrucciones> proQocar9 Rue 5e lance una eUcepción System.OverfIowException% Por 5u
par7eN la 72;34066782 unchecked 5e u5a a5VL
unchecked
<instrucciones>
El lenguaje de programación C# (ema :=L In57ruccione5
En e57e ca5oN 7odo de5Mordamien7o Rue 5e produ8ca al reali8ar operacione5 ari7m67ica5
con 7ipo5 M95ico5 en7ero5 en <instrucciones> 5er9 ignorado S lo Rue 5e War9 5er9 7omar el
Qalor re5ul7an7e de Ruedar5e con lo5 Mi75 meno5 5igniOica7iQo5 nece5ario5%
Por deOec7oN en au5encia de e57a5 in57ruccione5 la5 eUpre5ione5 con57an7e5 5e eQalTan
como 5i 5e incluSe5en den7ro de una in57rucción checked S la5 Rue no con57an7e5 como
5i 5e incluSe5en den7ro de una in57rucción unchecked% Sin emMargoN a 7raQ65 de la
opción /c*ec<ed del compilador e5 po5iMle 7an7o Wacer Rue por deOec7o 5e comprueMen
lo5 de5Mordamien7o5 en 7odo5 lo5 ca5o5 para a5V 5iempre poder de7ec7arlo5 S 7ra7arlo5%
#e5de ,i5ual S7udio%NE(N la Oorma de con7rolar el 7ipo de comproMacione5 Rue por
deOec7o 5e War9n e5 a 7raQ65 de V71D  P4.<13: P9=1;  C.2@7=04937.2 S13372=; 
B07-5  CJ16E @.4 .A14@-.D 02514@-.D%
El 5iguien7e código mue57ra un ejemplo de cómo u5ar amMa5 in57ruccione5L
using System;
class Unchecked
{
static short x = 32767; // Valor maximo del tipo short
public static void Main()
{
unchecked
{
Console.WriteLine((short) (x+1)); // (1)
Console.WriteLine((short) 32768); // (2)
}
}
}
En un principio e57e código compilarVaN pero lo5 de5Mordamien7o5 producido5 por el
WecWo de Rue *&.=' no e5 un Qalor Rue 5e pueda repre5en7ar con un short I:= Mi75 con
5ignoK proQocarVan Rue aparecie5e por pan7alla dicWo Qalor 7runcadoN mo57r9ndo5eL
'(DXRI
'(DRXI
Sin emMargoN 5i 5u57i7uS65emo5 la in57rucción unchecked por checkedN el código
an7erior ni 5iRuiera compilarVa Sa Rue el compilador de7ec7arVa Rue 5e Qa a producir un
de5Mordamien7o en (2) deMido a Rue *&.=' e5 con57an7e S no repre5en7aMle con un short%
Si eliminamo5 la in57rucción (2) el código compilarVa Sa Rue (x+1) no e5 una eUpre5ión
con57an7e S por 7an7o el compilador no podrVa de7ec7ar de5Mordamien7o al compilar% Sin
emMargoN cuando 5e ejecu7a5e la aplicación 5e lan8arVa una System.OverfIowException%
Instrucción Iock
La 72;34066782 Iock e5 T7il en aplicacione5 concurren7e5 donde mTl7iple5 Wilo5 pueden
e57ar accediendo 5imul79neamen7e a un mi5mo recur5oN Sa Rue lo Rue Wace e5 garan7i8ar
El lenguaje de programación C# (ema :=L In57ruccione5
Rue un Wilo no pueda acceder a un recur5o mien7ra5 o7ro 7amMi6n lo e576 Waciendo% Su
5in7aUi5 e5 la 5iguien7eL
Iock (<objeto>)
<instrucciones>
Su 5igniOicado e5 el 5iguien7eL ningTn Wilo puede ejecu7ar la5 <instrucciones> del MloRue
indicado 5i o7ro la5 e579 ejecu7andoN S 5i alguno lo in7en7a 5e Ruedar9 e5perando Wa57a
Rue acaMe el primero% E57o 7amMi6n aOec7a a MloRue5 de <instrucciones> de cualRuier o7ro
Iock cuSo <objeto> 5ea el mi5mo% E57e <objeto> Wa de 5er de algTn 7ipo reOerencia%
En realidadN la in57rucción an7erior e5 eRuiQalen7e a WacerL
System.Threading.Monitor.Enter(<objeto>);
try
<instrucciones>
finaIIy
{
System.Threading.Monitor.Exit(<objeto>);
}
Sin emMargoN u5ar Iock 7iene do5 Qen7aja5L e5 m95 compac7o S eOicien7e I<objeto> 5ólo 5e
eQalTa una Qe8K

"na Muena Oorma de garan7i8ar la eUclu5ión mu7ua duran7e la ejecución de un m67odo de
un cier7o oMje7o e5 u5ando this como <objeto> En el ca5o de Rue 5e 7ra7a5e de un m67odo
de 7ipoN en 7an7o Rue this no 7iene 5en7ido den7ro de e57o5 m67odo5 e5797ico5 una Muena
al7erna7iQa 5erVa u5ar el oMje7o System.Type Rue repre5en7a5e a e5e 7ipo% Por ejemploL
class C
{
public static void F()
{
lock(typeof(C))
{
// ... Código al que se accede exclusivamente
}
}
}
Instrucción using
La 72;34066782 using Oacili7a el 7raMajo con oMje7o5 Rue 7engan Rue ejecu7ar alguna 7area
de limpie8a o liMeración de recur5o5 una Qe8 Rue 7ermine de 5er T7ile5% AunRue para
e57o5 mene57ere5 Sa e579n lo5 de57ruc7ore5N dado 5u car9c7er inde7ermini57a puede Rue en
de7erminada5 oca5ione5 no 5ea conQenien7e conOiar en ello5 para reali8ar e57e 7ipo de
7area5% La 5in7aUi5 de u5o de e57a in57rucción e5 la 5iguien7eL

using (<tipo> <declaraciones>)
<instrucciones>
En <declaraciones> 5e puede indicar uno o Qario5 oMje7o5 de 7ipo <tipo> 5eparado5 por
coma5% E57o5 oMje7o5 5er9n de 5ólo lec7ura S 5ólo 5er9n acce5iMle5 de5de <instrucciones>%
Adem95N Wan de implemen7ar la in7erOa8 System.IDisposabIe deOinida como 5igueL
El lenguaje de programación C# (ema :=L In57ruccione5
interface IDisposabIe
{
void Dispose()
}
En la implemen7ación de Dispose() 5e e5criMirVa el código de limpie8a nece5arioN pue5 el
5igniOicado de using con5i57e en Rue al acaMar la ejecución de <instrucciones>N 5e llama
au7om97icamen7e al m67odo Dispose() de lo5 oMje7o5 deOinido5 en <declaraciones>%
HaS Rue 7ener en cuen7a Rue la llamada a Dispose() 5e Wace 5ea cual 5ea la ra8ón de Rue
5e deje de ejecu7ar la5 <instrucciones> E5 decirN 7an7o 5i 5e Wa producido una eUcepción
como 5i 5e Wa acaMado 5u ejecución normalmen7e o con una in57rucción de 5al7oN
Dispose() e5 5iempre llamado% En realidad una in57rucción using comoL
using (R1 r1 = new R1())
{
r1.F();
}
E5 7ra7ada por el compilador comoL
{
R1 r1 = new R1()
try
{
r1.F();
}
finally
{
if (r1!=null)
((ÌDisposable) r1).Dispose();
}
}
Si 5e declara5en Qario5 oMje7o5 en <declaraciones>N a Dispose() 5e le llamarVa en el orden
inQer5o a como Oueron declarado5% Lo mi5mo ocurre 5i 5e anida5en Qaria5 in57ruccione5
usingL primero 5e llamarVa al Dispose() de la5 QariaMle5 declarada5 en lo5 using in7erno5
S luego a la5 de lo5 eU7erno5% A5VN e57a5 do5 in57ruccione5 5on eRuiQalen7e5L
using (Recurso obj = new Recurso(), obj2= new Recurso())
{
r1.F();
r2.F();
}
using (Recurso obj = new Recurso())
{
using (Recurso obj2= new Recurso())
{
r1.F();
r2.F();
}
}
El 5iguien7e ejemplo re5ume cómo Ounciona la 5en7encia usingL
using System;
El lenguaje de programación C# (ema :=L In57ruccione5
class A:ÌDisposable
{
public void Dispose()
{
Console.WriteLine("Llamado a Dispose() de {0}", Nombre);
}
public A(string nombre)
{
Nombre = nombre;
}
string Nombre;
}
class Using
{
public static void Main()
{
A objk = new A("objk");
using (A obj1 = new A("obj1"), obj2 = new A("objy"))
{
Console.WriteLine("Dentro del using");
}
Console.WriteLine("Fuera del using");
}
}
La 5alida por pan7alla re5ul7an7e de ejecu7ar e57e ejemplo 5er9L
Dentro del using
Llamando a Dispose() de objy
Llamando a Dispose() de obj1
Fuera del using
Como 5e deduce de lo5 men5aje5 de 5alida oM7enido5N ju57o an7e5 de 5alir5e del using 5e
llama a lo5 m67odo5 Dispose() de lo5 oMje7o5 declarado5 en la 5ección <declaraciones> de
dicWa in57rucción S en el mi5mo orden en Rue Oueron declarado5%
Instrucción fixed
La 72;34066782 fixed 5e u7ili8a para Oijar oMje7o5 en memoria de modo Rue el recolec7or
de Ma5ura no pueda moQerlo5 duran7e la ejecución de un cier7o MloRue de in57ruccione5%
E57a in57rucción 5ólo 7iene 5en7ido den7ro de regione5 de código in5eguroN concep7o Rue
5e 7ra7a en el Tema %8: C)di(o inse(#roN por lo Rue 5er9 allV e5 donde 5e eUpliRue a
Oondo cómo u7ili8arla% ARuV 5ólo diremo5 Rue 5u 5in7aUi5 de u5o e5L
fixed(<tipoPunteros> <declaracionesPunterosAFijar>)
<instrucciones>
El lenguaje de programación C# (ema :.L A7riMu7o5
TEMA 17: ATRIBUTOS
Concepto de atributo
"n 9347C03. e5 inOormación Rue 5e puede aXadir a lo5 me7ada7o5 de un módulo de
código% E57a inOormación puede 5er reOeren7e 7an7o al propio módulo o el en5amMlado al
Rue per7ene8ca como a lo5 7ipo5 de da7o5 deOinido5 en 6lN 5u5 miemMro5N lo5 par9me7ro5
de 5u5 m67odo5N lo5 MloRue5 set S get de 5u5 propiedade5 e indi8adore5 o lo5 MloRue5 add
S remove de 5u5 eQen7o5%
En C# 5e incluSen numero5o5 modiOicadore5 Rue no5 permi7en a5ociar inOormación a lo5
me7ada7o5 de un módulo% Por ejemploN con lo5 modiOicadore5 pubIicN protectedN privateN
internaI o protected internaI podemo5 aXadir inOormación 5oMre la Qi5iMilidad de lo5
7ipo5 del módulo S de 5u5 miemMro5% Pue5 MienN lo5 a7riMu7o5 pueden Qer5e como un
mecani5mo median7e el cual el programador puede crear 5u5 propio5 modiOicadore5%
"n ejemplo de a7riMu7o podrVa 5er uno llamado Ayuda Rue pudie5e preOijar la5
deOinicione5 de miemMro5 de 7ipo5 e indica5e cu9l e5 la ")L donde 5e pudie5e encon7rar
inOormación de7allada con aSuda 5oMre el 5igniOicado del miemMro preOijado%
5tili3ación de atributos
Para colocar un a7riMu7o a un elemen7o Ma57a preOijar la deOinición de dicWo elemen7o
con una e57ruc7ura de e57a OormaL
[<nombreAtributo>(<parámetros>)]
E57a e57ruc7ura Wa de colocar5e inclu5o an7e5 Rue cualRuier modiOicador Rue pudie5e
acompaXar la deOinición del elemen7o a a7riMuir%
Lo5 par9me7ro5 de un a7riMu7o pueden 5er opcionale5N S 5i 5e u5a 5in e5peciOicar Qalore5
para 5u5 par9me7ro5 no WaS porRu6 Rue u5ar par6n7e5i5 QacVo5 como en la5 llamada5 a
m67odo5N 5ino Rue Ma57a u5ar el a7riMu7o indicando 5ólo la 5in7aUi5 [<nombreAtributo>]
Lo5 par9me7ro5 de un a7riMu7o pueden 5er de do5 7ipo5L
• P94M?134.; ;72 2.?C41: Se u5an de Oorma 5imilar a lo5 par9me7ro5 de lo5
m67odo5N 5ólo Rue no pueden con7ar con modiOicadore5 ref u out%
• P94M?134.; 6.2 2.?C41: Son opcionale5 S pueden colocar5e en cualRuier
po5ición en la li57a de <parámetros> del a7riMu7o% Lo Tl7imo 5e deMe a Rue para
darle5 Qalor 5e u5a la 5in7aUi5 <nombreParámetro>=<valor>N con lo el compilador
no depender9 de la po5ición en Rue 5e le5 pa5en lo5 Qalore5 para de7erminar a
Ru6 par9me7ro 5e le e579 dando cada QalorN 5ino Rue reciMe eUplVci7a 5u nomMre%
El lenguaje de programación C# (ema :.L A7riMu7o5
Para eQi7ar conOlic7o5 en7re par9me7ro5 con nomMre S par9me7ro5 5in nomMreN lo5
primero5 5iempre 5e Wan de incluir de5pu65 de lo5 5egundo5N no 5iendo po5iMle
me8clarlo5 indi5criminadamen7e%
Si 5e de5ean e5peciOicar Qario5 a7riMu7o5 para un mi5mo elemen7o 5e pueden indicar
7odo5 ello5 en7re uno5 mi5mo5 corcWe7e5 5eparado5 por coma5% E5 decirN de la OormaL
[<atributo1>(<parametros&>), <atributo2>(<parámetros2>), ...]
AunRue 7amMi6n 5erVa po5iMle e5peciOicarlo5 por 5eparado% 5eaN de e57a o7ra OormaL
[<atributo1>(<parametros&>)] [<atributo2>(<parámetros2>)] ...
HaS ca5o5 en lo5 Rue por la uMicación del a7riMu7o no 5e puede de7erminar de manera
unVQoca a cu9l elemen7o 5e le de5ea aplicarN Sa Rue podrVa 5er aplicaMle a Qario5% En e5o5
ca5o5N para eQi7ar amMigiedade5 lo Rue 5e Wace e5 u5ar el a7riMu7o preOijando 5u nomMre
de un 7257695.4 51 37<. 51 1-1?123.N Ruedando a5V la 5in7aUi5 a u5arL
[<indicadorElemento>/<nombreAtributo>(<parámetros>)]
AunRue cada implemen7ación de C# puede incluir 5u5 propio5 indicadore5 de 7ipo de
elemen7oN 7oda5 ella5 incluir9n al meno5 lo5 5iguien7e5L
• assembIy: Indica Rue el a7riMu7o 5e aplica al en5amMlado en Rue 5e compile el
código Ouen7e Rue lo con7enga% Al deOinir a7riMu7o5 de en5amMlado e5 oMliga7orio
incluir e57e indicadorN Sa Rue e57o5 a7riMu7o5 5e colocan precediendo cualRuier
deOinición de cla5e o e5pacio de nomMre5 S 5i no 5e incluSe5en 5e conOundirVa
con a7riMu7o5 de 7ipoN Rue 5e colocan en el mi5mo 5i7io%
• moduIe: Indica Rue el a7riMu7o 5e aplica al módulo en Rue 5e compile el código
Ouen7e Rue lo con7enga% Al igual Rue el indicador assembIyN WaS Rue incluirlo
5iempre para deOinir e57e 7ipo de a7riMu7o5 porRue 5i no 5e conOundirVan con
a7riMu7o5 de 7ipoN Sa Rue 7amMi6n 5e Wan de uMicar precediendo la5 deOinicione5
de cla5e5 S e5pacio5 de nomMre5%
• type: Indica Rue el a7riMu7o 5e aplica al 7ipo cuSa deOinición precede% En realidad
no Wace Oal7a u7ili8arloN pue5 e5 lo Rue por deOec7o 5e con5idera para 7odo a7riMu7o
Rue preceda a una deOinición de 7ipo% Sin emMargoN 5e Wa incluido por
con5i57encia con el re57o de indicadore5 de 7ipo de a7riMu7o S porRue puede
re5ul7ar conQenien7e incluirlo Sa Rue eUplici7arlo Oacili7a la lec7ura del código%
• return: Indica Rue el a7riMu7o 5e aplica a un Qalor de re7orno de un m67odoN
operadorN MloRue getN o deOinición de delegado% Si no 5e incluSe5e 5e
con5iderarVa Rue 5e aplica a la deOinición del m67odoN operadorN MloRue get o
delegadoN Sa Rue e57o5 a7riMu7o5 5e colocan an7e5 de la mi5ma al igual Rue lo5
a7riMu7o5 de Qalore5 de re7orno%
• param: Indica Rue el a7riMu7o 5e aplica a un par9me7ro de un m67odo% Si no 5e
incluSe5e al deOinir MloRue5 setN add o remove 5e con5iderarVa Rue el a7riMu7o 5e
reOiere a lo5 MloRue5 en 5V S no al par9me7ro vaIue en ello5 implVci7o%
El lenguaje de programación C# (ema :.L A7riMu7o5
• method: Indica Rue el a7riMu7o 5e aplica al m67odo al Rue precede% En realidad no
e5 nece5ario u5arlo porRueN como 5e dice en la eUplicación de lo5 indicadore5
param S returnN e5 lo Rue 5e con5idera por deOec7o% Sin emMragoN S como pa5aMa
con typeN 5e incluSe por con5i57encia S porRue puede 5er Muena idea incluirlo
para Oacili7ar la legiMilidad del código con 5u eUplici7ación%
• event: Indica Rue el a7riMu7o 5e aplica al eQen7o a cuSa deOinición precede% En
realidad no e5 nece5ario incluirlo porRue e5 lo Rue 5e con5idera por deOec7oN pero
nueQamen7e 5e Wa incluido por con5i57encia S para Oacili7ar la lec7ura del código%
• property: Indica Rue el a7riMu7o 5e aplica a la propiedad a cuSa deOinición
precede% >57e 7amMi6n e5 un indicador innece5ario e incluido 7an 5ólo por
con5i57encia S para Oacili7ar la legiMilidad del código%
• fieId: Indica Rue el a7riMu7o 5e aplica al cuSa deOinición precede% Como o7ro5
indicadore5N 5ólo 5e incluSe por con5i57encia S para Wacer m95 legiMle el código%
(efinición de nuevos atributos
Especificación deI nombre deI atributo
Se con5idera Rue un a7riMu7o e5 7oda aRuella cla5e Rue deriQe de System.Attribute% Por
7an7oN para deOinir un nueQo 7ipo de a7riMu7o WaS Rue crear una cla5e Rue deriQe de ella%
Por conQenioN a e57e 7ipo de cla5e5 5uele d9r5ele5 nomMre5 acaMado5 en AttributeN aunRue
a la Wora de u5arla5 de5de C# e5 po5iMle oMQiar dicWo 5uOijo% "n ejemplo de cómo deOinir
un a7riMu7o llamado Ayuda e5L
using System;
class AyudaAttribute:Attribute
{}
2 ejemplo5 de cómo u5arlo preOijando la deOinición de cla5e5 5onL
[Ayuda] class A
{}
[AyudaAttribute] class B
{}
Puede dar5e la circun57ancia de Rue 5e WaSa deOinido un a7riMu7o con un cier7o nomMre
5in 5uOijo Attribute S o7ro Rue 5i lo 7enga% Como e5 lógicoN en e5e ca5o cuando 5e u5e el
a7riMu7o 5in e5peciOicar el 5uOijo 5e War9 reOerencia a la Qer5ión 5in 5uOijo S cuando 5e u5e
con 5uOijo 5e War9 reOerencia a la Qer5ión con 5uOijo%
Especificación deI uso de un atributo
Por deOec7o cualRuier a7riMu7o Rue 5e deOina puede preceder la deOinición de cualRuier
elemen7o del lenguaje% Si 5e de5ea limi7ar a Ru6 deOinicione5 puede preceder e5
El lenguaje de programación C# (ema :.L A7riMu7o5
nece5ario preOijar la cla5e Rue lo deOine con un a7riMu7o e5pecial llamado
System.AttributeUsage% E57e a7riMu7o con57a de lo5 5iguien7e5 par9me7ro5 con nomMreL
• AIIowMuItipIe: Por deOec7o cada a7riMu7o 5ólo puede aparecer una Qe8 preOijando
a cada elemen7o% #9ndole el Qalor true a e57e par9me7ro 5e con5iderar9 Rue
puede aparecer mTl7iple5 Qece5%
• Inherited: Por deOec7o lo5 a7riMu7o5 aplicado5 a una cla5e no 5on Weredado5 en 5u5
cla5e5 Wija5% #9ndole el Qalor true a e57e par9me7ro 5e con5igue Rue 5V lo 5ean%
Apar7e de e57o5 do5 par9me7ro5N AttributeUsage 7amMi6n puede con7ar con un par9me7ro
opcional 5in nomMre Rue indiRue a Ru6 7ipo5 de deOinicione5 puede preceder% Por
deOec7o 5e con5idera Rue un a7riMu7o puede preceder a cualRuier elemen7oN lo Rue e5
eRuiQalen7e a darle el Qalor AttributeTargets.AII a e57e par9me7ro% Sin emMrago e5
po5iMle e5peciOicar o7ra5 po5iMilidade5 d9ndole Qalore5 de la enumeración
System.AttributeTargetsN Rue 5on lo5 Rue 5e recogen en la (aMla 0L
V9-.4 51 AttributeTargets S7=27@769 /01 1- 9347C03. <0151 <4161514 9...
AII
CualRuier deOinición
AssembIy
#eOinicione5 de e5pacio de nomMre5N con5ider9ndo5e
Rue el a7riMu7o 5e reOiere al en5amMlado en general%
ModuIe
#eOinicione5 de e5pacio de nomMre5N con5ider9ndo5e
Rue el a7riMu7o 5e reOiere al módulo en 5u conjun7o%
CIass
#eOinicione5 de cla5e5
DeIegate
#eOinicione5 de delegado5
Interface
#eOinicione5 de in7erOace5
Struct
#eOinicione5 de e57ruc7ura5
Enum
#eOinicione5 de enumeracione5
FieId
#eOinicione5 de campo5
Method
#eOinicione5 de m67odo5
Constructor
#eOinicione5 de con57ruc7ore5
Property
#eOinicione5 de propiedade5 o indi8adore5
Event
#eOinicione5 de eQen7o5
Parameter
#eOinicione5 de par9me7ro5 de m67odo5
ReturnVaIue
#eOinicione5 de Qalore5 de re7orno de m67odo5
T9C-9 (: ,alore5 de AttributeTargets
E5 po5iMle comMinar Qario5 de e57o5 Qalore5 median7e operacione5 lógica5 _or` Icar9c7er
| K Por ejemploN 5i Rueremo5 deOinir el a7riMu7o Ayuda an7erior de modo Rue 5ólo pueda
5er u5ado para preOijar deOinicione5 de enumeracione5 o de cla5e5 5e WarVaL
[AttributeUsage(AttributeTargets.Class | AttributeTargetes.Enum)]
class Ayuda:Attribute
{}
E5 impor7an7e re5al7ar Rue AttributeUsage 5ólo puede incluir5e precediendo deOinicione5
de o7ro5 a7riMu7o5 Io 5eaN de cla5e5 deriQada5 de System.AttributeK
El lenguaje de programación C# (ema :.L A7riMu7o5
Especificación de parámetros váIidos
Se con5idera Rue lo5 par9me7ro5 5in nomMre Rue puede 7omar un a7riMu7o 5on aRuello5
Rue 5e e5peciOiRuen como par9me7ro5 en el con57ruc7or del 7ipo Rue lo deOineN S Rue 5u5
par9me7ro5 con nomMre 5er9n la5 propiedade5 S campo5 pTMlico5N no e5797ico5 S de
lec7ura^e5cri7ura deOinido5 en dicWo 7ipo%

"n ejemplo de cómo deOinir el a7riMu7o Ayuda an7erior de modo Rue 7ome un par9me7ro
5in nomMre con la ")L Rue indiRue dónde encon7rar la aSuda 5oMre el miemMro o cla5e
al Rue precede S un par9me7ro con nomMre llamado Autor Rue indiRue Rui6n e5 el au7or
de e5a documen7ación e5L
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Enum)]
class Ayuda:Attribute
{
private string autor;
private string url;
public Ayuda(string URL)
{ url=URL; }
public string Autor
{
set {autor = value;}
get {return autor;}
}
}
Ejemplo5 de u5o5 Q9lido5 de e57e a7riMu7o 5onL
[Ayuda(“http://www.josan.com/Clases/A.html”)]
class A {}
[Ayuda(“http://www.josan.com/Clases/B.html”, Autor=”José Antonio González Seco”)]
class B {}
Lo5 7ipo5 Q9lido5 de par9me7ro5N 7an7o con nomMre como 5in 6lN Rue puede 7omar un
a7riMu7o 5onL cualRuier 7ipo M95ico eUcep7o decimaI S lo5 7ipo5 en7ero5 5in 5ignoN
cualRuier enumeración pTMlicaN System.Type o 7aMla5 unidimen5ionale5 de elemen7o5 de
cualRuiera de lo5 an7eriore5 7ipo5 Q9lido5%
Lectura de atributos en tiempo de e&ecución
Para acceder a lo5 me7ada7o5 de cualRuier en5amMlado 5e u7ili8an la5 cla5e5 del e5pacio
de nomMre5 System.RefIection% E57e e5pacio de nomMre5 e5 inmen5o S eUplicar cómo
u7ili8arlo Rueda Ouera del alcance de e57e liMroN aunRue de 7odo5 modo5 a con7inuación
5e dar9n una5 idea5 M95ica5 5oMre cómo acceder a 7raQ65 de 5u5 7ipo5 a lo5 a7riMu7o5
incluido5 en lo5 en5amMlado5%
La claQe para acceder a lo5 a7riMu7o5 5e encuen7ra en el m67odo e5797ico de la cla5e
System.Attribute llamado Attribute[] GetCustomAttributes(<x> objetoRefIexivo)N donde
<x> e5 el 7ipo de System.RefIection Rue repre5en7a a lo5 elemen7o5 cuSo5 a7riMu7o5 5e
de5ea oM7ener% Lo5 po5iMle5 7ipo5 5onL AssembIyN Rue repre5en7a en5amMlado5N ModuIe
El lenguaje de programación C# (ema :.L A7riMu7o5
Rue repre5en7a módulo5N MemberInfo Rue repre5en7a miemMro5 Iincluido5 7ipo5N Rue al
Oin S al caMo 5on miemMro5 de e5pacio5 de nomMre5KN S ParameterInfo Rue repre5en7a
par9me7ro5% El par9me7ro 7omado por e57e m67odo 5er9 el oMje7o Rue repre5en7e al
elemen7o en concre7o cuSo5 me7ada7o5 5e Ruieren oM7ener%
Como 5e QeN GetCustomAttributes() deQuelQe una 7aMla con lo5 a7riMu7o5 en Oorma de
oMje7o5 AttributeN Rue e5 la cla5e Ma5e de 7odo5 lo5 a7riMu7o5N por lo Rue 5i a par7ir de
ello5 5e de5ea5e acceder a carac7erV57ica5 e5pecVOica5 de cada 7ipo de a7riMu7o WaMrVa Rue
aplicar doYnca57ing como 5e comen7ó en el Tema 5: Clases Ipara a5egura5e de Rue la5
conQer5ione5 5e realicen con 6Ui7o recu6rde5e Rue 5e puede u5ar el operador is para
de7erminar cu9l e5 el Qerdadero 7ipo de cada a7riMu7o de e57a 7aMlaK
Para oM7ener el oMje7o AssembIy Rue repre5en7a al en5amMlado al Rue per7ene8ca el
código Rue 5e e576 ejecu7ando 5e u5a el m67odo AssembIy GetExecutingAssembIy() de la
cla5e AssembIyN Rue 5e u5a 7al S como 5e mue57raL
Assembly ensamblado = Assembly.GetExecutingAssembly();
7ra po5iMilidad 5erVa oM7ener e5e oMje7o AssembIy a par7ir del nomMre del OicWero
donde 5e encuen7re almacenado el en5amMlado% Para ello 5e u5a el m67odo AssembIy
LoadFrom(string rutaEnsambIado) de la cla5e AssembIy como 5e mue57raL

Assembly ensamblado = Assembly.LoadFrom(“josan.dll”);
"na Qe8 oM7enido el oMje7o Rue repre5en7a a un en5amMladoN pueden oM7ener5e lo5
oMje7o5 ModuIe Rue repre5en7an a lo5 módulo5 Rue lo Oorman a 7raQ65 de 5u m67odo
ModuIe[] GetModuIes()%
A par7ir del oMje7o ModuIe Rue repre5en7a a un módulo puede oM7ener5e lo5 oMje7o5 Type
Rue repre5en7an a 5u5 7ipo5 a 7raQ65 de 5u m67odo Type[] GetTypes() 7ra po5iMilidad
5erVa u5ar el operador typeof Sa Qi57o para oM7ener el Type Rue repre5en7a a un 7ipo en
concre7o 5in nece5idad de crear oMje7o5 ModuIe o AssembIy%
En cualRuier ca5oN una Qe8 oM7enido un oMje7o TypeN a 7raQ65 de 5u5 m67odo5 FieIdInfo[]
GetFieIds()N MethodInfo[] GetMethods()N ConstructorInfo[] GetConstructors()N EventInfo[]
GetEvents[] S PropertyInfo[] GetProperties() pueden oM7ener5e lo5 oMje7o5 reOleUiQo5 Rue
repre5en7anN de manera re5pec7iQaN a 5u5 campo5N m67odo5N con57ruc7ore5N eQen7o5 S
propiedade5 o indi8adore5% (an7o 7odo5 e57o5 oMje7o5 como lo5 oMje7o5 Type deriQan de
MemberInfoN por lo Rue pueden 5er pa5ado5 como par9me7ro5 de GetCustomAttributes()
para oM7ener lo5 a7riMu7o5 de lo5 elemen7o5 Rue repre5en7an%

Por o7ro ladoN a 7raQ65 de lo5 oMje7o5 MethodInfo S ConstructorInfoN e5 po5iMle oM7ener
lo5 7ipo5 reOleUiQo5 Rue repre5en7an a lo5 par9me7ro5 de m67odo5 S con57ruc7ore5
llamando a 5u m67odo ParameterInfo[] GetParameters() Adem95N en el ca5o de lo5
oMje7o5 MethodInfo 7amMi6n e5 po5iMle oM7ener el oMje7o Rue repre5en7a al 7ipo de
re7orno del m67odo Rue repre5en7an median7e 5u propiedad Type ReturnType {get;}%
En lo reOeren7e a la5 propiedade5N e5 po5iMle oM7ener lo5 oMje7o5 MethodInfo Rue
repre5en7an a 5u5 MloRue5 get S set a 7raQ65 de lo5 m67odo5 MethodInfo GetSetMethod() S
MethodInfo GetSetMethod() de lo5 oMje7o5 PropertyInfo Rue la5 repre5en7an% Adem95N
El lenguaje de programación C# (ema :.L A7riMu7o5
para oM7ener lo5 oMje7o5 reOleUiQo5 Rue repre5en7en a lo5 Vndice5 de lo5 indi8adore5
7amMi6n 5e di5pone de un m67odo ParamterInfo[] GetIndexParameters()
2 en cuan7o a lo5 eQen7o5N lo5 oMje7o5 EventInfo di5ponen de m67odo5 MethodInfo
GetAddMethod() S MethodInfo GetRemoveMethod() median7e lo5 Rue e5 po5iMle oM7ener
lo5 oMje7o5 reOleUiQo5 Rue repre5en7an a 5u5 MloRue5 add S remove%
A con7inuación 5e mue57ra un programa de ejemplo Rue lo Rue Wace e5 mo57rar por
pan7alla el nomMre de 7odo5 lo5 a7riMu7o5 Rue en 6l 5e WaSan deOinidoL
using System.Reflection;
using System;
[assembly: EjemploEnsamblado]
[module: EjemploModulo]
[AttributeUsage(AttributeTargets.Method)]
class EjemploMétodo:Attribute
{}
[AttributeUsage(AttributeTargets.Assembly)]
class EjemploEnsamblado:Attribute
{}
[AttributeUsage(AttributeTargets.Module)]
class EjemploModulo:Attribute
{}
[AttributeUsage(AttributeTargets.Class)]
class EjemploTipo:Attribute
{}
[AttributeUsage(AttributeTargets.Field)]
class EjemploCampo:Attribute
{}
[EjemploTipo]
class A
{
public static void Main()
{
Assembly ensamblado = Assembly.GetExecutingAssembly();
foreach (Attribute atributo in Attribute.GetCustomAttributes(ensamblado))
Console.WriteLine("ENSAMBLADO: {0}",atributo);
foreach (Module modulo in ensamblado.GetModules())
{
foreach(Attribute atributo in Attribute.GetCustomAttributes(modulo))
Console.WriteLine("MODULO: {0}", atributo);
foreach (Type tipo in modulo.GetTypes())
{
foreach(Attribute atributo in Attribute.GetCustomAttributes(tipo))
Console.WriteLine("TÌPO: {0}", atributo);

foreach (FieldÌnfo campo in tipo.GetFields())
muestra("CAMPO", campo);
El lenguaje de programación C# (ema :.L A7riMu7o5
f oreach (MethodÌnfo metodo in tipo.GetMethods())
muestra("METODO", metodo);
foreach (EventÌnfo evento in tipo.GetEvents())
muestra("EVENTO", evento);
f oreach (PropertyÌnfo propiedad in tipo.GetProperties())
muestra("PROPÌEDAD", propiedad);
foreach (ConstructorÌnfo constructor in tipo.GetConstructors())
muestra("CONSTRUCTOR",constructor);
}
}
}
static private void muestra(string nombre, MemberÌnfo miembro)
{
foreach (Attribute atributo in Attribute.GetCustomAttributes(miembro))
Console.WriteLine("{0}: {1}", nombre, atributo);
}
}
Lo Tnico Rue Wace el Main() de e57e programa e5 oM7ener el AssembIy Rue repre5en7a el
en5amMlado ac7ual S mo57rar 7odo5 5u5 a7riMu7o5 de en5amMlado% Luego oM7iene 7odo5
lo5 ModuIe5 Rue repre5en7a a lo5 módulo5 de dicWo en5amMladoN S mue57ra 7odo5 lo5
a7riMu7o5 de módulo de cada uno% Adem95N de cada módulo 5e oM7ienen 7odo5 lo5 Type5
Rue repre5en7an a lo5 7ipo5 en 6l deOinido5 S 5e mue57ran 7odo5 5u5 a7riMu7o5b S de cada
7ipo 5e oM7ienen lo5 oMje7o5 reOleUiQo5 Rue repre5en7an a 5u5 diOeren7e5 7ipo5 de
miemMro5 S 5e mue57ran lo5 a7riMu7o5 de cada miemMro%
Apar7e del m67odo Main() en el ejemplo 5e Wan incluido deOinicione5 de numero5o5
a7riMu7o5 de ejemplo aplicaMle5 a diOeren7e5 7ipo5 de elemen7o S 5e Wan di5eminado a lo
largo del Ouen7e Qario5 u5o5 de e57o5 a7riMu7o5% Por elloN la 5alida del programa e5L
@YS.M1L.9/+ @7em5lo@nsam-lado
@YS.M1L.9/+ System.9iagnostics.9e-ugga-le.ttri-ute
M/9?L/ @7em5loModulo
T;4/+ System..ttri-ute?sage.ttri-ute
T;4/+ System..ttri-ute?sage.ttri-ute
T;4/+ System..ttri-ute?sage.ttri-ute
T;4/+ System..ttri-ute?sage.ttri-ute
T;4/+ System..ttri-ute?sage.ttri-ute
T;4/+ @7em5loTi5o
M@T/9/+ @7em5loMPtodo
Nó7e5e Rue apar7e de lo5 a7riMu7o5 u7ili8ado5 en el código Ouen7eN la 5alida del programa
mue57ra Rue el compilador Wa a5ociado a niQel de en5amMlado un a7riMu7o eU7ra llamado
DebuggabIe% E57e a7riMu7o incluSe inOormación 5oMre 5i pueden aplicar5e op7imi8acione5
al compilar 4I( el en5amMlado o 5i 5e Wa de reali8ar una 7ra8a de 5u ejecución% Sin
emMargoN no conQiene Oiar5e de 5u implemen7ación Sa Rue no e579 documen7ado por
!icro5oO7 S puede camMiar en Ou7ura5 Qer5ione5 de la pla7aOorma %NE(%
El lenguaje de programación C# (ema :.L A7riMu7o5
4tributos de compilación
AunRue la maSorVa de lo5 a7riMu7o5 5on in7erpre7ado5 en 7iempo de ejecución por el CL)
u o7ra5 aplicacione5N WaS una 5erie de a7riMu7o5 Rue 7ienen un 5igniOicado e5pecial en C#
S condicionan el proce5o de compilación% E57o5 5on lo5 Rue 5e eUplican a con7inuación%
Atributo System.AttributeUsage
2a Wemo5 Qi57o en e57e mi5mo 7ema Rue 5e u5a para indicar dónde 5e pueden colocar lo5
nueQo5 a7riMu7o5 Rue el programador deOinaN por lo Rue no 5e War9 m95 Wincapi6 en 6l%
Atributo System.ObsoIete
Puede preceder a cualRuier elemen7o de un OicWero de código Ouen7e para indicar Rue Wa
Ruedado oM5ole7o% Admi7e lo5 5iguien7e5 do5 par9me7ro5 5in nomMreL
• "n primer par9me7ro de 7ipo string Rue con7enga una cadena con un men5aje a
mo57rar cuando al compilar 5e de7ec7e Rue 5e Wa u5ado el elemen7o oM5ole7o%
• "n 5egundo par9me7ro de 7ipo booI Rue indiRue 5i 5e Wa de producir un aQi5o o
un error cuando 5e de7ec7e el u5o del elemen7o oM5ole7o% Por deOec7o 5e mue57ra
un aQi5oN pero 5i 5e da Qalor true a e57e par9me7roN el men5aje 5er9 de error%
El 5iguien7e ejemplo mue57ra como u7ili8ar e57e a7riMu7oL
using System;
class Obsoleta
{
[Obsolete(“No usar f(), que está obsoleto.”, true)]
public static void f()
{}
public static void Main()
{
f();
}
}
Cuando 5e compile e57e programaN el compilador emi7ir9 el 5iguien7e men5aje de errorL
obsolete.cs(11,17): error CS0619: 'Obsoleta.f()' is obsolete: No usar f(), que está obsoleto.
Si no 5e WuMie5e e5peciOicado a ObsoIete 5u 5egundo par9me7roN en7once5 el men5aje
5erVa de aQi5o en Qe8 de errorL

obsolete.cs(11,17): warning CS0618: 'Obsoleta.f()' is obsolete: No usar f(), que está obsoleto.
El lenguaje de programación C# (ema :.L A7riMu7o5
Atributo System.Diagnostics.ConditionaI
E57e a7riMu7o 5ólo puede preOijar deOinicione5 de m67odo5N S permi7e deOinir 5i la5
llamada5 al m67odo preOijado 5e Wan de compilar o no% Puede u5ar5e mTl7iple5 Qece5
preOijando a un mi5mo m67odo S 7oma un par9me7ro 5in nomMre de 7ipo string% Sólo 5e
compilar9n aRuella5 llamada5 al m67odo 7ale5 Rue en el momen7o de Wacerla5 e576
deOinida alguna direc7iQa de preproce5ado con el mi5mo nomMre Rue el par9me7ro de
alguno de lo5 a7riMu7o5 ConditionaI Rue preOijen la deOinición de e5e m67odo%
Como 5e QeN e57e a7riMu7o e5 una Muena Oorma de 5impliOicar la e5cri7ura de código Rue
5e deMa compilar condicionalmen7eN Sa Rue eQi7a 7ener Qaria5 direc7iQa5 #if Rue encierren
cada llamada al m67odo cuSa ejecución 5e de5ea con7rolar% Sin emMargoN ConditionaI no
con7rola la compilación de e5e m67odoN 5ino 5ólo la5 llamada5 al mi5mo%
El 5iguien7e ejemplo mue57ra cómo u5ar ConditionaIL
using System;
using System.Diagnostics;
class Condicional
{
[Conditional(“DEBUG”)]
public static void F()
{ Console.WriteLine(“F()”); }
public static void Main()
{
F();
}
}
Sólo 5i compilamo5 el e57e código deOiniendo la con57an7e de preproce5ado DEBUG 5e
mo57rar9 por pan7alla el men5aje F() En ca5o con7rarioN nunca 5e War9 la llamada a F()
HaS Rue preci5ar Rue en realidad ConditionaI no puede preceder a cualRuier deOinición
de m67odoN 5ino Rue en 5u colocación WaS impue57a5 cier7a5 re57riccione5 e5peciale5L
• El m67odo Wa de 7ener un 7ipo de re7orno void% E57o 5e deMe a Rue 5i 7uQie5e o7ro
5e podrVa u5ar 5u Qalor de re7orno como operando en eUpre5ione5N S cuando no
Oue5en compilada5 5u5 llamada5 e5a5 eUpre5ione5 podrVan no 7ener 5en7ido S
producir errore5 de compilación%
• Si 5e aplica a un m67odo Qir7ual 7oda5 5u5 redeOinicione5 lo WeredanN 5iendo
erróneo aplic9r5elo eUplVci7amen7e a una de ella5% E57o deMe a Rue en 7iempo de
compilación puede no 5aMer5e cu9l e5 el Qerdadero 7ipo de un oMje7oN S 5i una5
redeOinicione5 pudie5en 5er condicionale5 S o7ra5 noN no podrVa de7erminar5e al
compilar 5i e5 condicional la Qer5ión del m67odo a la Rue en cada ca5o 5e llame%
• No puede a7riMuir5e a m67odo5 deOinido5 en in7erOace5 ni a implemen7acione5 de
m67odo5 de in7erOace5N pue5 5on 7amMi6n Qir7uale5 S podrVan reimplemen7ar5e%
El lenguaje de programación C# (ema :.L A7riMu7o5
Atributo System.CIsCompIiant
Permi7e e5peciOicar Rue el compilador Wa de a5egurar5e de Rue el en5amMladoN 7ipo de
da7o o miemMro al Rue 5e aplica e5 compa7iMle con el CLS% Ello 5e le indica ISa 5ea por
nomMre o po5icionalmen7eK a 7raQ65 de 5u Tnico par9me7ro booI IsCompIiantN 7al S como
5e mue57ra en el 5iguien7e código ejemploL
using System;
[assembly:CLSCompliant(true)]
public class A
{
public void F(uint x)
{}
public static void Main()
{}
}
Si in7en7a compilarlo 7al cualN oM7endr9 el 5iguien7e men5aje de errorL
error CS(C+ @l ti5o de argumento MuintM no es com5ati-le con CLS
E57o 5e deMe a Rue el 7ipo uint no Oorma par7e del CLSN S en el código 5e e579 u7ili8ando
como par7e de un m67odo pTMlico aTn cuando median7e el a7riMu7o CLSCompIiant 5e e579
indicando Rue 5e de5ea Rue el código 5ea compa7iMle con el CLS% Si 5e le Rui7a5e e57e
a7riMu7oN o 5e die5e el Qalor faIse a 5u par9me7roN o 5e deOinie5en la cla5e A o el m67odo
F() como priQado5N o 5e camMia5e el 7ipo del par9me7ro x a un 7ipo per7enecien7e al CLS
IpeN intKN en7once5 5V Rue compilarVa el código%
Nó7e5e Rue cuando el a7riMu7o CLSCompIiant 5e aplica a niQel de 7odo un en5amMladoN 5e
comprueMa la adecuación al CLS de 7odo5 5u5 7ipo5 de da7o5N mien7ra5 Rue 5i 5olamen7e
5e aplica a un 7ipo de da7oN 5ólo 5e comproMar9 la adecuación al CLS del mi5mob S 5i 7an
5ólo 5e aplica a un miemMroN Tnicamen7e 5e comproMar9 la adecuación al CLS de 657e%
+seudoatributos
La BCL proporciona alguno5 a7riMu7o5 RueN aunRue 5e u5an de la mi5ma manera Rue el
re57oN 5e almacenan de manera e5pecial en lo5 me7ada7o5N como lo WarVan modiOicadore5
como virtuaI o private% Por ello 5e le5 denomina <;105.9347C03.;N S no 5e pueden
recuperar median7e el Sa Qi57o m67odo GetCustomAttributes()N aunRue para alguno5 de
ello5 5e proporcionan o7ro mecani5mo5 de recuperación e5pecVOico5% "n ejemplo e5 el
a7riMu7o DIIImport Rue Sa 5e Wa Qi57o Rue 5e u5a para deOinición de m67odo5 eU7erno5%
A5VN dado el 5iguien7e códigoL
using System.Reflection;
using System.Runtime.ÌnteropServices;
using System;
using System.Diagnostics;
class A
El lenguaje de programación C# (ema :.L A7riMu7o5
{
[DllÌmport("kernel32")][Conditional("DEBUG")]
public static extern void CopyFile(string fuente, string destino);

public static void Main()
{
MethodÌnfo método = typeof(A).GetMethod("CopyFile");
foreach (Attribute atributo in método.GetCustomAttributes(false))
Console.WriteLine(atributo);
}
}
La 5alida Rue 5e oM7endrVa al ejecu7arlo e5 la 5iguien7eL
System.9iagnostics.Conditional.ttri-ute
#onde como 5e puede QerN no 5e Wa recuperado el p5eudoa7riMu7o DIIImport mien7ra5 Rue
el o7ro IConditionaI)N Rue e5 un a7riMu7o normalN 5V Rue lo Wa WecWo%
El lenguaje de programación C# (ema :'L Código in5eguro
TEMA 18: Código inseguro
Concepto de código inseguro
C857=. 72;1=04. e5 7odo aRu6l Oragmen7o de código en C# den7ro del cual e5 po5iMle
Wacer u5o de pun7ero5%
"n <02314. en C# e5 una QariaMle Rue e5 capa8 de almacenar direccione5 de memoria%
1eneralmen7e 5uele u5ar5e para almacenar direccione5 Rue almacenen oMje7o5N por lo
Rue en e5o5 ca5o5 5u 5igniOicado e5 5imilar al de QariaMle5 normale5 de 7ipo5 reOerencia%
Sin emMargoN lo5 pun7ero5 no cuen7an con mucWa5 de la5 re57riccione5 de 657a5 a la Wora
de acceder al oMje7o% Por ejemploN al acceder5e a lo5 elemen7o5 de una 7aMla median7e un
pun7ero no 5e pierde 7iempo en comproMar Rue el Vndice e5peciOicado 5e encuen7re
den7ro de lo5 lVmi7e5 de la 7aMlaN lo Rue permi7e Rue el acce5o 5e Waga m95 r9pidamen7e%
Apar7e de 5u maSor eOicienciaN 7amMi6n WaS cier7o5 ca5o5 en Rue e5 nece5ario di5poner
del código in5eguroN como cuando 5e de5ea Wacer llamada5 a Ouncione5 e5cri7a5 en
lenguaje5 no ge57ionado5 cuSo5 par9me7ro5 7engan Rue 5er pun7ero5%
E5 impor7an7e 5eXalar Rue lo5 pun7ero5 5on una eUcepción en el 5i57ema de 7ipo5 de
%NE(N Sa Rue no deriQan de la cla5e primigenia System.ObjectN por lo Rue no di5pondr9n
de lo5 m67odo5 comune5 a 7odo5 lo5 oMje7o5 S una QariaMle object no podr9 almacenarlo5
I7ampoco eUi57en proce5o5 5imilare5 al MoUing S unMoUing Rue permi7an 5imularloK
Compilación de códigos inseguros
El u5o de pun7ero5 Wace el código m95 procliQe a Oallo5 en 7an7o Rue 5e 5al7a mucWa5 de
la5 medida5 incluida5 en el acce5o normal a oMje7o5N por lo Rue e5 nece5ario incluir
cier7a5 medida5 de 5eguridad Rue eQi7en la in7roducción acciden7al de e57a in5eguridad
La primera medida 7omada con5i57e en Rue eUplVci7amen7e WaS Rue indicar al
compilador Rue de5eamo5 compilar código in5eguro% Para elloN al compilador de lVnea
de comando5 Wemo5 de pa5arle la opción /unsa0eN como 5e mue57ra el ejemploL
csc cBdigo;nseguro.cs *unsa<e
Si no 5e indica la opción unsa<eN cuando el compilador de7ec7e algTn Ouen7e con código
in5eguro producir9 un men5aje de error como el 5iguien7eL
códigoÌnseguro(5,23): error CS0277: unsafe code may only appear if compiling with /unsafe
En ca5o de Rue la compilación 5e QaSa a reali8ar a 7raQ65 de ,i5ual S7udio%NE(N la
Oorma de indicar Rue 5e de5ea compilar código in5eguro e5 ac7iQando la ca5illa V71D 
P4.<143: P9=1;  C.2@7=04937.2 P4.<14371;  B07-5  A--.D 02;9@1 6.51 C-.6E;
El lenguaje de programación C# (ema :'L Código in5eguro
Marcado de códigos inseguros
Apar7e de Oor8ar5e a indicar eUplVci7amen7e Rue 5e de5ea compilar código in5eguroN C#
7amMi6n oMliga a Rue 7odo u5o de código in5eguro Rue 5e Waga en un OicWero Ouen7e
7enga Rue 5er eUplVci7amen7e indicado como 7al% A la5 8ona5 de código donde 5e u5a
código in5eguro 5e le5 denomina 6.231I3.; 72;1=04.;N S C# oOrece Qario5 mecani5mo5
para marcar e57e 7ipo de con7eU7o5%
"na primera po5iMilidad con5i57e en preceder un MloRue de in57ruccione5 de la palaMra
re5erQada unsafe 5iguiendo la 5iguien7e 5in7aUi5L
unsafe <instrucciones>
En el código incluido en <instrucciones> podr9n deOinir5e QariaMle5 de 7ipo5 pun7ero S
podr9 Wacer5e u5o de la5 mi5ma5% Por ejemploL
public void f()
{
unsafe
{
int *x;
}
}
7ra Oorma de deOinir con7eU7o5 in5eguro5 con5i57e en aXadir el modiOicador unsafe a la
deOinición de un miemMroN ca5o en Rue den7ro de 5u deOinición 5e podr9 Wacer u5o de
pun7ero5% A5V e5 po5iMle deOinir campo5 de 7ipo pun7eroN m67odo5 con par9me7ro5 de
7ipo5 pun7eroN e7c% El 5iguien7e ejemplo mue57ra cómo deOinir do5 campo5 de 7ipo
pun7ero% Nó7e5e 5in emMargo Rue no e5 po5iMle deOinir lo5 do5 en una mi5ma lVneaL
struct PuntoÌnseguro
{
public unsafe int *X; // No es válido hacer public unsafe int *X, Y;
public unsafe int *Y; // Tampoco lo es hacer public unsafe int *X, *Y;
}
MQiamen7eN en un m67odo Rue incluSa el modiOicador unsafe no e5 nece5ario preceder
con dicWa palaMra 5u5 MloRue5 de in57ruccione5 in5eguro5%
HaS Rue 7ener en cuen7a Rue el aXadido de modiOicadore5 unsafe e5 comple7amen7e
inocuo% E5 decirN no inOluSe para nada en cómo 5e WaSa de redeOinir S 5i un m67odo
Main() lo 7iene 5igue 5iendo un pun7o de en7rada Q9lido%

"na 7ercera Oorma con5i57e en aXadir el modiOicador unsafe en la deOinición de un 7ipoN
ca5o en Rue 7oda5 la5 deOinicione5 de miemMro5 del mi5mo podr9n incluir código
in5eguro 5in nece5idad de aXadir a cada una el modiOicador unsafe o preceder 5u5
MloRue5 de in57ruccione5 in5egura5 de la palaMra re5erQada unsafe% Por ejemploL
unsafe struct PuntoÌnseguro
{
public int * X, *Y;
}
El lenguaje de programación C# (ema :'L Código in5eguro
(efinición de punteros
Para deOinir una QariaMle pun7ero de un de7erminado 7ipo 5e 5igue una 5in7aUi5 parecida
a la u5ada para deOinir QariaMle5 normale5 5ólo Rue al nomMre del 7ipo 5e le po57pone un
5VmMolo de a57eri5co I*K 5eaN un pun7ero 5e deOine a5VL
<tipo> * <nombrePuntero>;
Por ejemploN una QariaMle pun7ero llamada a Rue pueda almacenar reOerencia5 a
po5icione5 de memoria donde 5e almacenen oMje7o5 de 7ipo int 5e declara a5VL
int * a;
En ca5o de Ruerer5e declarar una 7aMla de pun7ero5N en7once5 el a57eri5co WaS Rue
incluirlo 7ra5 el nomMre del 7ipo pero an7e5 de lo5 corcWe7e5% Por ejemploN una 7aMla de
nomMre t Rue pueda almacenar pun7ero5 a oMje7o5 de 7ipo int 5e declara a5VL
int*[] t;
HaS un 7ipo e5pecial de pun7ero Rue e5 capa8 de almacenar reOerencia5 a oMje7o5 de
cualRuier 7ipo% >57o5 pun7ero5 5e declaran indicando void como <tipo>% Por ejemploL
void * punteroACualquierCosa;
HaS Rue 7ener en cuen7a Rue en realidad lo Rue indica el 7ipo Rue 5e d6 a un pun7ero e5
cu9l e5 el 7ipo de oMje7o5 Rue 5e Wa de con5iderar Rue 5e almacenan en la dirección de
memoria almacenada por el pun7ero% Si 5e le da el Qalor void lo Rue 5e e579 diciendo e5
Rue no 5e de5ea Rue 5e con5idere Rue el pun7ero apun7a a ningTn 7ipo e5pecVOico de
oMje7o% E5 decirN no 5e e579 dando inOormación 5oMre el 7ipo apun7ado%
Se pueden declarar mTl7iple5 QariaMle5 locale5 de 7ipo pun7ero en una mi5ma lVnea% En
e5e ca5o el a57eri5co 5ólo WaS Rue incluirlo an7e5 del nomMre de la primera% Por ejemploL
int * a, b; // a y b son de tipo int * No sería válido haberlas definido como int *a, *b;
HaS Rue 7ener en cuen7a Rue e57a 5in7aUi5 e5pecial para deOinir en una mi5ma deOinición
Qario5 pun7ero5 de un mi5mo 7ipo 5ólo e5 Q9lida en deOinicione5 de QariaMle5 locale5% Al
deOinir campo5 no 5irQe S WaS Rue dar para cada campo una deOinición independien7e%
El recolec7or de Ma5ura no 7iene en cuen7a lo5 da7o5 a lo5 Rue 5e reOerencie con pun7ero5N
pue5 Wa de conocer cu9l e5 el oMje7o al reOerenciado por cada QariaMle S un pun7ero en
realidad no 7iene porRu6 almacenar reOerencia5 a oMje7o5 de ningTn 7ipo en concre7o% Por
ejemploN pueden 7ener5e pun7ero5 int * Rue en realidad apun7en a oMje7o charN o pun7ero5
void * Rue no almacenen inOormación 5oMre el 7ipo de oMje7o al Rue deMerVa con5iderar5e
Rue apun7anN o pun7ero5 Rue apun7e a direccione5 donde no WaSan oMje7o5N e7c%
Como el recolec7or de Ma5ura no 7raMaja con pun7ero5N no e5 po5iMle deOinir pun7ero5 de
7ipo5 Rue 5e almacenen en memoria din9mica o con7engan miemMro5 Rue 5e almacenen
en memoria din9micaN Sa Rue en7once5 podrVa ocurrir Rue un oMje7o 5ólo reOerenciado a
7raQ65 de pun7ero5 5ea de57ruido por con5iderar el recolec7or Rue nadie le reOerenciaMa%
Por elloN 5ólo e5 Q9lido deOinir pun7ero5 de 7ipo5 cuSo5 oMje7o5 5e puedan almacenar
El lenguaje de programación C# (ema :'L Código in5eguro
comple7amen7e en pilaN pue5 la Qida de e57o5 oMje7o5 no e579 con7rolada por el recolec7or
de Ma5ura 5ino Rue 5e de57ruSen cuando 5e aMandona el 9mMi7o donde Oueron deOinido5%
En concre7oN lo5 Tnico5 pun7ero5 Q9lido5 5on aRuello5 Rue apun7en a 7ipo5 Qalor M95ico5N
enumeracione5 o e57ruc7ura5 Rue no con7engan campo5 de 7ipo5 reOerencia5% (amMi6n
pueden deOinir5e pun7ero5 a 7ipo5 pun7eroN como 5e mue57ra en el 5iguien7e ejemplo de
declaración de un pun7ero a pun7ero5 de 7ipo int llamando punteroApunterosL
int ** punteroApunteros;
MQiamen7e la anidación puede Wacer5e a cualRuier niQel de proOundidadN pudi6ndo5e
deOinir pun7ero5 a pun7ero5 a pun7ero5N o pun7ero5 a pun7ero5 a pun7ero5 a pun7ero5N e7c%
Manipulación de punteros
Obtención de dirección de memoria. Operador &
Para almacenar una reOerencia a un oMje7o en un pun7ero 5e puede aplicar al oMje7o el
operador preOijo &N Rue lo Rue Wace e5 deQolQer la dirección Rue en memoria ocupa el
oMje7o 5oMre el Rue 5e aplica% "n ejemplo de 5u u5o para iniciali8ar un pun7ero e5L
int x =10;
int * px = &x;
E57e operador no e5 aplicaMle a eUpre5ione5 con57an7e5N pue5 657a5 no 5e almacenan en
ninguna dirección de memoria e5pecVOica 5ino Rue 5e incru57an en la5 in57ruccione5% Por
elloN no e5 Q9lido Wacer direc7amen7eL
int px = &10; // Error 10 no es una variable con dirección propia
(ampoco e5 Q9lido aplicar & a campo5 readonIyN pue5 5i e57o5 pudie5en 5er apun7ado5
por pun7ero5 5e correrVa el rie5go de poderlo5 modiOicar Sa Rue a 7raQ65 de un pun7ero 5e
accede a memoria direc7amen7eN 5in 7ener5e en cuen7a 5i en la po5ición accedida WaS
algTn oMje7oN por lo Rue mucWo meno5 5e con5iderar9 5i 657e e5 de 5ólo lec7ura%
Lo Rue e5 5V Q9lido e5 almacenar en un pun7ero e5 la dirección de memoria apun7ada por
o7ro pun7ero% En e5e ca5o amMo5 pun7ero5 apun7arVan al mi5mo oMje7o S la5
modiOicacione5 a 657e reali8ada5 a 7raQ65 de un pun7ero 7amMi6n aOec7arVan al oMje7o
Qi57o por el o7roN de Oorma 5imilar a como ocurre con la5 QariaMle5 normale5 de 7ipo5
reOerencia% E5 m95N lo5 operadore5 relacionale5 7Vpico5 I==N !=N <N >N <= S >=K 5e Wan
redeOinido para Rue cuando 5e apliRuen en7re do5 pun7ero5 de cuale5Ruiera do5 7ipo5 lo
Rue 5e compare 5ean la5 direccione5 de memoria Rue e57o5 almacenan% Por ejemploL
int x = 10;
int px = &x;
int px2 = px; // px y px2 apuntan al objeto almacenado en x
Console.WriteLine( px == px2); // Ìmprime por pantalla True
En realidad la5 QariaMle5 5oMre la5 Rue 5e apliRue & no 7ienen porRu6 e57ar iniciali8ada5%
Por ejemploN e5 Q9lido WacerL
private void f()
El lenguaje de programación C# (ema :'L Código in5eguro
{
int x;
unsafe
{ int px = &x;}
}
E57o 5e deMe a Rue uno de lo5 principale5 u5o5 de lo5 pun7ero5 en C# e5 poderlo5 pa5ar
como par9me7ro5 de Ouncione5 no ge57ionada5 Rue e5peren reciMir pun7ero5% Como
mucWa5 de e5a5 Ouncione5 Wan 5ido programada5 para iniciali8ar lo5 con7enido5 de lo5
pun7ero5 Rue 5e le5 pa5anN pa5arle5 pun7ero5 iniciali8ado5 implicarVa perder 7iempo
innece5ariamen7e en iniciali8arlo5%
Acceso a contenido de puntero. Operador *
"n pun7ero no almacena direc7amen7e un oMje7o 5ino Rue 5uele almacenar la dirección
de memoria de un oMje7o Io 5eaN apun7a a un oMje7oK Para oM7ener a par7ir de un pun7ero
el oMje7o al Rue apun7a WaS Rue aplicarle al mi5mo el operador preOijo *N Rue deQuelQe el
oMje7o apun7ado% Por ejemploN el 5iguien7e código imprime en pan7alla un :+L
int x = 10;
int * px= &x;
Console.WriteLine(*px);
E5 po5iMle en un pun7ero almacenar nuII para indicar Rue no apun7a a ninguna dirección
Q9lida% Sin emMargoN 5i luego 5e in7en7a acceder al con7enido del mi5mo a 7raQ65 del
operador * 5e producir9 generalmen7e una eUcepción de 7ipo NuIIReferenceException
IaunRue realmen7e e57o depende de la implemen7ación del lenguajeK Por ejemploL
int * px = null;
Console.WriteLine(*px); // Produce una NullReferenceException
No 7iene 5en7ido aplicar * a un pun7ero de 7ipo void * Sa Rue e57o5 pun7ero5 no
almacenan inOormación 5oMre el 7ipo de oMje7o5 a lo5 Rue apun7an S por 7an7o no e5
po5iMle recuperarlo5 a 7raQ65 de lo5 mi5mo5 Sa Rue no 5e 5aMe cuan7o e5pacio en
memoria a par7ir de la dirección almacenada en el pun7ero ocupa el oMje7o apun7ado SN
por 7an7oN no 5e 5aMe cuan7a memoria WaS Rue leer para oM7enerlo%
Acceso a miembro de contenido de puntero. Operador ->
Si un pun7ero apun7a a un oMje7o e57ruc7ura Rue 7iene un m67odo F() 5erVa po5iMle
llamarlo a 7raQ65 del pun7ero conL
(*objeto).F();
Sin emMargoN como llamar a oMje7o5 apun7ado5 por pun7ero5 e5 algo Ma57an7e WaMi7ualN
para Oacili7ar la 5in7aUi5 con la Rue Wacer e57o 5e Wa incluido en C# el operador ->N con el
Rue la in57rucción an7erior 5e e5criMirVa a5VL
objeto->f();
El lenguaje de programación C# (ema :'L Código in5eguro
E5 decirN del mi5mo modo Rue el operador . permi7e acceder a lo5 miemMro5 de un
oMje7o reOerenciado por una QariaMle normalN -> permi7e acceder a lo5 miemMro5 de un
oMje7o reOerenciado por un pun7ero% En generalN un acce5o de la Oorma O -> M e5
eRuiQalen7e a Wacer (*O).M. Por 7an7oN al igual Rue e5 incorrec7o aplicar * 5oMre pun7ero5
de 7ipo void *N 7amMi6n lo e5 aplicar ->
Conversiones de punteros
#e 7odo lo Qi57o Wa57a aWora parece Rue no 7iene mucWo 5en7ido el u5o de pun7ero5 de
7ipo void * Pue5 MienN una u7ilidad de e57e 7ipo de pun7ero5 e5 Rue pueden u5ar5e como
almac6n de pun7ero5 de cualRuier o7ro 7ipo Rue luego podr9n 5er recuperado5 a 5u 7ipo
original u5ando el operador de conQer5ión eUplVci7a% E5 decirN igual Rue lo5 oMje7o5 de
7ipo object pueden almacenar implVci7amen7e oMje7o5 de cualRuier 7ipoN lo5 pun7ero5 void
* pueden almacenar pun7ero5 de cualRuier 7ipo S 5on T7ile5 para la e5cri7ura de m67odo5
Rue puedan acep7ar par9me7ro5 de cualRuier 7ipo de pun7ero%
A diOerencia de lo Rue ocurre en7re QariaMle5 normale5N la5 conQer5ione5 en7re pun7ero5
5iempre 5e permi7enN al reali8arla5 nunca 5e comprueMa 5i 5on Q9lida5% Por ejemploL
char c = 'A';
char* pc = &c;
void* pv = pc;
int* pi = (int*)pv;
int i = *pi; // Almacena en 16 bits del char de pi + otros 16 indeterminados
Console.WriteLine(i);
*pi = 123456; // Machaca los 32 bits apuntados por pi
En e57e código pi e5 un pun7ero a un oMje7o de 7ipo int I*& Mi75KN pero en realidad el
oMje7o al Rue apun7a e5 de 7ipo char I:= Mi75KN Rue e5 m95 peRueXo% El Qalor Rue 5e
almacene en i e5 en principio indeOinidoN pue5 depende de lo Rue WuMie5e en lo5 := Mi75
eU7ra5 re5ul7an7e5 de 7ra7ar pv como pun7ero a int cuando en realidad apun7aMa a un char%

#el mi5mo modoN conQer5ione5 en7re pun7ero5 pueden 7erminar produciendo Rue un
pun7ero apun7e a un oMje7o de maSor 7amaXo Rue lo5 oMje7o5 del 7ipo del pun7ero% En
e57o5 ca5o5N el pun7ero apun7arVa a lo5 Mi75 meno5 5igniOica7iQo5 del oMje7o apun7ado%

(amMi6n e5 po5iMle reali8ar conQer5ione5 en7re pun7ero5 S 7ipo5 M95ico5 en7ero5% La
conQer5ión de un pun7ero en un 7ipo en7ero deQuelQe la dirección de memoria apun7ada
por el mi5mo% Por ejemploN el 5iguien7e código mue57ra por pan7alla la dirección de
memoria apun7ada por pxL
int x = 10;
int *px = &x;
Console.WriteLine((int) px);
Por 5u par7eN conQer7ir cualRuier Qalor en7ero en un pun7ero 7iene el eOec7o de deQolQer
un pun7ero Rue apun7e a la dirección de memoria indicada por e5e nTmero% Por
ejemploN el 5iguien7e código Wace Rue px apun7e a la dirección :+&0 S luego imprime
por pan7alla la dirección de memoria apun7ada por px IRue 5er9 :+&0KL
int *px = (int *) 10;
Console.WriteLine((int) px);
El lenguaje de programación C# (ema :'L Código in5eguro
Nó7e5e Rue aunRue en un principio e5 po5iMle Wacer Rue un pun7ero almacene cualRuier
dirección de memoriaN 5i dicWa dirección no per7enece al mi5mo proce5o Rue el código
en Rue 5e u5e el pun7ero 5e producir9 un error al leer el con7enido de dicWa dirección% El
7ipo de error Wa producir no 5e indica en principio en la e5peciOicación del lenguajeN pero
la implemen7ación de !icro5oO7 lan8a una reOerencia NuIIReferenceException% Por
ejemploN el 5iguien7e código produce una eUcepción de dicWo 7ipo al ejecur7a5eL
using System;
class AccesoÌnválido
{
public unsafe static void Main()
{
int * px = (int *) 100;
Console.Write(*px); // Se lanza NullReferenceException
}
}
Aritmética de punteros
Lo5 pun7ero5 5e 5uelen u5ar para recorrer 7aMla5 de elemen7o5 5in nece5idad de 7ener Rue
comproMar5e Rue el Vndice al Rue 5e accede en cada momen7o 5e encuen7ra den7ro de lo5
lVmi7e5 de la 7aMla% Por elloN lo5 operadore5 ari7m67ico5 deOinido5 para lo5 pun7ero5 e579n
orien7ado5 a Oacili7ar e57e 7ipo de recorrido5%
HaS Rue 7ener en cuen7a Rue 7odo5 lo5 operadore5 ari7m67ico5 aplicaMle5 a pun7ero5
dependen del 7amaXo del 7ipo de da7o apun7adoN por lo Rue no 5on aplicaMle5 a pun7ero5
void * Sa Rue e57o5 no almacenan inOormación 5oMre dicWo 7ipo% E5o5 operadore5 5onL
• ++ S --L El operador ++ no 5uma uno a la dirección almacenada en un pun7eroN
5ino Rue le 5uma el 7amaXo del 7ipo de da7o al Rue apun7a% A5VN 5i el pun7ero
apun7aMa a un elemen7o de una 7aMla pa5ar9 a apun7ar al 5iguien7e Ilo5 elemen7o5
de la5 7aMla5 5e almacenan en memoria con5ecu7iQamen7eK #el mi5mo modoN --
re57a a la dirección almacenada en el pun7ero el 7amaXo de 5u 7ipo de da7o% Por
ejemploN una 7aMla de :++ elemen7o5 a cuSo primer elemen7o inicialmen7e
apun7a5e pt podrVa recorrer5e a5VL
for (int i=0; i<100; i++)
Console.WriteLine(“Elemento{0}={1}”, i, (*p)++);
El proMlema Rue puede plan7ear en cier7o5 ca5o5 el u5o de ++ S -- e5 Rue Wacen
Rue al Oinal del recorrido el pun7ero deje de apun7ar al primer elemen7o de la
7aMla% Ello podrVa 5olucionar5e almacenando 5u dirección en o7ro pun7ero an7e5
de iniciar el recorrido S re57aur9ndola a par7ir de 6l 7ra5 Oinali8arlo%
• + S -L Permi7en 5olucionar el proMlema de ++ S -- an7e5 comen7ado de una Oorma
m95 cómoda Ma5ada en 5umar o re57ar un cier7o en7ero a lo5 pun7ero5% + deQuelQe
la dirección re5ul7an7e de 5umar a la dirección almacenada en el pun7ero 5oMre el
Rue 5e aplica el 7amaXo del 7ipo de dicWo pun7ero 7an7a5 Qece5 como indiRue el
en7ero 5umado% - 7iene el mi5mo 5igniOicado pero r e57ando dicWa can7idad en Qe8
de 5umarla% Por ejemploN u5ando + el Mucle an7erior podrVa re5criMir5e a5VL
El lenguaje de programación C# (ema :'L Código in5eguro
for (int i=0; i<100; i++)
Console.WriteLine(“Elemento{0}={1}”, i, *(p+i));
El operador - 7amMi6n puede aplicar5e en7re do5 pun7ero5 de un mi5mo 7ipoN ca5o
en Rue deQuelQe un Iong Rue indica cu9n7o5 elemen7o5 del 7ipo del pun7ero
pueden almacenar5e en7re la5 direccione5 de lo5 pun7ero5 indicado5%
• []L #ado Rue e5 Orecuen7e u5ar + para acceder a elemen7o5 de 7aMla5N 7amMi6n 5e
Wa redeOinido el operador [] para Rue cuando 5e apliRue a una 7aMla Waga lo
mi5mo S deQuelQa el oMje7o con7enido en la dirección re5ul7an7e% 5ea *(p+i) e5
eRuiQalen7e a p[i]N con lo Rue el código an7erior eRuiQale aL
for (int i=0; i<100; i++)
Console.WriteLine(“Elemento{0}={1}”, i, p[i]);
No WaS Rue conOundir el acce5o a lo5 elemen7o5 de una 7aMla aplicando [] 5oMre
una QariaMle de 7ipo 7aMla normal con el acce5o a 7raQ65 de un pun7ero Rue apun7e
a 5u primer elemen7o% En el 5egundo ca5o no 5e comprueMa 5i el Vndice indicado
5e encuen7ra den7ro del rango de la 7aMlaN con lo Rue el acce5o e5 m95 r9pido pero
7amMi6n m95 procliQe a errore5 diOVcile5 de de7ec7ar%
/inalmen7eN re5pec7o a la ari7m67ica de pun7ero5N WaS Rue 7ener en cuen7a Rue por
eOicienciaN en la5 operacione5 con pun7ero5 nunca 5e comprueMa 5i 5e producen
de5Mordamien7o5N S en ca5o de producir5e 5e 7runcan lo5 re5ul7ado5 5in aQi5ar5e de ello
median7e eUcepcione5% Por e5o WaS Rue 7ener e5pecial cuidado al operar con pun7ero5 no
5ea Rue un de5Mordamien7o no de7ec7ado cau5e errore5 de cau5a5 diOVcile5 de encon7rar%
%peradores relacionados con código inseguro
Operador sizeof. Obtención de tamaño de tipo
El operador unario S preOijo sizeof deQuelQe un oMje7o int con el 7amaXo en MS7e5 del
7ipo de da7o 5oMre el Rue 5e aplica% Sólo puede aplicar5e en con7eU7o5 in5eguro5 S 5ólo a
7ipo5 de da7o5 para lo5 Rue 5ea po5iMle deOinir pun7ero5N 5iendo 5u 5in7aUi5 de u5oL
sizeof(<tipo>)
Cuando 5e aplica a 7ipo5 de da7o5 M95ico5 5u re5ul7ado e5 5iempre con57an7e% Por elloN el
compilador op7imi8a dicWo5 u5o5 de sizeof 5u57i7uS6ndolo5 in7ernamen7e por 5u Qalor
IinliningK S con5iderando Rue el u5o del operador e5 una eUpre5ión con57an7e% E57a5
con57an7e5 corre5pondien7e5 a lo5 7ipo5 M95ico5 5on la5 indicada5 en la (aMla :+L
T7<.; R1;0-395.
sbyte, byte, bool 1
short, ushort, char 2
int, uint, float 4
long, ulong, double 8
Tabla 10: Resultados de sizeof para tipos básicos
El lenguaje de programación C# (ema :'L Código in5eguro
Para el re57o de 7ipo5 a lo5 Rue 5e le5 puede aplicarN sizeof no 7iene porRu6 deQolQer un
re5ul7ado con57an7e 5ino Rue lo5 compiladore5 pueden alinear en memoria la5 e57ruc7ura5
incluSendo Mi75 de relleno cuSo nTmero S Qalore5 5ean en principio inde7erminado% Sin
emMargoN el Qalor deQuel7o por sizeof 5iempre deQolQer9 el 7amaXo en memoria eUac7o
del 7ipo de da7o 5oMre el Rue 5e apliRueN incluSendo Mi75 de relleno 5i lo5 7uQie5e%
Nó7e5e Rue e5 O9cil implemen7ar lo5 operadore5 de ari7m67ica de pun7ero5 u5ando sizeof%
Para elloN ++ 5e deOinirVa como aXadir a la dirección almacenada en el pun7ero el
re5ul7ado de aplicar sizeof a 5u 7ipo de da7oN S -- con5i57irVa en re57arle dicWo Qalor% Por
5u par7eN el operador + u5ado de la Oorma P + N IP e5 un pun7ero de 7ipo T S N un en7eroK
lo Rue deQuelQe e5 el re5ul7ado de aXadir al pun7ero sizeof(T)*NN S P ÷ N deQuelQe el
re5ul7ado de re57arle sizeof(T)*N% Por Tl7imoN 5i 5e u5a - para re57ar do5 pun7ero5 P1 S P2
de 7ipo TN ello e5 eRuiQalen7e a calcular I((long)P1) - ((long)P2)))/sizeof(T)
Operador stackaIIoc. Creación de tabIas en piIa.
Cuando 5e 7raMaja con pun7ero5 puede re5ul7ar in7ere5an7e re5erQar una 8ona de memoria
en la pila donde po57eriormen7e 5e puedan ir almacenando oMje7o5% Preci5amen7e para
e5o e579 el operador stackaIIocN Rue 5e u5a 5igui6ndo5e la 5iguien7e 5in7aUi5L
stackaIIoc <tipo>[<número>]
stackaIIoc re5erQa en pila el e5pacio nece5ario para almacenar con7iguamen7e el nTmero
de oMje7o5 de 7ipo <tipo> indicado en <número> Ire5erQa sizeof(<tipo>)*<número> MS7e5K S
deQuelQe un pun7ero a la dirección de inicio de e5e e5pacio% Si no Rueda5e memoria
liMre 5uOicien7e para re5erQarlo 5e producirVa una eUcepción
System.StackOverfIowException.
stackaIIoc 5ólo puede u5ar5e para iniciali8ar pun7ero5 declarado5 como QariaMle5 locale5
S 5ólo en el momen7o de 5u declaración%% Por ejemploN un pun7ero pt Rue apun7a5e al
principio de una región con capacidad para :++ oMje7o5 de 7ipo int 5e declararVa conL
int * pt = stackalloc int[100];
Sin emMargoN no 5erVa Q9lido WacerL
int * pt;
pt = stackalloc int[100]; // ERROR: Sólo puede usarse stackalloc en declaraciones
AunRue pueda parecer Rue stackaIIoc 5e u5a como 5u57i7u7o de new para crear 7aMla5 en
pila en lugar de en memoria din9micaN no WaS Rue conOundir5eL stackaIIoc 5ólo re5erQa
un e5pacio con7iguo en pila para oMje7o5 de un cier7o 7ipoN pero ello no 5igniOica Rue 5e
cree una 7aMla en pila% La5 7aMla5 5on oMje7o5 Rue Weredan de System.Array S cuen7an
con lo5 miemMro5 Weredado5 de e57a cla5e S de objectN pero regione5 de memoria en pila
re5erQada5 por stackaIIoc no% Por ejemploN el 5iguien7e código e5 inQ9lido%
int[] tabla;
int * pt = stackalloc int[100];
tabla = *pt; // ERROR: El contenido de pt es un int, no una tabla (int[])
Console.WriteLine(pt->Length); // ERROR: pt no apunta a una tabla
El lenguaje de programación C# (ema :'L Código in5eguro
Sin emMargoN gracia5 a Rue como Sa 5e Wa comen7ado en e57e 7ema el operador [] e579
redeOinido para 7raMajar con pun7ero5N podemo5 u5arlo para acceder a lo5 diOeren7e5
oMje7o5 almacenado5 en la5 regione5 re5erQada5 con stackaIIoc como 5i Oue5en 7aMla5%
Por ejemploN e57e código guarda en pila lo5 :++ primero5 en7ero5 S luego lo5 imprimeL
class Stackalloc
{
public unsafe static void Main()
{
int * pt = stackalloc int[100];
for (int i=0; i<100; i++)
pt[i] = i;
for(int i=0; i<100; i++)
System.Console.WriteLine(pt[i]);
}
}
Nó7e5e RueN a diOerencia de lo Rue ocurrirVa 5i pt Oue5e una 7aMlaN en lo5 acce5o5 con pt[i]
no 5e comprueMa Rue i no 5upere el nTmero de oMje7o5 para lo5 Rue 5e Wa re5erQado
memoria% Como con7rapar7idaN 5e 7iene el inconQenien7e de Rue al no 5er pt una 7aMla no
cuen7a con lo5 m67odo5 7Vpico5 de 657a5 S no puede u5ar5e foreach para recorrerla%
7ra Qen7aja de la 5imulación de 7aMla5 con stackaIIoc e5 Rue 5e re5erQa la memoria
mucWo m95 r9pido Rue el 7iempo Rue 5e 7ardarVa en crear una 7aMla% E57o 5e deMe a Rue
re5erQar la memoria nece5aria en pila e5 7an 5encillo como incremen7ar el pun7ero de
pila en la can7idad corre5pondien7e al 7amaXo a re5erQarN S no WaS Rue perder 7iempo en
5olici7ar memoria din9mica% Adem95N stackaIIoc no pierde 7iempo en iniciali8ar con
algTn Qalor el con7enido de la memoriaN por lo Rue la _7aMla` 5e crea an7e5 pero a co57a
de Rue luego 5ea m95 in5eguro u5arla Sa Rue WaS Rue 7ener cuidado con no leer 7ro8o5 de
ella an7e5 de a5ignarle5 Qalore5 Q9lido5%
:i&ación de variables apuntadas
AunRue un pun7ero 5ólo puede apun7ar a da7o5 de 7ipo5 Rue puedan almacenar5e
comple7amen7e en pila Io 5eaN Rue no 5ean ni oMje7o5 de 7ipo5 reOerencia ni e57ruc7ura5
con miemMro5 de 7ipo5 reOerenciaKN nada garan7i8a Rue lo5 oMje7o5 apun7ado5 en cada
momen7o e576n almacenado5 en pila% Por ejemploN la5 QariaMle5 e5797ica5 de 7ipo int o lo5
elemen7o5 de una 7aMla de 7ipo int 5e almacenan en memoria din9mica aTn cuando 5on
oMje7o5 a lo5 Rue 5e le5 puede apun7ar con pun7ero5%
Si un pun7ero almacena la dirección de un oMje7o almacenado en memoria din9mica S el
recolec7or de Ma5ura camMia al oMje7o de po5ición 7ra5 una compac7ación de memoria
re5ul7an7e de una recolecciónN el Qalor almacenado en el pun7ero dejar9 de 5er Q9lido%
Para eQi7ar Rue e57o ocurra 5e puede u5ar la in57rucción fixedN cuSa 5in7aUi5 de u5o e5L
fixed(<tipo> <declaraciones>)
<instrucciones>
El 5igniOicado de e57a in57rucción e5 el 5iguien7eL 5e a5egura Rue duran7e la ejecución del
MloRue de <instrucciones> indicado el recolec7or de Ma5ura nunca camMie la dirección de
ninguno de lo5 oMje7o5 apun7ado5 por lo5 pun7ero5 de 7ipo <tipo> declarado5% E57a5
El lenguaje de programación C# (ema :'L Código in5eguro
<declaraciones> 5iempre Wan de incluir una e5peciOicación de Qalor inicial para cada
pun7ero declaradoN S 5i 5e declaran Qario5 5e Wan de 5eparar con coma5%
Lo5 pun7ero5 declarado5 en <declaraciones> 5ólo eUi57ir9n den7ro de <instrucciones>N S al
5alir de dicWo MloRue 5e de57ruir9n% Adem95N 5i 5e le5 indica como Qalor inicial una 7aMla
o cadena Rue Qalga nuII 5al7ar9 una NuIIReferenceException% (amMi6n WaS Rue 5eXalar
Rue aunRue 5ólo pueden declara5e pun7ero5 de un mi5mo 7ipo en cada fixedN 5e puede
5imular O9cilmen7e la declaración de pun7ero5 de di57in7o5 7ipo5 anidando Qario5 fixed%
Por o7ro ladoN lo5 pun7ero5 declarado5 en <declaraciones> 5on de 5ólo lec7uraN Sa Rue 5i
no podrVa camMi9r5ele5 5u Qalor por el de una dirección de memoria no Oijada S conducir
ello a errore5 diOVcile5 de de7ec7ar%

"n u5o Orecuen7e de fixed con5i57e en apun7ar a oMje7o5 de 7ipo5 para lo5 Rue 5e puedan
declarar pun7ero5 pero Rue e576n almacenado5 en 7aMla5N Sa Rue ello no 5e puede Wacer
direc7amen7e deMido a Rue la5 7aMla5 5e almacenan en memoria din9mica% Por ejemploN
copiar u5ando pun7ero5 una 7aMla de :++ elemen7o5 de 7ipo int en o7ra 5e WarVa a5VL
class CopiaÌnsegura
{
public unsafe static void Main()
{
int[] tOrigen = new int[100];
int[] tDestino = new int[100];
fixed (int * pOrigen=tOrigen, pDestino=tDestino)
{
for (int i=0; i<100; i++)
pOrigen[i] = pDestino[i];
}
}
}
Como puede deducir5e del ejemploN cuando 5e iniciali8a un pun7ero con una 7aMlaN la
dirección almacenada en el pun7ero en la 8ona <declaraciones> del fixed e5 la del primer
elemen7o de la 7aMla I7amMi6n podrVa WaMer5e WecWo pOrigen = &tOrigen[0]KN S luego e5
po5iMle u5ar la ari7m67ica de pun7ero5 para acceder al re57o de elemen7o5 a par7ir de la
dirección del primero Sa Rue 657o5 5e almacenan con5ecu7iQamen7e%
Al igual Rue 7aMla5N 7amMi6n puede u5ar5e fixed para recorrer cadena5% En e57e ca5o lo
Rue WaS Rue Wacer e5 iniciali8ar un pun7ero de 7ipo char * con la dirección del primer
car9c7er de la cadena a la Rue 5e de5ee Rue apun7e 7al S como mue57ra e57e ejemplo en el
Rue 5e camMia el con7enido de una cadena “Hola” por “XXXX”L
class CadenaÌnsegura
{
public unsafe static void Main()
{
string s=”Hola”;
Console.WriteLine(“Cadena inicial: {0}”, s);
fixed (char * ps=s)
{
for (int i=0;i<s.Length;i++)
ps[i] = 'A';
El lenguaje de programación C# (ema :'L Código in5eguro
}
Console.WriteLine(“Cadena final: {0}”, s);
}
}
La 5alida por pan7alla de e57e Tl7imo programa e5L
Hola
....
La Qen7aja de modiOicar la cadena median7e pun7ero5 e5 Rue 5in ello5 no 5erVa po5iMle
Wacerlo Sa Rue el indi8ador deOinido para lo5 oMje7o5 string e5 de 5ólo lec7ura%
Cuando 5e modiOiRuen cadena5 median7e pun7ero5 WaS Rue 7ener en cuen7a RueN aunRue
para Oacili7ar la comunicación con código no ge57ionado e5cri7o en C o CPP la5 cadena5
en C# 7amMi6n acaMan en el car9c7er '###BOT_TEXT###'N no 5e recomienda conOiar en ello al recorrerla5
con pun7ero5 porRue '###BOT_TEXT###' 7amMi6n puede u5ar5e como car9c7er de la cadena% Por elloN e5
mejor Wacer como en el ejemplo S de7ec7ar 5u Oinal a 7raQ65 de 5u propiedad Length%
HaS Rue 5eXalar Rue como fixed proQoca Rue no pueda camMiar5e de dirección a cier7o5
oMje7o5 almacenado5 en memoria din9micaN ello puede producir la generación de Wueco5
en memoria din9micaN lo Rue 7iene do5 eOec7o5 muS nega7iQo5L
• El recolec7or de Ma5ura e579 op7imi8ado para 7raMajar con memoria compac7adaN
pue5 5i 7odo5 lo5 oMje7o5 5e almacenan con5ecu7iQamen7e en memoria din9mica
crear uno nueQo e5 7an 5encillo como aXadirlo 7ra5 el Tl7imo% Sin emMargoN fixed
rompe e57a con5ecu7iQidad S la creación de oMje7o5 en memoria din9mica den7ro
de e57e 7ipo de in57ruccione5 e5 m95 len7a porRue WaS Rue Mu5car Wueco5 liMre5%
• Por deOec7oN al eliminar5e oMje7o5 de memoria duran7e una recolección de Ma5ura
5e compac7a la memoria Rue Rueda ocupada para Rue 7odo5 lo5 oMje7o5 5e
almacenen en memoria din9mica% Hacer e57o den7ro de 5en7encia5 fixed e5 m95
len7o porRue WaS Rue 7ener en cuen7a 5i cada oMje7o 5e puede o no moQer%
Por e57a5 ra8one5 e5 conQenien7e Rue el con7enido del MloRue de in57ruccione5 de una
5en7encia fixed 5ea el mVnimo po5iMleN para Rue a5V el fixed 5e ejecu7e lo an7e5 po5iMle%
El lenguaje de programación C# (ema :0L #ocumen7ación -!L
Tema 19: Documentación XML
Concepto $ utilidad de la documentación ;ML
La documen7ación de lo5 7ipo5 de da7o5 creado5 5iempre Wa 5ido una de la5 7area5 m95
pe5ada5 S aMurrida5 a la5 Rue un programador 5e Wa 7enido Rue enOren7ar duran7e un
proSec7oN lo Rue Wa WecWo Rue mucWa5 Qece5 5e e5criMa de manera de5cuidada S poco
conci5a o Rue inclu5o Rue no 5e e5criMa en aM5olu7o% Sin emMargoN e5criMirla e5 una 7area
muS impor7an7e 5oMre 7odo en un enOoRue de programación orien7ada a componen7e5 en
7an7o Rue lo5 componen7e5 de5arrollado5 mucWa5 Qece5 Qan a reu7ili8ado5 por o7ro5% E
inclu5o para el propio creador del componen7e puede re5ul7ar de ine57imaMle aSuda 5i en
el Ou7uro 7iene Rue modiOicarlo o u5arlo S no recuerda eUac7amen7e cómo lo implemen7ó%
Para Oacili7ar la pe5ada 7area de e5criMir la documen7aciónN el compilador de C# e5 capa8
de generarla au7om97icamen7e a par7ir de lo5 comen7ario5 Rue el progamador e5criMa en
lo5 OicWero5 de código Ouen7e% A5V 5e 1A739 349C9>94 6.2 5.; 37<.; 51 5.60?123.; por
5eparado IOuen7e5 S documen7aciónK Rue deMan ac7uali8ar5e 5imul79neamen7e para eQi7ar
inco5i57encia5 deriQada5 de Rue por error eQolucionen por 5eparado%
El compilador genera la documen7ación en @.4?93. 'ML con la idea de Rue 5ea
O9cilmen7e legiMle para cualRuier aplicación% Por ejemploN el 5i57ema I231--7;12;1 51
VS.NET -9 9<4.A16J9 para proporcionar la5 de5cripcione5 emergen7e5 de lo5 7ipo5 de
da7o5 S miemMro5 Rue 5e QaSan u7ili8ando en el código% Para elloN e5pera encon7rar e57a
documen7ación en el mi5mo direc7orio Rue lo5 en5amMlado5 a lo5 Rue 5e reOerencieN con
el mi5mo nomMre Rue e57o5 S eU7en5ión .I?-% El 5iguien7e ejemplo mue57ra a ,S%NE(
aproQecWando e57a documen7ación para de5criMir un par9me7ro b de un m67odo F()L
El lenguaje de programación C# (ema :0L #ocumen7ación -!L
Por 5u par7eN para Oacili7ar la legiMilidad de e57a documen7ación a Wumano5 Ma57arVa
aXadir al -!L generado una J.>9 51 1;37-. 'SL o u5ar u7ili8ar aplicación e5pecVOica
encargada de conQer7irla a un Oorma7o O9cilmen7e legiMle por Wumano5N como H(!LN el
P#/ de AcroMa7 )eaderN el %doc de !icro5oO7 <ord o el %cWm de la aSuda de <indoY5%
AunRue eUplicar -!L S -SL Rueda Ouera del alcance del liMroN a con7inuación
re5umir9n MreQemen7e 7an7o -!L como la Oorma de aplicar Woja5 -SL a OicWero5 -!L%
ntroducción a ;ML
An7e5 de con7inuar e5 nece5ario Wacer una peRueXa in7roducción a -!L Sa Rue e5 el
lenguaje en Rue 5e Wan de e5criMir lo5 comen7ario5 e5peciale5 de documen7ación% Si Sa
conoce e57e lenguaje puede 5al7ar5e e57e epVgraOe%
'ML IEU7en5iMle !ar]up LanguageK e5 un ?139-12=09>1 51 137/0139;N lo Rue 5igniOica
Rue e5 un lenguaje Rue 5e u7ili8a para deOinir lenguaje5 de e7iRue7a5% A cada lenguaje
creado con -!L 5e le denomina A.69C0-947. 'MLN S la documen7ación generada por
el compilador de C# e579 e5cri7a en un QocaMulario de e57e 7ipo%
Lo5 comen7ario5 a par7ir de lo5 Rue el compilador generar9 la documen7ación Wan de
e5criMir5e en -!LN por lo Rue Wan de re5pe7ar la5 5iguien7e5 regla5 comune5 a 7odo
documen7o -!L Mien OormadoL

:% La inOormación Wa de incluir5e den7ro de 137/0139;N Rue 5on e57ruc7ura5 de la OormaL
<<etiqueta>> <contenido> </<etiqueta>>
En <etiqueta> 5e indica cu9l e5 el nomMre de la e7iRue7a a u5ar% Por ejemploL
<EtiquetaEjemplo> Esto es una etiqueta de ejemplo </EtiquetaEjemplo>
Como <contenido> de una e7iRue7a puede incluir5e 7an7o 7eU7o plano Ie5 el ca5o del
ejemploK como o7ra5 e7iRue7a5% Lo Rue e5 impor7an7e e5 Rue 7oda e7iRue7a cuSo u5o
comience den7ro de o7ra 7amMi6n Wa de 7erminar den7ro de ella% 5eaN no e5 Q9lidoL
<Etiqueta1> <Etiqueta2> </Etiqueta1></Etiqueta2>
Pero lo Rue 5V 5erVa Q9lido e5L
<Etiqueta1> <Etiqueta2> </Etiqueta2></Etiqueta1>
(amMi6n e5 po5iMle me8clar 7eU7o S o7ra5 e7iRue7a5 en el <contenido>% Por ejemploL
<Etiqueta1> Hola <Etiqueta2> a </Etiqueta2> todos </Etiqueta1>
&% -!L e5 un lenguaje 5en5iMle a maST5cula5N por lo Rue 5i una e7iRue7a 5e aMre con
una cier7a capi7ali8aciónN a la Wora de cerrarla WaMr9 Rue u5ar eUac7amen7e la mi5ma%
*% E5 po5iMle u5ar la 5iguien7e 5in7aUi5 aMreQiada para e5criMir e7iRue7a5 5in <contenido>L
<<etiqueta>/>
El lenguaje de programación C# (ema :0L #ocumen7ación -!L
Por ejemploL
<EtiquetaSinContenidoDeEjemplo/>
3% En realidad en la <etiqueta> inicial no 7iene porRu6 indicar5e 5ólo un iden7iOicador
Rue 5irQa de nomMre para la e7iRue7a u5adaN 5ino Rue 7amMi6n pueden indicar5e
9347C03.; Rue permi7an conOigurar 5u 5igniOicado% E57o5 a7riMu7o5 5e e5criMen de la
Oorma <nombreAtributo>="<valor>" S 5eparado5 median7e e5pacio5% Por ejemploL
<EtiquetaConAtributo AtributoEjemplo=”valor1” >
Etiqueta de ejemplo que incluye un atributo
</EtiquetaConAtributo>
<EtiquetaSinContenidoYConAtributo AtributoEjemplo=”valor2” />
;% Sólo pueden u7ili8ar5e carac7ere5 ASCIIN S lo5 no ASCII Iacen7o5N eXe5N %%%K o Rue
7engan algTn 5igniOicado e5pecial en -!LN Wan de 5u57i7uir5e por 5ecuencia5 de
e5cape de la Oorma &#<códigoUnicode>; Para lo5 carac7ere5 m95 WaMi7uale5 7amMi6n
5e Wan deOinido la5 5iguien7e5 5ecuencia5 de e5cape e5peciale5L
C94M6314 S16012679 51 1;69<1 U276.51 S16012679 51 1;69<1 1;<1679-
< &#60; &lt;
> &#62; &gt;
& &#38; &amp;
' &#39; &apos;
“ &#34; &quot;
T9C-9 11: Secuencia5 de e5pace -!L de u5o Orecuen7e
Comentarios de documentación ;ML
Sintaxis generaI
Lo5 comen7ario5 de documen7ación -!L 5e e5criMen como comen7ario5 normale5 de
una lVnea pero con la5 peculiaridade5 de Rue 5u primer car9c7er Wa de 5er 5iempre / S de
Rue 5u con7enido Wa de e57ar e5cri7o en -!L Sa Rue 5er9 in5er7ado por el compilador en
el OicWero -!L de documen7ación Rue genera% Por 7an7oN 5on comen7ario5 de la OormaL
/// <textoXML>
E57o5 comen7ario5 Wan preceder la5 deOinicione5 de lo5 elemen7o5 a documen7ar% E57o5
elemen7o5 5ólo pueden 5er deOinicione5 de miemMro5N Sa 5ean 7ipo5 de da7o5 IRue 5on
miemMro5 de e5pacio5 de nomMre5K o miemMro5 de 7ipo5 da7o5N S Wan de colocar5e
inclu5o an7e5 Rue 5u5 a7riMu7o5%
En <textoXML> el programador puede incluir cuale5Ruiera e7iRue7a5 con el 5igniOicadoN
con7enido S a7riMu7o5 Rue con5idere opor7uno5N Sa Rue en principio el compilador no la5
proce5a 5ino Rue la5 incluSe 7al cual en la documen7ación Rue genera dejando en mano5
de la5 Werramien7a5 encargada5 de proce5ar dicWa documen7ación la de7erminación de 5i
5e Wan u5ado correc7amen7e%
Sin emMargoN el compilador comprueMa Rue lo5 comen7ario5 de documen7ación 5e
coloRuen donde deMerVan S Rue con7engan -!L Mien Oormado% Si no Oue5e a5V generarVa
El lenguaje de programación C# (ema :0L #ocumen7ación -!L
un men5aje de aQi5o S en la documen7ación generada lo5 5u57i7uirVa por un comen7ario
-!L Rue eUplica5e el 7ipo de error come7ido%
EI atributo cref
AunRue en principio lo5 a7riMu7o5 de la5 e7iRue7a5 no 7ienen ningTn 5igniOicado
prede7erminado para el compiladorN WaS una eUcepciónL el a7riMu7o cref 5iempre Qa a
7ener un 5igniOicado concre7o con5i57en7e en Oor8arlo a comproMar cuando QaSa a generar
la documen7ación 5i eUi57e el elemen7o cuSo nomMre indiRue SN 5i no e5 a5VN Wacerle
producir un men5aje de aQi5o I5u nomMre Qiene de _cWec] reOerence`K
Lo5 elemen7o5 e5peciOicado5 en cref 5uelen indicar5e median7e caliOicación comple7aN S
pueden 5er 7an7o nomMre5 de miemMro5 como de e5pacio5 de nomMre5% En el Tema 2:
Es!a$ios de Nombres Sa 5e eUplicó como indicar a5V nomMre5 de 7ipo5 S de e5pacio5 de
nomMre5N mien7ra5 Rue para indicar el de miemMro5 de 7ipo5 Ma57a e5criMir el nomMre
comple7o del 7ipo donde e576n deOinido5 5eguido de un pun7o 7ra5 el cualN dependiendo
del 7ipo de miemMro del Rue 5e 7ra7eN 5e e5criMirVa L
• Si e5 un 69?<.N <4.<71595P 1A123. o 37<. in7ernoN 5u nomMre%
• Si e5 un ?N3.5.N 5u nomMre 5eguido de lo5 nomMre5 comple7o5 de lo5 7ipo5 de 5u5
par9me7ro5 5eparado5 median7e coma5 S en7re par6n7e5i5% E57o5 nomMre5 de 7ipo5 de
par9me7ro5 lleQan un car9c7er @ conca7enado al Oinal en lo5 par9me7ro5 ref u outN un
car9c7er * al Oinal en lo5 Rue 5ean de 7ipo5 pun7ero5N un 5VmMolo [] por cada niQel de
anidación al Oinal de lo5 Rue 5ean 7aMla5 unidimen5ionale5N S una e57ruc7ura de la
Oorma [0:,0:] al Oinal de lo5 Rue 5ean 7aMla5 Midimen5ionale5 Ipara 7aMla5 de m95
dimen5ione5 5implemen7e 5e irVan aXadiendo lo5 MloRue5 ,0: apropiado5K
:3
• Si e5 un 7257K95.4N el iden7iOicador Item 5eguido de la li57a de 7ipo5 de 5u5 Vndice5
como 5i de lo5 par9me7ro5 de un m67odo 5e 7ra7a5e
• Si e5 un 6.2;34063.4 de oMje7oN el iden7iOicador #ctor 5eguido de la li57a de 7ipo5 de
5u5 par9me7ro5 como 5i de un m67odo normal 5e 7ra7a5e% Si el con57ruc7or Oue5e de
7ipo5 en7once5 el iden7iOicador u5ado 5erVa #cctor
• Si e5 un 51;34063.4N el iden7iOicador FinaIize%
• Si e5 un .<1495.4N el iden7iOicador Rue repre5en7e a e5e operador 5eguido de la li57a
de lo5 7ipo5 de 5u5 operando5 como 5i Oue5en lo5 par9me7ro5 de un m67odo normal%
En la (aMla :& 5e re5umen lo5 iden7iOicadore5 Rue 5e dan a cada operadorL
O<1495.4 I51237@7695.4 O<1495.4 I5123@7695.4
+ op_Addition & op_BitwiseAnd
- op_Substraction | op_BitwiseOr
* op_MuItipIy ^ op_ExcIusiveOr
/ op_Division ~ op_OnesCompIement
% op_ModuIus << op_LeftShift
:3
En general la 5in7aUi5 Rue 5e 5igue e5 <índiceÌnferior>:<.ndice/uperior>N pero en C# 5e genera
5iempre 0: porRue la5 7aMla5 5ólo pueden indi8ar5e de5de + S 5u lVmi7e 5uperior e5 QariaMleN
El lenguaje de programación C# (ema :0L #ocumen7ación -!L
< op_LessThan >> op_RightShift
> op_GreaterThan true op_True
>= op_GreaterThanOrEquaI faIse op_FaIse
<= op_LowerThanOrEquaI ++ op_Increment
== op_EquaIity -- op_Decrement
!= op_InequaIity
ConQer5ión eUplVci7a
Op_ExpIict
! op_LogicaINot
ConQer5ión
implVci7a
Op_ImpIicit
T9C-9 1: NomMre5 dado5 a operadore5 en documen7ación -!L
En el ca5o de lo5 operadore5 de conQer5iónN 7ra5 la li57a de par9me7ro5 5e incluSe
adicionalmen7e un car9c7er ~ 5eguido del 7ipo de re7orno del operador%
Para Rue 5e en7ienda mejor la Oorma en Rue 5e Wan de dar Qalore5 a crefN a con7inuación
5e mue57ra un Oragmen7o de código de ejemplo en el Rue jun7o a cada deOinición 5e Wa
e5cri7o un comen7ario con el Qalor Rue WaMrVa Rue darle a cref para reOerenciarlaL
// cref=”Espacio”
namespace Espacio
{
// cref=”Espacio.Clase”
class Clase
{
// cref=”Espacio.Clase.Campo”
int Campo;
// cref=”Espacio.Clase.Propiedad”
int Propiedad
{ set {} }
// cref=”Espacio.Clase.EstructuraÌnterna”
struct EstructuraÌnterna {}
// cref=”Espacio.Clase.DelegadoÌnterno”
public delegate int DelegadoÌnterno(string s, float f);
// cref =”Espacio.Clase.Evento”
public event DelegadoÌnterno Evento;
// cref=”Espacio.Clase.Metodo(System.Ìnt32, System.Ìnt32@,
// System.Ìnt32*, System.Ìnt32@,
// System.Ìnt32[][], System.Ìnt32[0:, 0:, 0:])”
int Metodo(int a, out int b, int * c, ref d, int[][] e, int[,,] f)
{return 1;}
// cref=”Espacio.Clase.Ìtem(System.String)”
int this[string s]
{ set {} }
// cref=”Espacio.Clase.#ctor”
Clase(int a)
{}
// cref=”Espacio.Clase.#cctor”
static Clase(int a)
{}
// cref=”Espacio.Clase.Finalize”
El lenguaje de programación C# (ema :0L #ocumen7ación -!L
~X()
{}
// cref=”Espacio.Clase.op_Addition(Espacio.Clase, Espacio.Clase)”
public static int operator +(Clase operando1, Clase operando2)
{ return 1; }
// cref=”Espacio.Clase.op_Explicit (Espacio.Clase)~System.Ìnt32”
public static explicit operator int(Clase fuente)
{ return 1; }
}
}
En realidad no e5 5iempre nece5ario u5ar caliOicación comple7a en el Qalor de cref% Si 5e
reOerencia a un 7ipo de5de la mi5ma deOinición de e5pacio de nomMre5 de5de donde 5e le
deOinió o Rue impor7a 5u e5pacio de nomMre5N no e5 nece5ario incluir dicWo e5pacio en la
reOerenciab S 5i 5e reOerencia a un miemMro de5de el mi5mo 7ipo donde 5e deOinióN no e5
nece5ario incluir ni el nomMre del 7ipo ni el de 5u e5pacio de nomMre5%
Etiquetas recomendadas para documentación ;ML
AunRue el programador puede u7ili8ar la5 e7iRue7a5 e57ime opor7una5 en 5u5 comen7ario5
de documen7ación S darle5 el 5igniOicado Rue RuieraN !icro5oO7 recomienda u5ar un
juego de e7iRue7a5 concre7o con 5igniOicado5 concre7o5 para e5criMir cier7o5 7ipo5 de
inOormación comTn% Con ello 5e oM7endrVa un conjun7o M95ico de e7iRue7a5 Rue cualRuier
Werramien7a Rue 7raMaje con documen7ación -!L pueda e57ar preparada para proce5ar
Icomo Qeremo5 m95 adelan7eN el propio ,i5ual S7udio%NE( da cier7o5 u5o5 e5pecVOico5 a
la inOormación a5V documen7adaK

En lo5 5iguien7e5 epVgraOe5 5e eUplican e57a5 e7iRue7a5 recomendada5 agrup9ndola5
5egTn 5u u7ilidad% (oda5 5on opcionale5N S no incluirla5 5ólo 7iene el eOec7o de Rue no en
la documen7ación re5ul7an7e no 5e generarVan la5 5eccione5 corre5pondien7e5 a ella5%
Etiquetas de uso genérico
HaS una 5erie de e7iRue7a5 predeOinida5 Rue pueden colocar5eN en cualRuier ordenN
precediendo la5 deOinicione5 de miemMro5 en lo5 OicWero5 Ouen7e% E57a5 e7iRue7a5N jun7o
al 5igniOicado recomendado para 5u con7enidoN 5on la5 eUplicada5 a con7inuaciónL
• <summary>L Su con7enido 5e u7ili8a para indicar un re5umen 5oMre el 5igniOicado del
elemen7o al Rue precede% Cada Qe8 Rue en ,S%NE( 5e u5e el operador . para acceder
a algTn miemMro de un oMje7o o 7ipo 5e u5ar9 e57a inOormación para mo57rar 5oMre la
pan7alla del edi7or de 7eU7o un re5umen acerca de 5u u7ilidad%
• <remarks>L Su con7enido indica una eUplicación de7allada 5oMre el elemen7o al Rue
precede% Se recomienda u5ar <remarks> para dar una eUplicación de7allada de lo5
7ipo5 de da7o5 S <summary> para dar una re5umida de cada uno de 5u5 miemMro5%
• <exampIe>L Su con7enido e5 un ejemplo 5oMre cómo u5ar el elemen7o al Rue precede%
El lenguaje de programación C# (ema :0L #ocumen7ación -!L
• <seeaIso>L Se u5a para indicar un elemen7o cuSa documen7ación guarda alguna
relación con la del elemen7o al Rue precede% No 7iene con7enido S el nomMre del
elemen7o al Rue 5e remi7e 5e indica en 5u a7riMu7o crefN por lo Rue el compilador
comproMar9 5i eUi57e% Para indicar mTl7iple5 documen7acione5 rela7iQa5 a un cier7o
elemen7o Ma57a u5ar una e7iRue7a <seeaIso> por cada una%
• <permission>L Se u7ili8a para indicar Ru6 permi5o nece5i7a un elemen7o para poder
Ouncionar% En 5u con7enido 5e indica una de5cripción del mi5moN S 5u a7riMu7o cref
5uele u5ar5e para indicar el 7ipo Rue repre5en7a a e5e permi5o Por ejemploL
/// <permission cref=”System.Security.Permissions.FileÌOPermission”>
/// Necesita permiso de lectura/escritura en el directorio C:\Datos
/// </permission>
Como con <seeaIso>N 5i un miemMro Wa de di5poner Qario5 7ipo5 de permi5o5 puede
documen7ar5e 5u deOinición con 7an7a5 e7iRue7a5 <permission> como 5ea nece5ario%
Etiquetas reIativas a métodos
Adem95 de la5 e7iRue7a5 u5o general Sa Qi57a5N en la5 deOinicione5 de m67odo5 5e pueden
u5ar la5 5iguien7e5 e7iRue7a5 recomendada5 adicionale5 para de5criMir 5u5 par9me7ro5 S
Qalor de re7ornoL
• <param>L Permi7e documen7ar el 5igniOicado de un par9me7ro de un m67odo% En 5u
propiedad name 5e indica el nomMre del par9me7ro a documen7ar S en 5u con7enido
5e de5criMe 5u u7ilidad% Por ejemploL
/// <summary> Método que muestra un texto por pantalla </summary>
/// <param name=”texto”> Texto a mostrar </param>
bool MuestraTexto(string texto)
{...}
Al generar5e la documen7ación 5e comprueMa 5i el m67odo documen7ado di5pone de
algTn par9me7ro con el nomMre indicado en name SN como ocurre con crefN 5i no
Oue5e a5V 5e generarVa un men5aje de aQi5o inOormando de ello%
• <paramref>L Se u5a para reOerenciar a par9me7ro5 de m67odo5% No 7iene con7enido S
el nomMre del par9me7ro reOerenciado 5e indica en 5u a7riMu7o name% Por ejemploL
/// <summary>
/// Método que muestra por pantalla un texto con un determinado color
/// </summary>
/// <param name=”texto”> Texto a mostrar </param>
/// <param name=”color”>
/// Color con el que mostrar el <paramref name=”texto”/> indicado
/// </param>
bool MuestraTexto(string texto, Color color)
{...}
El lenguaje de programación C# (ema :0L #ocumen7ación -!L
NueQamen7eN al generar5e la documen7ación 5e comproMar9 5i realmen7e el
par9me7ro reOerenciado eUi57e en la deOinición del m67odo documen7ado S 5i no e5
a5V 5e genera un men5aje de aQi5o inOormando de ello%
• <returns>L Permi7e documen7ar el 5igniOicado del Qalor de re7orno de un m67odoN
indicando como con7enido 5uSo una de5cripción 5oMre el mi5mo% Por ejemploL
/// <summary>
/// Método que muestra por pantalla un texto con un determinado color
/// </summary>
/// <param name=”texto”> Texto a mostrar </param>
/// <param name=”color”>
/// Color con el que mostrar el <paramref name=”texto”/> indicado
/// </param>
/// <returns> Ìndica si el método se ha ejecutado con éxito o no </returns>
bool MuestraTexto(string texto, Color color)
{...}
Etiquetas reIativas a propiedades
El u5o m95 WaMi7ual de una propiedad con5i57e en con7rolar la Oorma en Rue 5e accede a
un campo priQadoN por lo Rue e57a 5e compor7a como 5i almacena5e un Qalor% !edian7e
el con7enido de la e7iRue7a <vaIue> e5 po5iMle de5criMir el 5igniOicado de e5e QalorL
private int edad;
/// <summary>
/// Almacena la edad de una persona. Si se le asigna una edad menor que 0 la
/// sustituye por 0.
/// </summary>
/// <value> Edad de la persona representada </value>
public int Edad
{
set { edad = (value<0)? 0:value }
get { return edad; }
}
Etiquetas reIativas a excepciones
Para documen7ar el 5igniOicado de un 7ipo deOinido como eUcepción puede incluir5e un
re5umen 5oMre el mi5mo como con7enido de una e7iRue7a de documen7ación <exception>
Rue preceda a 5u deOinición% El a7riMu7o cref de 657a 5uele u5ar5e para indicar la cla5e de
la Rue deriQa la eUcepción deOinida% Por ejemploL
/// <exception cref=”System.Exception”>
/// Excepción de ejemplo creada por Josan
/// </exception>
class JosanExcepción: Exception
{}
El lenguaje de programación C# (ema :0L #ocumen7ación -!L
Etiquetas reIativas a formato
Para mejorarla Oorma de eUpre5ar el con7enido de la5 e7iRue7a5 de documen7ación Rue 5e
u7ilicen e5 po5iMle incluir en ella5 la5 5iguien7e5 e7iRue7a5 de Oorma7oL

• <see>L Se u7ili8a para indicar WiperQVnculo5 a o7ro5 elemen7o5 de la documen7ación
generada% E5 una e7iRue7a 5in con7enido en la Rue el de57ino del enlace e5 la
documen7ación del miemMro cuSo nomMre comple7o 5e indica en 5u a7riMu7o cref%
E5e nomMre e5 7amMi6n el 7eU7o Rue la5 Woja5 de e57ilo 5uelen mo57rar para
repre5en7ar por pan7alla el enlaceN por lo Rue lo5 u5o5 de e57a e7iRue7a 5uelen 5er de
la OormaL
/// <summary>
/// Muestra por la salida estándar el mensaje ¡Hola!
/// Si no sabe como se escribe en pantalla puede consultar la documentación del
///método <see cref=”System.Console.WriteLine”/>
/// </summary>
public static void Saluda()
{
Console.WriteLine(“¡Hola!”);
}
Nó7e5e Rue la diOerencia de <see> S <seeaIso> e5 Rue la primera 5e u5a para indicar
enlace5 en medio de 7eU7o5 mien7ra5 Rue la o7ra 5e u5a para indicar enlace5 Rue 5e
de5een incluir en una 5ección apar7e 7ipo _,6a5e 7amMi6n`%
• <code> S <c>L AmMa5 e7iRue7a5 5e u5an para delimi7ar 7eU7o5 Wan de 5er con5iderar5e
Oragmen7o5 de código Ouen7e% La diOerencia en7re ella5 e5 Rue <code> 5e recomienda
u5ar para Oragmen7o5 mul7ilVnea S <c> para lo5 de una Tnica lVneab S Rue la5 Woja5 de
e57ilo mo57rar9n el con7enido de la5 e7iRue7a5 <code> re5pe7ando 5u e5paciado S el
de la5 e7iRue7a5 <c> 5in re5pe7arlo S 7ra7ando cualRuier aparición con5ecu7iQa de
Qario5 carac7ere5 de e5paciado como 5i Oue5en un Tnico e5pacio en Mlanco%
En generalN <code> 5uele u5ar5e den7ro de e7iRue7a5 <exampIe> para mo57rar
Oragmen7o5 de código5 de ejemploN mien7ra5 Rue <c> 5uele u5ar5e para Wacer
reOerencia a elemen7o5 pun7ale5 de lo5 código5 Ouen7e% Por ejemploL
/// <example>
/// Este ejemplo muestra cómo llamar al método <c>Cumple()</c> de esta clase:
/// <code>
/// Persona p = new Persona(...);
/// p.Cumple();
/// </code>
/// </example>
• <para>L Se u5a para delimi7ar p9rraOo5 den7ro del 7eU7o con7enido en o7ra5 e7iRue7a5N
con5ider9ndo5e Rue el con7enido de cada e7iRue7a <para> Oorma par7e de un p9rraOo
di57in7o% 1eneralmen7e 5e u5a den7ro de e7iRue7a5 <remarks>N Sa Rue 5on la5 Rue
5uelen nece5i7ar p9rraOo5 al 7ener un con7enido m95 largo% Por ejemploL
/// <remarks>
/// <para>
/// Primer párrafo de la descripción del miembro...
/// </para>
El lenguaje de programación C# (ema :0L #ocumen7ación -!L
/// <para>
/// Segundo párrafo de la descripción del miembro...
/// </para>
/// </remarks>
• <Iist>L Se u7ili8a para incluir li57a5 S 7aMla5 como con7enido de o7ra5 e7iRue7a5% (odo
u5o de e57a e7iRue7a deMerVa incluir un a7riMu7o type Rue indiRue el 7ipo de e57ruc7ura
5e de5ea deOinir 5egTn 7ome uno de lo5 5iguien7e5 Qalore5L
 buIIetL Indica Rue 5e 7ra7a de una li57a no numerada
 numberL Indica Rue 5e 7ra7a de una li57a numerada
 tabIeL Indica Rue 5e 7ra7a de una 7aMla
El con7enido de <Iist> depender9 del 7ipo de e57ruc7ura repre5en7ado en cada ca5oL
 Si 5e 7ra7a de una li57a normal dSa 5ea numerada o no numeradaD 5u
con7enido 5er9 una e7iRue7a <item> por cada elemen7o de la li57aN S cada e7iRue7a
de e57e 7ipo con7endr9 una e7iRue7a <description> con el 7eU7o corre5pondien7e a
e5e elemen7o% Por ejemploL
/// <list type=”bullet”>
/// <item>
/// <description>
/// Elemento 1
/// </description>
/// </item>
/// <item>
/// <description>
/// Elemento 2
/// </description>
/// </item>
/// </list>
Si 5e 7ra7a5e de una 7aMlaN 5u con7enido 5erVa 5imilar al de la5 li57a5 normale5 5ólo
Rue por cada Oila 5e incluirVa una e7iRue7a <item> S den7ro de 657a 5e incluirVa una
e7iRue7a <description> por cada columna de e5a Oila% pcionalmen7e 5e podrVa
incluir 7amMi6n una e7iRue7a ~<Iistheader> an7e5 de la5 ~<item> donde 5e
indicarVa el 7eU7o de la caMecera de la 7aMla% E57a e7iRue7a 5e u5a igual Rue la5
e7iRue7a5 ~<item>L incluir9 una e7iRue7a ~<description> por cada columna%
 Por Tl7imoN 5i Oue5e una li57a de deOinicione5 cada <item> con7endrVa una
primera e7iRue7a <term> con el nomMre del elemen7o a deOinir S o7ra 5egunda
e7iRue7a <description> con 5u deOinición% pcionalmen7e 7amMi6n podrVa
incluir5e una e7iRue7a <Iistheader> con la caMecera de la li57a% Por ejemploL
/// <list type=”bullet”>
/// <item>
/// <term>
/// Término 1
/// </term>
/// <description>
/// Descripción de término 1
/// </description>
/// </item>
/// <item>
El lenguaje de programación C# (ema :0L #ocumen7ación -!L
/// <term>
/// Término 2
/// </term>
/// <description>
/// Descripción de término 2
/// </description>
/// </item>
/// </list>
<eneración de documentación ;ML
Generación a través deI compiIador en Iínea de comandos
"5ando el compilador en lVnea de comando5 puede generar5e documen7ación 5oMre lo5
7ipo5 deOinido5 en lo5 Ouen7e5 a compilar u5ando la opción de compilación
/doc:<fichero>% Por ejemploN para compilar un OicWero de código Ouen7e Persona.cs S
generar 5u documen7ación en Persona.xmlN WaMrVa Rue llamar al compilador conL
csc 5ersona.cs *doc+5ersona.$ml
Si 5e aMre con In7erne7 EUplorer el OicWero -!L a5V generado 5e Qer9 un conjun7o de
e7iRue7a5 Rue recogen 7oda la inOormación uMicada en lo5 comen7ario5 de documen7ación
de lo5 Ouen7e5 compilado5% AunRue para una per5ona pueda re5ul7ar diOVcil leer e57a
inOormaciónN para una aplicación Wacerlo e5 muS 5encillo a 7raQ65 de un anali8ador
-!L% Si 5e de5ea Rue 7amMi6n 5ea legiMle para Wumano5 Ma57a aMrirlo con cualRuier
edi7or de 7eU7o5 S aXadirle una primera lVnea de la OormaL
<?xmI:styIesheet href="<ficheroXSL>" type="text/xsI"?>
Con e57a lVnea 5e indica Rue 5e de5ea u7ili8ar el OicWero indicado en <ficheroXSL> como
Woja de e57ilo -SL con la Rue conQer7ir la documen7ación -!L a algTn lenguaje m95
O9cilmen7e legiMle por Wumano5 Igeneralmen7eN H(!LK% Por ejemploN 5i doc.$sl e5 el
nomMre de dicWo OicWero -SLN Ma57arVa e5criMirL
<?xml:stylesheet href="doc.xsl" type="text/xsl"?>
Para Wacer5e una idea de la5 diOerencia5 eUi57en7e5 en7re aMrir con In7erne7 EUplorer un
OicWero de documen7ación 5in Woja -SL a5ociada S aMrir e5e mi5mo OicWero pero
a5oci9ndole una Woja -SLN puede oM5erQar en la Ilu57ración = S la Ilu57ración .L
El lenguaje de programación C# (ema :0L #ocumen7ación -!L
I-0;3496782 6: #ocumen7ación -!L 5in Woja de e57ilo
I-0;3496782 7: #ocumen7ación -!L con Woja de e57ilo -SL
No 5e preocupe 5i no 5aMe e5criMir Woja5 de e57iloN pue5 como 5e eUplica en el 5iguien7e
epVgraOeN ,i5ual S7udio%NE( incluSe una Werramien7a Rue puede generar direc7amen7e la
documen7ación en un H(!L O9cilmen7e legiMle para Wumano5%
Generación a través de VisuaI Studio.NET
El lenguaje de programación C# (ema :0L #ocumen7ación -!L
Si preOiere u5ar ,i5ual S7udio%NE(N en7once5 para la generación de la documen7ación
Ma57a 5eXalar el proSec7o a documen7ar en el (olution ,xplorer S e5criMir el nomMre
del OicWero -!L a generar en el cuadro de 7eU7o -iew  roperty ages 
Con0iguration roperties  Build  =;# 'ocumentation %ile
Cuando 5e compile el proSec7oN la documen7ación -!L 5oMre el mi5mo 5e guardar9 en
el OicWero indicado en el cuadro de 7eU7o an7erior% E57e OicWero 5e almacenar9 den7ro de
la 5uMcarpe7a 1in del direc7orio del proSec7oN S 5i 5e de5ea poder Qi5uali8arla de5de el
(olution ,xplorer WaS Rue ac7iQar en 657e el Mo7ón (*ow +ll %iles%
En principioN para con5eguir Qi5uali8ar e57a documen7ación en un Oorma7o m95 legiMle
para Wumano5 podrVa a5oci9r5ele una Woja -SL como 5e eUplicó para el ca5o del
compilador en lVnea de comando5% Sin emMargoN ,i5ual S7udio%NE( proporciona una
Oorma m95 5encilla de Wacerlo a 7raQ65 de la Werramien7a uMicada en Tools  Build
Comments )eb ages E57a u7ilidad a par7ir de la inOormación incluida en la5 e7iRue7a5
recomendada5 de lo5 comen7ario5 del Ouen7e genera p9gina5 H(!L Rue mue57ran la
documen7ación del proSec7o de una Oorma Qi57o5a e in7ui7iQa IQer Ilu57ración 'K
I-0;3496782 8: #ocumen7ación H(!L generada por ,i5ual S7udio%NE(
Estructura de la documentación ;ML
AWora Rue Sa 5aMemo5 cómo e5criMir comen7ario5 de documen7ación S generar a par7ir
de ello5 un OicWero -!L con la documen7ación de lo5 7ipo5 de da7o5 de un OicWeroN 5ólo
Rueda e57udiar cu9l e5 concre7amen7e la e57ruc7ura de dicWo OicWero generado Sa Rue
en7enderla e5 Oundamen7al para la e5cri7ura de aplicacione5 encargada5 de proce5arlo%
En principioN 5i compilamo5 como módulo un Ouen7e 5in comen7ario5 de documen7ación
pero 5olici7ando la generación de documen7aciónN 5e oM7endr9 el 5iguien7e OicWero -!LL
El lenguaje de programación C# (ema :0L #ocumen7ación -!L
<?xml version="1.0"?>
<doc>
<members>
</members>
</doc>
Como 5e QeN la primera lVnea del OicWero e5 la caMecera 7Vpica de 7odo OicWero -!L en la
Rue 5e indica cu9l e5 la Qer5ión del lenguaje Rue u7ili8a% (ra5 ella 5e coloca una e7iRue7a
<doc> Rue con7endr9 7oda la documen7ación generadaN S lo5 comen7ario5 de
documen7ación de lo5 miemMro5 del Ouen7e compilado 5e irVan incluSendo den7ro de la
e7iRue7a <members> Rue con7iene Ien e57e ca5o dicWa e7iRue7a e579 QacVa Sa Rue el Ouen7e
compilado carecVa de comen7ario5 de documen7aciónK
Si WuMi65emo5 compilado el Ouen7e como liMrerVa o como ejecu7aMle 5e WaMrVa generado
un en5amMladoN S a la e57ruc7ura an7erior 5e le aXadirVa una e7iRue7a adicional den7ro de
<doc> con inOormación 5oMre el mi5moN RuedandoL
<?xml version="1.0"?>
<doc>
<assembly>
<name>Persona</name>
</assembly>
<members>
</members>
</doc>
Como 5e QeN den7ro de la e7iRue7a <assembIy> con7enida en <doc> 5e indican la5
carac7erV57ica5 del en5amMlado generado% En concre7oN 5u nomMre 5e indica en la e7iRue7a
<name> Rue con7iene I5e 5upone Rue el en5amMlado 5e compiló con el nomMre 4ersonaK
Si aWora le aXadimo5 comen7ario5 de documen7ación Qeremo5 Rue el con7enido de e57o5
5e in5er7a den7ro de la e7iRue7a <members>N en una e7iRue7a <member> e5pecVOica para
cada miemMro con comen7ario5 de documen7ación% Por ejemploN dado el Ouen7eL
/// <summary>
/// Clase de ejemplo de cómo escribir documentación XML
/// </summary>
class A
{
/// <summary>
/// Método principal de ejemplo perteneciente a clase <see cref="A"/>
/// </summary>
/// <remarks>
/// No hace nada
/// </remarks>
static void Main()
{}
}
La documen7ación -!L Rue generara compilarlo con la opción /doc e5L
<?xml version="1.0"?>
<doc>
<assembly>
<name>A</name>
</assembly>
<members>
El lenguaje de programación C# (ema :0L #ocumen7ación -!L
<member name="T:A">
<summary>
Clase de ejemplo de cómo escribir documentación XML
</summary>
</member>
<member name="M:A.Main">
<summary>
Método principal de ejemplo perteneciente a clase <see cref="T:A"/>
</summary>
<remarks>
No hace nada
</remarks>
</member>
</members>
</doc>
Como puede Qer5eN den7ro de la e7iRue7a <members> no 5e 5igue ninguna e57ruc7ura
jer9rRuica a la Wora de de5criMir lo5 elemen7o5 del Ouen7eN 5ino Rue 7odo5 5e de5criMen al
mi5mo niQel S de la mi5ma OormaL 5e incluSe una e7iRue7a <member> por cada miemMro
documen7ado en cuSo a7riMu7o name 5e indica 5u nomMre S en cuSo con7enido 5e in5er7a
el 7eU7o de 5u5 comen7ario5 de documen7ación%
Nó7e5e Rue a cada elemen7o 5e le da en el a7riMu7o name de 5u e7iRue7a <member>
corre5pondien7e un iden7iOicador Rue lo di57ingue unVQocamen7e del re57o de miemMro5
documen7ado5 S Rue 5igue la 5iguien7e 5in7aUi5L
<indicadorElemento>:<nombreCompletamenteCalificado>
El <indicadorElemento> e5 5implemen7e un car9c7er Rue indica Ru6 7ipo de elemen7o 5e
documen7a den7ro de la e7iRue7a <member>% Puede 7omar e57o5 Qalore5L
I257695.4 51 37<. 51 1-1?123. T7<. 51 1-1?123. 7257695.
T
(ipo de da7o
F
Campo
P
Propiedad o indi8ador
M
!67odo Iincluido5 operadore5 S con7ruc7ore5K
E
EQen7o
T9C-9 1$: Indicadore5 de 7ipo5 de elemen7o5 en documen7acione5 -!L
Como 5e Qe en el ejemploN en la documen7ación generada 5e u5a 7amMi6n la 5in7aUi5 de
lo5 Qalore5 del a7riMu7o name de la5 e7iRue7a5 <member> para repre5en7ar la5 reOerencia5
median7e a7riMu7o5 cref% Adem95N cuando dicWa 5in7aUi5 5e u5a para eUpre5ar Qalore5 de
cref pueden u5ar5e do5 7ipo5 de indicadore5 m95L
I257695.4 51 37<. 51 1-1?123. T7<. 51 1-1?123. 7257695.
N
E5pacio de nomMre5
!
Ninguno% Se genera cuando el miemMro indicado
en cref no eUi57e%
T9C-9 14L Indicadore5 de 7ipo5 de elemen7o5 para a7riMu7o5 cref
La idea Rue WaS de7r95 de u5ar la 5in7aUi5 Qi57a para repre5en7ar elemen7o5 del Ouen7e e5
proporcionar un mecani5mo 5encillo median7e el Rue la5 Werramien7a5 encargada5 de
El lenguaje de programación C# (ema :0L #ocumen7ación -!L
proce5ar la5 documen7acione5 -!L puedan de7erminar cu9le5 5on lo5 miemMro5
documen7ado5 o reOerenciado5 S accederN con aSuda de lo5 7ipo5 de System.RefIectionN a
5u5 me7ada7o5 a5ociado5.
!eparación entre documentación ;ML $ código fuente
A Qece5 puede Rue in7ere5ar incru57ar 7oda la documen7ación en el mi5mo OicWero Rue el
código Ouen7eN por ejemplo 5i 5e de5ea reu7ili8arla en mTl7iple5 Ouen7e5 o 5i e5 muS
Qolumino5a e incluirla en el Ouen7e diOicul7arVa 5u legiMilidad% Para e57o5 ca5o5 5e da la
po5iMilidad de dejar la documen7ación en un OicWero -!L apar7e S reOerenciarla en el
código Ouen7e a 7raQ65 de la e7iRue7a de documen7ación <incIude>N Rue 5u u5a a5VL
<incIude fiIe="<nombreFichero>" path="<rutaDocumentación>"/>
Cuando el compilador encuen7re e57a e7iRue7a al generar la documen7ación lo Rue War9
5er9 7ra7arla como 5i Oue5e la e7iRue7a del OicWero <nombreFichero> indicada por la
eUpre5ión 'P93J
1)
<rutaDocumentación> Por ejemploN 5i 5e 7iene el códigoL
/// <include file=”otro.xml” path=”Miembros/Miembro[@nombre=”A”]/*”/>
class A
{}
En e57e u5o de <incIude> 5e e579 indicando Rue 5e Wa de in5er7ar 7odo el con7enido de la
e7iRue7a <Miembro> con7enida en <Miembros> cuSo a7riMu7o nombre Qalga A% LuegoN 5i el
con7enido del OicWero otro.$ml e5 de la OormaL
<Miembros>
...
<Miembro name=”A”>
<remarks>
Ejemplo de inclusión de documentación XML externa
</remarks>
<example>
Para crear un objeto de esta clase usar:
<code>
A obj = new A();
</code>
</example>
</Miembro>
...
</Miembros>
En7once5N el compilador generar9 documen7ación como 5i el Ouen7e con7uQie5eL
/// <remarks>
/// Ejemplo de inclusión de documentación XML externa
/// </remarks>
/// <example>
/// Para crear un objeto de esta clase usar:
/// <code>
/// A obj = new A();
/// </code>
/// </example>
:;
'P93J e5 un lenguaje Rue 5e u7ili8a para e5peciOicar ru7a5 en OicWero5 -!L Rue permi7an 5eleccionar
cier7a5 e7iRue7a5 de lo5 mi5mo5% Si no lo conoce puede encon7rar 5u e5peciOicación en e-Pa7Wf
El lenguaje de programación C# (ema :0L #ocumen7ación -!L
class A
{}
El lenguaje de programación C# (ema &+L El compilador de C# de
!icro5oO7
TEMA 20: EI compiIador de C# de Microsoft
ntroducción
A lo largo de lo5 7ema5 an7eriore5 5e Wan eUplicando mucWo5 a5pec7o5 5oMre cómo u5ar
el compilador de C# de !icro5oO7 incluido en el %NE( /rameYor] S#A% Sin emMargoN
una Qe8 de5cri7o el lenguaje por comple7o e5 el momen7o adecuado para eUplicar
pormenori8adamen7e cómo u7ili8arlo S Ru6 opcione5 de compilación admi7eN pue5
mucWa5 de ella5 5e Ma5an en concep7o5 relacionado5 con carac7erV57ica5 del lenguaje%
Por o7ro ladoN la5 diOeren7e5 eUplicacione5 dada5 5oMre 6l 5e Wan ido de5perdigando a lo
largo de mucWo5 de lo5 7ema5 preQio5N por lo Rue e5 7amMi6n conQiene agruparla5 7oda5
en un mi5mo 5i7io de modo Rue 5ea m95 O9cil locali8arla5%
AunRue en un principio lo Rue 5e Qa e5 a eUplicar cómo u5ar el compilador en lVnea de
comando5N dado Rue ,i5ual S7udio%NE( 7amMi6n Wace u5o in7erno de 6l para compilarN
al Oinal del 7ema 5e incluir9 un epVgraOe dedicado a eUplicar cómo con7rolar de5de dicWa
Werramien7a Qi5ual la5 opcione5 Rue 5e u7ili8ar9n al llamarlo%
!inta1is general de uso del compilador
El nomMre del ejecu7aMle del compilador de C# incluido en el %NE( /rameYor] S#A e5
csc.exe S podr9 encon7rarlo en la carpe7a Microso<t.Y@T8Grame,orK82D..VRX
incluida den7ro del direc7orio de in57alación de 5u Qer5ión de <indoY5
:=
%
Como Sa 5e Qió en el Tema 6 duran7e la primera 7oma de con7ac7o con C#N el S#A
au7om97icamen7e aXade al pa7W e57a ru7a para poder reOerenciarlo 5in proMlema5N aunRue
5i e57amo5 u5ando ,S%NE( WaMr9 Rue aXadVr5elo a manoN ejecu7ando vsvars32.bat o
aMriendo la con5ola de comando5 de5de SL?C.-. 51- ;7;31?9 51 V7;09- S3057..NET%
La Oorma m95 M95ica de ejecu7ar al compilador con5i57e en pa5arle como argumen7o5 lo5
nomMre5 de lo5 Ouen7e5 a compilarN ca5o en Rue in7en7arVa generar en el direc7orio de5de
el Rue 5e le llame un ejecu7aMle a par7ir de ello5 con el mi5mo nomMre Rue el primero de
lo5 Ouen7e5 indicado5 S eU7en5ión .exe Por ejemploN an7e una llamada comoL
csc Guente..cs Guente1.cs GuenteC.cs
El compilador in7en7ar9 generar un Ouen7e Guente..e$e en el direc7orio de5de el Rue 5e
lo llamó cuSo código 5ea el re5ul7an7e de compilar /uen7eA%c5N /uen7eB%c5 S /uen7eC%c5
MQiamen7eN para Rue ello 5ea po5iMle el compilador WaMr9 de di5poner de permi5o de
e5cri7ura S e5pacio 5uOicien7e en dicWo direc7orio S adem95 alguno de lo5 Ouen7e5
indicado5 7endr9 Rue di5poner de un pun7o de en7rada Q9lido%
E57e compor7amien7o por deOec7o puede Qariar5e e5peciOicando en la llamada a csc
opcione5 de compilación adicionale5 Rue 5igan la 5in7aUi5L
:=
El nomMre de la carpe7a Q&%+%3+=+. 5egTn la Qer5ión del S#A Rue u7ilice% En concre7oN el Qalor Rue aRuV
5e indica corre5ponde a la de la Be7a : del %NE( /rameYor] S#A &%+%
El lenguaje de programación C# (ema &+L El compilador de C# de
!icro5oO7
:indicador/5ciBn=:o5ciBn=
El :indicador/5ciBn= puede 5er el car9c7er / o el car9c7er >N aunRue en adelan7e 5ólo
Waremo5 u5o de /% )e5pec7o a :o5ciBn=N pueden indicar5e do5 7ipo5 de opcione5L
• F-9=;: Son opcione5 cuSa aparición o au5encia 7ienen un de7erminado 5igniOicado
para el compilador% Se indican de e57a maneraL
:nom-reGlag=<activado?>
:acti2ado= e5 opcional e indica 5i 5e de5ea ac7iQar el 5igniOicado del Olag% Puede
5er el car9c7er $ para indicar Rue 5V o el car9c7er - para indicar Rue noN aunRue en
realidad darle el Qalor $ e5 innece5ario porRue e5 lo Rue 5e 7oma por deOec7o%
(amMi6n WaS alguno5 Olag5 Rue no admi7en ninguno de lo5 do5 carac7ere5N pue5 5e
con5idera Rue 5iempre Rue apare8can en la llamada al compilador e5 porRue 5e de5ea
ac7iQar 5u 5igniOicado S 5i no aparecie5en 5e con5iderarVa Rue 5e de5ea de5ac7iQarlo%
A con7inuación 5e mue57ran alguno5 ejemplo5 de u5o de un Olag llamado /optimi6e%
No 5e preocupe por 5aMer aWora para Rue 5irQeN 5ino 5implemen7e OVje5e en cómo 5e
u5a S no7e Rue lo5 do5 primero5 ejemplo5 5on eRuiQalen7e5L
csc *o5timiEe Guente.cs
csc *o5timiEeZ Guente.cs
csc *o5timiEe' Guente.cs
• O<67.21; 6.2 A9-.41;: A diOerencia de lo5 Olag5N 5on opcione5 cuSa aparición no e5
Q9lida por 5V mi5ma 5ino Rue 5iempre Rue 5e u5en Wan de incluir la e5peciOicación de
uno o Qario5 Qalore5% La Oorma en Rue 5e e5peciOican e5L
:nom-reGlag=?:2alores=
Lo5 :2alores= indicado5 pueden 5er cuale5RuieraN aunRue 5i 5e de5ea e5peciOicar
Qario5 WaS Rue 5epararlo5 en7re 5V con carac7ere5 de coma I@K ó pun7o S coma IAK
Como e5 lógicoN en principio lo5 :2alores= indicado5 no pueden incluir carac7ere5
de e5pacio Sa Rue 657o5 5e in7erpre7arVan como 5eparadore5 de argumen7o5 en la
llamada a csc% Sin emMargoN lo Rue 5V 5e permi7e e5 incluirlo5 5i preQiamen7e 5e le5
encierra en7re comilla5 doMle5 IBK
MQiamen7eN como la5 comilla5 doMle5 7amMi6n 7iene un 5igniOicado e5pecial en lo5
argumen7o5 de csc 7ampoco 5er9 po5iMle incluirla5 direc7amen7e como car9c7er en
:2alores=% En e57e ca5oN para 5olQen7ar e57o lo Rue 5e Wace e5 in7erpre7arla5 como
carac7ere5 normale5 5i Qan precedida5 de \ S con 5u 5igniOicado e5pecial 5i no%
#e nueQoN e57o lleQa al proMlema de Rue el 5igniOicado de \ 5i precede a B 7amMi6n
puede 5er e5pecialN S para 5olucionarlo lo aWora Rue 5e Wace e5 incluirlo duplicado
I\K 5i aparece precediendo a un B pero no 5e de5ea Rue 7ome 5u 5igniOicado e5pecial%
Ejemplo5 eRuiQalen7e5 de cómo compilar dando Qalore5 a una opción /r 5onL
csc *r+Li-.dll *r+Li-D.dll Guente.cs
csc *r+Li-C.dll#Li-D.dll Guente.cs
csc *r+Li-C.dll&Li-(.dll Guente.cs
El lenguaje de programación C# (ema &+L El compilador de C# de
!icro5oO7
AunRue en lo5 ejemplo5 mo57rado5 5iempre 5e Wan incluido la5 opcione5 an7e5 Rue lo5
nomMre5 de lo5 Ouen7e5 a compilarN en realidad ello no 7iene porRu6 5er a5V S 5e pueden
me8clar liMremen7e S en cualRuier orden opcione5 S nomMre5 de Ouen7e5 a compilar
I5alQo eUcepcione5 Rue en 5u momen7o 5e eUplicar9nK
%pciones de compilación
"na Qe8 eUplicado cómo u7ili8ar el compilador en lVnea5 generale5 e5 el momen7o
propicio para pa5ar a eUplicar cu9le5 5on en concre7o la5 opcione5 Rue admi7e% E57o 5e
War9 de5glo59ndola5 en diOeren7e5 ca7egorVa5 5egTn 5u u7ilidad%
An7e5 de empe8ar e5 preci5o comen7ar Rue la maSorVa de e57a5 opcione5 di5ponen de do5
nomMre5 diOeren7e5L un nomMre largo Rue permi7e deducir con Oacilidad 5u u7ilidad S un
nomMre cor7o meno5 claro pero Rue permi7e e5peciOicarla5 m95 aMreQiadamen7e% Cuando
5e Waga reOerencia por primera Qe8 a cada opción 5e u7ili8ar9 5u nomMre largo S en7re
par6n7e5i5 5e indicar9 5u nomMre cor7o ju57o a con7inuación% El re57o de reOerencia5 a
cada opción 5e War9n u5ando indi57in7amen7e uno u o7ro de 5u5 nomMre5%
Opciones básicas
En e57e epVgraOe 5e eUplicar9n 7oda5 aRuella5 opcione5 Rue 5uelen u5ar5e con maSor
Orecuencia a la Wora de compilar aplicacione5% Como la maSorVa Sa 5e eUplicaron en
de7alle en el Tema 6: "ntrod#$$i)n a C7N dicWa5 opcione5 aRuV 5implemen7e 5e re5umenL
• /recurseL Si en Qe8 de indicar el nomMre de cada OicWero a compilar como 5e Wa
dicWo 5e indica como Qalor de e57a opción 5e con5igue Rue 5i el compilador no lo
encuen7ra en la ru7a indicada lo Mu5Rue en lo5 5uMdirec7orio5 de la mi5ma%
Por ejemploN la 5iguien7e llamada indica Rue 5e de5ea compilar el OicWero <uente.cs
uMicado den7ro del direc7orio c+8Mis 9ocumentos o algTn 5uMdirec7orio 5uSoL
csc *recurse+"Mis 9ocumentos"8<uente.cs
• /target I/tKL Por deOec7o al compilar 5e genera un ejecu7aMle cuSa ejecución
proQoca la aper7ura de una Qen7ana de con5ola 5i al lan8arlo no WuMie5e ninguna
aMier7a% E57o puede camMiar5e dando uno de lo5 Qalore5 indicado5 en la (aMla :; a
e57a opciónL
V9-.4 T7<. 51 @76J14. 9 =121494
exe ó ninguno Ejecu7aMle con Qen7ana de con5ola IQalor por deOec7oK
winexe
Ejecu7aMle 5in Qen7ana de con5ola% @7il para e5criMir
aplicacione5 de Qen7ana5 o 5in in7erOa8
Iibrary
LiMrerVa
moduIe
!ódulo de código no per7enecien7e a ningTn en5amMlado
T9C-9 1): ,alore5 admi7ido5 por la opción /t de csc
El lenguaje de programación C# (ema &+L El compilador de C# de
!icro5oO7
(an7o la5 liMrerVa5 como lo5 ejecu7aMle5 5on 5imple5 coleccione5 de 7ipo5 de da7o5
compilado5% La Tnica diOerencia en7re ello5 e5 Rue lo5 5egundo5 di5ponen de un
m67odo e5pecial IMain()K Rue 5irQe de pun7o de en7rada a par7ir del Rue puede
ejecu7ar5e código u5ando lo5 mecani5mo5 oOrecido5 por el 5i57ema opera7iQo
Ie5criMiendo 5u nomMre en la lVnea de comando5N 5eleccion9ndolo gr9Oicamen7eN e7c%K
La diOerencia de un módulo con lo5 an7eriore5 7ipo5 de OicWero5 e5 Rue 657e no Oorma
par7e de ningTn en5amMlado mien7ra5 Rue lo5 primero5 5V% El CL) no puede 7raMajar
con módulo5 porRue e57o5 carecen de maniOie57oN pero crearlo5 permi7e di5poner de
código compilado Rue pueda aXadir5e a en5amMlado5 Rue 5e generen po57eriormen7e
S Rue podr9n acceder a 5u5 miemMro5 internaI%
• /mainL Si al compilar un ejecu7aMle WuMie5e m95 de un pun7o de en7rada Q9lido en7re
lo5 7ipo5 deOinido5 en lo5 Ouen7e5 a compilar 5e Wa de indicar como Qalor de e57a
opción cual e5 el nomMre del 7ipo Rue incluSe la deOinición del Main() a u7ili8arN pue5
5i no el compilador no 5aMrVa con cTal de 7oda5 Ruedar5e%
Como e5 lógicoN lo Rue nunca puede Wacer5e e5 deOinir m95 de un pun7o de en7rada
en un mi5mo 7ipo de da7oN pue5 en7once5 ni 5iRuiera a 7raQ65 de la opción /main
podrVa re5olQer5e la amMigiedad%
• /out I/oKL Por deOec7o el re5ul7ado de la compilación de un ejecu7aMle e5 un OicWero
.exe con el nomMre del Ouen7e compilado Rue con7enga el pun7o de en7radaN S el de
la compilación de un módulo o liMrerVa e5 un OicWero con el nomMre del primero de
lo5 Ouen7e5 a compilar indicado5 S eU7en5ión dependien7e del 7ipo de OicWero
generado I.netmodule para módulo5 S .dll para liMrerVa5K Si 5e de5ea darle o7ro
nomMre Ma57a indicarlo como Qalor de e57a opción%
El Qalor Rue 5e le d6 Wa de incluir la eU7en5ión del OicWero a generarN lo Rue permi7e
compilar OicWero5 con eU7en5ione5 diOeren7e5 a la5 de 5u 7ipo% Por ejemploN para crear
un módulo ..e$e a par7ir de un Ouen7e ..cs puede Wacer5eL
csc *out+..e$e *t+module ..cs
MQiamen7eN aunRue 7enga eU7en5ión .exe el OicWero generado 5er9 un módulo S no
un ejecu7aMleN por lo Rue 5i 5e in7en7a ejecu7arlo 5e producir9 un error inOormando de
Rue no e5 un ejecu7aMle Q9lido% Como puede deducir5eN camMiar la eU7en5ión de lo5
OicWero5 generado5 no 5uele 5er T7il S 5ólo podrVa Qenir Mien para diOicul7ar apo57a la
compren5ión del Ouncionamien7o de una aplicación o para iden7iOicar en5amMlado5
con algTn 5igniOicado o con7enido e5pecial%
• /re0erence I/rKL Por deOec7o 5ólo 5e Mu5can deOinicione5 de 7ipo5 de da7o5
eU7erna5 a lo5 Ouen7e5 a compilar en la liMrerVa mscorlib.dll Rue Oorma par7e de la
BCL% Si alguno de lo5 Ouen7e5 a compilar Wace u5o de 7ipo5 pTMlico5 deOinido5 en
o7ro5 en5amMlado5 WaS Rue indicar como Qalore5 de /r cu9le5 5on e5o5 en5amMlado5
para Rue 7amMi6n 5e Mu5Rue en ello5%
En mscorlib.dll 5e encuen7ran lo5 7ipo5 de u5o m95 Orecuen7e5 incluido5 en la
BCL% En el poco Orecuen7e ca5o de Rue WaSa deOinido 5u propia Qer5ión de ello5 S no
El lenguaje de programación C# (ema &+L El compilador de C# de
!icro5oO7
de5ee Rue 5e u5e la de la BCLN puede pa5ar al compilador el Olag /nostdlib para
indicarle Rue no de5ea Rue Mu5Rue implVci7amen7e en mscorlib.dll%
Puede Rue 7ermine de5cuMriendo Rue en realidad 7ampoco Wace Oal7a reOerenciar a la
maSorVa de la5 re57an7e5 liMrerVa5 Rue Oorman la BCL% Pue5 MienN e57o no 5e deMe a
Rue 7amMi6n la5 reOerencie implVci7amen7e el compiladorN 5ino a Rue 5e incluSen en
un OicWero de re5pue57a Im95 adelan7e 5e eUplica lo Rue 5on e57e 7ipo de OicWero5K
u5ado por deOec7o por el compilador% Si no de5ea Rue u7ilice e57e OicWero puede
pa5arle el Olag /nocon0ig%
Cuando 5e den Qalore5 a /r WaS Rue 7ener en cuen7a Rue por deOec7o el compilador
in7erpre7ar9 cada ru7a a5V indicada de manera rela7iQa re5pec7o al direc7orio de5de el
Rue 5e le llame% Si no lo encuen7ra allV lo War9 rela7iQamen7e re5pec7o al direc7orio
donde e576 in57alado el CL)N Rue en lo5 5i57ema5 <indoY5 e5 el 5uMdirec7orio
;icroso0t.N,T\%ramewor<\v:2ersiBnClr= del direc7orio de in57alación de
<indoY5% 2 5i 7ampoco lo encuen7ra allV la in7erpre7ar9 re5pec7o a lo5 direc7orio5
indicado5 por la QariaMle de en7orno #CB de 5u 5i57ema opera7iQo%
E57a polV7ica de MT5Rueda puede modiOicar5e incluSendo opcione5 /lib al llamar al
compilador cuSo5 Qalore5 le indiRuen en Ru6 direc7orio5 Wa de Mu5car an7e5 de pa5ar
a Mu5car en lo5 indicado5 por la QariaMle de en7orno #CB%
• /addmoduleL /unciona de Oorma parecida a /r pero 5e u7ili8a cuando lo Rue u5an lo5
Ouen7e5 5on 7ipo5 deOinido5 eU7ernamen7e en módulo5 en Qe8 de en en5amMlado5%
Inclu5o a la Wora de Mu5car módulo5 5e 5igue la mi5ma polV7ica Rue al Mu5car
en5amMlado5 S 5e admi7e el u5o de /lib para modiOicarla%
Se incluSen opcione5 /r S /addmodule 5eparada5 porRue aXadir un módulo a una
compilación implica decir Rue 5e de5ea Rue lo5 7ipo5 Rue incluSe Oormen par7e del
en5amMlado a generarN por lo Rue lo5 Ouen7e5 a compilar podr9n acceder a 5u5
miemMro5 internaI% Sin emMargoN cuando 5e reOerencia a o7ro5 en5amMlado5 con /r
e57o no ocurre S lo5 Ouen7e5 compilado5 no podr9n acceder a 5u5 miemMro5 internaI%
E5 impor7an7e 5eXalar Rue el CL) e5pera Rue 7odo5 lo5 módulo5 Rue 5e aXadan a un
en5amMlado 5e di57riMuSan den7ro del mi5mo direc7orio Rue la liMrerVa o ejecu7aMle
corre5pondien7e al mi5mo% Si no 5e Wicie5e a5V no lo5 podrVa locali8ar S en 7iempo de
ejecución 5e producirVa una System.TypeLoadException 5i 5e in7en7a5e acceder a lo5
7ipo5 deOinido5 en ello5%
AunRue en principio 5e Wa dicWo Rue no impor7a cómo 5e in7ercalen opcione5 S
nomMre5 de Ouen7e5 en7re lo5 argumen7o5 pa5ado5 a cscN WaS una eUcepción Rue con5i57e
en Rue /out S /r 5iempre Wan de indicar5e an7e5 de algTn Ouen7e% E57o permi7e Rue en
una mi5ma llamada al compilador 5ea po5iMle 5olici7ar la generación de un en5amMlado
S mTl7iple5 módulo5 de códigoN pue5 5e con5idera Rue cada aparición de la5 opcione5
an7eriore5 Wace reOerencia 5ólo a lo5 Ouen7e5 Rue le 5iguen% Por ejemploN dadaL
csc *t+li-rary *out+Li-..dll ..cs *t+module *out+Mod1.netmodule 1.cs
E57a llamada proQocar9 la compilación de ..cs como liMrerVa de nomMre Li-..dll S la
de 1.cs como módulo llamado Mod1.netmodule.
El lenguaje de programación C# (ema &+L El compilador de C# de
!icro5oO7
Sin emMargoN al Wacer a5V compilacione5 mTl7iple5 WaS Rue 7ener en cuen7a Rue 5ólo e5
Q9lido 5olici7ar Rue el primer grupo de OicWero5 indicado 5e compile como en5amMlado%
Por 7an7oN 5erVa incorrec7o WacerL
csc *t+module *out+Mod1.netmodule 1.cs *t+li-rary *out+Li-..dll ..cs
E57a llamada e5 incorrec7a porRue indica Rue 5e de5ea Rue el 5egundo grupo de OicWero5
d6 lugar a un en5amMlado S ello 5ólo puede Wacer5e con el primero%
Por o7ro ladoN 7amMi6n WaS Rue 7ener en cuen7a Rue no e5 Q9lido Rue un mi5mo 7ipo de
da7o 5e deOina en Qario5 de lo5 grupo5 de OicWero5 indicado5% Por ejemploN 5i 5e Rui5ie5e
compilar ..cs como ejecu7aMle S como módulo podrVa pen5ar5e en WacerL
csc ..cs *t+li-rary ..cs
Sin emMargoN e57a llamada no e5 Q9lida porRue lo5 do5 grupo5 de OicWero5 indicado5
con7ienen el mi5mo OicWero S por 7an7o deOinicione5 comune5 de 7ipo5 de da7o5% La Tnica
5olución po5iMle 5erVa Wacer do5 llamada5 por 5eparado al compilador comoL
csc ..cs
csc *t+li-ary ..cs
ManipuIación de recursos
Lo5 @76J14.; 51 41604;.; 5on arcWiQo5 Rue no con7ienen código 5ino 5ólo da7o5 7ale5
como cadena5 de 7eU7o5N im9gene5N QVdeo5 o 5onido5% Su u7ilidad e5 Oacili7ar el de5acople
en7re la5 aplicacione5 S lo5 da7o5 concre7o5 Rue u5enN de modo Rue 5ea O9cil reu7ili8arlo5
en mTl7iple5 aplicacione5N modiOicarlo5 5in 7ener Rue recompilar lo5 Ouen7e5 S
de5arrollar diOeren7e5 Qer5ione5 de cada aplicación en la5 Rue 5ólo QarVen dicWo5 da7o5%
E57o5 OicWero5 5on e5pecialmen7e T7ile5 al Wora de in7ernacionali8ar aplicacione5N pue5 5i
5e dejan 7odo5 lo5 da7o5 Rue 5e u7ilicen en OicWero5 de recur5o5 independien7e5 del
códigoN a la Wora de crear nueQa5 Qer5ione5 en o7ro5 idioma5 5ólo 5er9 nece5ario camMiar
lo5 OicWero5 de recur5o5 S WaMr9 Rue 7ocar para nada el código%
El oMje7iQo de e57e 7ema no e5 eUplicar cómo crear S acceder a OicWero5 de recur5o5N 5ino
eUplicar el 5igniOicado de la5 opcione5 de compilación relacionada5 con ello5% Si de5ea
aprender m95 5oMre recur5o5 puede comen8ar Mu5cando en el apar7ado -isual
(tudio.N,T  .N,T %ramewor<  .N,T %ramewor< Tutorials  "esources
and #ocali6ation Dsing t*e .N,T %ramewor< ('E de la aSuda del S#A%
Lo Rue 5V e5 impor7an7e e5 5eXalar Rue aunRue en la pla7aOorma %NE( pueden crear5e
OicWero5 de recur5o5 7an7o en Oorma7o .txt como .resxN el compilador de C# 5ólo lo5
admi7e 5i e579n compilado5 en Oorma7o .resources% Para elloN en el S#A 5e incluSe una
u7ilidad llamad resgen.exe Rue permi7e compilar en dicWo Oorma7o OicWero5 de recur5o5
e5cri7o5 en cualRuiera de lo5 Oorma7o5 an7eriore5 con 5ólo pa59r5elo5 como argumen7o5%
Por ejemploN 5i 5e le llama a5VL

resgen misrecursos.res$
El lenguaje de programación C# (ema &+L El compilador de C# de
!icro5oO7
Suponiendo Rue el con7enido de misrecursos.res$ 5ea el de un OicWero .resx Q9lidoN
7ra5 e57a llamada 5e WaMr9 generado en el direc7orio de5de el Rue 5e le llamó un OicWero
misrecursos.resources con el con7enido de misrecursos.res$%
Para aXadir e57e OicWero al en5amMlado re5ul7an7e de una compilación 5e puede u7ili8ar la
opción /lin<resource I/lin<resK A5V por ejemploN para crear un en5amMlado
<uenteC.dll Oormado por el código re5ul7an7e de compilar <uenteC.cs S lo5 recur5o5
de misrecursos.resources podrVa compilar5e conL
csc *t+li-rary <uenteC.cs *linKres+misrescursos.resources
#e e57e modo el OicWero de recur5o5 Oormar9 par7e del en5amMlado generado pero
permanecer9 en un OicWero 5eparado de 0uenteF.dll% Si 5e de5ea5e incru57arlo en 6l
WaMrVa Rue WaMer compilado con la opción /resource I/resK en Qe8 de /lin<res 7al S
como 5e mue57ra a con7inuaciónL
csc *t+li-rary <uenteC.cs *res+misrescursos.resources
#e5de código podr9 acceder5e a e57o5 recur5o5 por medio de lo5 5erQicio5 de la cla5e
ResourceManager del e5pacio de nomMre5 System.Resources 5i Oueron generado5 con
re57enN o con lo5 m67odo5 GetManifestResource() de la cla5e AssembIy del e5pacio de
nomMre5 System.RefIection% Para Wacer reOerencia a cada uno 5e u5arVa en principio 5u
nomMre de OicWeroN aunRue /res S /lin<res permi7e Rue 7ra5 la ru7a de 657e 5e indiRue
5eparado por una coma cualRuier o7ro iden7iOicador a a5ociarle% Por ejemploL
csc *t+li-rary <uenteC.cs *res+misrescursos.resources#recursos
Como un 7ipo e5pecial de recur5o Rue comTnmen7e 5uele incru57ar5e en lo5 ejecu7aMle5
de lo5 programa5 e5 el icono IOicWero gr9Oico en Oorma7o .icoK con el Rue de5de la5
in7erOace5 gr9Oica5 de lo5 5i57ema5 opera7iQo5 5e le5 repre5en7ar9N csc oOrece una opción
e5pecVOica llamada /win32icon en cuSo Qalor puede indic9r5ele el icono a incru57arL

csc 5rograma.cs *,in(Dicon+5rograma.ico
En realidad WaS Rue recordar el u5o de OicWero5 de recur5o5 no e5 un a5pec7o in7roducido
en la pla7aOorma %NE( 5ino di5poniMle de5de Wace 7iempo en la pla7aOorma <indoY5 en
Oorma de OicWero5 .res% Por compa7iMilidad con e57e an7iguo Oorma7o de recur5o5N csc
incorpora una opción /win32res Rue permi7e incru57arlo5 de igual Oorma a como /res
incru57a lo5 noQedo5o5 OicWero5 .resources%
En cualRuier ca5oN WaS Rue 5eXalar Rue 5iempre Rue 5e aXada un OicWero de recur5o5 a un
en5amMlado la Qi5iMilidad Rue 5e con5iderar9 para lo5 recur5o5 Rue incluSa e5 pubIic%
Configuración de mensajes de avisos y errores
Cada Qe8 Rue el compilador de7ec7a algTn error en uno de lo5 Ouen7e5 a compilar genera
un men5aje inOormando de ello en el Rue indica en Ru6 OicWero de código Ouen7e S en
Ru6 po5ición eUac7a del mi5mo IlVnea S columnaK lo Wa de7ec7ado% Por ejemploN 5i en la
columna * de la lVnea . de un Ouen7e llamado e7.cs 5e llama a un m67odo con nomMre
comple7o ..[(% ineUi57en7eN 5e mo57rar9 un men5aje comoL
El lenguaje de programación C# (ema &+L El compilador de C# de
!icro5oO7
e7.cs(X#(%+ error CSCCX+ M.M does not contain a de<inition <or M[M
Nó7e5e Rue del OicWero 5ólo 5e da 5u nomMre S ello podrVa no iden7iOicarlo unVQocamen7e
5i 5e compilaron a la Qe8 Qario5 con el mi5mo nomMre pero per7enecien7e5 a direc7orio5
diOeren7e5% Para 5olucionar e57o puede u5ar5e la opción /0ullpat*sN con lo Rue de lo5
men5aje5 de error incluirVan 5iempre la ru7a comple7a de lo5 OicWero5 deOec7uo5o5% Por
ejemploN 5i el OicWero del ejemplo an7erior 5e encon7raMa en C+8@7em5loN al compilarlo
con e57a opción 5e mo57rarVa el men5aje de error a5VL
C+8@7em5lo8e7.cs(X#(%+ error CSCCX+ M.M does not contain a de<inition
<or M[M
HaS Qece5 Rue el compilador de7ec7a Rue 5e Wan e5cri7o en el Ouen7e cier7a5 5eccione5 de
7al manera Rue 5in 5er errónea5 5on cuan7o meno5 5o5pecWo5a5 ISa 5ea por 5er aM5urda5N
por pre57ar5e a conOu5iónN e7cKN S en e5o5 ca5o5 lo Rue Wace e5 emi7ir men5aje5 de aQi5o%
Por ejemploN 5i en la deOinición del 7ipo A del Ouen7e 5rue-a.cs 5e WuMie5e incluidoL

static void Main(int x)
{}
En principio e5 una deOinición de m67odo perOec7amen7e Q9lida% Sin emMargoN como 5e
parece mucWo a una deOinición de pun7o de en7rada pero no e5 Q9lida como 7alN el
compilador generar9 el men5aje de aQi5o Rue 5igue para inOormar de ello al u5uario por
5i aca5o 657e lo Rue RuerVa Wacer era deOinir un pun7o de en7rada S 5e eRuiQocóL
5rue-a.cs(X#CV%+ ,arning CSDI+ M..Main(int%M Jas tJe ,rong signature
to -e an entry 5oint
Como 5e QeN la e57ruc7ura de lo5 men5aje5 de aQi5o e5 muS 5imilar a la de lo5 men5aje5
de error S 5ólo 5e diOerencia de 657a en Rue incluSe ,arning en Qe8 de error 7ra5 el
indicador de po5ición en el Ouen7e% Inclu5o como a e57o5N la opción /0ullpat*s
7amMi6n le5 aOec7a S proQoca Rue 5e mue57ren la5 ru7a5 de lo5 Ouen7e5 al comple7o%
"na diOerencia impor7an7e en7re aQi5o5 S errore5 e5 Rue la aparición de men5aje5 de lo5
5egundo5 duran7e la compilación aMor7a la generación del MinarioN mien7ra5 Rue la
aparición de lo5 primero5 no IaunRue en amMo5 ca5o5 nunca 5e aMor7a la compilación
5ino Rue 7ra5 mo57rarlo5 5e 5igue anali8ando lo5 Ouen7e5 por 5i pudie5en de7ec7ar5e m95
errore5 S aQi5o5K AWora MienN 7amMi6n puede Oor8ar5e a Rue ello ocurra con lo5 de aQi5o
pa5ando al compilador el Olag /warnaserrorN con lo Rue 5e con5eguirVa Rue 7odo
men5aje de aQi5o 5e mo57ra5e como error% Ello puede re5ul7ar T7il porRue Ouer8a a
e5criMir lo5 Ouen7e5 de la manera m95 OiaMle e in7eligen7emen7e po5iMle%
En el lado opue57oN puede Rue WaSa cier7o5 7ipo5 de men5aje5 de aQi5o de lo5 Rue no 5e
de5ea 5iRuiera Rue 5e inOorme en 7an7o Rue la inOormación Rue apor7an Sa 5e conoce S 5e
5aMe Rue no aOec7ar9 nega7iQamen7e al programa% En e5o5 ca5o5 puede u5ar5e la opción
/nowarn indicando como Qalore5 5uSo5 lo5 código5 a5ociado5 a lo5 men5aje de aQi5o
Rue no 5e de5ea Rue 5e repor7en% El código a5ociado a cada 7ipo de men5aje de aQi5o e5
la palaMra de la Oorma C(:cBdigo= Rue 5e mue57ra 7ra5 ,arning en el men5aje de aQi5o%
A5VN para compilar el 5rue-a.cs del ejemplo an7erior 5in Rue 5e genere el men5aje de
aQi5o arriMa mo57rado puede Wacer5eL
csc 5rue-a.cs *no,arn+DI
El lenguaje de programación C# (ema &+L El compilador de C# de
!icro5oO7
En realidad lo5 cero5 incluido5 a la i8Ruierda del código del aQi5o en lo5 men5aje5 de
aQi5o 5on opcionale5N por lo Rue la compilación an7erior e5 eRuiQalen7e aL
csc 5rue-a.cs *no,arn+DI
Cada Qer5ión del compilador ignorar9 por compa7iMilidad la5 5upre5ione5 de aQi5o5
eUi57en7e5 en an7eriore5 Qer5ione5 del mi5mo pero eliminado5 en la5 nueQa5N aunRue 5i
5e le5 e5peciOican código5 no Q9lido5 para ninguna Qer5ión emi7ir9n un men5aje de error%
Si de5ea oM7ener la li57a comple7a de 7odo5 lo5 7ipo5 de men5aje de aQi5o S error con 5u5
re5pec7iQo5 código5 puede con5ul7ar den7ro de la documen7ación del %NE( /rameYor]
S#A en -isual (tudio.N,T  -isual Basic and -isual CG  -isual CG
#anguage  CG Compiler /ptions  Compiler ,rrors C(HHHF to C(IIII
Si en lugar de de5ac7iQar cier7o5 7ipo5 de aQi5o5 uno por uno de5ea de5ac7iQarlo5 por
grupo5 5egTn 5u 5eQeridadN en7once5 puede Wacerlo a 7raQ65 de la opción /warn Io /wK
E57a opción 7oma como Qalor un nTmero comprendido en7re + S 3 Rue indica cu9l e5 el
niQel de aQi5o5 con el Rue 5e de5ea 7raMajar% Por deOec7o 657e Qale 3N lo Rue 5igniOica Rue
5e mo57rar9n 7odo5 lo5 aQi5o5N pero puede d9r5ele cualRuiera de lo5 de la (aMla :=L
N7A1- 51 9A7;. AA7;.; ?.;3495.;
H
Ninguno
F
Sólo lo5 m95 graQe5
2
Lo5 m95 graQe5 S alguno5 meno5 graQe5 como por ejemplo lo5
rela7iQo5 a ocul7acione5 de miemMro5
3
Lo5 de niQel & m95 alguno5 poco graQe5 como lo5 rela7iQo5 al u5o
de eUpre5ione5 aM5urda5 Rue 5iempre produ8can el mi5mo re5ul7ado
J
(odo5% E5 lo Rue 5e 7oma <.4 51@163.
T9C-9 16: NiQele5 de men5aje5 de aQi5o
Si e579 in7ere5ado en conocer en concre7o el niQel de algTn 7ipo de aQi5o puede remi7ir5e
a la de5cripción 5oMre el mi5mo incluida en la documen7ación del S#A an7e5 comen7ada
Ficheros de respuesta
La lVnea de comando5 no e5 la Tnica Oorma de pa5ar inOormación al compilador I7an7o
OicWero5 a compilar como opcione5 de compilaciónKN 5ino Rue 7amMi6n e5 po5iMle
almacenar inOormación de e57e 7ipo en un OicWero S pa59r5ele al compilador como
argumen7o 5olamen7e dicWo OicWero S no 7oda la inOormación en 6l con7enida% #e e57e
modo 5e Oacili7arVa la laMor de pa5ar como par9me7ro5 la5 opcione5 de u5o m95 Orecuen7e
Sa Rue Ma57arVa 5ólo indicar cu9l e5 el nomMre de un OicWero Rue la5 e5peciOica%
A e57e OicWero5 5e le5 llama @76J14.; 51 41;<01;39N Sa Rue al pa59r5elo5 al compilador
5u con7enido puede Qer5e como la re5pue57a a cu9le5 5on lo5 argumen7o5 a u5ar duran7e
la compilación% La eU7en5ión de e57o5 OicWero5 5uele 5er .rspN S aunRue nada oMliga a
d9r5ela e5 conQenien7e Wacerlo como ocurre con 7odo conQenio%
El lenguaje de programación C# (ema &+L El compilador de C# de
!icro5oO7
Al compilarN por deOec7o el compilador 5iempre lee un OicWero de re5pue57a llamado
csc.rsp uMicado en el direc7orio del CL) Rue almacena reOerencia5 a 7odo5 lo5
en5amMlado5 predeOinido5% Por 7an7oN para en7ender la 5in7aUi5 a 5eguir para e5criMir e57e
7ipo de OicWero5 nada mejor Rue Qer cu9l e5 el con7enido de e57e csc.rsp S de pa5o
5aMer cu9le5 5on la5 opcione5 Rue por deOec7o 5e aXadir9n a 7oda compilaciónL
# This file contains command-line options that the C#
# command line compiler (CSC) will process as part
# of every compilation, unless the "/noconfig" option
# is specified.
# Reference the common Framework libraries
/r:Accessibility.dll
/r:Microsoft.Vsa.dll
/r:System.Configuration.Ìnstall.dll
/r:System.Data.dll
/r:System.Design.dll
/r:System.DirectoryServices.dll
/r:System.dll
/r:System.Drawing.Design.dll
/r:System.Drawing.dll
/r:System.EnterpriseServices.dll
/r:System.Management.dll
/r:System.Messaging.dll
/r:System.Runtime.Remoting.dll
/r:System.Runtime.Serialization.Formatters.Soap.dll
/r:System.Security.dll
/r:System.ServiceProcess.dll
/r:System.Web.dll
/r:System.Web.RegularExpressions.dll
/r:System.Web.Services.dll
/r:System.Windows.Forms.Dll
/r:System.XML.dll
#el con7enido de e57e OicWero e5 O9cil deducir Rue la e57ruc7ura de lo5 OicWero5 de
re5pue57a e5 5encillaL la5 opcione5 a pa5ar al compilador 5e indican en el mi5o 7al cuale5
S pueden incluir5e comen7ario5 como lVnea5 Rue comiencen en #% Adem95N como puede
Qer5eN el OicWero de re5pue57a u5ado por deOec7o aXade reOerencia5 a la5 liMrerVa5 de la
BCL de u5o m95 comTnN lo Rue eQi7a 7ener Rue incluirla5 con57an7emen7e al compilar%
(ra5 7omar la5 opcione5 de e57e OicWeroN el compilador mira 5i en el direc7orio de5de el
Rue 5e le llama WaS o7ro csc.rsp S 5i e5 a5V 7oma 5u5 opcione5% Si por alguna ra8ón no
no5 in7ere5a5e Rue 5e 7oma5en la5 opcione5 de dicWo5 OicWero5 Ipor ejemploN para u5ar
nueQa5 Qer5ione5 de 7ipo5 incluido5 en la5 liMrerVa5 Rue reOerencianK Ma57arVa pa5ar el
Olag /nocon0ig al compilar para de5ac7iQar e57a MT5Rueda por deOec7o en ello5N aunRue
WaS Rue 5eXalar Rue e57e Olag no admi7e lo5 5uOijo5 $ S 3 admi7ido5 por el re57o de Olag5%
Al e5criMir OicWero5 de re5pue57a WaS Rue 7ener cuidado con do5 co5a5L no e5 po5iMle
cor7ar la5 opcione5 o nomMre5 de OicWero con re7orno5 de carro Rue proQoRuen Rue
ocupen Qaria5 lVnea5b S la5 opcione5 5on pa5ada5 al compilador en el mi5mo orden en
Rue apare8can en el Ouen7eN por lo Rue WaS Rue 7ener cuidado con cómo 5e coloRuen la5
opcione5 /out S /t por la Sa comen7ada impor7ancia del orden de e5peciOicación%
"na Qe8 e5cri7o un OicWero de re5pue57aN para indicar al compilador Rue Wa de u5arlo
Ma57a pa59r5elo como un nomMre de Ouen7e m95 pero precediendo 5u nomMre del 5uOijo
El lenguaje de programación C# (ema &+L El compilador de C# de
!icro5oO7
2% Por ejemploN para compilar ..cs u5ando la5 opcione5 almacenada5 en o5c.rs5
WaMrVa Rue llamar al compilador conL
csc Ho5c.rs5 ..rs5
(amMi6n 5erVa po5iMle indicar mTl7iple5 OicWero5 de re5pue57aN ca5o en Rue 5e 7omarVan
la5 opcione5 de cada uno en el mi5mo orden en Rue aparecie5en en la llamada a csc% Por
ejemploN para compilar ..rs5 7omando la5 opcione5 de o5cC.rs5 S luego la5 de
o5cD.rs5 podrVa llamar5e al compilador conL
csc Ho5cC.rs5 Ho5cD.rs5 ..rs5
Puede ocurrir Rue la5 opcione5 indicada5 en un OicWero de re5pue57a con7radigan a
opcione5 indicada5 en o7ro OicWero de re5pue57a indicado a con7inuación o a opcione5
dada5 al compilador en la lVnea de comando5% Para re5olQer e57a5 amMigiedade5 el
compilador 5iempre Qa proce5ando lo5 argumen7o5 Rue 5e le pa5en de i8Ruierda a
derecWa S 5e Rueda con la Tl7ima e5peciOicación dada a cada opción% A5VN en el ejemplo
an7erior la5 opcione5 del csc.rsp del direc7orio de5de el Rue 5e le llamó d5i eUi57ie5eD
7endrVa preOerencia 5oMre la5 del csc.rsp del direc7orio del CL)N la5 de o5cD.rs5
7endrVan preOerencia 5oMre la5 de 657eN S la5 de o5cC.rs5 5oMre la5 de o5cD.rs5%
(amMi6n pueden incluir5e en lo5 OicWero5 de re5pue57a opcione5 2 Rue incluSan a o7ro5
OicWero5 de re5pue57aN con lo Rue 5e 7omarVa 5u5 opcione5 an7e5 de con7inuar 7omando la5
5iguien7e5 del OicWero Rue lo incluSóN aunRue oMQiamen7e nunca 5e admi7ir9 Rue un
OicWero incluido 5ea el mi5mo Rue el Rue lo incluSe o Rue alguno Rue incluSa a 657eN
pue5 en7once5 5e OormarVan ciclo5 S nunca acaMarVa la MT5Rueda de opcione5%

Opciones de depuración
Sin duda la opción de depuración m95 impor7an7e e5 el Olag /debugN cuSa inclu5ión
indica al compilador Rue Wa de generar un OicWero .pdb con inOormación 5oMre la
relación en7re el OicWero Minario generado S la5 lVnea5 de lo5 Ouen7e5 a par7ir de lo5 Rue
5e generó% E57a inOormación e5 muS T7il para depurar aplicacione5N pue5 permi7e mo57rar
la in57rucción de código Ouen7e Rue produjo la5 eUcepcione5 en lugar de mo57rar la5
in57ruccione5 de código na7iQo en Rue Oue 7raducida%
Para en7ender mejor la u7ilidad de e57e OicWero .pdb puede e5criMir el programaL
class A
{
public static void Main()
{throw new System.Exception();}
}
Si lo compila conL
csc ..cs
Al ejecu7arlo 5e producir9 una eUcepción S 5urgir9 una Qen7ana de 5elección de
depurador% Si pul5a No en ella Qer9 en la con5ola un men5aje como el 5iguien7eL

El lenguaje de programación C# (ema &+L El compilador de C# de
!icro5oO7
Unhandled Exception: System.Exception: Exception of type System.Exception was thrown.
at A.Main()
Sin emMargoN 5i lo compila conL
csc ..cs *de-ug
Al ejecu7arlo 5e oM7endr9 un men5aje mucWo m95 de7allado en el Rue 5e indicar9 cu9l e5
la lVnea eUac7a del código Ouen7e duran7e cuSa ejecución 5e produjo la eUcepciónL
Unhandled Exception: System.Exception: Exception of type System.Exception was thrown
at A.Main() in E:\c#\Ej\A.cs:line 5
Como e5 O9cil deducirN a par7ir de e57a inOormación e5 O9cil crear Werramien7a5 de
depuración Dcomo el depurador de ,i5ual S7udio%NE( o el CL) #eMugger del S#AD
Rue mue57ren la lVnea eUac7a del código Ouen7e donde 5e produjo la eUcepción lan8adab S
oMQiamen7e e57o5 da7o5 7amMi6n pueden 7ener mucWo5 o7ro5 u5o5N como permi7ir ejecu7ar
pa5o a pa5o lo5 programa5 mo57rando en cada momen7o cu9l e5 la lVnea del Ouen7e Rue
5e ejecu7ar9 a con7inuación S co5a5 5imilare5%
(amMi6n puede u5ar5e /debug como opción con argumen7o5 en Qe8 de cómo OlagN lo
Rue permi7e generar una Qer5ión recor7ada de la inOormación de depuración% Si de e57a
Oorma 5e le da el Qalor 0ull Ouncionar9 eUac7amen7e igual Rue al ac7iQarla como OlagN
pero 5i 5e le da el Qalor pdbonly en7once5 la inOormación de depuración generada 5ólo
e57ar9 di5poniMle para lo5 depuradore5 de5de lo5 Rue 5e WaSa lan8ado la aplicaciónN pero
no para lo5 Rue 5e le WaSan adjun7ado din9micamen7e una Qe8 lan8ada%
Por Tl7imoN re5pec7o a la depuración de aplicacione5 conQiene 5eXalar Rue por deOec7o el
compilador 5iempre in7en7a generar el código lo m95 r9pidamen7e po5iMle para Oacili7ar
el de5arrollo de aplicacione5N Sa Rue mien7ra5 5e depuran 5uele 5er nece5ario reali8arle5
mucWa5 recompilacione5% No oM57an7eN una Qe8 Oinali8ada la depuración 5uele conQenir
ac7iQar la reali8ación de op7imi8acione5 por par7e del compilador en el e5pacio S 7iempo
de ejecución con5umido por el !SIL pa59ndole la opción /optimi6e$ I/o$K
CompiIación incrementaI
La 6.?<7-96782 72641?1239- con5i57e en 5ólo recompilar en cada compilación Rue 5e
Waga de un proSec7o aRuello5 m67odo5 cuSa deOinición WaSa camMiado re5pec7o a la
Tl7ima compilación reali8adaN con lo Rue el proSec7o podrVa compilar5e m95 r9pido Rue
Waciendo una compilación comple7a normal%
Para Rue e57o 5ea po5iMle Wacerlo WaS Rue llamar al compilador con el Olag
/incremental I/incrKN lo Rue proQocar9 la generación de un OicWero adicional con el
mi5mo nomMre Rue el Minario generado m95 una eU7en5ión .incr% Por ejemploN dadoL
csc *out+<uente.e$e *incremental Guente.cs
Se generar9 un ejecu7aMle <uente.e$e S un OicWero adicional <uente.e$e.incr%
AunRue pueda parecer redundan7e incluir en el ejemplo la opción /out al llamar al
compiladorN e5 nece5aria porRue al meno5 en la ac7ual Qer5ión del compilador e5
oMliga7orio e5peciOicarla 5iempre Rue 5e u7ilice /incr%
El lenguaje de programación C# (ema &+L El compilador de C# de
!icro5oO7
El OicWero .incr generado incluSe inOormación 5oMre la compilación Rue permi7ir9 Rue
po57eriore5 compilacione5 Rue 5e realicen con /incr ac7iQado puedan Wacer5e de
manera incremen7al% MQiamen7eN 5i e57e OicWero 5e elimina 5er9 recon57ruido en la
5iguien7e compilación Rue 5e Waga con /incrN pero dicWa compilación no 5e reali8ar9 de
manera comple7a por no di5poner5e del OicWero .incr duran7e ella%
Sin emMargoN el WecWo de Rue e576 di5poniMle un OicWero .incr al compilar un proSec7o
no implica Rue 5e u5eN pue5 el compilador puede ignorarlo S reali8ar una compilación
comple7a 5i de7ec7a Rue Wan camMiado la5 opcione5 de compilación e5peciOicada5 o 5i
de7ec7a Rue lo5 Ouen7e5 Wan camMiado 7an7o Rue e5 al meno5 igual de eOicien7e Wacerla a5V
Rue de manera incremen7al%
En realidad no e5 Mueno Wacer 5iempre la5 compilacione5 incremen7almen7e 5ino Rue
5ólo e5 T7il Wacerlo en proSec7o5 Oormado5 por mTl7iple5 Ouen7e5 de peRueXo 7amaXoN
mien7ra5 Rue en proSec7o5 con poco5 S grande5 OicWero5 5e gana poco o nada en 7iempo
de compilación% Adem95N lo5 ejecu7aMle5 generado5 incremen7almen7e pueden ocupar
m95 Rue lo5 generado5 por compilación comple7aN por lo 5ólo e5 recomendaMle compilar
incremen7almen7e la5 Qer5ione5 de prueMa de lo5 proSec7o5 pero no la5 deOini7iQa5%
Opciones reIativas aI Ienguaje
A lo largo de lo5 an7eriore5 7ema5 5e Wa ido di5eminando diQer5a5 opcione5 de
compilación relacionada5 de manera m95 o meno5 direc7a con el lenguaje C#% En e57e
pun7o Waremo5 recapi7ulación de 7oda5 ella5 mi5ma5 S la5 re5umiremo5L
• /de0ine I/dKL En el Tema &: El !re!ro$esador Sa 5e in7rodujo e57a opción cuSo5
Qalore5 recordemo5 Rue 5e u7ili8an para in7roducir deOinicione5 de 5VmMolo5 de
preproce5ado al principio de 7odo5 lo5 Ouen7e5 a compilar%
Por ejemploN 5i 5e de5ea compilar lo5 Ouen7e5 ..cs S 1.cs como 5i al principio de
ello5 5e WuMie5e incluido la5 direc7iQa5 de preproce5ado #define PRUEBA S #define
VERSÌON1 podrVa llamar5e al compilador conL
csc *d+4>?@1.&)@>S;/YC ..cs 1.cs
• /c*ec<edL En lo5 7ema5 3 S := 5e eUplicó Rue 7odo de5Mordamien7o Rue ocurra en
operacione5 ari7m67ica5 en7re QariaMle5 en7era5 e5 7ra7ado por deOec7o 7runcando el
re5ul7ado% Pue5 MienN la u7ilidad de ac7iQar e57a opción e5 preci5amen7e Oor8ar a Rue
5e incluSan en el código generado la5 comproMacione5 nece5aria5 para Rue en ca5o
de de5Mordamien7o 5e lance en 5u lugar una System.OverfIowException%
MQiamen7e el código compilado con /c*ec<ed 5e ejecu7ar9 m95 len7o Rue el Rue lo
Waga 5in ella Sa Rue incluir9 comproMacione5 de de5Mordamien7o adicionale5% Sin
1?C94=.N a camMio con ello 5e con5igue de7ec7ar con Oacilidad errore5 deriQado5 de
de5Mordamien7o5 Rue de o7ra manera podrVan pa5ar inadQer7ido5%
El lenguaje de programación C# (ema &+L El compilador de C# de
!icro5oO7
• /unsafeL En el Tema %8: C)di(o inse(#ro Sa 5e eUplicó Rue la Tnica u7ilidad de e57a
opción e5 5erQir al compilador de mecani5mo de 5eguridad gracia5 al Rue pueda
a5egurar5e de Rue el u5uario 5aMe lo Rue Wace al compilar código con pun7ero5%
• /docL E57a opción Sa 5e in7rodujo en el Tema %:: Do$#menta$i)n ;M+N donde 5e
eUplicó Rue 5e u5a para indicar al compilador Rue e5 de5ea generar un OicWero -!L
con el con7enido de lo5 comen7ario5 de documen7ación incluido5 en lo5 Ouen7e5 a
compilar% El nomMre de e5e OicWero 5er9 el Rue 5e d6 como Qalor a e57a opción%
Al u5ar e57a opción WaS Rue 7ener en cuen7a una co5aN S e5 Rue para op7imi8ar el
7iempo Rue 5e 7arda en reali8ar compilacione5 incremen7ale5N duran7e ella5 e57a
opción e5 ignorada% Por 7an7oN no 7iene mucWo 5en7ido comMinar /doc S /incr%
Otras opciones
Apar7e de la5 opcione5 comen7ada5N csc admi7e una5 cuan7a5 m95 aTn no de5cri7a5 Sa
5ea porRue 5u u5o e5 muS poco Orecuen7e o porRue no encajan correc7amen7e en ninguno
de lo5 5uMepVgraOe5 7ra7ado5% (oda5 e57a5 opcione5 5e recogen Oinalmen7e aRuVL
• /0ilealignL Lo5 Qalore5 dado5 a e57a opción indican el 7amaXo de la5 5eccione5 en
Rue 5e diQidir9n lo5 OicWero5 Minario5 re5ul7an7e5 de la compilación% Puede 7omar lo5
Qalore5 ;:&N :+&3N &+3'N 3+0= ó ':0&N S cada 5ección en lo5 Minario5 comen8ar9 en
una po5ición Rue 5ea mTl7iplo del Qalor dado a e57a opción%
Por deOec7o el Qalor Rue 5e le d6 puede Qariar dependiendo de la implemen7ación
Rue 5e Waga del CL)N aunRue darle un Qalor a medida puede 5er T7il en el di5eXo de
aplicacione5 para di5po5i7iQo5 empo7rado5 con e5ca5a capacidad de almacenamien7o
Sa Rue puede reducir el 7amaXo de lo5 OicWero5 generado5%
• /bugreportL #ado Rue e5 muS diOVcil di5eXar un compilador :++a liMre de errore5N
!icro5oO7 proporciona a 7raQ65 de e57a opción un mecani5mo Rue Oacili7a a lo5
u5uario5 el enQVo de inOormación 5oMre lo5 errore5 Rue de5cuMran en el mi5mo S
Oacili7a a !icro5oO7 la laMor de in7erpre7arla para 5olucionarlo5 lo an7e5 po5iMle%
El Qalor Rue 5e d6 a e57a opción e5 el nomMre de con el Rue 5e de5ea Rue 5e genere el
OicWero con la inOormación rela7iQa al error de5cuMier7o duran7e la compilación% En
dicWo OicWero csc in5er7ar9 au7om97icamen7e la 5iguien7e inOormaciónL
 pcione5 de compilación u7ili8ada5%
 ,er5ión del compiladorN CL) S 5i57ema opera7iQo u5ado%
 Copia de 7odo5 lo5 código5 Ouen7e5 compilado5% Como e5 lógicoN para
Oacili7ar la corrección a !icro5oO7 5e recomienda enQiar el programa m95
compac7o po5iMle en el Rue 5e produ8ca el error de5cuMier7o%
 Con7enido en WeUadecimal de lo5 módulo5 S en5amMlado5 no
predeOinido5 a lo5 Rue 5e Wa reOerenciado duran7e la compilación%
 !en5aje5 de 5alida mo57rado5 duran7e la compilación%
Apar7e de 7oda e57a inOormación in5er7ada au7om97icamen7e por el compiladorN
duran7e la generación del OicWero de error 7amMi6n 5e pedir9 al u5uario Rue indiRue
El lenguaje de programación C# (ema &+L El compilador de C# de
!icro5oO7
una peRueXa de5cripción 5oMre el error de7ec7ado S cómo cree Rue podrVa
5olucionar5e% #icWa inOormación 7amMi6n 5er9 aXadida de manera au7om97ica al
OicWero de error Rue 5e cree%
"n ejemplo cómo generar inOormación rela7iQa a un error QerVdico Rue 5e produce al
compilar un programa error.cs con la Be7a : del %NE( S#A /rameYor] e5L
csc error.cs *-ugre5ort+@rror?sing.cs
(ra5 con7e57ar a la5 pregun7a5 Rue el compilador War9 al u5uario 5oMre el error
encon7radoN el con7enido del OicWero generado e5 el 5iguien7eL
### C# Compiler Defect Report, created 07/12/00 20:14:36
### Compiler version: 7.00.9030
### Common Language Runtime version: 1.00.2914.16
### Operating System: Windows NT 5.0.2195 Service Pack 2
### User Name: Administrador
### Compiler command line
csc.exe error.cs /bugreport:ErrorUsing.cs
### Source file: 'e:\c#\ej\error.cs'
using System;
public class R1:ÌDisposable
{
public static void Main()
{
using (R1 r1 = new R1())
{
}
}
public void Dispose()
{}
}
### Compiler output
error.cs(7,3): error CS1513: } expected
error.cs(7,26): error CS1002: ; expected
error.cs(12,9): error CS1518: Expected class, delegate, enum, interface, or struct
error.cs(14,1): error CS1022: Type or namespace definition, or end-of-file expected
### User description
No detecta la instruccion using
### User suggested correct behavior
Posiblemente no haya sido implementada en esta version del compilador
Nó7e5e Rue aunRue el error de7ec7ado en el ejemplo e5 QerVdicoN en Qer5ione5 del
compilador po57eriore5 a la Be7a : no 5e produce porRue Sa Oue corregido%
• /baseaddressL E57a opción 5ólo 7iene 5en7ido cuando 5e 5olici7a la
generación de una liMrerVa e indica cu9l e5 la dirección de memoria en Rue 5e
preOiere Rue 657a 5e cargue cuando 5ea enla8ada din9micamen7e% Nó7e5e Rue 5e
Wa dicWo liMrerVaN pue5 5i el OicWero generado e5 de cualRuier o7ro 7ipo 5er9
ignorada%
El Qalor Rue 5e d6 a e57a opción puede indicar5e 7an7o en WeUadecimal como en
oc7al o decimal 5iguiendo la5 regla5 u5ada5 en C# para la e5cri7ura de li7erale5
El lenguaje de programación C# (ema &+L El compilador de C# de
!icro5oO7
en7ero5% Sin emMargoN WaS Rue 7ener en cuen7a Rue lo5 Mi75 meno5 5igniOica7iQo5
de e57a dirección pueden 5er redondeado5% Por ejemploN 5i e5criMimo5L
csc <icJero.cs *-aseaddress+$CCCCC
El compilador 7ra7ar9 e57a llamada 7al S como 5i 5e le WuMie5e pa5adoL
csc <icJero.cs *-aseaddress+$CCCC
Si no 5e da Qalor a e57a opciónN la5 liMrerVa5 5e in57alar9n en el 9rea de memoria
Rue 5e e57ime conQenien7e en cada implemen7ación del CL)%
• /codepageL Por deOec7o el compilador acep7a Ouen7e5 e5cri7o5 en
"nicodeN "(/D' o u5ando la p9gina de código5 por deOec7o del 5i57ema
opera7iQo% Si 5e de5ea compilar Ouen7e5 e5cri7o5 en o7ra5 p9gina5 de código WaS
Rue indicar como Qalor de e57a opción el iden7iOicador de ella%
"n u5o 7Vpico de e57a opción e5 permi7ir compilar Ouen7e5 e5cri7o5 en e5paXol con
un edi7or de 7eU7o5 de !SD#S Icomo edit.comKN ca5o en Rue WaS Rue darle el
Qalor V(X para Rue acep7e lo5 carac7ere5 e5peciale5 7ale5 como acen7o5 o eXe5%
• /ut0KoutputL Su inclu5ión indica Rue el compilador Wa de mo57rar lo5
men5aje5 u5ando el juego de carac7ere5 "(/D'N lo Rue e5 T7il cuando 5e u7ili8an
cier7o5 5i57ema5 opera7iQo5 in7ernacionale5 en lo5 Rue por deOec7o no 5e mue57ren
correc7amen7e dicWo5 men5aje5 por la Qen7ana de con5ola%
Para poder leerla en e5o5 ca5o5 5e recomienda u5ar e57e Olag al compilar S
redirigir la 5alida a un OicWero como mue57ra el 5iguien7e ejemplo donde 5e
compila ..cs redirigiendo lo5 men5aje5 de compilación a salida.t$t y
mo57r9ndolo5 en "(/D'L
csc ..cs *ut<Iout5ut = salida.t$t
• /*elp I/LKL !ue57ra un men5aje de aSuda re5umiendo cu9le5 5on la5
opcione5 admi7ida5 por el compilador S para Ru6 5irQen% (oda opción o OicWero a
compilar e5peciOicado jun7o opción 5on 7o7almen7e ignorado5%
• /nologoL Indica Rue no 5e de5ea Rue al ejecu7ar el compilador 5e genere
el men5aje Rue incluSe inOormación 5oMre la Qer5ión del compilador S el
copSrigW7 de !icro5oO7 5oMre el mi5mo Rue por deOec7o 5e mue57ra%
Suele u5ar5e cuando la compilación 5e 5olici7a de5de una aplicación o OicWero de
proce5amien7o por lo7e5N pue5 ocul7a la ejecución del compilador al u5uario S
ello puede Qenir Mien para eQi7ar Rue 657e cono8ca cómo Ounciona la aplicación o
para con5eguir un Ouncionamien7o m95 elegan7e S 7ran5paren7e de la mi5ma%
4cceso al compilador desde 2isual !tudio.NET
Como 5e eUplicó en 5u momen7o en el Tema 6: "ntrod#$$i)n a C7N a la5 opcione5 de
compilación de un proSec7o 5e accede de5de ,S%NE( a 7raQ65 de la5 p9gina5 de
El lenguaje de programación C# (ema &+L El compilador de C# de
!icro5oO7
propiedade5 del mi5moN la5 cuale5 7iene el a5pec7o mo57rado en la Ilu57ración 0 S 5e
oM7ienen 5eleccionando el proSec7o en el (olution ,xplorer S pul5ando 5oMre -iew
 roperty ages en el menT principal de ,i5ual S7udio%
I-0;3496782 (: P9gina5 de propiedade5 del proSec7o en ,i5ual S7udio%NE(
Para la maSorVa de opcione5 admi7ida5 por csc.exe 5e incluSe en e57a5 p9gina5
con7role5 7ale5 como caja5 de 7eU7o S li57a5 de5plegaMle5 Rue permi7en conOigurarla5 de
una manera Qi5ualN cómoda e in7ui7iQa% En la (aMla :. 5e re5ume en orden alOaM67ico
cu9l e5 el con7rol Rue en concre7o 5e a5ocia en e57a5 p9gina5 a cada opciónL
O<6782 C.234.- A7;09-
/baseaddress
Con0iguration roperties  +dvanced  Base +ddress
/nostdlib
Con0iguration roperties  +dvanced  'o no use
mscorlib
/c*ec<ed
Con0iguration roperties  Build  C*ec< 0or
+rit*metic /ver0low/Dnder0low
/debug
Con0iguration roperties  Build  .enerate 'ebugging
Cn0ormation
/de0ine
Con0iguration roperties  Build  Conditional
Compilation Constants
/doc
Con0iguration roperties  Build  =;# 'ocumentation
%ile
/0ilealign
Con0iguration roperties  Build  %ile +lignment
/incremental
Con0iguration roperties  +dvanced  Cncremental
Build
/main
Common roperties  .eneral  (tartup /b!ect
/optimi6e
Con0iguration roperties  Build  /ptimi6e code
/out
Common roperties  .eneral  +ssembly Name
/target
Common roperties  .eneral  /utput Type
/unsa0e
Con0iguration roperties  Build  +llow unsa0e code
bloc<s
El lenguaje de programación C# (ema &+L El compilador de C# de
!icro5oO7
/warn
Con0iguration roperties  Build  )arning #evel
bloc<s
/warnaserror
Con0iguration roperties  Build  Treat )arnings +s
,rrors
/win32icon
Common roperties  .eneral  +pplication Ccon
T9C-9 17: Con7role5 a5ociado5 a opcione5 de compilación
Como puede oM5erQarN de5de ,S%NE( no e5 po5iMle acceder a mucWa5 de la5 opcione5
del compilador en lVnea de comando5% En lo5 ca5o5 de /codepage, /0ullpat*s, /lib,
/*elp, /nologo, /recurse S /ut0Koutput e57o e5 lógico Sa Rue 5on opcione5 Rue
pierden 5u 5en7ido de5de den7ro en una in7erOa8 gr9Oica% HaS o7ro5 ca5o5 en Rue ello 5e
deMe a Rue 5e oOrecen de5de el menT principal de ,S%NE( o7ro5 mecani5mo5
al7erna7iQo5 para e5peciOicarla5N como 5on lo5 indicado5 en la (aMla :'L
O<6782 M16927;?. 51 9661;.
/bugreport
Melp  Customer %eedbac<
/resource
AXadir el recur5o a la 5olución a 7raQ65 de ro!ect  +dd ,xisting
Ctem% ConOigurarle en 5u Qen7ana de propiedade5 la propiedad Build
+ction con el Qalor ,mbedded "esource%
/re0erence
AXadir la reOerencia a la 5olución con ro!ect  +dd "e0erence
T9C-9 18: Acce5o a opcione5 Ouera de la5 p9gina5 de propiedade5
/inalmen7eN Rueda un grupo de opcione5 Rue no e579n di5poniMle5 5implemen7e porRue
la implemen7ación de ac7ual de ,S%NE( no la5 con7empla% Son 2N /lin<resourceN
/nocon0igN /nowarn S /win32res% A5V mi5moN el Qalor module de /t 7ampoco e5
5opor7adoN por lo Rue ,S%NE( no permi7e 7raMajar con módulo5%
El lenguaje de programación C# (ema &:L NoQedade5 de C# &%+
Tema 21: Novedades de C# 2.0
ntroducción
El &3 de c7uMre de &++* !icro5oO7 Wi8o pTMlico el primer Morrador de lo Rue 5erVa la
Qer5ión &%+ del lenguaje C#N incluida en la nueQa Qer5ión del %NE( /rameYor] conocida
con el nomMre claQe BJ75C1:% En ella 5e in7roducVa una impor7an7e noQedad en el CL)
con5i57en7e en proporcionar 5opor7e para 7ipo5 gen6rico5 Rue 5e pudie5en u5ar como
plan7illa5 en Ma5e a la Rue deOinir o7ro5 7ipo5% E57o lógicamen7e implicaMa Rue a lo5
lenguaje5 %NE( de !icro5oO7 en primer lugarN S pre5umiMlemen7e el re57o de5pu65N 5e
le5 Wicie5en 7amMi6n modiOicacione5 orien7ada5 a aproQecWar e57a nueQa Ouncionalidad%
En e57e 7ema 5e eUplican la5 noQedade5 para ello incluida5 en la Qer5ión &%+ de C#N a5V
como o7ra5 noQedade5 no direc7amen7e relacionada5 con lo5 gen6rico5 Rue 7amMi6n
incorporaL lo5 731495.41; para Oacili7ar la implemen7ación de la5 in7erOace5 IEnumerabIe
e IEnumeratorN lo5 ?N3.5.; 92827?.; S o7ro5 mecani5mo5 de57inado5 a Oacili7ar el
7raMajo con lo5 delegado5N la capacidad de diQidir la5 deOinicione5 de la5 cla5e5 en7re
Qario5 OicWero5 a 7raQ65 de 6-9;1; <94679-1;N la po5iMilidad de a5ignar nuII a lo5 7ipo5
Qalor a 7raQ65 de lo5 nueQo5 37<.; A9-.4 920-9C-1;N e7c%
En principioN la5 modiOicacione5 in7roducida5 en C# 5e Wan di5eXado con la idea de
man7ener el ?MI7?. 27A1- 51 6.?<937C7-7595 con código5 e5cri7o5 para la5 an7eriore5
Qer5ione5 del lenguaje dA14;7.21; 1.'D% Por elloN la5 nueQa5 palaMra5 con 5igniOicado
e5pecial in7roducida5 IwhereN yieIdN e7c%K 2. ;1 J92 6-9;7@7695. 6.?. 41;14A959;N de
modo Rue 5eguir9n 5iendo Q9lido5 lo5 iden7iOicadore5 Rue 5e WuMie5en declarado5 con
5u5 nomMre5% Sólo 5e Wan in7roducido una5 ?L27?9; 726.?<937C7-75951; relacionada5
con la 5in7aUi5 de lo5 gen6rico5 Rue 5e de5criMen en el epVgraOe .mbi(<edades del 7ema%
<en.ricos
Concepto
C# &%+ permi7e e5peciOicar lo5 7ipo5 u7ili8ado5 en la5 deOinicione5 de o7ro5 7ipo5 de da7o5
S de m67odo5 de Oorma parame7ri8adaN de manera Rue en Qe8 de indicar5e eUac7amen7e
cu9le5 5on 5e coloRue en 5u lugar un par9me7ro d<94M?134. 37<.D Rue 5e concre7ar9 en
el momen7o en Rue 5e QaSan a u5ar Ial crear un oMje7o de la cla5eN llamar al m67odoNmK
A e57a5 deOinicione5 5e le5 llama =12N476.;N S un ejemplo de una de ella5 e5 el 5iguien7eL
public class A<T>
{
T valor;
public void EstablecerValor(T valor)
{
this.valor = valor;
}
}
El lenguaje de programación C# (ema &:L NoQedade5 de C# &%+
En e57a cla5e no 5e Wan concre7ando ni el 7ipo del campo priQado valor ni el del Tnico
par9me7ro del m67odo EstablecerValor() En 5u lugar 5e le e5peciOicado un par9me7ro 7ipo
T Rue 5e concre7ar9 al u7ili8ar la cla5e% Por ejemploN al crear un oMje7o 5uSoL

A<int> obj = new A<int>();
E57o crearVa un oMje7o de la cla5e gen6rica A con el par9me7ro 7ipo T concre7i8ado con el
94=0?123. 37<. int% La primera Qe8 Rue el CL) encuen7re e57a concre7i8ación de T a int
reali8ar9 un proce5o de 1I<92;782 o 72;3926796782 51- =12N476. con5i57en7e en generar
una nueQa cla5e con el re5ul7ado de 5u57i7uir en la deOinición gen6rica 7oda aparición de
lo5 par9me7ro5 7ipo5 por lo5 argumen7o5 7ipo% Para el ejemplo an7erior e57a cla5e 5erVaL

public class A<int>
{
int valor;
public void EstablecerValor(int valor)
{
this.valor = valor;
}
}
A lo5 7ipo5 con par9me7ro5 7ipoN como A<T>, 5e le5 llama 37<.; =12N476.; 614495.;b a
lo5 generado5 al concre79r5ele5 algTn par9me7ro 7ipo 5e le llama 37<.; 6.2;34075.;b S a
lo5 generado5 al concre79r5ele5 7odo5 37<.; =12N476.; 9C7143.;% La relación e57aMlecida
en7re ello5 e5 5imilar a la e57aMlecida en7re la5 cla5e5 normale5 S lo5 oMje7o5L al igual Rue
cla5e5 5irQen de plan7illa5 en Ma5e a la5 Rue crear oMje7o5N lo5 7ipo5 gen6rico5 cerrado5
ac7Tan como plan7illa5 en Ma5e a la5 Rue crear 7ipo5 gen6rico5 aMier7o5% Por e5oN en el CP
P 7radicional 5e llamaMa <-9237--9; a la5 con57ruccione5 eRuiQalen7e5 a lo5 gen6rico5%
La eUpan5ión la Wace el CL) en 7iempo de ejecuciónN a diOerencia de lo Rue 5ucede en
o7ro5 en7orno5 IpeN CPPK en lo5 Rue 5e reali8a al compilar% E57o 7iene Qaria5 Qen7aja5L
• E2;9?C-95.; ?M; <1/01Z.;L Como 5ólo almacenan el 7ipo gen6rico cerradoN Rue
el CL) Sa eUpandir9 en 7iempo de ejecuciónN 5u 7amaXo e5 m95 peRueXo S 5e eQi7a
el proMlema del eUce5iQo inOlado del código Minario generado I6.51 C-.93K
Adem95N para eQi7ar el inOlado de la memoria con5umidaN el CL) reu7ili8a gran par7e
del !SIL generado para la primera eUpan5ión de un gen6rico por un 7ipo reOerencia
en la5 5iguien7e5 eUpan5ione5 del mi5mo por o7ro5 7ipo5 reOerenciaN Sa Rue 7oda5 la5
reOerencia5 5on al Oin S al caMo pun7ero5 Rue en memoria 5e repre5en7an igual%
• M139593.; 476.;L Al almacenar5e lo5 7ipo5 gen6rico5 cerrado5 en lo5 en5amMlado5N
5e podr9n con5ul7ar median7e reOleUión S 5er aproQecWado5 por Werramien7a5 como el
In7elliSen5e de ,i5ual S7udio%NE( para proporcionar aSuda 5oMre 5u e57ruc7ura%
• I?<-1?12396782 @M67-L Como e5 el propio CL) Ruien reali8a gran par7e del 7raMajo
nece5ario para dar 5opor7e a lo5 gen6rico5N la inclu5ión de lo5 mi5mo5 en cualRuiera
de lo5 lenguaje5 %NE( 5e 5impliOica con5ideraMlemen7e%
El lenguaje de programación C# (ema &:L NoQedade5 de C# &%+
Usos de Ios genéricos
Lo5 gen6rico5 no 5on una noQedad in7roducida por C# en el mundo de la programaciónN
5ino Rue o7ro5 lenguaje5 como AdaN EiOOel o CPP Iplan7illa5K Sa la5 incluSen de5de Wace
7iempo% Su principal u7ilidad e5N como 5u propio nomMre indicaN Oacili7ar la creación de
código gen6rico Rue pueda 7raMajar con da7o5 de cualRuier 7ipo% E57o e5 e5pecialmen7e
T7il para crear 7ipo5 Rue ac7Ten como coleccione5 Ipila5N cola5N li57a5N e7c%KN co5a Rue C#
:%- 5ólo permi7Va crear deOini6ndolo5 en Ma5e a la cla5e Ma5e comTn object% Por ejemploN
una cola Rue admi7ie5e oMje7o5 de cualRuier 7ipo WaMVa Rue declararla como 5igueL
public class Cola
{
object[] elementos;
public int NúmeroElementos;
public void Encolar(object valor);
{.}
public object Desencolar()
{.}
}
El primer proMlema de e57a 5olución e5 lo incómo