C# Quick Syntax Reference - En.es PDF

www.it-ebooks.
info
Para su comoddad Apress ha coocado agunos de a parte deantera
mporta e matera despus de ndce. Utce os Marcadores
y contendo en un nks Gance para acceder a eos.
www.it-ebooks.info
Mapa de contendos
Sobre e autor xv
Sobre e Revsor Tcnco xv
Introduccn xx
Captuo 1: Heo Word 1
Captuo 2: Compar y E|ecutar 3
Captuo 3: Varabes 5
Captuo 4: Operadores 9
Captuo 5: Strng 13
Captuo 6: Matrces 17
Captuo 7: Condconaes 19
Captuo 8: Loops 21
Captuo 9: Mtodos 23
Captuo 10: Case 29
Captuo 11: Herenca 37
Captuo 12: La redencn de Membros 41
Captuo 13: Nvees de acceso 45
Captuo 14: Esttca 49
Captuo 15: Propedades 53
Captuo 16: Los ndzadores 57
Captuo 17: Interfaz 61
www.it-ebooks.info
Contendo de un vstazo
Captuo 18: Resumen 65
Captuo 19: Los espacos de nombres 69
Captuo 20: Enum 73
Captuo 21: Contro de excepcones 75
Captuo 22: Sobrecarga de operadores 79
Captuo 23: Las conversones de encargo 83
Captuo 24: Constantes 85
Captuo 25: Preprocessor 87
Captuo 26: Los deegados 91
Captuo 27: Eventos 97
Captuo 28: Los genrcos 101
Captuo 29: Struct 109
Captuo 30: Mtodos asncronos 113
ndce 117
v
www.it-ebooks.info
Introduccn
E engua|e de programacn C # es un engua|e moderno y orentado a ob|etos creado por
Mcrosoft para a pataforma. NET Framework. C # (pronuncado "ver sharp") se basa en agunos de os
me|ores caracterstcas de os prncpaes engua|es de programacn. Combna e poder de C + + con
a sencez de Vsua Basc y tambn toma mucho de |ava. Esto se traduce en un engua|e
que es fc de aprender y usar, robusto frente a errores y que permte a apcacn rpda
desarroo. Todo esto se ogra sn sacrcar gran parte de a potenca o veocdad, cuando
en comparacn con C + +.
En os sguentes aos de su anzamento en 2002, C # se ha convertdo en a tercera ms popuar
engua|e de programacn - despus de |ava y C / C + + - y su popuardad sgue crecendo. Es
un engua|e de programacn de propsto genera, por o que es t para crear una ampa gama de
programas. Todo, desde pequeas utdades para |uegos de ordenador, apcacones de escrtoro o
ncuso os sstemas operatvos pueden ser construdos en C #. E engua|e tambn se puede utzar con
ASP.NET
para crear apcacones basadas en web.
En e desarroo de. NET, os programadores se es da una ampa gama de eeccn en cuanto a qu
engua|e de programacn para utzar. . Agunos de os ms popuares engua|es NET ncuyen: VB.NET,
C + + / CLI, C # y C #. Entre stos, C # es a menudo e doma de su eeccn. A gua que e otro. NET
engua|es, C # se compa ncamente a un engua|e ntermedo. Este engua|e se ama a
Common Intermedate Language (CIL) y se e|ecuta en e. NET Framework. Un programa NET.
por o tanto ser capaz de e|ecutar en cuaquer sstema que tenga ese marco nstaado.
E. NET Framework es un marco de software que ncuye una e|ecucn comn
motor y una rca bboteca de cases. Se e|ecuta en Mcrosoft Wndows y por o tanto so se utza
para escrbr apcacones para Wndows. Sn embargo, tambn hay puertos de pataforma cruzada
dsponbes,
e os dos ms grandes ser Mono1y DotGNU.2Estos son os dos proyectos de cdgo aberto
que o permtan. NET que se e|ecutan en otras pataformas, como Lnux, Mac OS X y
sstemas embebdos.
1
2
http://www.mono-pro|ect.com
http://www.dotgnu.org
xx
www.it-ebooks.info
Captuo 1
Heo Word
La eeccn de un IDE
Para empezar a programar en C # que necesta un entorno de desarroo ntegrado (IDE) que apoya e
Mcrosoft. NET Framework. La opcn ms popuar es a propa Mcrosoft
Vsua Studo.1Este IDE tambn est dsponbe de forma gratuta como una versn gera amada Vsua
Studo
Express, que se puede descargar desde a pgna de Mcrosoft.2
E engua|e C # ha sufrdo una sere de cambos desde a versn nca de C # 1.0 en 2002. En e
momento de a escrtura, C # 5.0 es a versn actua, que fue anzado en e ao 2012. Cada versn de a
engua corresponde a una versn de Vsua Studo, por o que con e n de utzar as caracterstcas de C
# 5.0 que necesta Vsua Studo Vsua Studo 2012 o Expresar 2012.
Crear un proyecto
Despus de nstaar e IDE, segur adeante y poner en marcha. A contnuacn, deber crear un nuevo
proyecto,
que se encargar de os archvos de cdgo fuente de C # y otros recursos. Para mostrar e nuevo proyecto
ventana r a Archvo > Nuevo > Proyecto de Vsua Studo o archvo > Nuevo proyecto en Vsua
Studo Express. Desde a, seeccone Vsua C # Tpo de panta en e marco de a zquerda. Entonces
seeccone a panta Apcacn de consoa en e marco derecho. En a parte nferor de a ventana
puede congurar e nombre y a ubcacn de proyecto s as o desea. Cuando haya termnado
haga cc en Aceptar y e asstente de proyecto crear e proyecto.
Ahora ha creado un proyecto de C #. En e pane Exporador de soucones (Ver >
Exporador de soucones) se puede ver que e proyecto consste en un archvo de orgen C # soo (. Cs)
que ya debe abrrse. S no, puede hacer dobe cc en e archvo de a soucn
Exporador para abrro. En e archvo de orgen no es ago de cdgo bsco para ayudare a obtener
comenzado. Sn embargo, para smpcar as cosas en este momento segur adeante y smpcar e
cdgo
en esto.
1
2
http://www.mcrosoft.com/vsuastudo
http://www.mcrosoft.com/express
1
www.it-ebooks.info
CAPTULO 1 Heo Word
case MyApp
{
statc vod Man ()
{
}
}
La apcacn se compone actuamente de una case amada MyApp que contene un vaco
Mtodo Man, tanto demtado por aves. E mtodo Man es e punto de entrada de programa y debe
tener este formato. La carcasa tambn es mportante ya que C # es mayscuas y mnscuas. Las aves
demtan o que pertenece a una entdad de cdgo, como una case o mtodo, y deben ser ncudos. Los
soportes, |unto con su contendo, se conocen como un boque de cdgo, o smpemente un boque.
Heo Word
Como es comn cuando se aprende un nuevo engua|e de programacn e prmer programa para escrbr
es
uno que muestra una cadena de texto "Heo Word". Esto se ogra medante a adcn de a sguente
nea de cdgo entre as aves de mtodo Man.
System.Consoe.WrteLne ("Heo Word");
Esta nea de cdgo utza e WrteLne mtodo que acepta una nca cadena
parmetro demtado por comas dobes. E mtodo se encuentra dentro de a Consoa case,
que pertenece a a Sstema espaco de nombres. Tenga en cuenta que e operador de punto (.) Se utza
para e acceso
membros de ambos espacos de nombres y cases. La decaracn debe termnar con un punto y coma,
como
deben todas as decaracones en C #. Su cdgo debe tener este aspecto.
case MyApp
{
statc vod Man ()
{
}
}
InteSense
A escrbr cdgo en Vsua Studo una ventana amada InteSense pop-up donde quera
hay varas aternatvas predetermnadas entre os que eegr. Esta ventana es
ncrebemente t y puede ser crado manuamente pusando Ctr + Espaco. Le da
acceso rpdo a cuaesquera entdades de cdgo que son capaces de utzar dentro de su programa,
ncuyendo e
cases y mtodos de. NET Framework, |unto con sus descrpcones. Este es un muy
caracterstca de gran acance que usted debe aprender a hacer buen uso de.
2
www.it-ebooks.info
Captuo 2
Compar y E|ecutar
Compacn de Vsua Studo
Con e programa Heo Word competado, e sguente paso es compar y e|ecutaro. Para eo
por o que abrr e men Depurar y seeccone Incar sn depurar, o smpemente puse
Ctr + F5. Vsua Studo entonces compar y e|ecutar a apcacn que muestra e
cadena en una ventana de a consoa.
La razn por a que no queres para eegr e comando Incar depuracn (F5) es
debdo a que a ventana de a consoa se cerre tan pronto como e programa ha termnado de e|ecutarse.
Compacn Consoe
S no tene un IDE como Vsua Studo, usted todava puede compar e programa como
sempre y cuando tenga e. NET Framework nstaado. Para probar esto, abre una ventana de consoa
(C: \ Wndows \ System32 \ cmd.exe) y navegue a a carpeta de proyecto donde a fuente
archvo se encuentra. A contnuacn, deber encontrar e compador de C # amado csc.exe, que se
encuentra en
una trayectora smar a a que se muestra a contnuacn. E|ecutar e compador con e nombre de
archvo fuente como una
argumento y producr un e|ecutabe en a carpeta actua.
C: \ MySouton \ MyPro|ect>
\ Wndows \ Mcrosoft.NET \ Framework64 \ v2.0.50727 \
csc.exe Program.cs
S ntenta e|ecutar e programa compado se mostrar e msmo resutado que a creada
por Vsua Studo.
C: \ MySouton \ MyPro|ect> Program.exe
Heo Word
3
www.it-ebooks.info
CAPTULO 2 Compar y e|ecutar
Comentaros
Los comentaros se utzan para nsertar notas en e cdgo fuente. C # utza e estndar C + +
comentaro
notacones, con tanto de una soa nea y comentaros mutnea. Eos estn destnados so para me|orar
a egbdad de cdgo fuente y no tenen nngn efecto en e programa na. E de una soa nea
comentaro comenza con "/ /" y se extende hasta e na de a nea. E comentaro de varas neas puede
abarcar varas neas y est demtada por "/ *" y "* /".
/ /-Lne soo comentaro
/ * Mutnea
comentaro * /
Adems de estos, hay dos comentaros de a documentacn. Una soa nea
documentacn comentaro que comenza con "/ / /" y una documentacn de varas neas,
comentan que est demtada por "/ **" y "* /" Estos comentaros se utzan cuando se producen.
documentacn de a case.
Documentacn de nve de case / / / <summary>. </ Summary>
case MyApp
{
/ ** Punto de entrada de programa <summary>. </ Summary>
<param name="args"> argumentos de a nea de comando. </ param>
* /
statc vod Man (strng || args)
{
}
}
4
www.it-ebooks.info
Captuo 3
Varabes
Las varabes se utzan para amacenar datos durante a e|ecucn de programa.
Los tpos de datos
En funcn de os datos que necesta para amacenar hay varos tpos dferentes de tpos de datos.
La tpos smpes en C # constar de cuatro tpos de enteros con sgno y sn sgno de cuatro, tres
tpos de punto otante, as como carbn de ea y boo.
Tpo de datos
sbyte
corto
nt
argo
byte
ushort
unt
uong
otador
dobe
decma
carbn de ea
boo
Tamao (bts)
8
16
32
64
8
16
32
64
32
64
128
16
4
Descrpcn
Los enteros con sgno
Enteros sn sgno
Nmeros de punto otante
Carcter Uncode
Vaor booeano
5
www.it-ebooks.info
CAPTULO 3 Varabes
Decaracn
En C #, una varabe debe ser decarado (Creado) antes de que pueda ser utzado. Para decarar una
varabe
usted comenza con e tpo de datos que desea que mantenga segudo de un nombre de varabe. E
nombre
puede ser cas cuaquer cosa que queras, pero es una buena dea dar a as varabes nombres que
estn estrechamente reaconados con e vaor que sostendrn.
nt myInt;
Asgnacn
Un vaor se asgna a a varabe utzando e sgno de guadad, que es a asgnacn
operador (=). La varabe se converte denda o ncazado.
myInt = 10;
La decaracn y a asgnacn se pueden combnar en una soa sentenca.
nt myInt = 10;
S se necestan mtpes varabes de msmo tpo hay una forma abrevada de
decarar o denros utzando e operador coma (,).
nt myInt = 10, myInt2 = 20, myInt3;
Una vez que una varabe se ha dendo (decarado y asgnado) que puede ser utzado por
referenca a nombre de a varabe.
System.Consoe.Wrte (myInt); / / 10
Los tpos enteros
Hay cuatro tpos de enteros con sgno que se pueden utzar dependendo de tamao de un nmero
usted necesta a varabe para que contenga.
/ / Enteros con sgno
sbyte myInt8 = 2;
corto myInt16 = 1;
ntmyInt32 = 0;
argo myInt64 = -1;
/ /
/ /
/ /
/ /
-128
-32768
-2 31
-2 63
a
a
a
a
127
32767
2 31-1
2 63-1
6
www.it-ebooks.info
CAPTULO 3 Varabes
Los tpos sn sgno pueden usarse s usted so necesta amacenar os vaores postvos.
/ / enteros sn sgno
byteuInt8 = 0; / /
ushort Unt16 = 1; / /
untuInt32 = 2; / /
uong Unt64 = 3; / /
0
0
0
0
a
a
a
a
255
65535
2 32-1
2 64-1
Adems de a notacn decma estndar, nmeros enteros tambn se pueden asgnar utzando
notacn hexadecma.
nt MyHex = 0xF; / / Hexadecma (base 16)
Tpos de punto otante
Los tpos de punto otante pueden amacenar nmeros reaes con dferentes nvees de precsn.
Nmeros de punto otante constantes en C # sempre se mantenen como dobes, por o que con e n de
asgnar
ta nmero a una varabe oat un carcter "F" tene que ser aaddo para convertr e
nmero a a otador escrba. Lo msmo sucede con e carcter "M" para decmaes.
oatmyFoat = 3.14F; / / 7 dgtos de precsn
dobe mDoube = 3,14; / / 15-16 dgtos de precsn
MyDecma decma = 3,14 mones; / / 28-29 dgtos de precsn
Una forma ms comn y t para convertr entre tpos de datos es utzar una expcta
funddo. Una conversn expcta se reaza coocando e tpo de datos deseado entre parntess antes de
a varabe o constante que se va a convertr. Esto convertr e vaor a a especcada
escrba, en este caso otar, antes se reace a cesn.
myFoat = (oat) MyDecma; / / Conversn expcta
Las precsones mostrados anterormente se reeren a nmero tota de dgtos que os tpos pueden
sostener. Por e|empo, cuando se ntenta asgnar ms de 7 dgtos para un otar, a menos
os sgncatvos consegurn redondeado.
myFoat = 12345.6789F; / / Redondeado a 12.345,68
Nmeros de coma otante se pueden asgnar utzando decma o exponenca
notacn.
mDoube = 3e2; / / 3 * 10 2 = 300
7
www.it-ebooks.info
CAPTULO 3 Varabes
Tpo char
La carbn de ea tpo puede contener un soo carcter Uncode demtado por comas smpes.
char c = '3 '; / / Uncode Char
Tpo Boo
La boo tpo puede amacenar un vaor booeano, que es un vaor que so puede ser verdadera o
fasa. Estos vaores se especcan con e verdadero y faso paabras cave.
boo b = true; / / Vaor boo
Ambto de as varabes
E acance de una varabe se reere a boque de cdgo dentro de a cua es posbe utzar ese varabe
sn cacacn. Por e|empo, una varabe oca es una varabe decarada dentro un mtodo. Esta varabe
so estar dsponbe dentro de boque de cdgo de ese mtodo, despus de
que ha sdo decarada. Una vez que e acance de mtodo termna, a varabe oca ser
destrudo.
nt man ()
{
nt LocaVar; / Varabe / oca
}
Adems de as varabes ocaes, C # tene e terreno y as varabes de tpo de parmetro, que ser
ser vsto en captuos posterores. Sn embargo, C # no tene varabes gobaes, como por e|empo
hace C + +.
8
www.it-ebooks.info
Captuo 4
Operadores
Los operadores se utzan para operar en os vaores. Se pueden agrupar en cnco tpos: artmtcos,
asgnacn, comparacn, operadores gcos y bt a bt.
Los operadores artmtcos
Los operadores artmtcos ncuyen as cuatro operacones artmtcas bscas, as como a
operador de mduo (%) que se utza para obtener e resto de a dvsn.
otar x
x
x
x
x
=
=
=
=
=
3
3
3
3
3
+
-
*
/
%
2;
2;
2;
2;
2;
/ /
/ /
/ /
/ /
/ /
5
1
6
1
1
/ /
/ /
/ /
/ /
/ /
adcn
sustraccn
mutpcacn
dvsn
mduo (resto de dvsn)
Observe que e sgno de dvsn da un resutado ncorrecto. Esto es debdo a que opera en
dos vaores enteros y sern, por tanto, a vueta a resutado y devover un entero. Para obtener e
vaor correcto, uno de os nmeros debe ser convertdo en un nmero de coma otante.
x = 3 / (oat) 2; / / 1,5
Operadores de asgnacn
E segundo grupo es e de os operadores de asgnacn. Lo ms mportante, a asgnacn
operador (=) en s, que asgna un vaor a una varabe.
Operadores de asgnacn combnados
Un uso comn de os operadores de asgnacn y a artmtca es operar en una varabe y
a contnuacn, guardar e resutado de nuevo en esa msma varabe. Estas operacones se pueden acortar
con os operadores de asgnacn combnados.
9
www.it-ebooks.info
4
CAPTULO 4 Operadores
nt x
x
x
x
x
x
= 0;
+ = 5;
- = 5;
* = 5;
/ = 5;
% = 5;
/ /
/ /
/ /
/ /
/ /
x
x
x
x
x
=
=
=
=
=
x 5;
x-5;
x * 5;
x / 5;
x 5%;
Operadores de ncremento y decremento
Otra operacn comn es para aumentar o dsmnur una varabe por uno. Esto puede ser
smpcado con e ncremento (+ +) y decremento - operadores ().
x + +; / / X = x 1;
x -; / / X = x-1;
Ambos operadores pueden ser utzados ya sea antes o despus de una varabe.
x + +;
x -;
+ + X;
- X;
/ /
/ /
/ /
/ /
post-ncremento
post-decremento
prencremento
pre-decremento
E resutado en a varabe se utza es a msma que sea. La dferenca es que
e post-operador devueve e vaor orgna antes de que cambe a varabe, mentras que e
pre-operador camba a varabe y uego devueve e vaor.
x = 5; y = x + +; / / Y = 5, x = 6
x = 5; y = x + +; / / Y = 6, x = 6
Los operadores de comparacn
Los operadores de comparacn comparan dos vaores y devueven true o fase. Eos son
utzado prncpamente para especcar as condcones, que son expresones que se evaan como true
o fasa.
boo x
x
x
x
x
x
=
=
=
=
=
=
(2
(2
(2
(2
(2
(2
== 3);
! = 3);
> 3);
<3);
> = 3);
<= 3);
/ /
/ /
/ /
/ /
/ /
/ /
faso
verdadero
faso
verdadero
faso
verdadero
/ /
/ /
/ /
/ /
/ /
/ /
gua a
no es gua a
ms que
menos que
mayor que o gua a
menos de o gua a
10
www.it-ebooks.info
Los operadores gcos
Los operadores gcos se utzan a menudo |unto con os operadores de comparacn. Lgco y
(&&) Devueve verdadero s tanto e ado zquerdo y derecho son verdaderos, y gco o (| |) se evaa
como
certo s a zquerda o a derecha es verdad. E no (!) Operador gco se utza para nvertr
un resutado booeano. Tenga en cuenta que tanto para "gco y" y "gco o" e ado derecho de a
operador no se evauar s e resutado ya est determnado por e ado zquerdo.
boo x = (true && fase); / / Fase / / gco y
x = (true | | fase); / / True / / gca o
x =! (true) ;/ / fase / / gco no
Operadores bt a bt
Los operadores de bts pueden manpuar bts ndvduaes dentro de un entero. Por e|empo, a
operador bt a bt y (&) hace que e bt resutante 1 s os bts correspondentes en ambos ados
de operador se estabecen.
nt x
x
x
x
x
x
=
=
=
=
=
=
5 y 4;
5 | 4;
5 4;
4 << 1;
4 >> 1;
- 4;
/ /
/ /
/ /
/ /
/ /
/ /
101 & 100
101 | 100
101 100
100 << 1
100 >> 1
- 00000100
= 100 (4)
= 101 (5)
= 001 (1)
= 1000 (8)
= 10 (2)
= 11111011 (-5)
/ /
/ /
/ /
/ /
/ /
/ /
y
o
xor
despazamento a a zquerda
despazamento a a derecha
nvertdo
Estos operadores bt a bt tenen os operadores de asgnacn de taqugrafa, a gua que e
operadores artmtcos.
nt x = 5;
x = 5;
x = 5;
x = 5;
x = 5;
x
x
x
x
x
& = 4; / /
| = 4; / /
= 4; / /
<< = 1 ;/ /
>> = 1 ;/ /
101
101
101
101
101
Y 100
| 100
100
<< 1
>> 1
= 100
= 101
= 001
= 1010
= 10
(4) / /
(5) / /
(1) / /
(10) / /
(2) / /
y
o
xor
despazamento a a zquerda
despazamento a a derecha
Precedentes de operador
En C #, as expresones se evaan normamente de zquerda a derecha. Sn embargo, cuando una
expresn
contene mtpes operadores, a precedenca de os operadores determna e orden en e
que se evaan.
11
www.it-ebooks.info
Pre
1
2
3
4
5
6
Operador
+ + -! -
* /%
+ -
<< >>
<< = >> =
==! =
Pre
7
8
9
10
11
12
Operador
Y
|
&&
| |
= Op =
Por e|empo, gco y (&&) se une ms db que os operadores reaconaes, que a su vez
enazar ms db que os operadores artmtcos.
boo x = 2 3> 1 * 4 && 5.5 == 1; / / True
Para hacer as cosas ms caras, se pueden utzar parntess para especcar qu parte de a
expresn
ser evauado prmero. Los parntess tenen a prordad ms ata de todos os operadores.
boo x = ((2 3)> (1 * 4)) && ((5/5) == 1); / / True
12
www.it-ebooks.info
Captuo 5
Cadena
E tpo de datos de cadena se utza para amacenar as constantes de cadena que estn demtadas por
comas dobes.
strng a = "Hoa";
La concatenacn de cadenas
E sgno ms se utza para combnar dos cadenas. Se e conoce como e operador de concatenacn
(+) En este contexto. Tambn tene un operador de acompaamento de asgnacn (+ =), que aade
una cadena a otra y crea una nueva cadena.
strng b = a + "mundo"; / / Heo Word
a + = "mundo" ;/ / Heo Word
Escapar caracteres
Una sentenca puede ser dvddo en varas neas, pero una constante de cadena debe estar en
una soa nea. Con e n de dvdro, a constante de cadena tene que prmero ser dvddo medante e
operador de concatenacn.
secuenca de c
= "Hoa" +
"Word";
Para agregar nuevas neas en a propa cadena, "\ n" se utza e carcter de escape.
cadena c = "Hoa \ Nword";
Esta notacn de barra dagona nversa se utza para escrbr caracteres especaes, como a barra
nvertda
s, o una coma dobe. Entre os caracteres especaes es tambn un carcter Uncode
notacn para escrbr cuaquer carcter.
13
www.it-ebooks.info
CAPTULO 5 Cadena
Carcter
\ N
\ T
\ V
\ B
\ R
\ 0
Sgncado
de nueva nea
tabuador horzonta
tabuacn vertca
Retroceso
retorno de carro
carcter nuo
Carcter
\ F
\ A
\ '
\ "
\ \
\ UFFFF
Sgncado
forma de amentacn
sondo de aerta
coma smpe
comas dobes
barra nvertda
Carcter Uncode (nmero hexadecma de 4 dgtos)
Caracteres de escape pueden ser gnoradas por a adcn de un smboo "@" antes de a cadena. Es
aman una cadena tera y puede por e|empo ser utzados para hacer rutas de archvos ms egbe.
cadena e = "c: \ \ Wndows \ \ System32 \ \ cmd.exe";
cadena f = @ "c: \ Wndows \ System32 \ cmd.exe";
Cadena comparar
La manera de comparar dos cadenas es smpemente usando e operador gua a. Esto no o har
comparar as dreccones de memora, como en otros engua|es como |ava.
boo c = (a == b); / / True
Membros de Cuerda
La cadena case tene una gran cantdad de membros tes. Por e|empo, os mtodos gusta Reempazar,
Insert
y Outar. Una cosa mportante a tener en cuenta es que no hay mtodos para cambar una cadena.
Los mtodos que aparecen para modcar una cadena en readad sempre devueven una nueva cadena.
Esto es debdo a que e cadena case es nmutabe. E contendo de una varabe de cadena no puede ser
cambado, a menos que se susttuye toda a cadena.
strng a =
strng b =
b =
b =
b =
b =
nt =
"Strng";
a.Repace ("", "o");
a.Inserte (0, "m");
a.Remove (0, 3);
a.Substrng (0, 3);
a.ToUpper ();
a.Length;
/ /
/ /
/ /
/ /
/ /
/ /
Fuerte
M cuerdas
ng
Str.
STRING
6
14
www.it-ebooks.info
CAPTULO 5 Cadena
Case StrngBuder
StrngBuder es una case de cadena mutabe. Debdo a costo de rendmento asocada con
susttucn de una cadena, e StrngBuder case es una me|or aternatva cuando una cadena tene que
ser modcado muchas veces.
System.Text.StrngBuder sb = new
System.Text.StrngBuder ("Heo");
La case tene varos mtodos que se pueden utzar para manpuar e contendo rea de
una cadena, taes como: Aadr, Emnar y Insertar.
sb.Append ("Mundo");
sb.Remove (0, 5);
sb.Insert (0, "Ads");
/ / Heo Word
/ / Mundo
/ / Ados Mundo
Para convertr un StrngBuder oponerse vueta a una cadena reguar, e ToStrng mtodo
se utza.
strng s = sb.ToStrng (); / / Ados Mundo
15
www.it-ebooks.info
Captuo 6
Arrays
Una matrz es una estructura de datos utzada para amacenar una coeccn de vaores que todos tenen
e msmo
tpo de datos.
Decaracn de matrz
Para decarar una matrz, un par de corchetes se aade a tpo de datos de a matrz se
contener, segudo de nombre de a matrz. Una matrz puede ser decarada con cuaquer tpo de datos y
todos os
de sus eementos ser entonces de ese tpo.
nt || x; / / No nt x ||
Asgnacn de matrz
La matrz se asgna a a nuevo paabra cave, seguda nuevamente por e tpo de datos y un con|unto de
corchetes que contenen a ongtud de a matrz. Este es e nmero |o de eementos
que a matrz puede contener. Una vez que se crea a matrz, os eementos sern automtcamente
asgnado a vaor predetermnado para ese tpo de datos.
nt || x = new nt |3|;
La asgnacn de matrz
Para enar os eementos a os que se puede hacer referenca a uno por vez y uego os vaores asgnados.
Un eemento de a matrz se hace referenca a coocar e ndce de eemento entre corchetes.
Observe que e ndce para e prmer eemento comenza con cero.
x |0| = 1;
x |1| = 2;
x |2| = 3;
17
www.it-ebooks.info
CAPTULO 6 Matrces
Por otra parte, os vaores pueden ser asgnados a a vez usando una notacn de corchetes rzado. La
nuevo paabra cave y tpo de datos pueden opconamente ser de|ados de ado s a matrz se decara a
msmo tempo.
nt || y = new nt || {1, 2, 3};
nt || z = {1, 2, 3};
Acceso a una matrz
Una vez que os eementos de a matrz se ncazan, se puede acceder medante una referenca a os
eementos '
ndces dentro de os corchetes.
System.Consoe.Wrte (x |0| + x |1| + x |2|); / / 6
Matrces rectanguares
Hay dos tpos de matrces mutdmensonaes en C #: rectanguares y escaonadas.
Una matrz rectanguar tene a msma ongtud de todas as sub-seres y separa as dmensones
medante una coma.
strng |,| x = new strng |2, 2|;
A gua que con matrces undmensonaes, que o ben se pueden enar en una en una o todas a a
una vez durante a asgnacn.
x |0, 0| = "00"; x |0, 1| = "01";
x |1, 0| = "10"; x |1, 1| = "11";
strng |,| y = {{"00", "01"}, {"10", "11"}};
Matrces escaonadas
Matrces escaonadas son matrces de matrces, y pueden tener dmensones rreguares. Las dmensones
son
asgnado uno a a vez y por o tanto as sub-seres se pueden asgnar a dferentes tamaos.
strng || || a = new strng |2| ||;
a |0| = new strng |1|; a |0| |0| = "00";
a |1| = new strng |2|; una |1| |0| = "10"; una |1| |1| = "11";
Es posbe asgnar os vaores durante a asgnacn.
strng || || b = {nuevo strng || {"00"},
nueva cadena || {"10", "11"}};
Todos estos son e|empos de matrces bdmensonaes. S ms de dos dmensones son
es necesaro, ms comas se pueden agregar para a matrz rectanguar o soportes ms cuadrados
para a matrz escaonada.
18
www.it-ebooks.info
Captuo 7
Condconaes
Sentencas condconaes se utzan para e|ecutar dferentes boques de cdgo basado en a dferente
condcones.
S a decaracn
La sentenca f so se e|ecutar s a condcn dentro de os parntess se evaa a
certo. La condcn puede ncur cuaquera de a comparacn y operadores gcos.
nt x = new System.Random () sguente (3).; / / Da 0, 1 o 2
s (x <1) {
System.Consoe.Wrte (x + "<1");
}
Para probar para otras condcones, a sentenca f se puede extender por cuaquer nmero de ese f
cusuas. Cada condcn adcona so se pondr a prueba s todas as condcones anterores son fasas.
ese f (x> 1) {
System.Consoe.Wrte (x + "> 1");
}
La sentenca f puede tener una cusua ese a na, que se e|ecutar s todos
condcones anterores son fasas.
ese {
System.Consoe.Wrte (x + "== 1");
}
En cuanto a as aves, que pueden ser de|ados de ado s so una nca nstruccn debe ser
e|ecutada de forma condcona.
s (x <1)
System.Consoe.Wrte (x + "<1");
ese f (x> 1)
System.Consoe.Wrte (x + "> 1");
ms
System.Consoe.Wrte (x + "== 1");
19
www.it-ebooks.info
CAPTULO 7 Condconaes
Instruccn Swtch
Los controes de os estados de nterruptor para a guadad entre un entero o una cadena y una sere
de caso de etquetas, y uego pasa a a e|ecucn para e caso a |uego. La decaracn puede contener
cuaquer nmero de cusuas de casos y puede termnar con una etqueta predetermnada para e mane|o
de todos os dems casos.
nt x = new System.Random () sguente (3).; / / Da 0, 1 o 2
nterruptor (x)
{
caso 0: System.Consoe.Wrte (x + "es 0"); romper;
case 1: System.Consoe.Wrte (x + "es 1"); romper;
defaut: System.Consoe.Wrte (x + "es 2"); romper;
}
Tenga en cuenta que as decaracones despus de cada etqueta de a ca|a no estn rodeadas por
aves.
En cambo, as decaracones termnan con a rotura paabra cave para romper e nterruptor. A dferenca
de muchos
otros domas, cusuas de caso en C # deben termnar con una nstruccn de sato, como descanso. Esto
sgnca
que e rotura paabra cave no se puede de|ar fuera para permtr a e|ecucn caen-a travs de a sguente
etqueta. La razn de esto es que no ntencona cada-through es un error de programacn comn.
Decaracn Goto
Para provocar una cada a travs de que se produzca, este comportamento se debe especcar de forma
expcta e uso de goto
satar decaracn seguda de una etqueta case. Esto har que a e|ecucn sate a a etqueta.
caso 0: goto case 1;
Goto puede utzarse fuera de os nterruptores para satar a una etqueta dentro de msmo mtodo de
mbto de apcacn. E contro puede entonces ser transferdo fuera de un mbto andado, pero no en un
mbto andado.
Sn embargo, utzar Goto de esta manera es que desanmarse, ya que puede egar a ser dfc de segur
e u|o de e|ecucn.
Ir myLabe;
/ / ...
myLabe:
Operador ternaro
Adems de as nstruccones f y swtch se encuentra e operador ternaro (? :). Este operador
puede susttur a una soa cusua f / ese que asgna un vaor a una varabe especca. E operador
toma tres expresones. S e prmero se evaa como true, a segunda expresn es
vov, y s es fasa, e tercero se devueve.
/ / Vaor entre 0.0 y 1.0
. dobe x = new System.Random () NextDoube ();
x = (x <0,5)? 0: 1; / / Operador ternaro (? :)
20
www.it-ebooks.info
Captuo 8
Loops
Hay cuatro estructuras de buce en C #. Estos se utzan para e|ecutar un boque de cdgo especco
mtpes veces. A gua que con e condcona f, as aves de os buces
puede omtrse s so hay una decaracn en e boque de cdgo.
Whe
E buce whe se e|ecuta a travs de boque de cdgo so s a condcn es verdadera, y contnuar
buce durante e tempo que e estado sgue sendo certo. Tenga en cuenta que a condcn se comprueba
so
a prncpo de cada teracn (crcuar).
nt = 0;
whe ( <10) {System.Consoe.Wrte ( + +); } / / 0-9
Buce do-whe
E buce do-whe funcona en a msma forma que e buce whe, excepto que comprueba e
condcn despus de que e boque de cdgo y por o tanto sempre se e|ecutan a travs de boque de
cdgo en
menos una vez. Tenga en cuenta que este buce termna con un punto y coma.
nt | = 0;
do {System.Consoe.Wrte (| + +); Mentras} (| <10); / / 0-9
Para oop
E buce se utza para r a travs de un boque de cdgo un nmero especco de veces. Se utza tres
parmetros. E prmer parmetro ncaza un contador y sempre se e|ecuta una vez, antes
e buce. E segundo parmetro contene a condcn para e buce y se comprueba antes
cada teracn. E tercer parmetro contene e ncremento de contador y se e|ecuta
a na de cada teracn.
for (nt k = 0; k <10; k + +) {
System.Consoe.Wrte (k); / / 0-9
}
21
www.it-ebooks.info
CAPTULO 8 Loops
E buce for tene varas varacones. Por e|empo, as prmera y tercera parmetros pueden
se dvda en varas decaracones utzando e operador coma.
for (nt k = 0, m = 5; k <10; k + +, m -) {
System.Consoe.Wrte (k + m); / / 5 (10 veces)
}
Tambn exste a opcn de de|ar fuera uno o ms de os parmetros. Por e|empo,
e tercer parmetro puede ser movdo en e cuerpo de buce.
for (nt k = 0; k <10 ;) {
System.Consoe.Wrte (k + +); / / 0-9
}
Buce Foreach
E buce foreach proporcona una manera fc para recorrer arrays. En cada teracn a
sguente eemento de a matrz se e asgna a a varabe especcada (e terador) y e buce
contna e|ecutndose hasta que ha pasado por toda a matrz.
nt || un = {1, 2, 3};
foreach (nt n en a) {
System.Consoe.Wrte (N); / / 123
}
Tenga en cuenta que a varabe de teracn se puede, por tanto, no puede utzarse para e cambo de
so ectura y
eementos de a matrz.
Romper y contnuar
Hay dos paabras cave especaes que se pueden utzar dentro de buces - rotura y contnuar.
La rotura paabra cave termna a estructura de buce, y contnuar sata e resto de a corrente
teracn y sgue a comenzo de a sguente teracn.
for (nt = 0; <10; + +)
{
romper ;/ / n de
contnuar; / / Start sguente teracn
}
22
www.it-ebooks.info
Captuo 9
Mtodos
Los mtodos son os boques de cdgo reutzabes que so se e|ecutarn cuando se e ama.
Dencn de os mtodos
Un mtodo se puede crear dentro de una case escrbendo vaco segudo por e nombre de mtodo,
un con|unto de parntess, y un boque de cdgo. La vaco sgnca paabra cave que e mtodo
no devueve un vaor. La convencn de nomencatura para os mtodos es a msma que para as cases -
una
nombre descrptvo con cada paabra con mayscua nca.
case MyApp
{
vod MyPrnt ()
{
System.Consoe.Wrte ("Heo Word");
}
}
Todos os mtodos en C # deben pertenecer a una case, y son e nco ugar donde
decaracones pueden ser e|ecutados. C # no tene funcones gobaes, que son mtodos
denda fuera de as cases.
Lamar a mtodos
E mtodo anteror se mprmr un mensa|e de texto. Para nvocar (ca) es una nstanca de a
MyApp de prmera case debe ser creada utzando a nuevo paabra cave. Se utza entonces E operador
de punto
despus de nombre de a nstanca para acceder a sus membros, o que ncuye a MyPrnt mtodo.
case MyApp
{
statc vod Man ()
{
MyApp m = new MyApp ();
m.MyPrnt (); / / Heo Word
}
23
www.it-ebooks.info
CAPTULO 9 MTODOS
vod MyPrnt ()
{
System.Consoe.Wrte ("Heo Word");
}
}
Los parmetros de mtodo
E parntess que sgue a nombre de mtodo se utzan para pasar argumentos a mtodo.
Para eo os parmetros correspondentes prmero se deben especcar en a dencn de mtodo
en a forma de una coma sta de decaracones de varabes separados.
vod MyPrnt (cadena s1, s2 cadena)
{
System.Consoe.Wrte (S1 + S2);
}
Un mtodo puede ser dendo a tomar cuaquer nmero de argumentos, y pueden tener
cuaquer tpo de datos. So asegrese de que e mtodo se ama con os msmos tpos y e nmero de
argumentos.
statc vod Man ()
{
m.MyPrnt ("Hoa", "Mundo"); / / Heo Word
}
Para ser precsos, parmetros aparecer en dencones de mtodos, mentras que argumentos
aparecer en
mtodo ama. Sn embargo, os dos trmnos se utzan a veces ndstntamente.
Paabra cave Parmetros
Para tomar un nmero varabe de argumentos de un tpo especco, una matrz con e params
modcador se puede aadr como e tmo parmetro en a sta. Los parmetros adconaes de
especque e tpo que se pasa a mtodo se amacenar automtcamente en a matrz.
vod MyPrnt (cadena params || s)
{
foreach (strng x en s)
System.Consoe.Wrte (x);
}
24
www.it-ebooks.info
CAPTULO 9 MTODOS
La sobrecarga de mtodos
Es posbe decarar varos mtodos con e msmo nombre, sempre y cuando os parmetros de
varar en tpo o nmero. Esto se ama sobrecarga de mtodos y puede por e|empo ser vsto
en a apcacn de a System.Consoe.Wrte mtodo, que tene 18 mtodo
dencones. Se trata de una caracterstca de gran acance que permte a un mtodo para mane|ar una
varedad de argumentos
sn que e programador pueda ser conscente de a utzacn de dferentes mtodos.
vod MyPrnt (strng s)
{
System.Consoe.Wrte (s);
}
vod MyPrnt (nt )
{
System.Consoe.Wrte ();
}
Parmetros opconaes
A partr de C # 4.0, os parmetros se pueden decarar como opcona a proporconar un vaor por defecto
para eos
en a decaracn de mtodo. Cuando se nvoca e mtodo, estos argumentos opconaes pueden
omtrse utzar os vaores predetermnados.
case MyApp
{
vod MySum (nt , nt | = 0, nt k = 0)
{
System.Consoe.Wrte (1 * + 2 * | + 3 * k);
}
statc vod Man ()
{
. nueva MyApp () MySum (1, 2); / / 5
}
}
Los argumentos con nombre
C # 4.0 tambn ntrodu|o argumentos con nombre, que permten que un argumento que se pasa
utzando
e nombre de su parmetro correspondente. Esta caracterstca compementa parmetros opconaes
a permtr que os argumentos que se pasan fuera de servco, en ugar de depender de su poscn en e
sta de parmetros. Por o tanto, os parmetros opconaes pueden especcarse sn tener que especcar
e vaor para cada parmetro opcona antes. Ambos parmetros opconaes y requerdos puede
ser dentcado, pero os argumentos con nombre deben coocarse despus de os sn nombre.
25
www.it-ebooks.info
CAPTULO 9 MTODOS
statc vod Man ()
{
. nueva MyApp () MySum (1, k: 2); / / 7
}
Sentenca return
Un mtodo puede devover un vaor. La vaco paabra cave se susttuye entonces con e tpo de datos que
e mtodo devover, y a retorno paabra cave se aade a cuerpo de mtodo con una
argumento de tpo de retorno especcado.
getprnt strng ()
{
return "Hoa";
}
Vover es una nstruccn de sato que hace que e mtodo para sar y vover a vaor de
e ugar en e que se am a mtodo. Por e|empo, a Getprnt mtodo anteror puede ser
pasado como argumento a a Escrbr mtodo ya que e mtodo se evaa como una cadena.
statc vod Man ()
{
System.Consoe.Wrte (m.GetPrnt ()); / / Heo Word
}
La decaracn de retorno tambn se puede utzar en os mtodos vod a a sada antes de que e
boque de extremo
se acanza.
vod MyMethod ()
{
vover;
}
Los tpos de vaor y de referenca
Hay dos cases de tpos de datos en C #: tpos de vaor y os tpos de referenca. Varabes de vaor
tpos contenen drectamente sus datos, mentras que as varabes de tpos de referenca tenen
referencas a
sus datos. Los tpos de referenca en C # son: tpos de case, nterfaz, matrz y deegadas.
Los tpos de vaor ncuyen os tpos smpes, as como a estructura, enumeracn y tpos anuabes.
Las varabes de tpo de referenca se crean normamente con e nuevo paabra cave, sn embargo, que no
es
sempre es necesaro, como por e|empo en e caso de ob|etos de cadena.
26
www.it-ebooks.info
CAPTULO 9 MTODOS
Una varabe de un tpo de referenca se denomna generamente un ob|eto, aunque estrctamente
habando
e ob|eto es e dato de que a varabe se reere. Con os tpos de referenca, mtpes varabes
pueden hacer referenca a msmo ob|eto, y por o tanto as operacones reazadas a travs de una varabe
afectar a otras varabes que hacen referenca a msmo ob|eto. En contraste, con os tpos de vaor,
cada varabe amacenar su propo vaor y as operacones en uno de eos no afectar a otro.
Pasar por vaor
A pasar parmetros de tpo de vaor so se pasa una copa oca de a varabe, por o que s e
se camba a copa no afectar a a varabe orgna.
anuar Set (nt ) { = 10; }
statc vod Man ()
{
nt x = 0 ;/ / tpo de vaor
m.Set (x) ;/ / vaor pase de x
System.Consoe.Wrte (x); / / 0
}
Pasar por referenca
Para os tpos de datos de referenca de C # utza verdadera pase por referenca. Esto sgnca que
cuando una referenca
tpo se pasa no so es posbe cambar su estado, sno tambn para reempazar a totadad
ob|eto y haga que e cambo se propaga de nuevo a ob|eto orgna.
vod set (nt || ) { = new nt || {10}; }
statc vod Man ()
{
nt || y = {0} ;/ / tpo de referenca
m.Set (y) ;/ / referenca de ob|eto pase
System.Consoe.Wrte (a |0|); / / 10
}
Paabra cave Ref
Una varabe de tpo de vaor puede ser pasado por referenca medante a rbtro paabra cave, tanto en
e
persona que ama y decaracn de mtodo. Esto har que a varabe que se pasa en por referenca,
y por o tanto e cambo se actuazar e vaor orgna.
27
www.it-ebooks.info
CAPTULO 9 MTODOS
anuar Set (ref nt ) { = 10; }
statc vod Man ()
{
nt x = 0 ;/ / tpo de vaor
m.Set (ref x) ;/ referenca / pase a tpo de vaor
}
Sn paabra cave
A veces es posbe que desee pasar una varabe no asgnada por referenca y a tengan asgnada
en e mtodo. Sn embargo, e uso de una varabe oca no asgnada dar un error en tempo de
compacn.
Para esta stuacn, a fuera paabra cave se puede utzar. Tene a msma funcn que ref, excepto que
e compador permtr e uso de a varabe no asgnada, y que e obgar a a creacn efectva
a varabe en e mtodo.
vod Set (fuera nt ) { = 10; }
statc vod Man ()
{
nt x ;/ / tpo de vaor
m.Set (fuera x) ;/ / pass referenca a tpo de vaor unset
}
28
www.it-ebooks.info
Captuo 10
Case
Una case es una panta que se utza para crear ob|etos. Se componen de membros, os dos prncpaes
de os cuaes son campos y mtodos. Los campos son varabes que contenen e estado de ob|eto,
mentras que os mtodos denen o que e ob|eto puede hacer.
case MyRectange
{
nt x, y;
nt GetArea () {return x * y; }
}
Creacn de ob|etos
Para utzar os membros de una case de fuera de a case que dene, un ob|eto de a case debe prmero
ser creado. Esto se hace medante e uso de a nuevo paabra cave, o que crear un nuevo ob|eto en e
a memora de sstema.
cass MyCass
{
statc vod Man ()
{
/ / Crear un ob|eto de MyRectange
MyRectange r = new MyRectange ();
}
}
Un ob|eto tambn se ama una nstanca. E ob|eto contene su propo con|unto de campos,
que puede contener vaores que son dferentes a os de otras nstancas de a case.
Acceso a membros de ob|etos
Adems de crear e ob|eto, os membros de a case que van a ser accesbes necesdad
para ser decarado como pbco en a dencn de case.
29
www.it-ebooks.info
CAPTULO 10 Case
case MyRectange
{
/ / Hacer membros accesbe para nstancas de a case
pubc nt x, y;
nt GetArea pbca () {return x * y; }
}
E operador punto se utza despus e nombre de ob|eto para hacer referenca a sus membros acceso.
statc vod Man ()
{
r.x = 10;
r.y = 5;
nt a = r.GetArea (); / / 50
}
Constructor
La case puede tener un constructor. Este es un tpo especa de mtodo utzado para crear una nstanca
(Construccn) de ob|eto. Sempre tene e msmo nombre que a case y no tene un
Tpo de vover, porque devueve mpctamente una nueva nstanca de a case. Para ser accesbe desde
otra case que debe ser decarado con a pbco modcador de acceso.
MyRectange pbca () {x = 10; y = 5; }
Cuando se crea una nueva nstanca de a case se ama a mtodo constructor, que
en e e|empo anteror estabece os campos a os vaores ncaes especcados.
statc vod Man ()
{
}
E constructor puede tener una sta de parmetros, a gua que cuaquer otro mtodo. Como ver ms
adeante,
esto se puede utzar para hacer que os vaores ncaes de os campos 'dependen de os parmetros que
se pasan a
se crea e ob|eto.
case MyRectange
{
pubc nt x, y;
MyRectange pbco (nt ancho, nt atura)
{
x = ancho; y = atura;
}
30
www.it-ebooks.info
CAPTULO 10 Case
statc vod Man ()
{
MyRectange r = nueva MyRectange (20, 15);
}
}
Esta paabra cave
Dentro de constructor, as como en otros mtodos pertenecentes a ob|eto, una especa
paabra cave denomnada este puede ser utzado. Esta paabra cave es una referenca a a nstanca
actua de
a case. Supongamos, por e|empo, que os parmetros de constructor tenen os msmos nombres
como os campos correspondentes. Los campos podran entonces todava puede acceder medante e uso
de a este
paabra cave, a pesar de que se ven opacados por os parmetros.
case MyRectange
{
nt x, y;
MyRectange pbco (nt x, nt y)
{
ths.x = x; / / Estabecer e campo x a parmetro x
ths.y = y;
}
}
Sobrecarga Constructor
Para apoyar a dferentes stas de parmetros a constructor se puede sobrecargar. En e e|empo
a contnuacn, os campos se asgnan vaores por defecto s a case es nstancada sn
argumentos. Con un argumento ambos campos se estabecen en e vaor especcado, y con
dos argumentos cada campo se e asgna un vaor separado. E ntento de crear una
ob|eto con un nmero errneo de argumentos, o con os tpos de datos ncorrectos, se traducr en una
en tempo de compacn de error, a gua que con cuaquer otro mtodo.
MyRectange pbca ()
{
x = 10; y = 5;
}
MyRectange pbco (nt a)
{
x = a; y = a;
}
MyRectange pbco (nt a, nt b)
{
x = a; y = b;
}
31
www.it-ebooks.info
CAPTULO 10 Case
Encadenamento Constructor
La este paabra cave tambn se puede utzar para amar a un constructor de otro. Esto se conoce como
constructor de encadenamento y permte una mayor reutzacn de cdgo. Tenga en cuenta que a
paabra cave aparece como
una amada a mtodo antes de que e cuerpo de constructor y despus de dos puntos.
MyRectange pbca (): este (10,5) {}
MyRectange pbca (nt a): este (un, una) {}
MyRectange pbco (nt a, nt b) {x = a; y = b; }
Vaores de campo ncaes
S exsten campos de a case que necesta ser asgnado vaores ncaes, taes como en e caso de os
E prmer constructor ms arrba, os campos smpemente se puede ncazar a msmo tempo, ya que
son
decarado. Esto puede hacer que e cdgo un poco ms mpo. Los vaores ncaes sern asgnados
cuando
se crea e ob|eto antes de amar a constructor.
case MyRectange
{
nt x = 10, y = 20;
}
Una asgnacn de este tpo se ama un ncazador de campo. Dcha asgnacn no puede
hacer referenca a otro campo de nstanca.
Por defecto constructor
Es posbe crear una case, ncuso s no se han dendo os constructores. Esto es debdo a que e
compador aadr automtcamente un constructor sn parmetros por defecto de ta case. La
constructor por defecto ser una nstanca de ob|eto y estabecer cada campo a su vaor predetermnado.
case MyRectange {}
case MyApp
{
statc vod Man ()
{
/ / Lama constructor por defecto
}
}
32
www.it-ebooks.info
CAPTULO 10 Case
Los ncazadores de ob|eto
Cuando se crea un ob|eto, como de C # 3.0, es posbe ncazar pbca de ob|eto
campos dentro de a decaracn de nstancas. A contnuacn se aade un boque de cdgo, que contene
una sta separada por comas de as tareas de campo. E boque ncazador de ob|eto se procesar
despus de que e constructor ha sdo amado.
case MyRectange
{
pubc nt x, y;
}
cass MyCass
{
statc vod Man ()
{
/ / Incazador de ob|eto
MyRectange r = new MyRectange () {x = 10, y = 5};
}
}
S no hay argumentos para e constructor, os parntess pueden ser qutados.
MyRectange r = new MyRectange {x = 10, y = 5};
Case parca
Una dencn de case se puede dvdr en archvos fuente separados medante e uso de a parca tpo
modcador. Estas cases parcaes se combnan en e tmo tpo por e compador. Todo
partes de una case parca, debe tener a parca paabra cave y compartr e msmo nve de acceso.
/ / Fe1.cs
MyPartaCass pubc parta cass {}
/ / Fe2.cs
MyPartaCass pubc parta cass {}
Cases Dvdr en mtpes archvos de orgen es prncpamente t cuando se parte de una case
se genera automtcamente. Por e|empo, esta funcn es utzada por grca Vsua Studo
constructor de nterfaces de usuaro para separar e cdgo generado automtcamente por escrto
manuamente
cdgo. Las cases parcaes tambn puede hacer que sea ms fc para que varos programadores
traba|en en e
msma case de forma smutnea.
33
www.it-ebooks.info
CAPTULO 10 Case
Basurero
E. NET Framework tene un recoector de basura que anza perdcamente a memora usada
por os ob|etos cuando ya no son accesbes. Esto bera a programador de a frecuenca
tedoso y propenso a errores tarea de gestn de memora manua. Un ob|eto ser eegbe
para su destruccn cuando no hay ms referencas a . Esto ocurre, por e|empo, cuando un
varabe de ob|eto oca est fuera de mbto. Un ob|eto no puede cancear a asgnacn expcta en C #.
Destructor
Adems de constructores, una case puede tener tambn un destructor. E destructor se utza para
berar os recursos no admnstrados asgnados por e ob|eto. Se ama automtcamente antes
un ob|eto es destrudo, y no se puede amar de forma expcta. E nombre de destructor es e
msmo que e nombre de a case, pero preceddo por una tde (-). Una case so puede tener un
destructor
y no toma nngn parmetro o devover cuaquer vaor.
case MyComponent
{
borrador System.ComponentMode.Component pbco;
MyComponent pbca ()
{
borrador = new System.ComponentMode.Component ();
}
/ / Destructor
- MyComponent ()
{
comp.Dspose ();
}
}
En genera, e. Recoector de basura NET Framework admnstra automtcamente e
asgnacn y beracn de memora para os ob|etos. Sn embargo, cuando una case utza no
admnstrado
recursos - taes como archvos, conexones de red y componentes de nterfaz de usuaro - una
destructor debe utzarse para berar esos recursos cuando ya no son necesaros.
Paabra cave Nu
La nuo paabra cave se utza para representar una referenca nua, que es una referenca que no hace
referrse a cuaquer ob|eto. So se puede asgnar a as varabes de tpo de referenca, y no para vaorar
escrba varabes. E operador gua a (==) se puede utzar para comprobar s un ob|eto es nuo.
Strng s = nu;
f (s == nu) s = new Strng ();
34
www.it-ebooks.info
CAPTULO 10 Case
Los tpos anuabes
Un tpo de vaor se puede hacer para mantener e vaor nu, adems de su rango norma de vaores
aadendo un sgno de nterrogacn (?) a su tpo subyacente. Esto se ama un tpo que acepta vaores
NULL
y permte a os tpos smpes, as como otros tpos struct, para ndcar un vaor ndendo.
Por e|empo, boo? es un tpo que acepta vaores NULL que puede contener os vaores true, fase y nuo.
boo? b = nu;
Operador nuo coaescenca
E operador nuo coaescenca (?) Devueve e operando de a zquerda s no es nuo y
de o contraro devueve e operando de a derecha. Este operador condcona proporcona un fc
sntaxs para asgnar un tpo anuabe a un tpo que no acepta vaores NULL.
nt? = nu;
nt | = ? 0; / / 0
Una varabe de un tpo que acepta vaores NULL no debe convertrse expctamente a un tpo que no
acepta vaores NULL.
S o hace, provocar un error en tempo de e|ecucn s a varabe tene nua como su vaor.
nt | = (nt) ; / / Error en tempo de e|ecucn
Los vaores por defecto
E vaor por defecto de un tpo de referenca es nuo. Para os tpos de datos smpes, os vaores por
defecto
son os sguentes: tpos numrcos se converten 0, un char tene e carcter Uncode para e cero
(\ 0000) y un boo es fasa. Los vaores por defecto sern asgnados automtcamente por e compador
para os campos. Sn embargo, especcar expctamente e vaor por defecto para os campos que se
consdera bueno
de programacn, ya que hace que e cdgo sea ms fc de entender. Para as varabes ocaes de
defecto
Los vaores no se |an por e compador. En su ugar, e compador obga a programador
asgnar vaores a as varabes ocaes que se utzan, a n de evtar probemas asocados con
utzando varabes no asgnadas.
case MyApp
{
se asgna nt x ;/ / campo de vaor por defecto 0
nt ctca ()
{
nt x; / / Varabe oca debe ser asgnado s se utza
}
}
35
www.it-ebooks.info
Captuo 11
Herenca
La herenca permte a una case para a adquscn de os membros de otra case. En e e|empo de aba|o,
a Paza de a case hereda de Rectange, especcado por e coon. Rectnguo entonces se converte
a case base de a paza, que a su vez se converte en una case dervada de Rectnguo. Adconamente
a sus propos membros, Paza gana todos os membros accesbes en Rectange, con excepcn de
cuaquer
constructores y destructor.
/ / La case base (case padre)
case Rectange
{
pubc nt x = 10, y = 10;
}
/ / Case dervada (case h|a)
case Square: Rectange {}
Case Ob|ect
Una case en C # so puede heredar de una case base. S no se especca una case base de a case
heredar mpctamente de System.Ob|ect. Por o tanto, es a case raz de todas as dems cases.
case Rectange: System.Ob|ect {}
C # tene un sstema de tpos uncado en que todos os tpos de datos drecta o ndrectamente
heredar de
Ob|eto. Esto no so se apca a as cases, sno tambn a otros tpos de datos, taes como matrces
y tpos smpes. Por e|empo, a nt a paabra cave es so un aas para e System.Int32
tpo de estructura. De msmo modo, ob|eto es un aas para e System.Ob|ect case.
System.Ob|ect o = new Ob|ect ();
Debdo a que todos os tpos heredan de Ob|eto, todos eos comparten un con|unto comn de mtodos.
Uno
ta mtodo es ToStrng, que devueve una cadena que representa e ob|eto actua.
System.Consoe.Wrte (o.ToStrng ()); / / System.Ob|ect
37
www.it-ebooks.info
CAPTULO 11 Herenca
Abatdo y upcast
Conceptuamente, una case dervada es una especazacn de a case base. Esto sgnca que
Square es una espece de rectnguo, as como un ob|eto, y por o tanto se puede utzar en cuaquer
ugar
Se espera un rectnguo o de ob|etos. S se crea una nstanca de a paza, puede ser proyectado a
Rectange desde a case dervada contene todo en a case base.
Square s = new Cuadrado ();
Rectange r = s;
E ob|eto se consdera actuamente como un rectnguo, por o que so os membros de rectnguo se
puede
vstada. Cuando e ob|eto es abatdo de nuevo en un todo a paza especca para e
Todava se conserva a case Square. Esto es porque e rectnguo so contena
a paza, no camb e ob|eto Paza de nnguna manera.
Square s2 = (cuadrado) r;
E abatdo tene que ser expcta desde downcastng un rectnguo rea en una
Square no se permte.
Rectange r2 = new Rectange ();
Square s3 = (cuadrado) r2; / / Error
Es a paabra cave
Hay dos operadores que se pueden utzar para evtar excepcones a anzar ob|etos.
En prmer ugar est a es operador, que devueve true s e ob|eto de ado zquerdo se puede convertr a
a
Tpo ado derecho sn causar una excepcn.
Rectnguo q = new Cuadrado ();
f (q es cuadrado) {Square o = q; } / / Condcn es verdadera
Como paabra cave
E segundo operador que se utza para evtar excepcones de ob|etos de fundcn es a como operador.
Este operador proporcona una forma aternatva de escrbr una conversn expcta, con a dferenca
que s no se estabece a referenca en nu.
Rectange r = new Rectange ();
O a Paza = r como Paza; / / Cast nvda, devueve nu
38
www.it-ebooks.info
CAPTULO 11 Herenca
Boxeo
E sstema de tpos uncado de C # permte una varabe de tpo de vaor a convertr mpctamente
en un tpo de referenca de a Ob|eto case. Esta operacn se conoce como e boxeo y una vez que e
vaor se ha copado en e ob|eto que es vsto como un tpo de referenca.
nt myInt = 5;
oponerse myOb| = myInt; / / Boxeo
Unboxng
Lo contraro de boxeo es unboxng. Esto converte e vaor en ca|a de nuevo en una varabe de
su tpo de vaor. La operacn de unboxng debe ser expcta, ya que s e ob|eto no es sn embaa|e
en e tpo correcto se producr un error en tempo de e|ecucn.
myInt = (nt) myOb|; / / Unboxng
39
www.it-ebooks.info
Captuo 12
Membros Redenendo
Un membro de una case dervada puede redenr un membro de su case base. Esto se puede hacer
para todo tpo de membros heredados, pero se utza ms a menudo para dar os mtodos de nstanca
nueva
mpementacones. Para dar un mtodo de una nueva apcacn, e mtodo se redene en
a case de no con a msma rma que o ha hecho en a case base. La rma ncuye
e nombre, os parmetros y e tpo de devoucn de mtodo.
case Rectange
{
pubc nt x = 1, y = 10;
}
Paza de a case: Rectange
{
nt GetArea pbca () {return 2 * x; }
}
Ocutacn de membros
Se debe especcar s e mtodo est destnado a ocutar o anuar a herenca
mtodo. Por defecto, e nuevo mtodo, se ocuta, pero e compador emtr una advertenca
que e comportamento se debe especcar expctamente. Para emnar a advertenca de nuevo
modcador
necesta ser utzado. Esto especca que a ntencn era ocutar e mtodo heredado y
para susttura por una nueva mpementacn.
{
pbca new nt GetArea () {return 2 * x; }
}
41
www.it-ebooks.info
CAPTULO 12 Membros Redenendo
Membros de reempazo
Antes de que un mtodo puede ser reempazado, e vrtua modcador prmero debe aadrse a mtodo
en a case base. Este modcador permte que e mtodo puede reempazar en una case dervada.
case Rectange
{
pubc nt x = 1, y = 10;
nt GetArea pubc vrtua () {return x * y; }
}
La anuar modcador a contnuacn, se puede utzar para cambar a apcacn de a
mtodo heredado.
{
pubc overrde nt GetArea () {return 2 * x; }
}
Cmo ocutar y anuar
La dferenca entre os anuar y nuevo se muestra cuando una paza es upcast a un
Rectnguo. S e mtodo se redene con a nuevo modcador a contnuacn, esto permte e acceso a os
e mtodo prevamente ocuta dene en rectnguo. Por otro ado, s e mtodo es
redendo medante a anuar modcador entonces e upcast todava amar a a versn denda en
Square. Bscamente, a nuevo modcador redene e mtodo de reduccn de a |erarqua de cases,
mentras que
anuar redene e mtodo arrba y haca aba|o en a |erarqua.
Paabra cave Seado
Para detener un mtodo reempazado se cambe an ms en as cases que heredan de
a case dervada, e mtodo puede ser decarado como seado para negar a vrtua modcador.
cass MyCass
{
pubc seaed overrde nt NonOverrdabe () {}
}
Una case tambn se puede decarar como seado para evtar cuaquer case de heredara.
case seada no heredabes {}
42
www.it-ebooks.info
CAPTULO 12 Membros Redenendo
Paabra cave Base
Hay una manera de acceder mtodo de os padres, ncuso s se ha redendo. Esto se hace
medante e uso de a base paabra cave para hacer referenca a a nstanca de a case base. S e mtodo
es
ocuta o anuado todava se puede egar medante e uso de esta paabra cave.
case Trange: Rectnguo
{
GetArea pubc overrde () {return base.GetArea () / 2; }
}
La base paabra cave tambn se puede utzar para amar a un constructor de a case base desde un
dervado
constructor de a case. La paabra cave se utza entonces como una amada de mtodo antes que e
constructor de
cuerpo, con e pre|o de dos puntos.
case Rectange
{
pubc nt x = 1, y = 10;
Rectnguo pbco (nt a, nt b) {x = a; y = b; }
}
{
Paza pbca (nt a): base (a, a) {}
}
Cuando un constructor de a case dervada no tene una amada expcta a a case base
constructor, e compador nserta automtcamente una amada a a case base sn parmetros
constructor con e n de asegurar que a case base se construye correctamente.
{
Paza pbca (nt a) {} / /: base () aade de forma mpcta
}
Tenga en cuenta que s a case base tene un constructor dendo que no es sn parmetros,
e compador no crear un constructor sn parmetros por defecto. Por o tanto, a dencn
un constructor de a case dervada, sn una amada expcta a una case base denda
constructor, provocar un error en tempo de compacn.
case Base {pubc Base (nt a) {}}
case dervada: Base {} / / error en tempo de compacn
43
www.it-ebooks.info
Captuo 13
Nvees de acceso
Cada membro de a case tene un nve de accesbdad que determna que e membro
sern vsbes. Hay cnco de eos dsponbe en C #: pubc, protected, nterna
nterna protegda y prvado. E nve de acceso predetermnado para os membros de una case
es prvado.
Acceso prvado
Todos os membros, ndependentemente de nve de acceso estn dsponbes en a case en a que se
han decarado,
a case envovente. Este es e nco ugar donde se puede acceder a un membro prvado.
case MyBase
{
/ / Acceso rrestrcto
pubc nt myPubc;
Monta|e / / Denr o case dervada
protegdos nt myProtInt nterna;
/ / Dencn de monta|e
nterna nt myInterna;
/ / Dencn o case dervada
nt protegda myProtected;
So / / a case que dene
nt myPrvate prvado;
Prueba de vaco ()
{
myPubc
myProtInt
myInterna
myProtected
myPrvate
}
}
=
=
=
=
=
0;
0;
0;
0;
0;
/ /
/ /
/ /
/ /
/ /
permtdo
permtdo
permtdo
permtdo
permtdo
45
www.it-ebooks.info
t
CAPTULO 13 Los nvees de acceso
Acceso Protegdo
Un membro protegdo tambn se puede acceder desde e nteror de una case dervada, pero es
naccesbe desde otras cases.
case dervada:
{
Prueba de vaco ()
{
myPubc
myProtInt
myInterna
myProtected
myPrvate
}
}
MyBase
=
=
=
=
=
0;
0;
0;
0;
0;
/ /
/ /
/ /
/ /
/ /
permtdo
permtdo
permtdo
permtdo
naccesbe
E acceso nterno
Un membro nterno se puede acceder en cuaquer ugar dentro de con|unto oca, pero no desde
otra asambea. En. NET, una asambea es o ben un programa (. Exe) o una bboteca (. D).
/ / Dencn de monta|e
case AnyCass
{
vod Test (MyBase m)
{
m.myPubc = 0;
m.myProtInt = 0;
m.myInterna = 0;
m.myProtected = 0;
m.myPrvate = 0;
}
}
/ /
/ /
/ /
/ /
/ /
permtdo
permtdo
permtdo
naccesbe
naccesbe
Acceso nterno Protegda
Acceso nterno Protegdo sgnca ya sea protegda o nterno. Un nterno protegdo
Por o tanto, os membros se puede acceder en cuaquer ugar dentro de con|unto actua, o en as cases
de
fuera de a asambea que se dervan de a case envovente.
/ / Otros tpos de monta|e
case dervada: MyBase
{
vod Test (MyBase m)
46
www.it-ebooks.info
{
m.myPubc
m.myProtInt
m.myInterna
m.myProtected
m.myPrvate
}
}
=
=
=
=
=
0;
0;
0;
0;
0;
/ /
/ /
/ /
/ /
/ /
permtdo
permtdo
naccesbe
permtdo
naccesbe
E acceso de pbco
E acceso pbco permte e acceso mtado desde cuaquer ugar que e membro puede ser
referenca.
/ / Otros tpos de monta|e
case AnyCass
{
vod Test (MyBase m)
{
m.myPubc = 0;
m.myProtInt = 0;
m.myInterna = 0;
m.myProtected = 0;
m.myPrvate = 0;
}
}
/ /
/ /
/ /
/ /
/ /
permtdo
naccesbe
naccesbe
naccesbe
naccesbe
Los nvees de acceso de nve superor
Un membro de nve superor es un tpo que se decara fuera de cuaquer otro tpo. En C #, e
sguentes tpos pueden ser decarados en e nve superor: case, nterfaz, estructura, enumeracn y
deegar. Por defecto, estos membros no contendos se dan acceso nterno. Para poder
utzar un membro de ato nve de a otra asambea os membros tenen que ser marcados como
pbca. Este es e nco otro nve de acceso permtdo para os membros de ato nve.
cases nterna MyInternaCass {}
pubc cass MyPubcCass {}
Las cases nternas
Las cases pueden contener cases nternas, que pueden a|ustarse a cuaquera de os cnco nvees de
acceso.
Los nvees de acceso tenen e msmo efecto en as cases nternas como o hacen en otros membros.
S a case es naccesbe, no se pueden crear nstancas o heredado. Por defecto, as cases nternas
son prvadas, o que sgnca que so se pueden utzar dentro de a case en e que se denen.
47
www.it-ebooks.info
case MyBase
{
Cases / / Interores (cases andadas)
pubccass MyPubc {}
protegda MyProtInt cases nterna {}
cases nterna myInterna {}
case protegda MyProtected {}
MyPrvate case prvada {}
}
Drectrz Nve de acceso
A ttuo orentatvo, a hora de eegr un nve de acceso generamente es me|or utzar a ms restrctva
nve posbe. Esto se debe a os ms ugares un membro se puede acceder ms
ugares se puede acceder ncorrectamente, o que hace que e cdgo ms dfc de depurar. Uso
nvees de acceso restrctvo tambn har que sea ms fc de modcar a case sn romper e
cdgo para cuaquer otro programadores que utzan esa case.
48
www.it-ebooks.info
Captuo 14
Esttco
La esttco paabra cave se puede utzar para decarar campos y mtodos que se puede acceder
sn tener que crear una nstanca de a case. Membros (case) esttcas so exsten en una
copar, que pertenece a a case en s, mentras que se crean nstancas membros (no esttcos)
como nuevas copas para cada nuevo ob|eto. Esto sgnca que os mtodos esttcos no pueden utzar
nstanca
membros, ya que estos mtodos no son parte de una nstanca. Por otro ado, nstanca
mtodos pueden utzar membros esttcos y de nstanca.
case myCrce
{
/ / Varabe de nstanca (una por cada ob|eto)
otar r = 10;
/ / Varabe esttca / case (una soa copa)
p otacn esttca = 3,14 F;
/ / Mtodo de Instanca
otar GetArea ()
{
vover ComputeArea (R);
}
/ / Mtodo esttco / case
ComputeArea otacn esttca (otar a)
{
vover p * a * a;
}
}
Acceso a membros esttcos
Para tener acceso a un membro esttco de fuera de a case, e nombre de a case se utza segudo de a
operador punto. Este operador es e msmo que e utzado para acceder a os membros de nstancas,
pero
para egar a eos se requere una referenca de ob|eto. Una referenca de ob|eto no se puede utzar para
acceso a un membro esttco.
49
www.it-ebooks.info
CAPTULO 14 Esttco
statc vod Man ()
{
otar f = MyCrce.ComputeArea (MyCrce.p);
}
Los mtodos esttcos
La venta|a de membros esttcos es que pueden ser utzados por otras cases sn tener
para crear una nstanca de a case. Por o tanto, os campos deben decararse cuando esttca so
Se necesta una soa nstanca de a varabe. Los mtodos deben ser decaradas esttca s
reazar una funcn genrca que es ndependente de cuaquer varabe de nstanca. Un buen e|empo
de eo es a System.Math case, que proporcona una muttud de mtodos matemtcos.
Esta case so contene membros esttcos y constantes.
statc vod Man ()
{
dobe p = System.Math.PI;
}
Los campos esttcos
Los campos esttcos tenen a venta|a de que perssten durante toda a vda de a apcacn.
Por tanto, una varabe esttca se puede utzar, por e|empo, para regstrar e nmero de veces que un
mtodo ha sdo amado.
nt cuenta esttca = 0;
pubc statc vod dummy ()
{
cuenta + +;
}
E vaor predetermnado para un campo esttco so se estabecer una vez antes de su prmer uso.
Las cases esttcas
Una case tambn puede marcarse esttco s so contene membros esttcos y campos constantes.
Una case esttca no se puede heredar o nstanca en un ob|eto. S ntenta hacero, se
causar un error en tempo de compacn.
myCrce case esttca {}
50
www.it-ebooks.info
CAPTULO 14 Esttco
Constructor esttco
Un constructor esttco puede reazar as accones necesaras para ncazar una case. Tpcamente,
estos
accones nvoucran ncazar os campos esttcos que no se puede ncar cuando se decaran. Este
puede ser necesaro s su ncazacn requere ms de una nea, o aguna otra gca, a
ser ncazado.
cass MyCass
{
statc nt || array = new nt |5|;
MyCass esttca ()
{
nt = 0;
for (nt eemento: array)
eemento = + +;
}
}
E constructor esttco, en contraste con e constructor de nstanca reguar, so ser drgdo
una vez. Esto se produce automtcamente, ya sea cuando se crea una nstanca de a case, o cuando un
membro esttco de a case se hace referenca. Los constructores esttcos no pueden ser amados
drectamente y
no se heredan. En e caso de os campos esttcos tambn tenen ncazadores, esos vaores ncaes
sern
asgnada antes de que se e|ecute e constructor esttco.
Los mtodos de extensn
Una nueva caracterstca de C # 3.0 es os mtodos de extensn, que proporconan una manera de
agregar aparentemente nuevo
mtodos de nstanca a una case exstente fuera de su dencn. Un mtodo de extensn debe ser
se dene como esttco en una case esttca y a paabra cave este se utza en e prmer parmetro a
desgnar qu case de extender.
MyExtensons case esttca
{
/ / Mtodo de extensn
pubc statc nt Tont (esta cadena s) {
vover Int32.Parse (s);
}
}
51
www.it-ebooks.info
CAPTULO 14 Esttco
E mtodo de extensn es exgbe para os ob|etos de su prmer tpo de parmetro, en este
caso cadena, como s fuera un mtodo de nstanca de dcha case. No se hace referenca a a case
esttca
que se necesta.
case MyApp
{
statc vod Man () {
strng s = "10";
nt = s.ToInt ();
}
}
Debdo a que e mtodo de extensn tene una referenca de ob|eto, puede hacer uso de a nstanca
membros de a case que se est extendendo. Sn embargo, no puede utzar membros de esa case que
son naccesbes debdo a su nve de acceso. La venta|a de os mtodos de extensn es que
e permten "agregar" mtodos a una case sn tener que modcar o dervar e tpo orgna.
52
www.it-ebooks.info
Captuo 15
Propedades
Propedades en C # proporconan a capacdad de proteger a un campo medante a ectura y a escrtura a
travs
mtodos especaes amados descrptores de acceso. Por o genera, se decaran como pbco con e
msmo
Tpo de datos que e campo que se va a proteger, segudo de nombre de a propedad y
un boque de cdgo que dene os descrptores de acceso get y set.
Case Tempo
{
nt segundos prvadas;
pubc nt sec
{
consegur {return segundo; }
set {segundos = vaor; }
}
}
Las propedades se mpementan como mtodos, sno que se utza como s fueran campos.
statc vod Man ()
{
Tempo t = new Tme ();
nt s = t.sec;
}
Tenga en cuenta que e contexto vaor paabra cave se corresponde con e vaor asgnado a
a propedad.
53
www.it-ebooks.info
CAPTULO 15 Propedades
Propedades mpementadas-Auto
E tpo de propedad donde os descrptores de acceso get y set corresponden drectamente a un campo es
muy
comn. Debdo a esto no es una forma abrevada de escrbr este tpo de propedad, de|ando
os boques de cdgo de acceso y e mbto prvado. Esta sntaxs se ntrodu|o en C # 3.0
y se ama una propedad auto-apcado.
Case Tempo
{
pubc nt sec
{
consegur;
estabecdo;
}
}
Venta|as de propedad
Puesto que no hay una gca especa en a propedad anteror, es prctcamente o msmo que s tuvera
sdo un campo pbco. Sn embargo, como rega genera, os campos pbcos nunca deben ser utzados
en benes
programacn mundo debdo a as muchas venta|as que aportan propedades.
Prmero de todo, propedades permten a un programador para cambar a mpementacn nterna
de a propedad sn romper todos os programas que o utzan. Esto es de partcuar
mportanca para as cases pubcadas, que pueden ser utzados por otros programadores. En e
Tempo case, por e|empo, podra necestar tpo de datos de campo a ser cambado de nt a byte.
Con propedades, esta conversn podra ser mane|ado en e fondo. Con un campo pbco,
Sn embargo, a cambar e tpo de datos subyacente para una case pubcada probabemente quebrarn
programas que utzan a case.
Case Tempo
{
segundo byte prvadas;
pubc nt sec
{
consegur
{
vover (nt) segundos;
}
con|unto
{
segundo = (byte) de vaor;
}
}
}
54
www.it-ebooks.info
Una segunda venta|a de as propedades es que permten a programador para vadar a
datos antes de permtr un cambo. Por e|empo, a segundo campo se puede evtar
que se e asgne un vaor negatvo.
con|unto
{
f (vaor> 0)
segundo = vaor;
ms
segundo = 0;
}
Propedades no tenen que corresponden a un campo rea. Pueden gua de ben
cacuar sus propos vaores. Los datos podran ncuso venr de fuera de a case, por e|empo, de
una base de datos. Tampoco hay nada que mpde a programador de hacer otras cosas
en os descrptores de acceso, taes como mantener un contador de actuazacn.
nt horas pbca
{
consegur
{
vover segundo / 3600;
}
con|unto
{
segundo = vaor * 3600;
cuenta + +;
}
}
nt cuenta prvada = 0;
So ectura y escrbr propedades de so
Cuaquera de os mtodos de acceso se puede omtr. Sn e acceso set de a propedad se converte en
de so ectura, y de|ando fuera de acceso get en ugar de a propedad se compone de so escrtura.
/ / Propedad de so ectura
nt seg prvada
{
pbcos get {segundo retorno; }
}
/ / Propedad So escrtura
nt seg prvada
{
set pbca {segundos = vaor; }
}
55
www.it-ebooks.info
Nvees de acceso de a propedad
Nvees de acceso de acceso pueden ser restrngdos. Por e|empo, hacendo que e con|unto
a propedad prvada.
con|unto prvado {segundos = vaor; }
E nve de acceso de a propedad en s tambn se puede cambar para restrngr ambos descrptores de
acceso.
Por defecto, os descrptores de acceso son pbcas y a propedad en s es prvado.
nt seg prvada {get; estabecdo; }
56
www.it-ebooks.info
Captuo 16
Indexadores
Los ndzadores permten un ob|eto a ser tratado como una matrz. Se decaran en a msma forma que
propedades, excepto que e este paabra cave se utza en ugar de un nombre y sus descrptores de
acceso
tomar parmetros. En e sguente e|empo, e ndzador corresponde a una matrz de ob|etos amados
datos, por o que e tpo de a ndzador se estabece en ob|eto.
case MMatrz
{
Ob|ect || data = new ob|ect |10|;
ob|eto pbco este |nt |
{
consegur
{
devover datos ||;
}
con|unto
{
data || = vaor;
}
}
}
E descrptor de acceso get devueve e eemento especcado de a matrz de ob|etos, y e con|unto
de acceso nserta e vaor en e eemento especcado. Con e ndzador en ugar de una nstanca
de esta case puede ser creado y utzado como una matrz, tanto para obtener y estabecer os eementos.
statc vod Man ()
{
Myarray a = new MMatrz ();
a |5| = "Hoa Mundo";
ob|ect o = a |5|; / / Heo Word
}
57
www.it-ebooks.info
CAPTULO 16 Indzadores
Parmetros paso a paso
La sta de parmetros de un ndzador es smar a a de un mtodo, excepto que debe tener
a menos un parmetro y que e rbtro o fuera modcadores no estn permtdos. Por e|empo,
s hay una matrz de dos dmensones, os ndces de a y coumna se pueden pasar como
parmetros separados.
case MMatrz
{
Ob|ect |,| data = new ob|ect |10,10|;
ob|eto pbco este |nt , nt ||
{
consegur {datos de retorno |, ||; }
set {datos |, || = vaor; }
}
}
E parmetro ndex no tene que ser de un tpo entero. Un ob|eto puede gua de ben
se pasa como e parmetro ndex. E descrptor de acceso get se puede utzar para devover e ndce
poscn en a que se encuentra e ob|eto pasado.
case MMatrz
{
pubc nt esta |ob|eto o|
{
consegur {return System.Array.IndexOf (datos, o); }
}
}
Sobrecarga ndexador
Ambas de estas funconadades se puede proporconar por a sobrecarga de ndzador. E tpo y
nmero de argumentos uego determnar as ndexador es amada.
case MMatrz
{
pubc nt esta |ob|eto o|
{
consegur {return System.Array.IndexOf (datos, o); }
}
58
www.it-ebooks.info
CAPTULO 16 Indzadores
{
consegur {return data ||; }
con|unto {data || = vaor; }
}
}
Tenga en cuenta que en un verdadero programa una prueba de acance debe ser ncudo en e
de acceso, a n de evtar excepcones causadas por tratar de r ms a de a ongtud de a matrz.
{
consegur
{
Regreso (> = 0 && <data.Length)? datos ||: nu;
}
con|unto
{
f (> = 0 && <data.Length)
data || = vaor;
}
}
59
www.it-ebooks.info
Captuo 17
Interfaz
Una nterfaz se utza para especcar os membros que as cases dervadas deben mpementar. Eos son
dendo con a nterfaz paabra cave seguda de un nombre y un boque de cdgo. Su nombramento
convencn es comenzar con una "I" mayscua y uego hacer que cada paabra con mayscua nca.
nterfaz IMyInterface {}
Frmas de nterfaz
E boque de cdgo de a nterfaz so puede contener rmas, y soamente os de os mtodos,
propedades, ndzadores y eventos. Los membros de nterfaz no pueden tener nngn
mpementacones. En ugar de eo, sus cuerpos son reempazados por puntos y comas. Asmsmo, no
puede
tener nngn modcador de acceso ya que os membros de nterfaz son sempre pbcos.
nterfaz IMyInterface
{
/ / Mtodo de nterfaz
nt GetArea ();
/ Property / Interfaz
nt zona {get; estabecdo; }
/ / Indzador de nterfaz
nt esta |nt ndex| {get; estabecdo; }
/ Evento / Interfaz
evento System.EventHander MyEvent;
}
61
www.it-ebooks.info
CAPTULO 17 Interfaz
E|empo de nterfaz
En e sguente e|empo, una nterfaz amada IComparabe se dene con un soo mtodo
amado Comparar.
nterfaz IComparabe
{
nt Compara (ob|ect o);
}
La case Crcuo se dene a contnuacn mpementa esta nterfaz, medante e uso de a msma
notacn que se utza para a herenca. La Crcuo case, entonces hay que denr e Comparar
mtodo, que para esta case devover a dferenca entre os rados de crcuo. La
membro mpementado debe ser pbca, adems de tener a msma rma que e
uno dendos en a nterfaz.
Crcuo de case: IComparabe
{
nt r;
pubc nt Comparar (ob|eto o)
{
vover r - (o como Crce) r;.
}
}
Aunque una case so puede heredar de una case base que puede mpementar cuaquer nmero
de as nterfaces, especcando en una sta separada por comas despus de cuaquer case de base.
Interfaz Funconadad
IComparabe demuestra e prmer uso de as nterfaces, que es para denr una especca
funconadad que as cases pueden compartr. Permte a os programadores utzar os membros de a
nterfaz
sn tener que saber e tpo rea de una case. Para ustrar esto, e mtodo a contnuacn tene
dos IComparabe ob|etos y devueve e ms grande. Este mtodo funcona para todas as cases
que mpementan as IComparabe nterfaz, ndependentemente de su tpo, ya que e mtodo so
utza a funconadad expuesta a travs de esa nterfaz.
ob|eto esttco ms grande (un IComparabe, IComparabe b)
{
vover (a.Compare (b)> 0)? a: b;
}
62
www.it-ebooks.info
CAPTULO 17 Interfaz
Interfaz de Case
Una segunda manera de usar una nterfaz es para proporconar una nterfaz rea para una case, a travs
que a case se puede utzar. Ta nterfaz dene a funconadad que os programadores
utzando a case va a necestar.
nterfaz IMyCass
{
anuar Exposed ();
}
cass MyCass: IMyCass
{
pubc vod Exposed () {}
pubc vod Ocuto () {}
}
Los programadores podrn ver as nstancas de a case a travs de esta nterfaz,
encerrando os ob|etos en varabes de tpo de nterfaz.
IMyInterface m = new MyCass ();
Esta abstraccn proporcona dos benecos. En prmer ugar, hace que sea ms fc para que otros
programadores
utzar a case ya que ahora so tenen acceso a os membros que son reevantes para eos.
En segundo ugar, hace que a case ms exbe ya que su apcacn puede cambar sn
sendo notabe por otros programadores que utzan a case, sempre y cuando a nterfaz es segudo.
63
www.it-ebooks.info
yo
Captuo 18
Abstracto
Una case abstracta proporcona una mpementacn parca que otras cases pueden construr.
Cuando una case se decara como abstracto que sgnca que a case puede contener ncompeta
membros que se deben mpementar en as cases dervadas, adems de a case norma,
membros.
Membros abstractos
Cuaquer membro que requere un cuerpo puede ser decarado abstracto - taes como os mtodos,
propedades
y ndexadores. Estos membros se de|an sn apcarse y so especcar su
rmas, mentras que sus cuerpos son reempazados por puntos y comas.
Forma case abstracta
{
/ / Abstract mtodo
abstract nt GetArea pbca ();
/ / Resumen propedad
pubc abstract nt area {get; estabecdo; }
/ / Resumen ndexador
abstract nt pbca esta |nt ndex| {get; estabecdo; }
/ / Resumen de eventos
deegado pubc vod MyDeegate ();
evento pubc abstract MyDeegate MyEvent;
/ / Case abstracta
InnerShape pubc abstract cass {};
}
65
www.it-ebooks.info
CAPTULO 18 Abstracto
Abstract e|empo
Como un e|empo, a case de aba|o tene un mtodo abstracto amado GetArea.
{
prvate nt x = 100, y = 100;
}
S una case se derva de esta case abstracta que se ve obgado a anuar e resumen
membro. Esto es dferente de a vrtua modcador, que especca que e membro
puede ser anuado.
case Rectange: Forma
{
}
La case dervada puede ser decarado abstracto, as, en cuyo caso no tene
para poner en prctca cuaquera de os membros abstractos.
Rectnguo case abstracta: Shape {}
Una case abstracta tambn puede heredar de una case no abstracta.
case no abstracta {}
case abstracta Resumen: no abstracto {}
S a case base tene membros vrtuaes, stos se pueden susttur con ta abstracto a a fuerza
adems dervar cases para proporconar nuevas mpementacones para eos.
cass MyCass
{
vod dummy vrtua () {}
}
case abstracta Resumen: MyCass
{
overrde vod Manqu abstracto () {}
}
Una case abstracta se puede utzar como una nterfaz para su|etar ob|etos hechos de dervados
cases.
Shape s = new Rectange ();
66
www.it-ebooks.info
CAPTULO 18 Abstracto
No es posbe crear una nstanca de una case abstracta. Aun as, una case abstracta puede tener
constructores que se pueden amar desde as cases dervadas medante e uso de a base paabra cave.
Shape s = new Shape (); / / Error en tempo de compacn
Las cases abstractas e nterfaces
Las cases abstractas son smares a as nterfaces de muchas maneras. Ambos pueden membro denr
rmas que as cases dervadas deben mpementar, y nnguno de eos puede ser
nstanca. Las prncpaes dferencas son en prmer ugar que a case abstracta puede contener no
abstracta
membros, mentras que a nterfaz no se puede. Y en segundo ugar, que una case puede mpementar
cuaquer
nmero de nterfaces, pero so heredar de una case, abstracta o no.
/ / Dene a funconadad por defecto y dencones
{
pubc nt x = 100, y = 100;
}
case Rectange: Shape {} / / case es una forma de
/ / Dene una nterfaz o una funconadad especca
nterfaz IComparabe
{
nt CompareTo ();
}
cass MyCass: IComparabe {} / / case puede compararse
Una case abstracta puede, a gua que una case no abstracta, extender una case base y
mpementar cuaquer nmero de nterfaces. Una nterfaz, sn embargo, no puede heredar de una case.
Aunque puede heredar de otra nterfaz, que combna ecazmente os dos
as nterfaces en una soa.
67
www.it-ebooks.info
Captuo 19
Los espacos de nombres
Los espacos de nombres proporconan un modo de grupo reaconadas con membros de ato nve en una
|erarqua. Eos son
tambn se utza para evtar conctos de nombres. Un membro de ato nve, taes como case, que no es
ncudo en un espaco de nombres se dce que pertenecen a espaco de nombres predetermnado. Se
puede mover a
otro espaco de nombres por nscrbrse en un boque de espaco de nombres. La convencn de
nomencatura para
espacos de nombres es a msma que para as cases, con cada paabra en mayscua ncamente.
MyNamespace espaco de nombres
{
cass MyCass {}
}
Espacos de nombres andados
Los espacos de nombres se pueden andar cuaquer nmero de nvees de profunddad para denr an
ms e espaco de nombres
|erarqua.
MyNamespace espaco de nombres
{
NestedNamespace espaco de nombres
{
cass MyCass {}
}
}
Una forma ms rpda de escrbr esto es so separar os espacos de nombres con un punto.
MyNamespace.NestedNamespace espaco de nombres
{
cass MyCass {}
}
Tenga en cuenta que se decara e msmo espaco de nombres de nuevo en otra case dentro de
proyecto
tene e msmo efecto que s ambos espacos de nombres se ncuyeron en e msmo boque, ncuso s e
case se encuentra en otro archvo de cdgo.
69
www.it-ebooks.info
CAPTULO 19 Los espacos de nombres
Acceso Espaco de nombres
Para acceder a una case de otro espaco de nombres de su nombre competo necesta ser especcada.
{
pubc cass MyCass {}
}
OtherNamespace espaco de nombres
{
case MyApp
{
statc vod Man ()
{
MyNamespace.NestedNamespace.MyCass mCase;
}
}
}
E uso de a drectva
E nombre competo se puede acortar a ncur e espaco de nombres con un uso
Drectva. Los membros de ese espaco de nombres se puede acceder a cuaquer parte de cdgo
presentar sn tener que anteponer e espaco de nombres para cada referenca. Es obgatoro e ugar
medante drectvas antes todos os dems membros en e archvo de cdgo.
utzando MyNamespace.NestedNamespace;
Tener acceso drecto a estos membros sgnca que s hay un membro de concto
rma en e espaco de nombres actua membro de espaco de nombres ncudo ser
ocuto. Por e|empo, s hay una MyCass en e OtherNamespace tambn, que a case se
ser utzado por defecto. Para utzar a case de espaco de nombres ncuye, e nombre competo
vovera a tener que ser especcado.
utzando MyNamespace.NestedNamespace;
{
pubc cass MyCass
{
statc nt x;
}
}
70
www.it-ebooks.info
CAPTULO 19 Los espacos de nombres
OtherNamespace espaco de nombres
{
pubc cass MyCass
{
statc vod Man ()
{
nt x = MyNamespace.NestedNamespace.MyCass.x
}
}
}
Para smpcar esta referenca, a drectva usng ugar se puede cambar para asgnar e
espaco de nombres a un aas.
utzando MyAas = MyNamespace.NestedNamespace;
/ / ...
nt x = MyAas.MyCass.x;
Una forma an ms corto sera denr e nombre competo de a case como un nuevo tpo
para e archvo de cdgo, utzando a msma notacn de aas.
utzando MyType = MyNamespace.NestedNamespace.MyCass;
/ / ...
nt x = MyType.x;
71
www.it-ebooks.info
Captuo 20
Enum
Una enumeracn es un tpo especa de tpo de vaor que consste en una sta de constantes con nombre.
Para crear uno, e enum paabra cave se utza segudo de un nombre y un boque de cdgo, que contene
una sta separada por comas de eementos constantes.
enum Estado {Run, espera, para, Desconectado};
Este tpo de enumeracn se puede utzar para crear as varabes que pueden contener estas
constantes.
Para asgnar un vaor a a varabe de enumeracn, se accede a os eementos de a enumeracn como s
eran membros esttcos de una case.
Estado s = State.Run;
E|empo Enum
La sentenca swtch es un buen e|empo de cuando una enumeracn puede ser t.
En comparacn con e uso de constantes ordnaras, una enumeracn tene a venta|a de permtr
e programador especcar caramente o que se permten vaores constantes. Esto proporcona
en tempo de compacn segurdad de tpos y InteSense tambn hace que os vaores ms fces de
recordar.
nterruptor
{
caso
caso
caso
caso
}
(S)
State.Run:
State.Wat:
State.Stop:
State.Omne:
romper;
romper;
romper;
romper;
Vaores constantes de enumeracn
Generamente, no hay necesdad de conocer os vaores constantes reaes que representan as constantes,
pero a veces puede ser necesaro. Por defecto, e prmer eemento tene e vaor 0, y cada
eemento sucesvo tene un vaor ms ato.
73
www.it-ebooks.info
CAPTULO 20 Enum
Estado enum
{
Corre, / /
Espere, / /
Detngase, / /
Desconectado / /
};
0
1
2
3
Estos vaores predetermnados se pueden anuar medante a asgnacn de vaores a as constantes.
Los vaores pueden ser cacuados y no tenen que ser ncos.
Estado enum
{
E|ecute = 0, Wat = 3, Stop = 5, conexn = Stop + 5
};
Tpo constante Enum
E tpo subyacente de os eementos constantes se especca mpctamente como nt, Pero esto puede
cambarse utzando dos puntos despus de nombre de a enumeracn segudo por e deseado
tpo entero.
MyEnum enum: byte {};
Los nvees de acceso de enumeracn y e acance
Los nvees de acceso para enumeracones son os msmos que para as cases. Eos son nternos por
por defecto, pero tambn puede ser decarado como pbco. Aunque as enumeracones se denen
habtuamente en
a de nve superor, que pueden estar contendos dentro de una case. En una case tenen acceso prvado
por
por defecto, y se puede a|ustar a cuaquera de os nvees de acceso.
Mtodos de enumeracn
Una constante de enumeracn se puede convertr en una nt y e ToStrng mtodo se puede utzar para
obtener su nombre. La mayora de os otros mtodos de enumeracn se pueden encontrar en a
System.Enum case.
statc vod Man ()
{
Estado s = State.Run;
nt = (nt) s ;/ / 0
cadena t = s.ToStrng (); / / E|ecutar
}
74
www.it-ebooks.info
Captuo 21
Mane|o de excepcones
E mane|o de excepcones permte a os programadores para hacer frente a stuacones nesperadas que
pueden
ocurrr en os programas. Como e|empo, consdere a posbdad de abrr un archvo utzando e
StreamReader case
en e System.IO espaco de nombres. Para ver os tpos de excepcones puede anzar esta case,
se pasa e cursor sobre e nombre de a case en Vsua Studo. Por e|empo, a System.IO
excepcones FeNotFoundExcepton y DrectoryNotFoundExcepton. S aguno de
ocurren esas excepcones, e programa termna con un mensa|e de error.
usng System;
usng System.IO;
case ErrorHandng
{
statc vod Man ()
{
/ / Error en tempo de e|ecucn
StreamReader sr = new StreamReader ("mssng.txt");
}
}
Try-catch decaracn
Para evtar a cada de programa de as excepcones deben ser capturados utzando una sentenca try-
catch.
Esta decaracn consta de un boque try contene e cdgo que puede causar a excepcn,
y una o ms cusuas catch. S e boque try se e|ecuta con xto, e programa
uego contne funconando despus de a nstruccn try-catch. Sn embargo, s se produce una excepcn
a
e|ecucn A contnuacn, se pasa a prmer boque catch capaz de mane|ar ese tpo de excepcn.
ntentar
{
StreamReader sr = new StreamReader ("mssng.txt");
}
captura
{
Consoe.Wrte ("Archvo no encontrado");
}
75
www.it-ebooks.info
CAPTULO 20 E mane|o de excepcones
Boque Catch
Desde e boque catch anteror no se a|usta a mane|ar cuaquer excepcn especca que se pondr a da
todos
eos. Esto equvae a controar e System.Excepton case, porque todas as excepcones
dervar de esta case.
catch (Excepton) {}
Para detectar una excepcn ms especca de boque catch tene que ser coocado antes de que ms
excepcones generaes.
catch (FeNotFoundExcepton) {}
catch (Excepton) {}
E boque catch puede denr opconamente un ob|eto de excepcn que puede ser utzado para
obtener
ms nformacn acerca de a excepcn, ta como una descrpcn de error.
catch (Excepton e)
{
Consoe.Wrte ("Error:" + e.Message);
}
Por tmo boque
Como a tma cusua de a nstruccn try-catch, se puede agregar un boque nay. Este boque es
utzado para mpar certos recursos asgnados en e boque try. Tpcamente, sstema mtado
recursos y componentes grcos deben ser berados de esta manera, una vez que hay
ya sea necesaro. E cdgo en e boque nay sempre se e|ecuta, s exste o no es
una excepcn. Este ser e caso ncuso s e boque try termna con una nstruccn de sato,
como vueta.
En e e|empo utzado anterormente, e archvo aberto en e boque try debe ser cerrado s
que se abr con xto. Esto se reaza correctamente en e sguente segmento de cdgo. Para poder
para acceder a a StreamReader ob|eto de a cusua que namente debe ser decarado fuera de
e boque try. Tenga en cuenta que s usted se ovda de cerrar a secuenca de controador de a basura se
namente cerraro para usted, pero es una buena prctca para hacero usted msmo.
StreamReader sr = nu;
ntentar
{
sr = new StreamReader ("mssng.txt");
}
catch (FeNotFoundExcepton) {}
namente
{
s sr.Cose () (= nu sr!);
}
76
www.it-ebooks.info
La decaracn anteror se conoce como una decaracn try-catch-nay. E boque catch can
quedar fuera para crear una decaracn try-nay. Esta decaracn no coger nnguna excepcn.
En ugar de eo, se asegurar a emnacn adecuada de os recursos asgnados en e boque try.
Esto puede ser t s e recurso asgnado no anza nnguna excepcn. Por e|empo,
una case de este tpo sera Btmap, en e System.Drawng espaco de nombres.
utzando System.Drawng;
/ / ...
Btmap b = nu;
ntentar
{
b = new Btmap (100, 100);
System.Consoe.WrteLne ("Ancho:" + + b.Wdth
"Atura:" + b.Heght);
}
namente
{
f (! b = nu) b.Dspose ();
}
Tenga en cuenta que cuando se utza un proyecto de consoa una referenca a a System.Drawng
monta|e
hay que aadr manuamente para aqueos membros que sean accesbes. Para eo, haga cc derecho en
e
Referencas carpeta en a ventana de Exporador de soucones y seeccone Agregar referenca. Luego,
desde
a cha NET. seecconar e System.Drawng monta|e y haga cc en Aceptar para agregar a referenca a
su proyecto.
Usng
La nstruccn usng proporcona una sntaxs ms smpe para a escrtura de a decaracn try-nay.
Esta decaracn comenza con a uso paabra cave seguda por e recurso a adqurr,
especcado en parntess. A contnuacn, ncuye un boque de cdgo en e que e recurso obtendo
puede
ser utzado. Cuando e boque de cdgo ha termnado de e|ecutarse, e Dsponer mtodo de ob|eto
se ama automtcamente a mparo. Este mtodo provene de a System.IDsposabe
nterfaz, por o que e recurso especcado debe mpementar esta nterfaz. E cdgo de aba|o
reaza a msma funcn que a de e|empo anteror, pero con un menor nmero de neas
de cdgo.
utzando System.Drawng;
/ / ...
usando (Btmap b = new Btmap (100, 100))
{
System.Consoe.WrteLne ("Ancho:" + + b.Wdth
"Atura:" + b.Heght);
}
77
www.it-ebooks.info
Lanzar excepcones
Cuando se produce una stuacn de que un mtodo no puede recuperarse de ea puede generar una
excepcn
para ndcar a persona que ama que e mtodo ha faado. Esto se hace usando a trar paabra cave
segudo de una nueva nstanca de una case que derva de System.Excepton.
statc vod MakeError ()
{
throw new System.DvdeByZeroExcepton ("M Error");
}
La excepcn se propagar por a pa de amadas hasta que entre. S una persona que ama
detecta a excepcn, pero no es capaz de recuperarse de ea, a excepcn puede ser re-anzado
utzando so e trar paabra cave.
statc vod Man ()
{
try {MakeError (); } Catch {throw; }
}
S no hay ms sentencas try-catch de programa se detendr a e|ecucn y vsuazacn
e mensa|e de error.
78
www.it-ebooks.info
Captuo 22
Sobrecarga de operadores
La sobrecarga de operadores permte a os operadores a ser redendos y se utzan donde uno o ambos
de os
operandos son de una certa case. Cuando se hace correctamente, esto puede smpcar e cdgo y
hacer
tpos dendos por e usuaro tan fc de usar como os tpos smpes.
Operador e|empo sobrecarga
En este e|empo, hay una case amada MyNum con un campo entero y un constructor para
estabecer ese campo. Tambn hay un esttco Aadr mtodo que agrega dos MyNum ob|etos |untos
y devueve e resutado como una nueva MyNum ob|eto.
case MyNum
{
nt va pbco;
MyNum pbco (nt ) {va = ; }
pubc statc MyNum Aadr (MyNum un MyNum b) {
return new MyNum (a.va + b.va);
}
}
Dos MyNum casos se pueden sumar con e Aadr mtodo.
MyNum a = new MyNum (10), b = new MyNum (5);
MNum C = MyNum.Add (a, b);
La sobrecarga de operadores bnaros
Lo que a sobrecarga de operadores no es smpcar esta sntaxs y proporconar as una mayor
nterfaz ntutva para a case. Para convertr a Aadr mtodo a una sobrecarga de mtodo para a
sgno Adems, cambe e nombre de mtodo con e operador paabra cave seguda por a
operador que ha de ser sobrecargado. E espaco en banco entre a paabra cave y e operador
opconamente se puede de|ar fuera. Tenga en cuenta que para un mtodo de sobrecarga de operadores
para traba|ar, debe
denrse como tanto pbco y esttca.
79
www.it-ebooks.info
CAPTULO 22 La sobrecarga de operadores
case MyNum
{
nt va pbco;
operador MyNum statc + (MyNum un MyNum b)
{
return new MyNum (a.va + b.va);
}
}
Desde a case ahora sobrecarga e sgno de a suma este operador se puede utzar para evar a cabo
e ccuo requerdo.
MyNum a = new MyNum (10), b = new MyNum (5);
MNum C = A + B;
La sobrecarga de operadores unaros
Adems es un operador bnaro, ya que toma dos operandos. Para sobrecargar un operador unaro,
taes como ncremento (+ +), un nco parmetro de mtodo se utza en su ugar.
operador MyNum statc + + (MyNum a)
{
return new MyNum (a.va + 1);
}
Tenga en cuenta que esto va a sobrecargar tanto e su|o y versones de pre|o de ncremento
operador.
MyNum a = new MyNum (10);
a + +;
+ + A;
Tpos y parmetros de retorno
Cuando a sobrecarga de un operador unaro de tpo tpo de retorno y e parmetro debe ser de a
ad|untando tpo. Por otro ado, cuando a sobrecarga de a mayora de os operadores bnaros e regreso
tpo puede ser cuaquer cosa, excepto para anuar, y so uno de os parmetros deben ser de
ad|untando tpo. Esto sgnca que es posbe sobrecargar adems un operador bnaro con
otros parmetros de mtodo, por e|empo para permtr un MyNum y un nt que se aaden |untos.
operador MyNum statc + (MyNum a, nt b)
{
return new MyNum (a.va + b);
}
80
www.it-ebooks.info
CAPTULO 22 La sobrecarga de operadores
Operadores sobrecargabes
C # permte a sobrecarga de cas todos os operadores, como se puede ver en a taba de aba|o. La
operadores de asgnacn combnados no se pueden sobrecargar de forma expcta. En cambo, son
mpctamente
sobrecargado cuando se sobrecargan sus operadores artmtcos o de bts correspondentes.
Los operadores bnaros
+ - * /% (+ = - = * = / =% =)
Y | << >> (& = | = = << = >> =)
==! => <> = <=
Operadores unaros
+ -! - + + - Verdadero o faso
No sobrecargabe
&& | | =. () ::: Nueva como es typeof
comprobado sn contro
Los operadores de comparacn, as como verdadero y faso, deben ser sobrecargados por pare|as.
Por e|empo, a sobrecarga de operador gua sgnca que e operador no gua tambn tene
estar sobrecargado.
Verdadero y faso sobrecarga de operadores
Observe en a taba anteror que verdadero y faso se consdera que son os operadores.
Por sobrecargaros, ob|etos de a case se pueden utzar en sentencas condconaes donde e
ob|eto necesta ser evauado como un tpo booeano. Cuando sobrecargaros os tpos de devoucn
debe ser boo.
case MyNum
{
nt va pbco;
boo operator statc verdadero (MyNum a) {
return (a.va = 0!);
}
operador statc boo pbco faso (MyNum a) {
vover (== a.va 0);
}
}
cass MyCass
{
statc vod Man () {
MyNum a = new MyNum (10);
s (a) System.Consoe.WrteLne ("ob|eto es verdad");
eseSystem.Consoe.WrteLne ("ob|eto es fasa");
}
}
81
www.it-ebooks.info
Captuo 23
Conversones personazadas
Este captuo trata sobre cmo denr conversones de tpos personazado para un ob|eto. Como puede ser
vsto en e e|empo de aba|o, hay una case amada MyNum con un soo nt campo y
un constructor. Con una conversn de tpo personazado, es posbe permtr un nt que mpctamente
convertdo en un ob|eto de esta case.
case MyNum
{
nt va pbco;
}
Mtodos de conversn mpctas
Para que esto funcone un mtodo de conversn mpcta necesta ser agregado a a case. Este
a rma de mtodo es smar a a utzada para a sobrecarga de operadores unaro. Debe ser
decarado como statc e ncuye a operador paabra cave. Sn embargo, en ugar de un
smboo de operador se especca e tpo de retorno, que es e tpo de destno para a conversn.
E nco parmetro tendr e vaor que se va a convertr. La mpcto paabra cave
tambn se ncuye, que especca que e mtodo se utza para reazar as conversones mpctas.
pubc statc MyNum operador mpcto (nt a)
{
return new MyNum (a);
}
Con este mtodo, en ugar de una nt se puede convertr mpctamente a un MyNum ob|eto.
MyNum a = 5;
Otro mtodo de conversn se puede agregar que se encarga de as conversones en e frente
dreccn, a partr de una MyNum oponerse a una nt.
pubc statc nt operador mpcto (MyNum a)
{
vover a.va;
}
83
www.it-ebooks.info
CAPTULO 23 Conversones de encargo
Mtodos de conversn expctos
Para evtar as conversones de tpos de ob|etos potencamente no deseados por e compador, e
mtodo de conversn se puede decarar como expcto en ugar de mpcta.
pubc statc nt operador expcta (MyNum a)
{
vover a.va;
}
La expcto paabra cave sgnca que e programador tene que especcar una conversn expcta en
Para nvocar e mtodo de conversn de tpo. En os mtodos de conversn determnados, expctos
debe ser utzado s e resutado de a conversn conduce a a prdda de nformacn, o s a
mtodo de conversn puede anzar excepcones.
MyNum a = 5;
nt = (nt) a;
84
www.it-ebooks.info
Captuo 24
Constantes
Una varabe en C # se puede convertr en una constante en tempo de compacn, aadendo e const
paabra cave
antes de que e tpo de datos. Este modcador sgnca que a varabe no se puede cambar y se
por o tanto, se e debe asgnar un vaor a msmo tempo que se decara. Cuaquer ntento de
asgnar un nuevo vaor a a constante producr un error en tempo de compacn.
Constantes ocaes
Una constante ocaes sempre se debe ncazar a msmo tempo que se decara.
statc vod Man ()
{
const nt a = 10; / / Tempo de compacn constante
}
La const modcador crea una constante en tempo de compacn, por o que e compador
reempazar todo e uso de a constante con su vaor. Por consguente, e vaor asgnado debe ser
conocdo en tempo de compacn. Como resutado de esto, a const modcador so puede usarse |unto
con os tpos smpes, as como con tpos de enumeracn y de cadena.
Campos constantes
La const modcador se puede utzar en campos as como en as varabes ocaes. A dferenca de C + +,
C # no permte que os parmetros de mtodo que se hagan constantes.
cass MyCass
{
const nt b = 5; / / Campo constante en tempo de compacn
}
Un campo que est marcado con const se accede como s fuera un campo esttco. Campos constantes
no se puede hacer esttca.
nt a = MyCass.b;
85
www.it-ebooks.info
CAPTULO 24 Constantes
Paabra cave readony
Otro modcador de a varabe smar a const es readony, que crea un tempo de e|ecucn
constante. Este modcador so se puede apcar a os campos, y como const que hace que e campo
nmutabe.
cass MyCass
{
nt readony c = 3; / / Campo constante de tempo de e|ecucn
}
Sn embargo, desde un campo de so ectura se asgna en tempo de e|ecucn se puede asgnar una
dnmca
vaor que no se sabe hasta e tempo de e|ecucn.
readony nt d = System.DateTme.Now.Hour;
Deseme|ante const readony se puede apcar a cuaquer tpo de datos.
readony nt || e = {1, 2, 3};
Adems, un campo de so ectura, no so se puede ncazar cuando se decara. Puede
aternatvamente, se e asgnar un vaor en e constructor.
cass MyCass
{
readony strng s;
MyCass pbca () {s = "Hoa Mundo"; }
}
Pauta constante
En genera, es una buena dea para decarar sempre as varabes como constantes s no necestan
ser reasgnado. Esto asegura que as varabes no se pueden cambar en cuaquer ugar en e
programa por error, que a su vez ayuda a prevenr errores.
86
www.it-ebooks.info
Captuo 25
Preprocessor
C # ncuye un con|unto de drectvas de preprocesador que se utzan prncpamente para a condcona
compacn. Aunque e compador de C # no tene un preprocesador separada, como C y
Compadores de C + +, as drectvas se muestran a contnuacn se procesan como s o hubera. Es decr,
se
parecen ser procesada antes de a compacn se reaza efectvamente.
Drectva
# S
# Ef
# Ese
# Endf
# Dene
# Undef
# Error
# Avso
# Lne
# Regon
# Endregon
Descrpcn
S
Ese f
Ms
End f
Smboo denr
Undene Smboo
Generar error
Generar aerta
Estabecer e nmero de nea
Seccn nca Marcos
Seccn de extremo Marcos
Sntaxs drectva de preprocesador
Las drectvas de preprocesador se dstnguen fcmente de cdgo de programacn norma en
que comenzan con una amohada (#). Eos sempre deben ocupar una nea que es ndependente de
todo o dems, a excepcn de os comentaros de una soa nea. E espaco en banco se puede ncur
opconamente
antes y despus de a marca de hash.
# Lne nmero 1 / / nea sere
87
www.it-ebooks.info
CAPTULO 25 Preprocesador
La compacn condcona - # f y # endf
La # S y # Endf Drectvas contenen una seccn de cdgo que se ncur o
excudos sobre a base de una condcn dada. Con mucha frecuenca, esta condcn ser una condcona
smboo de compacn.
# S MySymbo
/ / ...
# Endf
Dencn de os smboos
Un smboo de compacn condcona se ha creado usando e # Dene drectva segudo por e
E nombre de smboo. Cuando se dene un smboo, se har entonces que una expresn condcona
usando esa condcn a evauar como verdadera. E smboo permanecer dendo so dentro de
e archvo de a fuente de corrente a partr de a nea en a que se crea e smboo.
# Dene MySymbo
Smboos ndenr
La # Undef (Undene) drectva puede desactvar un smboo prevamente dendo.
MySymbo # undef
La compacn condcona - # ef y # ese
A gua que con e C # f, a # S drectva puede ncur opconamente cuaquer cantdad de
# Ef Drectvas (ese f) y un tmo # Ese Drectva. Drectvas condconaes tambn pueden
andarse dentro de otra seccn condcona. En os condconaes ms argas, es una buena prctca
aadr comentaros a a # Endf drectrces para ayudar a mantener un segumento de os # S drectva
que
corresponden a.
# S Profesona
/ / ...
# Ef avanzada | | Empresa
/ / ...
# Ese
# S depuracn
/ / ...
# Endf / / Debug
# Endf / / no profesona, Advanced o Enterprse
88
www.it-ebooks.info
r
CAPTULO 25 Preprocesador
Drectvas de dagnstco
Hay dos drectvas de dagnstco: # Error y # Avso. La # Error se utza a Drectva
para abortar una compacn medante a generacn de un error de compacn. Esta drectva puede,
opconamente,
tomar un parmetro que especca a descrpcn de error.
# S Profesona && Empresa
Bud # error no puede ser a a vez profesona y Empresa
# Endf
Smar a error, a # Avso Drectva genera un mensa|e de advertenca de compacn.
La presente Drectva no se detendr a compacn.
# If! Profesona &&! Empresa
# Avso Bud debe ser profesona o Enterprse
# Endf
Drectva Lne
Otra drectva que afecta a a sada de compador es # Lne. Esta drectva se utza para
cambar e nmero de a nea y, opconamente, e nombre de archvo fuente que se muestra cuando un
error o advertenca se produce durante a compacn. Esto es prncpamente t cuando se utza un
programa de
que combna os archvos de orgen en un archvo ntermedo que se compa a contnuacn.
# Lne 500 "MArchvo"
# Error MError / / MError on ne 500
Drectva Regn
Las dos tmas drectvas # Regon y # Endregon. Se demtan una seccn de cdgo que
se puede ampar o contraer utzando a caracterstca de esquematzacn de Vsua Studo.
# Regon MyRegon
# Endregon
A gua que as drectvas condconaes, as regones se pueden andar cuaquer nmero de nvees de
profunddad.
# Regon MyRegon
# Regon MySubRegon
# Endregon
# Endregon
89
www.it-ebooks.info
Captuo 26
Deegados
Un deegado es un tpo que se utza para hacer referenca a un mtodo. Esto permte que os mtodos
que se asgnar a
varabes y pasa como argumentos. La decaracn de deegado especca e mtodo
rma a a cua os ob|etos de tpo de deegado se puede referr. Los deegados son por convencn
nombrado con cada paabra en mayscua nca seguda de "Deegado" a na de nombre.
deegate vod MyDeegate (strng s);
Un mtodo que concde con a rma de deegado puede ser asgnado a un ob|eto deegado
de este tpo.
cass MyCass
{
statc vod Prnt (Strng t)
{
System.Consoe.Wrte (t);
}
statc vod Man ()
{
MyDeegate d = mpresn;
}
}
Este ob|eto deegado se comportar como s fuera e propo mtodo, no mporta s se
se reere a un esttco o un mtodo de nstanca. Una amada a un mtodo en e ob|eto ser remtda
por e deegado para e mtodo, y cuaquer vaor de retorno se pasa de nuevo a travs de
e deegado.
MyDeegate d = mpresn;
d ("Heo");
La sntaxs usada anterormente para crear una nstanca de deegado es en readad una notacn
smpcada
que se ntrodu|o en C # 2.0. La forma compatbe a nstancas de un deegado es
utzar a sntaxs norma de ncazacn tpo de referenca.
MyDeegate d = new MyDeegate (mpresn);
91
www.it-ebooks.info
CAPTULO 26 Deegados
Los mtodos annmos
C # 2.0 tambn ntrodu|o os mtodos annmos, que pueden ser asgnados a deegar ob|etos.
Un mtodo annmo se especca medante e deegado paabra cave seguda de un mtodo
sta de parmetros y e cuerpo. Esto puede smpcar a creacn de nstancas de deegado ya un
ndependente
mtodo no tendr que ser dendo con e n de crear una nstanca de deegado.
MyDeegate f = deegado (cadena t)
{
System.Consoe.Wrte (t);
};
Las expresones ambda
C # 3.0 fue un paso ms a e ntrodu|o as expresones ambda. Logran a msma
go mtodos annmos, pero con una sntaxs ms concsa. Una expresn ambda es
escrto como una sta de parmetros segudo por e operador ambda (=>) y una expresn.
deegar nt MyDeegate (nt );
statc vod Man ()
{
/ / Mtodo Anonymous
de deegado a = (nt x) {return x * x; };
/ / Expresn Lambda
de b = (nt x) => x * x;
un (5); / / 25
b (5); / / 25
}
La ambda debe concdr con a rma de deegado. Tpcamente, e compador
puede determnar e tpo de datos de os parmetros a partr de contexto, de modo que no es necesaro
a especcar. Los parntess tambn pueden ser excudos s a ambda tene una soa entrada
parmetro.
de c = x => x * x;
S no se necestan parmetros de entrada se debe especcar un con|unto vaco de parntess.
deegate vod MyEmptyDeegate ();
/ / ...
MyEmptyDeegate d = () => System.Consoe.Wrte ("Heo");
92
www.it-ebooks.info
CAPTULO 26 Deegados
Una expresn ambda que so se e|ecuta una soa nstruccn se denomna expresn
ambda. La expresn de un ambda tambn puede ser encerrada entre aves para permtr que se
contener varas decaracones. Esta forma se ama una ambda comuncado.
MyDeegate e = (nt x) => {
nt y = x * x;
regresar y;
};
Deegados de mutdfusn
Es posbe que un ob|eto deegado para referrse a ms de un mtodo. Ta ob|eto es
conocdo como un deegado de mutdfusn y os mtodos que se reere a estn contendos en e amado
sta de nvocacn. Para agregar otro mtodo a a sta de nvocacn de deegado, o ben e
operador de suma o e operador de asgnacn Adems se pueden utzar.
statc vod H () {System.Consoe.Wrte ("Hoa"); }
statc vod Ads () {System.Consoe.Wrte ("Ads"); }
/ / ...
MyDeegate d = H;
d = d + H;
d + = Ads;
De msmo modo, para emnar un mtodo de a sta de nvocacn, a resta o sustraccn
se utzan operadores de asgnacn.
d - = H;
A amar a un ob|eto deegado de mutdfusn, todos os mtodos en su sta de nvocacn ser
se nvoca con os msmos argumentos en e orden en que fueron aaddos a a sta.
d (); / / HBye
S e deegado devueve un vaor, so e vaor de a tma mtodo nvocado ser
devueto. De msmo modo, s e deegado tene un parmetro de sada, su vaor na ser e vaor
asgnado por e tmo mtodo.
Deegar a rma
Como se ha menconado antes, un mtodo puede ser asgnado a un ob|eto deegado s concde con a
a rma de deegado. Sn embargo, un mtodo no tene que concdr con a rma exactamente.
Un ob|eto deegado tambn puede referrse a un mtodo que tene un tpo de retorno ms dervado que
que se dene en e deegado, o que tene os tpos de parmetros que son ancestros de os
tpos de parmetros de deegado correspondente.
93
www.it-ebooks.info
CAPTULO 26 Deegados
Case base {}
case dervada: Base {}
deegado Base MyDeegate (d Dervado);
cass MyCass
{
esttca Dervado manqu (o base) {return new Derved (); }
statc vod Man ()
{
MyDeegate d = manqu;
}
}
Los deegados como parmetros
Una propedad mportante de os deegados es que se pueden pasar como parmetros de mtodo. A
demostrar e beneco de este, se denrn dos cases smpes. E prmero es un dato
Case de amacenamento amada PersonDB que tene una matrz que contene un par de nombres.
Tambn tene un
mtodo que toma un ob|eto deegado como argumento, y pde que e deegado para cada nombre
en a matrz.
deegar (strng nombre) vod ProcessPersonDeegate;
case PersonDB
{
strng || st = {"|uan", "Sam", "Dave"};
pubc vod Proceso (ProcessPersonDeegate f)
{
foreach (strng s en a sta) f (s);
}
}
La segunda case es Cente, que utzar a case de amacenamento. Tene un mtodo Man
que crea una nstanca de PersonDB, y ama a ese ob|eto de Proceso con un mtodo
mtodo que se dene en a Cente case.
case de cente
{
statc vod Man ()
{
PersonDB p = new PersonDB ();
p.Process (PrntName);
}
94
www.it-ebooks.info
CAPTULO 26 Deegados
statc vod PrntName (strng nombre)
{
System.Consoe.WrteLne (nombre);
}
}
E beneco de este enfoque es que permte a apcacn de a de amacenamento de datos
ser separado de a apcacn de tratamento de datos. La case de amacenamento so
mane|a e amacenamento y no tene conocmento de a transformacn que se reaza sobre os datos.
Esto permte a a case de amacenamento para ser escrto de una manera ms genera que s esta case
tuvo que
mpementar todas as operacones de tratamento posbes que un cente o desea, puede evar a cabo en
os datos. Con esta soucn, e cente smpemente puede conectar su propo cdgo de procesamento en
e
Case de amacenamento exstente.
95
www.it-ebooks.info
Captuo 27
Eventos
Los eventos permten un ob|eto de notcar a otros ob|etos cuando se produce ago de nters.
E ob|eto que provoca e evento se ama a edtor y os ob|etos que se encargan de a
caso se aman suscrptores.
Edtor
Para demostrar e uso de os eventos de edtor se crear prmero. Esta ser una case
que se hereda de ArrayLst, pero esta versn se desencadena un evento cada vez que un artcuo es
aaddo a a sta. Antes de evento se puede crear se necesta un deegado que contendr e
suscrptores. Esto podra ser cuaquer tpo de deegado, pero e patrn de dseo estndar es utzar
un deegado vaco que acepta dos parmetros. E prmer parmetro especca a fuente
ob|eto de evento, y e segundo parmetro es un tpo que se apca o se hereda de a
System.EventArgs case. Este parmetro normamente contene os detaes de evento, pero en
este e|empo no hay necesdad de pasar os datos de eventos y as a base EventArgs vountad de case
ser utzado como e tpo de parmetro.
deegate vod pbca
EventHanderDeegate (ob|ect sender,
System.EventArgs e);
case Edtora: System.Coectons.ArrayLst
{
/ / ...
}
Paabra cave Event
Con e deegado dendo, e evento se puede crear en e Edtor case utzando e
evento paabra cave seguda por e deegado y e nombre de evento. La evento paabra cave
crea un tpo especa de deegado que so se puede nvocar desde dentro de a case donde se
est decarada. Su nve de acceso es pbco para que otras cases pueden suscrbrse a esta
evento. E deegado que sgue a a paabra cave evento es amado e deegado de eventos. E nombre
de evento es comnmente un verbo. En este caso e evento se pante despus de que e artcuo tene
97
www.it-ebooks.info
CAPTULO 27 Eventos
ha aaddo por o que e tempo pasado de verbo "Agregar" se utza, que es S un pre-evento "Ata".
fue creada en cambo, que se provoca antes de evento, a contnuacn, a forma-cn de verbo
sera utzado, en este caso "Aadr".
acto pbco EventHanderDeegate Agregado;
Como aternatva, en ugar de este evento personazado deegar a predenda
System.EventHander deegado podra haber sdo utzado. Este deegado es dntca a a
uno se han dendo prevamente, y se utza en as bbotecas de cases. NET para a creacn de eventos
que
No dsponemos de datos de eventos.
Persona que ama Evento
Para nvocar e caso de que una persona que ama evento puede ser creado. La convencn de
nomencatura para esta
mtodo es que preceder e nombre de evento con a paabra "On", que en este caso se converte,
"OnAdded" E mtodo tene e nve de acceso protegdo para evtar que se e ame.
de una case de reacn, y se marca como vrtua para permtr que as cases para anuar o que derva.
Toma os argumentos de evento como su un parmetro, que en este caso es de a EventArgs
escrba. E mtodo so se provoca e evento s no es nuo, es decr, so cuando e evento
tene nngn suscrptores regstrados. Para provocar e evento de este se pasa referenca de nstanca
como e remtente, y e EventArgs ob|eto es e ob|eto que se ha pasado a mtodo.
vrtua vod protegda OnAdded (System.EventArgs e)
{
f (Aaddo = nuo!) Aaddo (esto, e);
}
Eventos Crando
Ahora que a case tene un evento y un mtodo para amar a que, e paso na es reempazar
a ArrayLst de Aadr mtodo para hacer que provoca e evento. En esta versn nvadada de
E mtodo de a case base Aadr mtodo se ama prmero, y e resutado se amacena. E evento
se eeva a contnuacn, con a OnAdded mtodo, pasando a ea e Vaco en e campo
System.EventArgs case, o que representa un evento sn datos. Fnamente, e resutado es
regresado a a persona que ama.
pubc overrde nt Add (vaor de ob|eto)
{
nt = base.Add (vaor);
OnAdded (System.EventArgs.Empty);
vover ;
}
98
www.it-ebooks.info
CAPTULO 27 Eventos
La case de edtor competo ahora tene e sguente aspecto.
case Edtora: System.Coectons.ArrayLst
{
deegate vod pbca
EventHanderDeegate (ob|ect sender,
System.EventArgs e);
acto pbco EventHanderDeegate Agregado;
vrtua vod protegda OnAdded (System.EventArgs e)
{
f (Aaddo = nuo!) Aaddo (esto, e);
}
pubc overrde nt Add (vaor de ob|eto)
{
nt = base.Add (vaor);
OnAdded (System.EventArgs.Empty);
vover ;
}
}
Suscrptor
Para hacer uso de a case de edtor de otra case, se crear que suscrbr
e evento.
case de abonado
{
/ / ...
}
Controador de eventos
Esta case contene un controador de eventos, que es un mtodo que tene a msma rma que e
deegado de eventos y se utza para controar un evento. E nombre de controador es comnmente
e msmo que e nombre de evento segudo por e su|o "EventHander".
case de abonado
{
pubc vod AddedEventHander (ob|ect sender,
System.EventArgs e)
{
System.Consoe.WrteLne ("AddEvent ocurr");
}
}
99
www.it-ebooks.info
CAPTULO 27 Eventos
La suscrpcn a os eventos
Las cases de edtor y suscrptor ya estn competos. Para demostrar su uso, una prncpa
se aade mtodo donde os ob|etos de a Edtor y Suscrptor se crean cases.
Con e n de regstrar e controador en e Suscrptor oponerse a evento en e Edtor
ob|eto, se agrega e controador de eventos para e evento como s se tratara de un deegado. A dferenca
de un deegado,
Sn embargo, e evento no se puede amar drectamente desde fuera de su case contenedora. En ugar de
eo,
e evento so puede ser eevado por e Edtor case, que en este caso se produce cuando un
eemento se agrega a ese ob|eto.
case MyApp
{
statc vod Man ()
{
Suscrptor s = new Suscrptor ();
Edtora p = new Edtora ();
p.Added + = s.AddedEventHander;
p.Add (10); / / Ocurr AddEvent
}
}
100
www.it-ebooks.info
Captuo 28
Genrcos
Genrcos se reeren a a utzacn de parmetros de tpo, que proporconan una forma de dseo de
cdgo
pantas que pueden operar con dferentes tpos de datos. Especcamente, es posbe crear
mtodos genrcos, cases, nterfaces, deegados y eventos.
Los mtodos genrcos
En e e|empo de aba|o, hay un mtodo que ntercamba dos argumentos enteros.
statc vod Swap (ref nt a, ref nt b)
{
nt temp = a;
a = b;
b = temp;
}
Para hacer esto en un mtodo genrco que puede traba|ar con cuaquer tpo de datos, un tpo
necesta prmer parmetro que se aade despus de nombre de mtodo, encerrado entre
escuadras. La convencn de nomencatura para os parmetros de tpo es que se debe comenzar con
mayscua, y uego hacer que cada paabra que descrbe e parmetro nca mayscua.
En casos como e presente, sn embargo, cuando un nombre descrptvo no aadra mucho vaor, es
comn para nombrar smpemente e parmetro con una T mayscua
statc vod Intercambo <T> (ref nt a, ref nt b)
{
nt temp = a;
a = b;
b = temp;
}
E parmetro de tpo ahora se puede utzar como cuaquer otro tpo dentro de mtodo, y por o que e
Lo segundo que hay que hacer para competar e mtodo genrco es reempazar os datos
tpo que se hzo genrco con e parmetro de tpo.
101
www.it-ebooks.info
CAPTULO 28 Genrcos
statc vod Intercambo <T> (ref T a, ref T b)
{
T temp = a;
a = b;
b = temp;
}
Lamar a mtodos genrcos
E mtodo genrco est termnado. Para amaro, e argumento tpo deseado tene que ser
especcado en escuadras antes de que os argumentos de mtodo.
nt a = 0, b = 1;
<nt> Swap (REF A, ref b);
En este caso, e mtodo genrco tambn puede ser amado como s fuera un mtodo reguar,
sn especcar e argumento de tpo. Esto se debe a que e compador puede automtcamente
determnar e tpo de puesto que os parmetros de mtodo genrco utzan e parmetro de tpo.
Sn embargo, s esto no fuera e caso, o utzar otro tpo de argumento que a que e
compador eegra, sera entonces necesaro especcar expctamente e argumento de tpo.
Swap (REF A, ref b);
Sempre que un medcamento genrco es amado por prmera vez durante e tempo de e|ecucn, una
versn especazada
de genrco ser una nstanca que tene cada ocurrenca de parmetro de tpo
susttudo con e argumento de tpo especcado. Es este mtodo generado que ser
amado y no e propo mtodo genrco. A amar a mtodo genrco de nuevo con a msma
argumento de tpo se vueva a utzar este mtodo nstancado.
<nt> Swap (REF A, ref b); / / Crear y amar <nt> Intercambo
<nt> Swap (REF A, ref b); / / Aternar amada <nt>
Cuando se ama a mtodo genrco con un nuevo tpo, otro mtodo especazado
crear nstancas.
de argo c = 0, d = 1;
<ong> Swap (ref c, ref d); / / Crear y amar <ong> Intercambo
Parmetros de tpo genrco
Un genrco puede ser dendo para aceptar ms de un parmetro de tpo smpemente aadendo ms de
es entre os corchetes anguares. Los mtodos genrcos tambn se pueden sobrecargar con base en a
nmero de parmetros de tpo que eos denen.
statc vod dummy <T, U> () {}
statc vod dummy <T> () {}
102
www.it-ebooks.info
CAPTULO 28 Genrcos
Vaor predetermnado
A usar genrcos, una cuestn que puede surgr es cmo asgnar un vaor predetermnado a un tpo
parmetro ya que este vaor depende de tpo. La soucn es utzar a defecto
paabra cave seguda por e parmetro de tpo entre parntess. Esta expresn se
devover e vaor por defecto no mporta qu se utza e parmetro de tpo.
statc vod Cambar <T> (ref T a)
{
a = defaut (T);
}
Las cases genrcas
Las cases genrcas permten a os membros de a case que utzan parmetros de tpo. Se denen en a
msma forma que os mtodos genrcos, medante a adcn de un parmetro de tpo despus de que e
nombre de a case.
case Pont <T>
{
T pbca x, y;
}
Para crear una nstanca de un ob|eto de a case genrca se utza a notacn estndar, pero
con e argumento de tpo especcado despus de que ambos nombres de case. Tenga en cuenta que en
contraste con genrco
mtodos, una case genrca sempre debe crear una nstanca con e argumento de tpo expctamente
especcado.
<short> Pont p = <short> nuevo Punto ();
Herenca de a case genrca
Herenca funcona de forma geramente dferente con cases genrcas. Una case genrca puede en
prmer ugar
heredar de una case no genrca, tambn amado una case concreta. En segundo ugar, puede heredar
de
otra case genrca que se ha especcado e argumento de tpo, o que se ama cerrada construda
case base. Por tmo, se puede heredar de una case base construdo aberto, que es un genrco
case que tene su argumento de tpo de|a sn especcar.
case BaseConcrete {}
case BaseGenerc <T> {}
case Gen1 <T>: BaseConcrete {} / / hormgn
case Gen2 <T>: <nt> BaseGenerc {} / / cerrado construdo
case Gen3 <T>: BaseGenerc <T> {} / / abrr construda
103
www.it-ebooks.info
-
CAPTULO 28 Genrcos
Una case genrca que hereda de una case base construdo aberto debe denr todos os
argumentos de tpo de a case base, ncuso s a case genrca dervada no as necesta.
Esto es debdo a que so os argumentos de tpo de a case nfant se pueden envar a o argo de cuando
e no
case se nstanca.
case BaseMutpe <T, U, V> {}
case Gen4 <T, U>: BaseMutpe <T, U, nt> {}
Esto tambn sgnca que una case no genrca so puede heredar de una cerrada construda
case base, y no de un sstema aberto, porque una case no genrca no puede especcar cuaquer
argumentos de tpo cuando se crea una nstanca.
case Con1: <nt> BaseGenerc {} / / ok
case Con2: BaseGenerc <T> {} / / error
Las nterfaces genrcas
Interfaces que se decaran con parmetros de tpo se converten en nterfaces genrcas. Genrco
nterfaces tenen os msmos nes que os dos nterfaces de reguares. Se crean, ya sea
para exponer a os membros de una case que sern utzados por otras cases, o para obgar a una case
de
mpementar una funconadad especca. Cuando se mpementa una nterfaz genrca, e tpo
argumento debe ser especcado. La nterfaz genrca puede ser mpementado por tanto genrco
y as cases no genrcas.
/ / Interfaz genrca funconadad
nterfaz IGenercCoecton <T>
{
vod tenda (T t);
}
/ / Case no genrca que mpementa a nterfaz genrca
case Box: IGenercCoecton <nt>
{
nt myBox pbco;
pubc vod tenda (nt ) {myBox = ; }
}
/ / Case genrca que mpementa a nterfaz genrca
case GenercBox <T>: IGenercCoecton <T>
{
pbco T myBox;
pubc vod tenda (T t) {myBox = t; }
}
104
www.it-ebooks.info
CAPTULO 28 Genrcos
Los deegados genrcos
Un deegado se puede denr con parmetros de tpo. A modo de e|empo, e deegado genrco
a contnuacn utza su parmetro type para especcar e parmetro de mtodo referabe. De esto
deegar tpo un ob|eto deegado se puede crear que puede referrse a cuaquer mtodo vaco que toma
un argumento nco, ndependentemente de su tpo.
cass MyCass
{
deegate vod pbco MyDeegate <T> (T arg);
pubc vod Prnt (Strng s)
{
System.Consoe.Wrte (s);
}
statc vod Man ()
{
MyDeegate <cadena> d = mpresn;
}
}
Eventos genrcos
Los deegados genrcos pueden utzarse para denr os eventos genrcos. Por e|empo, en ugar de
utzar a
patrn de dseo tpco en e que e remtente de evento es de a Ob|eto tpo, un parmetro de tpo
puede permtr que e tpo de remtentes rea que se especca. Esto har que e argumento de tpo fuerte,
que permte a compador que o mponen e tpo correcto se utza para ese argumento.
deegate vod MyDeegate <T, U> (T remtente, U eventArgs);
evento MyDeegate <MyCass, System.EventArgs> myEvent;
Genrcos y ob|etos
En genera, e uso de a Ob|eto tpo como un recpente unversa debe ser evtado. La razn
por qu Ob|eto recpentes, taes como a ArrayLst, exsten en a bboteca de cases de NET. es porque
os genrcos no se ntrodu|eron hasta C # 2.0. Cuando se compara con a Ob|eto tpo, os genrcos
no so garantzar a segurdad de tpos en tempo de compacn, sno que tambn emnan e
rendmento
sobrecarga asocada con e boxeo y tpos de vaor unboxng en un Ob|eto recpente.
/ / Case de contenedor de ob|etos
case MyBox {ob|ect o pbco; }
/ / Case de contenedor genrco
case MyBox <T> {T pbca o; }
105
www.it-ebooks.info
CAPTULO 28 Genrcos
cass MyCass
{
statc vod Man ()
{
/ /. Contenedor de ob|etos de NET
System.Coectons.ArrayLst una;
/ /. Contenedor genrco NET (preferdo)
System.Coectons.Generc.Lst <nt> b;
}
}
Restrccones
A denr una case o mtodo genrco, as restrccones de tempo de compacn forzada pueden ser
apcado en os tpos de argumentos de tpo que se pueden utzar cuando a case o mtodo es
nstanca. Estas restrccones se denomnan restrccones y se especcan medante a donde
paabra cave. En tota hay ses tpos de restrccones.
En prmer ugar, e parmetro de tpo puede ser restrngda a os tpos de vaor medante e uso de a
struct paabra cave.
case C <T> donde T: struct {} / tpo / vaor
En segundo ugar, e parmetro puede ser restrngdo a os tpos de referenca a travs de a case paabra
cave.
case D <T> donde T: cass {}
/ / Tpo de referenca
En tercer ugar, a restrccn puede ser un nombre de case. Esto restrngr e tpo de ben que
case o una de sus cases dervadas.
case B {}
case E <T> donde T: B {}
/ / Ser / dervar de a case base
En cuarto ugar, e tpo puede ser obgado a ser tanto o dervar de otro parmetro de tpo.
case F <T, U> donde T: U {}
/ / Ser / dervar de U
La qunta restrccn es para especcar una nterfaz. Esto restrngr e parmetro de tpo de
so os tpos que mpementan a nterfaz especcada o es ob|eto de a msma e tpo de nterfaz.
nterface I {}
a case G <T> donde T: {}
/ / Ser / mpementar a nterfaz
Por tmo, e argumento de tpo puede estar mtada so a aqueos tpos que tenen un pbco
constructor sn parmetros.
case H <T> donde T: new () {}
/ / No parmetro de constructor
106
www.it-ebooks.info
CAPTULO 28 Genrcos
Varas mtacones
Varas mtacones se pueden apcar a un parmetro de tpo medante a especcacn de eos en una
coma
sta separada. Adems, para mtar ms de un parmetro de tpo donde adcona
Se pueden aadr cusuas. Tenga en cuenta que s se utza cuaquera de a case o e struct restrccn
se debe
aparecer prmero en a sta. Por otra parte, s a restrccn de constructor sn parmetros se utz
debe ser e tmo de a sta.
case | <T, U>
donde T: case,
donde U: Yo, new () {}
Por qu utzar as restrccones
Aparte de a restrccn de uso de un mtodo genrco o case a so certo parmetro
tpos, otra razn para a apcacn de as restrccones es aumentar e nmero de permtdo
operacones y amadas a mtodos admtdos por e tpo de restrccn. Un tpo sn restrccones
so podr utzar e System.Ob|ect mtodos. Sn embargo, medante a apcacn de una restrccn de
case base,
os membros accesbes de esa case base tambn estn dsponbes.
cass Person
{
nombre de a cadena pbca;
}
case PersonNameBox <T> donde T: Persona
{
cuadro Cadena pbca;
pubc vod StorePersonName (T a)
{
box = a.name;
}
}
Otro e|empo sguente utza a restrccn de constructor sn parmetros. Este
restrccn permte nuevos ob|etos de parmetro de tpo para ser nstancados.
cass MyCass <T> donde T: new () {}
Tenga en cuenta que s una case tene una restrccn en su parmetro de tpo, y un no de esa case
tene un parmetro de tpo que est mtada por a case base, que a restrccn debe ser tambn
apcado a parmetro de tpo de a case h|a.
case M h|o <T>: MyCass <T>
donde T: MyCass <T>, new () {}
107
www.it-ebooks.info
Captuo 29
Struct
La struct paabra cave en C # se utza para crear os tpos de vaor. Una estructura es smar a una case
en que
que representa una estructura con prncpamente campo y os membros de mtodo. Sn embargo, una
estructura es una
tpo de vaor, mentras que una case es un tpo de referenca. Por o tanto, una varabe struct amacena
drectamente
os datos de a estructura, mentras que una varabe de case so se amacena una referenca a un ob|eto
asgnado
en a memora.
Varabes de estructura
Las estructuras comparten a mayor parte de a msma sntaxs que as cases. Por e|empo, a estructura a
contnuacn se denomna
Punto y consta de dos campos pbcos.
struct Pont
{
pubc nt x, y;
}
Dada a dencn de struct anterormente, una varabe de a Punto tpo puede ser ncazado en e
manera famar con e nuevo operador.
Pont p = new Pont ();
A crear una varabe struct de esta manera e constructor por defecto ser amado,
que estabece os campos a su vaor predetermnado. A dferenca de cases, estructuras tambn se
pueden crear nstancas
sn utzar e nuevo operador. Los campos a contnuacn, permanecer sn asgnar. Sn embargo, smar
que cuando se ntenta utzar una varabe sn ncazar oca, e compador no permtr que e
campos que se deben eer hasta que se hayan ncazado.
Apunte q;
nt y = q.x; / / Error en tempo de compacn
109
www.it-ebooks.info
CAPTULO 29 Struct
Constructores Struct
Las estructuras pueden contener os msmos membros que as cases pueden, savo que no pueden
contener os destructores o constructores sn parmetros. E constructor sn parmetros es
proporconado de forma automtca y puede que no sea dendo por e usuaro. Sn embargo, una
estructura puede decarar
constructores que tenen parmetros. E compador entonces mponer que todos os campos struct
se asgnan en os constructores, a n de evtar probemas asocados con a no asgnada
varabes.
struct Pont
{
pubc nt x, y;
Punto pbco (nt x, nt y)
{
ths.x = x;
ths.y = y;
}
}
Tenendo en cuenta a dencn anteror, as sguentes decaracones sern tanto crear un punto con e
campos ncazados a cero.
P1 = new Pont Pont ();
Punto P2 = new Pont (0, 0);
Incazadores de campo de estructura
Los campos dentro de una estructura no se pueden dar vaores ncaes, a menos que sean decaradas
como const
o esttca.
struct Pont
{
pubc nt x = 1, y = 1; / / Error en tempo de compacn
statc nt A = 5; / / Permtdo
pubc const nt B = 10; / / Permtdo
}
Herenca Struct
Las estructuras no pueden heredar de otra estructura o case, y no pueden ser una case base.
Esto sgnca tambn que membros de a estructura no se pueden decarar como protegdo o protegdo
nterna, y que os mtodos de estructura no se pueden marcar como vrtua. Las estructuras de forma
mpcta
heredar de System.VaueType, que a su vez hereda de System.Ob|ect. Aunque
estructuras no admten a herenca denda por e usuaro, se pueden mpementar nterfaces en e
msma manera que cases.
110
www.it-ebooks.info
CAPTULO 29 Struct
Gua de estructura
E tpo de estructura se utza tpcamente para representar as cases de peso gero que encapsuan
pequea
grupos de varabes reaconadas. La razn prncpa para e uso de una estructura en ugar de una case es
consegur semntca de tpo vaor. Por e|empo, os tpos smpes son, de hecho, todos os tpos struct. Para
este tpo es ms natura que a asgnacn copa e vaor en ugar de a referenca.
Las estructuras tambn pueden ser tes por razones de rendmento. Una estructura es ms ecente
que
una case en trmnos de memora. No so ocupa menos memora que una case, sno que tambn
no necesta a memora que se asgnar a os trmnos requerdos por ob|etos de tpo de referenca.
Adems, una case requere dos espacos de memora, una para a varabe y uno para e
oponerse, mentras que una estructura so necesta una. Esto puede hacer una dferenca sgncatva
para un
programa que opera en un gran nmero de estructuras de datos. Tenga en cuenta que a asgnacn
y e parmetro de vaor de paso son generamente ms caro, con estructuras que con
tpos de referenca, ya que toda a estructura se debe copar para taes operacones.
111
www.it-ebooks.info
Captuo 30
Mtodos asncrncos
Un mtodo asncrnco es un mtodo que puede devover antes de que haya termnado de e|ecutarse.
Cuaquer mtodo que reaza una tarea potencamente arga duracn, taes como e acceso a una web
de recursos o a ectura de un archvo, se pueden hacer asncrona para me|orar a capacdad de respuesta
de
e programa. Esto es especamente mportante en apcacones grcas, porque cuaquer mtodo
que tarda mucho tempo en e|ecutarse en e subproceso de nterfaz de usuaro har que e programa sea
que no responden a a espera de que e mtodo para competar.
Async y esperar
Introducdo en C # 5.0, a async y awat paabras cave permten mtodos asncrncos a
ser escrto con una estructura smpe que es smar a os mtodos sncronos (reguares).
La async modcador especca que e mtodo es asncrono y que por o tanto puede
contener una o ms expresones esperan. Una expresn consste en a espera de a awat
paabra cave seguda de una amada a un mtodo awatabe.
async vod MyAsync ()
{
System.Consoe.Wrte ("A");
esperar System.Threadng.Tasks.Task.Deay (2000);
System.Consoe.Wrte ("C");
}
E mtodo anteror se e|ecutar de forma sncrnca hasta que se acanza a expresn esperar, en
punto que e mtodo se suspende y a e|ecucn vueve a a persona que ama. La esperada
tarea est programada para e|ecutarse en segundo pano en e msmo subproceso. En este caso, a tarea
es
un retardo de tempo que competar despus de 2000 msegundos. Una vez que a tarea se ha
competado a
resto de mtodo asncrono se e|ecutar.
A amar a mtodo asncrono de sada vountad prncpa "AB", segudo de "C" despus de a demora.
Tenga en cuenta e uso de mtodo ReadKey aqu para evtar que e programa de a consoa saga
antes de que e mtodo asncrnco ha nazado.
113
www.it-ebooks.info
CAPTULO 30 Mtodos asncrncos
statc vod Man ()
{
. nueva MyApp () MyAsync ();
System.Consoe.Wrte ("B");
System.Consoe.ReadKey ();
}
Tpos de retorno asncrono
Un mtodo asncrnco puede tener uno de tres tpos de retorno ntegrados: Tarea <T>, tareas, y sn
efecto.
Especcacn de tareas o vaco ndca que e mtodo no devueve un vaor, mentras que
Tarea <T> sgnca que va a devover un vaor de tpo T. A dferenca de anuar, e Grupo de Tarea y <T>
tpos son awatabe, por o que una persona que ama puede utzar e awat paabra cave a suspender en
s hasta despus de a
tarea ha termnado. E tpo vod se utza prncpamente para denr os controadores de eventos
asncrncos, como e evento
manpuadores requeren un tpo de vaor devueto vod.
Mtodos Custom asncrncos
Con e n de amar a un mtodo de forma asncrnca tene que ser envueto en otro mtodo que
devueve una tarea ncada. Para ustrar esto, e sguente mtodo dene, se nca y se vueve una tarea
que tene 2.000 msegundos para e|ecutar antes de que vueva a etra "Y" La tarea est aqu.
dendo medante e uso de una expresn ambda para a concsn.
utzando System.Threadng.Tasks;
usng System.Threadng;
/ / ...
Tarea <cadena> MyTask ()
{
vover Task.Run <strng> (() => {
Thread.Seep (2000);
vover "Y";
});
}
Este mtodo de traba|o se puede amar de forma asncrnca de un mtodo asncrnco. E
nombramento
convencn para estos mtodos es anexar "Async" a nombre de mtodo. E asncrono
mtodo en este e|empo espera e resutado de a tarea y uego o mprme.
async vod MyTaskAsync ()
{
Resutado cadena = esperan MyTask ();
System.Consoe.Wrte (resutado);
}
114
www.it-ebooks.info
CAPTULO 30 Mtodos asncrncos
E mtodo asncrono se ama de a msma manera como un mtodo reguar, como se puede ver en
e sguente mtodo Man. La sada de programa ser "XY".
statc vod Man ()
{
. nueva MyApp () MyTaskAsync ();
System.Consoe.Wrte ("X");
System.Consoe.ReadKey ();
}
115
www.it-ebooks.info
ndce
????????La
abstracto, 65
nvees de acceso, 45
accessor, 53
mtodos annmos, 92
matrces, 17
como, 38
monta|e, 46
operador de asgnacn (=), 9
async, 113
mtodos asncrncos, 113
esperan, 113
contnuar, 22
entre aves ({}), 2
conversones de encargo, 83
????????D
tpos de datos, 5
decma, 7
decarar, 6
operador de decremento (-), 10
De forma predetermnada, 103
constructor predetermnado, 32
vaores por defecto, 35
denr, 6
# Dene, 88
deegar, 91
destructor, 34
dot operador (.), 2, 23
dobe, 7
do-whe, 21
abatdo, 38
????????B
base, 43
boo, 8
boxeo, 39
romper, 22
byte, 7
????????C
coger, 75
char, 8
case, 29
membro de a case, 49
boque de cdgo, 2
operador de coma (,), 6, 22
comentaros, 4
compar, 3
concatenacn
operador (+), 13
condconaes, 19
const, 85
mtacones, 106
constructor, 30
????????E
# Ef, 88
# Ese, 88
case que o contene, 45
# Endf, 88
# Endregon, 89
enumeracn, 73
# Error, 89
caracteres de escape, 13
evento, 97
controador de eventos, 99
mane|o de excepcones, 75
expcta, 84
conversn expcta, 7
mtodo de extensn, 51
117
www.it-ebooks.info
ndce
????????F
faso, 10
campo, 29
campo ncazador, 32
namente, 76
otar, 7
para, 21
foreach, 22
gco y (&&), 11
gco no (!) 11
gco o (| |), 11
de argo, 6
buces, 21
????????M
Mtodo Man, 2
Mtodo (s), 23
La sobrecarga de mtodos, 25
operador de mduo (%), 9
Deegado de mutdfusn, 93
Array mut-dmensona, 18
????????T
recoector de basura, 34
genrcos, 101
Goto, 20
????????H
hoa mundo, 1
????????N
Argumento con nombre, 25
Espaco de nombres, 69
nueva, 23, 26, 29, 41
nu, 34
Los tpos anuabes, 35
operador nuo-coaescenca (?), 35
????????Yo
IDE, 1
S, 19
# S, 88
mpcta, 83
operador de ncremento (+ +), 10
ndzadores 57
herenca, 37
ncazar, 6
case nterna, 47
e|empo, 29
membro de nstanca, 49
crear una nstanca, 30
nt, 6
nterfaz, 61
nterna, 46
sta de nvocacn, 93
nvocar, 23
es, 38
teracn, 21
????????O
Ob|eto, 27, 29, 37
Incazador de ob|eto, 33
Operador (s), 9, 79
La sobrecarga de operadores, 79
Parmetro opcona, 25
a cabo, 28
anuar, 42
???? O????P,
params, 24
parca, 33
Preprocessor, 87
prvado, 45
Propedades, 53
protegda, 46
nterna protegda, 46
pbca, 47
Edtora, 97
???? K????|,
matrz escaonada, 18
????????L
expresones ambda, 92
ambda operador (=>), 92
# Lne, 89
????????R
readony, 86
Matrz rectanguar, 18
Vueva a denr, 41
118
www.it-ebooks.info
ndce
ref, 27
Tpo de referenca, 26
# Regon, 89
vover, 26
certo, 10
tratar, 75
????????U
unt, 7
uong, 7
unboxng, 39
# Undef, 88
upcast, 38
ushort, 7
utzando, 70, 77
????????S
sbyte, 6
mbto de apcacn, 8
seada, 42
punto y coma (;), 2
corto, 6
rma, 41
Los tpos smpes, 5
esttca, 49
Cadena, 13
StrngBuder, 15
estructura, 109
Suscrptor, 99
cambar, 20
????????V
vaor, 53
tpo de vaor, 26
varabes, 5
cadena textua, 14
vrtua, 42
anuar, 23
????????T
operador ternaro (? :), 20
esto, 31-32
anzar, 78
Top-eve membro, 47
ToStrng, 37
???? X, Y, Z????W,
# Avso, 89
donde, 106
mentras que, 21
WrteLne, 2
119
www.it-ebooks.info
Rpdo de a sntaxs de C
#
Referenca
Mkae Osson
www.it-ebooks.info
C # Sntaxs de consuta rpda
Copyrght 2013 por Mkae Osson
Esta obra est su|eta a derecho de autor. Todos os derechos estn reservados por e pubcador, s a totadad o
parte
de matera se reere, en concreto os derechos de traduccn, rempresn, a reutzacn de as ustracones,
rectacn, radodfusn, a reproduccn en mcroms o en cuaquer otra forma fsca, y a transmsn
o amacenamento y recuperacn de nformacn, a adaptacn eectrnca, software, o por smares o
metodooga dferente conocda ahora o desarroada en e futuro. Ouedan exentos de esta reserva ega son
breves extractos en reacn con os exmenes o anss o estudos acadmcos sumnstran especcamente para
e propsto de ser ntroducdo y e|ecutado en un sstema nformtco, para uso excusvo por e comprador
de a obra. La dupcacn de esta pubcacn o partes de ea so se permte ba|o as dsposcones
de a Ley de Derecho de Autor de a ubcacn de a edtora, en su versn actua, y e permso para su uso debe
sempre ser obtendo a partr de Sprnger. Permsos para e uso se pueden obtener a travs Rghtsnk en e
Copyrght Cearance Center. Voacnes deben ser procesados ba|o a respectva Ley de Propedad Inteectua.
ISBN-13 (pbk): 978-1-4302-6280-0
ISBN-13 (eectrnco): 978-1-4302-6281-7
Los nombres comercaes, ogotpos y as mgenes pueden aparecer en este bro. En ugar de utzar una marca
comerca
smboo con cada aparcn de un nombre de marca regstrada, ogotpo o magen que usamos os nombres, ogotpos
y
mgenes so en forma edtora y para e beneco de propetaro de a marca regstrada, sn a ntencn de
nfraccn de a marca.
La utzacn de esta pubcacn de nombres comercaes, marcas regstradas, marcas de servco y trmnos
smares, aunque
no se dentcan como ta, no debe ser tomado como una expresn de a opnn en cuanto a s son o no son
su|etos a derechos de propedad.
Mentras que e asesoramento y a nformacn en este bro se cree que son verdaderos y precsos en a fecha de
pubcacn, n os autores n os edtores n e edtor puede aceptar nnguna responsabdad ega
de os errores u omsones que se pueden hacer. E edtor ofrece nnguna garanta, expresa o mpcta,
con respecto a matera contendo en e presente documento.
Presdente y Edtor: Pau Mannng
Edtor prncpa: Steve Angn
Revsor tcnco: Mchae Thomas
Conse|o de Redaccn: Steve Angn, Mark Beckner, Ewan Buckngham, Gary Corne, Louse Corrgan,
Morgan Erte, |onathan gennck, |onathan Hasse, Robert Hutchnson, Mchee Lowman,
|ames Markham, Matthew Moode, |eh Oson, |ehrey Pepper, Dougas Pundck,
Ben RENOW-Carke, Domnc Shakeshaft, Gwenan Spearng, Matt Wade, Tom Wesh
Coordnar Edtor: Kate Suvan
Compostor: SP Goba
Indexador: SP Goba
Artsta: SP Goba
Cover Desgner: Anna Ishchenko
Dstrbudo para e comerco de bros en todo e mundo por Sprnger Scence + Busness Meda de Nueva York, 233
Prmavera
Street, 6th Foor, New York, NY 10013. Tefono 1-800-SPRINGER, fax (201) 348-4505, e-ma
orders-ny@sprnger-sbm.com, O vste www.sprngeronne.com. Apress Meda, LLC es una Caforna
LLC y e nco membro (propetaro) es Sprnger Scence + Busness Meda Fnance Inc (SSBM Fnanzas
Inc). SSBM Fnance Inc es una Deaware corporacn.
Para obtener nformacn sobre traduccones, por favor enve un correo eectrnco rghts@apress.com, O vste
www.apress.com.
Apress y amgos de os bros ED se pueden comprar en grandes cantdades para e sector acadmco, corporatvo o
de promocn
utzar. versones de bros eectrncos y cencas tambn estn dsponbes para a mayora de os ttuos. Para
obtener ms nformacn, referenca
nuestra pgna web especa Buk Saes-eBook Lcencas de www.apress.com / a grane-venta.
Cuaquer cdgo fuente u otro matera compementaro a que hace referenca e autor en este texto estn
dsponbes para
ectores en www.apress.com. Para obtener nformacn detaada acerca de cmo ocazar e cdgo fuente de su
bro,
r a www.apress.com / cdgo fuente
www.it-ebooks.info
Contendo
Sobre e autor xv
Sobre e Revsor Tcnco xv
Introduccn xx
Captuo 1: Heo Word 1
La eeccn de un IDE 1
Crear un proyecto 1
Heo Word 2
InteSense 2
Captuo 2: Compar y E|ecutar 3
Compacn de Vsua Studo 3
Compacn Consoe 3
Comentaros 4
Captuo 3: Varabes 5
Los tpos de datos 5
Decaracn 6
Asgnacn 6
Los tpos enteros 6
Tpos de punto otante 7
Tpo char 8
Tpo Boo 8
Ambto de as varabes 8
v
www.it-ebooks.info
Contendo
Captuo 4: Operadores 9
Los operadores artmtcos 9
Operadores de asgnacn 9
Operadores de asgnacn combnados 9
Operadores de ncremento y decremento 10
Los operadores de comparacn 10
Los operadores gcos 11
Operadores bt a bt 11
Precedentes de operador 11
Captuo 5: Strng 13
La concatenacn de cadenas 13
Escapar caracteres 13
Cadena comparar 14
Membros de Cuerda 14
Case StrngBuder 15
Captuo 6: Matrces 17
Decaracn de matrz 17
Asgnacn de matrz 17
La asgnacn de matrz 17
Acceso a una matrz 18
Matrces rectanguares 18
Matrces escaonadas 18
Captuo 7: Condconaes 19
S a decaracn 19
Instruccn Swtch 20
v
www.it-ebooks.info
Contendo
Decaracn Goto 20
Operador ternaro 20
Captuo 8: Loops 21
Whe 21
Buce do-whe 21
Para oop 21
Buce Foreach 22
Romper y contnuar 22
Captuo 9: Mtodos 23
Dencn de os mtodos 23
Lamar a mtodos 23
Los parmetros de mtodo 24
Paabra cave Parmetros 24
La sobrecarga de mtodos 25
Parmetros opconaes 25
Los argumentos con nombre 25
Sentenca return 26
Los tpos de vaor y de referenca 26
Pasar por vaor 27
Pasar por referenca 27
Paabra cave Ref 27
Sn paabra cave 28
Captuo 10: Case 29
Creacn de ob|etos 29
Acceso a membros de ob|etos 29
Constructor 30
v
www.it-ebooks.info
Contendo
Esta paabra cave 31
Sobrecarga Constructor 31
Encadenamento Constructor 32
Vaores de campo ncaes 32
Por defecto constructor 32
Los ncazadores de ob|eto 33
Case parca 33
Basurero 34
Destructor 34
Paabra cave Nu 34
Los tpos anuabes 35
Operador nuo coaescenca 35
Los vaores por defecto 35
Captuo 11: Herenca 37
Case Ob|ect 37
Abatdo y upcast 38
Es a paabra cave 38
Como paabra cave 38
Boxeo 39
Unboxng 39
Captuo 12: La redencn de Membros 41
Ocutacn de membros 41
Membros de reempazo 42
Cmo ocutar y anuar 42
Paabra cave Seado 42
Paabra cave Base 43
v
www.it-ebooks.info
Contendo
Captuo 13: Nvees de acceso 45
Acceso prvado 45
Acceso Protegdo 46
E acceso nterno 46
Acceso nterno Protegda 46
E acceso de pbco 47
Los nvees de acceso de nve superor 47
Las cases nternas 47
Drectrz Nve de acceso 48
Captuo 14: Esttca 49
Acceso a membros esttcos 49
Los mtodos esttcos 50
Los campos esttcos 50
Las cases esttcas 50
Constructor esttco 51
Los mtodos de extensn 51
Captuo 15: Propedades 53
Propedades mpementadas-Auto 54
Venta|as de propedad 54
So ectura y escrbr propedades de so 55
Nvees de acceso de a propedad 56
Captuo 16: Los ndzadores 57
Parmetros paso a paso 58
Sobrecarga ndexador 58
x
www.it-ebooks.info
Contendo
Captuo 17: Interfaz 61
Frmas de nterfaz 61
E|empo de nterfaz 62
Interfaz Funconadad 62
Interfaz de Case 63
Captuo 18: Resumen 65
Membros abstractos 65
Abstract e|empo 66
Las cases abstractas e nterfaces 67
Captuo 19: Los espacos de nombres 69
Espacos de nombres andados 69
Acceso Espaco de nombres 70
E uso de a drectva 70
Captuo 20: Enum 73
E|empo Enum 73
Vaores constantes de enumeracn 73
Tpo constante Enum 74
Los nvees de acceso de enumeracn y e acance 74
Mtodos de enumeracn 74
Captuo 21: Contro de excepcones 75
Try-catch decaracn 75
Boque Catch 76
Por tmo boque 76
Usng 77
Lanzar excepcones 78
x
www.it-ebooks.info
Contendo
Captuo 22: Sobrecarga de operadores 79
Operador e|empo sobrecarga 79
La sobrecarga de operadores bnaros 79
La sobrecarga de operadores unaros 80
Tpos y parmetros de retorno 80
Operadores sobrecargabes 81
Verdadero y faso sobrecarga de operadores 81
Captuo 23: Las conversones de encargo 83
Mtodos de conversn mpctas 83
Mtodos de conversn expctos 84
Captuo 24: Constantes 85
Constantes ocaes 85
Campos constantes 85
Paabra cave readony 86
Pauta constante 86
Captuo 25: Preprocessor 87
Sntaxs drectva de preprocesador 87
La compacn condcona - # f y # endf 88
Dencn de os smboos 88
Smboos ndenr 88
La compacn condcona - # ef y # ese 88
Drectvas de dagnstco 89
Drectva Lne 89
Drectva Regn 89
x
www.it-ebooks.info
Contendo
Captuo 26: Los deegados 91
Los mtodos annmos 92
Las expresones ambda 92
Deegados de mutdfusn 93
Deegar a rma 93
Los deegados como parmetros 94
Captuo 27: Eventos 97
Edtor 97
Paabra cave Event 97
Persona que ama Evento 98
Eventos Crando 98
Suscrptor 99
Controador de eventos 99
La suscrpcn a os eventos 100
Captuo 28: Los genrcos 101
Los mtodos genrcos 101
Lamar a mtodos genrcos 102
Parmetros de tpo genrco 102
Vaor predetermnado 103
Las cases genrcas 103
Herenca de a case genrca 103
Las nterfaces genrcas 104
Los deegados genrcos 105
Eventos genrcos 105
Genrcos y ob|etos 105
x
www.it-ebooks.info
Contendo
Restrccones 106
Varas mtacones 107
Por qu utzar as restrccones 107
Captuo 29: Struct 109
Varabes de estructura 109
Constructores Struct 110
Incazadores de campo de estructura 110
Herenca Struct 110
Gua de estructura 111
Captuo 30: Mtodos asncronos 113
Async y esperar 113
Tpos de retorno asncrono 114
Mtodos Custom asncrncos 114
ndce 117
x
www.it-ebooks.info
Sobre e autor
Mkae Osson es un profesona emprendedor web, programador y autor. Traba|a
para una empresa de I + D en Fnanda donde se especaza en e desarroo de software. En
su tempo bre, escrbe bros y crea stos web que resumen varos campos de a
nters. Los bros que escrbe se centran en a enseanza de su asgnatura en a ms ecente
manera posbe, a expcar so o que es reevante y prctca sn nngn nnecesaro
repetcn o teora.
xv
www.it-ebooks.info
Acerca de a Tcnca
Crtco
Mchae Thomas ha traba|ado en e desarroo de software para ms de 20 aos como un ndvduo
contrbuyente, responsabe de equpo, drector de programa, y e vcepresdente de Ingenera. Mchae
tene
ms de 10 aos de experenca traba|ando con os dspostvos mves. Su enfoque actua est en e
mdco
sector de uso de os dspostvos mves para aceerar a transferenca de nformacn entre os pacentes
y
proveedores de atencn mdca.
xv
www.it-ebooks.info

C# Quick Syntax Reference - En.es PDF

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

C# Quick Syntax Reference - En.es PDF

Загружено:

Авторское право:

Доступные форматы

www.it-ebooks.

Вам также может понравиться