P. 1
Manual de c#

Manual de c#

|Views: 9|Likes:
Publicado porEdwin Aruhuanca

More info:

Published by: Edwin Aruhuanca on Nov 06, 2013
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

08/27/2014

pdf

text

original

MANUAL C#

MANUAL DE C#
¿Qué es C#? C# o C Sharp es un lenguaje de programación que está incluido en la Plataforma . !" # corre en el $enguaje Com%n en "iempo de !jecución &C$'( Common $anguage 'untime). !l primer lenguaje en importancia para el C$' es C#( mucho de lo que soporta la Plataforma . !" está escrito en C#. C# intenta ser el lenguaje *ase para escri*ir aplicaciones . !" C# deri+a de C # C,,( es moderno( simple # enteramente orientado a o*jetos( simplifica # moderni-a a C,, en las áreas de clases( namespaces( so*recarga de métodos # manejo de e.cepciones. Se elimino la complejidad de C,, para hacerlo más fácil de utili-ar # menos propenso a errores. /lgunas caracter0sticas de C# son1
 

C# provee el beneficio de un ambiente elegante y unificado. No soporta herencia múltiple, solamente el runtime .NET permite la herencia múltiple en la forma de interfaces, las cuales no pueden contener implementación. No maneja apuntadores, para emular la función de los apuntadores se utili a delegates el cual provee las bases para el .NET event model. !or default trabaja con código administrado. "a !lataforma .NET provee un colector de basura #ue es responsable de administrar la memoria en los programas C#. El manejo de errores est$ basado en e%cepciones. &oporta los conceptos como encapsulación, herencia y polimorfismo de la programación orientada a objetos. El 'odelo completo de clases est$ construido en la cima del .NET (irtual )bject &ystem *()&+. El modelo de objetos es parte de la infraestructura y ya no forma parte del lenguaje de progrmación. No e%isten funciones globales, variables o constantes. Todo deber ser encapsulado dentro de la clase, como un miembro de la instancia *accesible via una instancia de clase+ o un miembro est$tico *via el tipo+. "os m,todos #ue se definen en las clases son por default no virtuales *no pueden ser sobre escritos al derivar clases+ &oporta los modificadores de acceso private, protected, public y agrega un cuarto modificador internal. &olamente se permite una base clase, si se re#uiere herencia múltiple es posible implementar intefaces. No es posible utili ar variables no iniciali adas. No es posible hacer el cast de un entero a un tipo de referencia *objeto+.

 

 

 

1

  

"os par$metros #ue son pasados son type-safe. El soporte de versiones lo provee el C".. !ermite acceder a diferentes /!0s a trav,s de .NET Common "anguage &pecification, el cual define el est$dar de interoperabilidad entre lenguajes #ue se adhieran a este est$ndar. "a !lataforma .NET provee un acceso transparente a C)'. &oporta )"E !ermite la interoperabilidad con /!0s al estilo C y 1""s, esta caracter2stica para acceder a /!0s nativas es llamada !latform 0nvocation &ervices *!0nvo3e+ !or default el código es safe mode, pero es posible declarar clases o sólo m,todos unsafe, esta declaración permite utili ar apuntadores, estructuras y almacenamiento de arreglos est$ticos. C# depende del runtime #ue provee la !lataforma .NET, el runtime administra la ejecución de código.

  

$enguaje 2rientado a 2*jetos Seg%n Bjarne Stroustrup autor del lenguaje de programación C,,( para que un lenguaje sea llamado 2rientado a 2*jetos de*e soportar tres conceptos1 objetos( clases # herencia. /unque los lenguajes orientados a o*jetos se constru#en so*re los conceptos de 1
  

Encapsulación 4erencia !olimorfismo

2*jeto 3n )bjeto es una instancia de un tipo de clase. $a instanciación es el acto de crear una instancia de un o*jeto( la instancia es un o*jeto( la instanciación usa el operador ne4( después la instanciación es posi*le comunicarnos con el o*jeto a tra+és de sus miem*ros. 3n )bjeto es una colección de información relacionada # funcional. 3n o*jeto se compone de1
 

Datos #ue describen el objeto y Operaciones #ue pueden ser reali adas por el objeto

5erencia $a 4erencia es la ha*ilidad para heredar datos # funcionalidad de un o*jeto padre( la herencia es una caracter0stica fundamental de un sistema orientado a o*jetos. / tra+és de la herencia es posi*le crear o deri+ar una nue+a clase *asada en una clase e.istente.

2

!.iste un mecanismo que se encarga de esto llamado garbage collector &recolector de *asura)( pero es una *uena práctica no ol+idar li*erar los recursos. 3na interfa. 3n o*jeto puede deri+ar sólo de una clase *ase. 3na referencia se refiere a una instancia( una instancia es la creación de un o*jeto del tipo clase que se está declarando. !" todos los o*jetos heredan de la %ltima clase *ase llamada o*ject # e.name. 3na Clase define las operaciones que un o*jeto puede reali-ar # define un +alor que mantiene el estado del o*jeto( los componentes principales de una clase son1 métodos( e+entos # propiedades. $a nue+a clase deri+ada hereda todos los miem*ros de la clase *ase por consiguiente permite reusar el tra*ajo pre+io. 3na clase deri+ada no de*er0a requerir más ni prometer menos que su clase *ase so*re cualquiera de sus interfaces heredadas.isten diferentes tipos de miem*ros. Clase 3na Clase es una plantilla para un o*jeto. 3 .de la instancia de la clase &o*jeto)1 using S#stem.iste sólo una herencia simple de o*jetos. Cuando se hace referencia a una +aria*le de instancia que tiene el mismo nom*re de un parámetro se de*e utili-ar this. 3na clase utili-a ninguno( uno o más constructores para a#udar a definir la instancia de una clase. 3na instancia de una clase es un o*jeto( se accede a la funcionalidad de un o*jeto in+ocando sus métodos # accediendo a sus propiedades( e+entos # campos. !n C# se puede asumir que la clase deri+ada podr0a heredar todos los miem*ros de la clase *ase.3na clase deri+ada es la nue+a clase que esta siendo creada # la clase *ase es una de las cuales la nue+a clase es deri+ada. $a herencia es un ejemplo del dise6o orientado a o*jetos conocido como una relación 7is8a7 &es8un)( por ejemplo1 7un empleado es una persona7. upcasting( cuando un programador tiene una referencia a la clase deri+ada( el programador siempre puede tratar a esa clase como si fuera la clase *ase. /l crear # manipular o*jetos no es necesario administrar la memoria que estos ocupan #a que e. 3n campo estático puede accederse a tra+és del nom*re de la clase( en +e. 9unciones :iem*ro 3na 5unción 'iembro puede ser un constructor( es decir( una pie-a de código que es in+ocada en una instancia del o*jeto.iste una pala*ra reser+ada llamada this que sir+e para hacer referencia a la clase actual en el ám*ito en el cual es utili-ada. !n el lenguaje com%n en tiempo de ejecución . 3na clase utili-a modificadores para especificar la accesi*ilidad de la clase # sus componentes( los componentes de una clase son llamados miem*ros por lo que e.de clase es un contrato entre esta # los programadores que usan la clase. 3n Campo Est$tico es el tipo más simple de un miem*ro estático( para declarar un campo estático se utili-a el modificador static. /l utili-ar la herencia la clase *ase necesita ser dise6ada teniendo en mente la herencia( si los o*jetos no tienen la estructura apropiada la herencia no podr0a funcionar correctamente. Campos !státicos 3n Miembro Estático definine miem*ros de un o*jeto que no son asociados con una instancia de clase espec0fica.

pu*lic int i!dad. 4 .Arite$ine&:iContador.iContador). ==Constructor pu*lic Persona&string s om*re( int i!dad)< this. Console. Console.class :iContador< ==Campo !stático pu*lic static int iContador > ?..==:étodo que la clase deri+ada de*e implementar @ ==5erencia Simple pu*lic class !mpleado 1 Persona< pu*lic !mpleado&string s om*re( int i!dad)1*ase&s om*re( i!dad)<@ o+erride pu*lic string "ipo&)< return 7!mpleado7.s om*re > s om*re. using S#stem. @ ==:étodos a*stract pu*lic string "ipo&). @ @ class /pp< pu*lic static +oid :ain&)< :iContador Contador/ > ne4 :iContador&). @ @ class /pp< ==/plicación pu*lic static +oid :ain&)< Console. Clase Base 3na Clase base es un o*jeto padre de donde se *asa un nue+o tra*ajo. @ @ !l ejemplo determina cuantas instancias del o*jeto han sido creadas.Arite$ine&7888 /rreglo de 2*jetos 8887). Clase Ceri+ada 3na Clase derivada es un o*jeto hijo.. a*stract pu*lic class Persona<==Dndica que la clase es a*stracta ==Propiedades pu*lic string s om*re. pu*lic :iContador&)< iContador.Arite$ine&:iContador.iContador).i!dad > i!dad. this. 3na Clase /bstracta define un contrato en donde las clases deri+adas de*en definir las funciones que la clase padre marca utili-ando la pala*ra reser+ada a*stract( además que la clase padre tam*ién se define como a*stract. :iContador ContadorB > ne4 :iContador&). !mpleadoEF aProgramadores > ne4 !mpleadoEGF. Clase /*stracta 3na Clase /bstracta define las funciones que una clase deri+ada de*e implementar.

7F.7F. using S#stem.cs(*. Console.istir miem*ros a los cuales no se pueda tener acceso por ser pri+ate.i!dad 1 7 .i.Arite$ine&7aProgramadoresE7 ."ipo&)). 2+erloading=So*recarga $a &obrecarga &-(erloading) hace posi*le utili-ar dos o más clases con el mismo nom*re( pero con parámetros diferentes.7 ! error "S#$#%! &"lase'eri(ada& ! cannot inherit )rom sealed class &"laseBase& sealed.s om*re 1 7 .is *ase. aProgramadoresEiF.*4 ! (+ocation o) s. aProgramadoresEiF.Arite$ine&7aProgramadoresE7 .mbol related to pre(ious error !l error es porque ClaseCeri+ada no puede utili-ar ClaseBase como una clase *ase porque ClaseBase es sealed( es decir( no permite deri+aciones."ipo 1 7 . Si se omite el constructor de la clase *ase # es in+ocado el compilador podr0a in+ocar el constructor de la clase *ase sin parámetros..Arite$ine&7aProgramadoresE7. Console. pu*lic class Persona< 5 . aProgramadoresEiF.cs(4. $os constructores no pueden ser heredados( por lo que es necesario escri*ir constructores # si funcionalmente no e.aProgramadoresE?F > ne4 !mpleado&7Bill Hates7( I?). 5erencia Simple $a 4erencia &imple permite deri+ar una clase en una clase nue+a( que contiene la definición de la clase de la cual deri+a( es decir( hereda todos los miem*ros datos de la clase( aunque pueden e. i L aProgramadores. $a so*recarga es com%n especialmente para los constructores para definir diferentes maneras de crear una instancia nue+a. sealed class ClaseBase< ClaseBase&)<@ @ class ClaseCeri+ada 1 ClaseBase< @ class Sellada< pu*lic static +oid :ain&)< ClaseCeri+ada CC > ne4 ClaseCeri+ada&). 'a#mond7( K?). 7F.s om*re).)< Console. aProgramadoresEJF > ne4 !mpleado&7!ric S. Cuando una función so*recargada es in+ocada el compilador selecciona la función apropiada que coincide con los parámetros. @ @ /l compilar el código se muestra el siguiente mensaje1 sealed.i!dad).iste alguna modificación se in+oca el constructor de la clase que hereda utili-ando la sinta. i . i . for&int i > ?. i. @ @ @ Clase Sealed 3na Clase sealed se utili-a para pre+enir que una clase sea utili-ada como una clase *ase( su principal uso es para pre+enir la deri+ación no planeada.$ength.

:e.Arite$ine&7888 5erencia Simple 8887).dSueldo > dSueldo. Console.icano.icano.7( IO).i!dad). ==Constructor pu*lic Persona&string s om*re( int i!dad)< this. @ dou*le dSueldo. Console. @ ==:étodos pu*lic string "ipo&)< return 7Persona7.Arite$ine&7Programador.s om*re). :e. @ pu*lic dou*le 2*tenerSueldo&)< return this. @ @ class /pp< ==/plicación pu*lic static +oid :ain&)< Persona :e.2*tenerSueldo&)).s om*re 1 7 .icano.icano. Console.icano > ne4 Persona&7Herado Nngeles a+a7( OO). Console.iSueldo 1 7 . dou*le dSueldo > JGO. :e. 1 7 .s om*re Programador."ipo&)).Arite$ine&7:e.Arite$ine&7:e.icano."ipo 1 7 .PIK. @ pu*lic ne4 dou*le 2*tenerSueldo&)< return this. Console.dSueldo > dSueldo M dSueldo.s om*re).icano. 6 .dSueldo. pu*lic int i!dad.Arite$ine&7:e./signarSueldo&dSueldo). :e.icano. pri+ate dou*le dSueldo.i!dad > i!dad. Console. !mpleado Programador > ne4 !mpleado&7Carlos Salinas H. this.i!dad 1 7 .icano. pu*lic ne4 +oid /signarSueldo&dou*le dSueldo)< this.Arite$ine&7:e. @ pu*lic +oid /signarSueldo&dou*le dSueldo)< this.s om*re > s om*re.icano. @ @ ==5erencia Simple pu*lic class !mpleado 1 Persona< pu*lic !mpleado&string s om*re( int i!dad)1*ase&s om*re( i!dad)<@ pu*lic ne4 string "ipo&)< return 7!mpleado7.==Propiedades pu*lic string s om*re.dSueldo. :e.

@ @ ==5erencia Simple pu*lic class !mpleado 1 Persona< pu*lic !mpleado&string s om*re( int i!dad)1*ase&s om*re( i!dad)<@ o+erride pu*lic string "ipo&)< return 7!mpleado7.Arite$ine&7Programador.tender el sistema sin modificar el código e."ipo&)). (irtual significa que cuando una in+ocación a funciones miem*ro( el compilador de*er0a *uscar por el tipo real del o*jeto # no por el tipo de la referencia( e in+ocar en *ase al tipo la función apropiada. @ ==:étodos +irtual pu*lic string "ipo&)< return 7Persona7.Arite$ine&7:e. Programador. Console. @ @ Polimorfismo # 9unciones Qirtuales !l polimorfismo es la funcionalidad que permite a código antiguo in+ocar código nue+o( tam*ién permite e. pu*lic class Persona< ==Propiedades pu*lic string s om*re.i!dad > i!dad.Arite$ine&7:e. aProgramadoresE?F > ne4 !mpleado&7Bill Hates7( I?).i!dad). Programador.icano. Programador. Console.Console. $as funciones a*stractas son automaticamente funciones +irtuales( las cuales permiten al programador usar polimorfismo para hacer su código simple. :e.icano. this.Arite$ine&7888 /rreglo de 2*jetos 8887)."ipo 1 7 .s om*re 1 7 .s om*re > s om*re. pu*lic int i!dad.istente( esto se logra so*reescri*iendo o redefiniendo el código( para lo cual se utili-an funciones +irtuales # la pala*ra cla+e o+erride. @ @ class /pp< ==/plicación pu*lic static +oid :ain&)< Persona :e. ==Constructor pu*lic Persona&string s om*re( int i!dad)< this./signarSueldo&dSueldo)."ipo&)). !mpleadoEF aProgramadores > ne4 !mpleadoEGF.icano > ne4 Persona&7Herado Nngeles a+a7( OO).icano.icano. 1 7 ."ipo 1 7 . Console. Console. Console. using S#stem.s om*re).i!dad Programador.icano.icano. Console.Arite$ine&7:e.i!dad 1 7 .Arite$ine&7Programador.Arite$ine&7Programador.iSueldo 1 7 . :e. :e.i!dad).2*tenerSueldo&)). 7 .

aProgramadoresEiF.   /*stracción 3na /bstracción se refiere a como un pro*lema dado es representado en el espacio de programa..s de cual#uier instancia de la clase.terna # los detalles de su implementación interna."ipo&)). i . si el usuario hace lode detalles dependientes. i ."ipo 1 7 . Console.Arite$ine&7aProgramadoresE7.s om*re 1 7 . $a encapsulación pro+ee los l0mites entre una interfa. Si se in+oca la función "oString&) en un o*jeto que que no la tiene como +ersión propia( la +ersión de la función que es parte de la clase o*ject podr0a ser in+ocada. Console.i. "os cambios reali ados en partes públicas de un objeto deben permanecer compatibles con la versión previa. "as partes públicas pueden ser cambiadas sin arruinar el código del usuario. @ @ @ Cuando una función es declarada con la pala*ra reser+ada o+erride significa que es la misma función que fue declarada en la clase *ase( si la pala*ra reser+ada o+erride se omite el compilador podr0a asumir que la función no está relacionada a la función de la clase *ase # no despacha la función +irtual &el compilador podr0a sugerir omitir o+erride o agregar ne4) . los cambios reali ados en el objeto #ui $ arruinen el código del usuario.$ength. i L aProgramadores. !ncapsulación # Qisi*ilidad Encapsulación &tam*ién llamada in)ormation hiding)( ha*ilidad de un o*jeto para ocultar sus datos internos o parte interna de sus usuarios # pro+ee una interface que hace las partes importantes del o*jeto accesi*le programaticamente. 'a#mond7( K?).i!dad 1 7 .7F. "os campos privados pueden sólo ser accesados desde la clase. 'a-ones para encapsular # ocultar1  El usuario no puede cambiar lo #ue es privado en el objeto. i. /l dise6ar o*jetos el programador decide que o*jetos son +isi*les al usuario # que es pri+ado dentro del o*jeto( los detalles que no son +isi*les al usuario son se6alados para ser encapsulados en la clase.e. for&int i > ?.aProgramadoresEJF > ne4 !mpleado&7!ric S. 8 . Cuando e.s om*re). lo cual reduce la oportunidad de #ue el usuario cambie o dependa de los detalles en el código. aProgramadoresEiF.)< Console.i!dad).Arite$ine&7aProgramadoresE7 . los campos públicos pueden ser accesados a trav.iste una función +irtual el programador puede pasar una referencia a la clase a*stracta aunque la clase deri+ada # el compilador podr0an escri*ir código para in+ocar la +ersión apropiada de la función en tiempo de ejecución. Por ejemplo( el o*jeto *ase o*ject tiene una función +irtual llamada "oString&) que con+ierte un o*jeto a string. 7F.Arite$ine&7aProgramadoresE7 . aProgramadoresEiF. 7F.

NET.NET    $a Dnfraestructura . 1ispositivos de &oft7are . 'icrosoft &tudio . los &ervidores Corporativos .  9 . $a interfa. !" es una plataforma nue+a que simplifica la aplicación del desarrollo en am*ientes altamente distri*uidos de Dnternet. tanto o si el código objeto es almacenado y ejecutado localmente.NET o acceso program$tico para ciertos servicios tales como almacenamiento de archivos. !"( todos los lenguajes .NET y 'icrosoft 9indo7s . "a E%periencia de 8suario . !" a su disposición. $a Plataforma . !" $a solución :icrosoft .NET. !roveer un ambiente de ejecución de código #ue minimice la distribución de soft7are y conflictos de versiones. !" algunas +eces llamada la Bi*lioteca de Clases Base &CB$). !" que permite desarrollar estas aplicaciones es la plataforma . !" consiste de un $enguaje Com%n en "iempo de !jecución &C$') # la Bi*lioteca de Clases de la Plataforma . calendario y pasaporte . $a Plataforma .NET el cual es un servicio de verificación de identidad. !l C$' es como una máquina +irtual &el código que corre dentro del C$' en ejecución en un am*iente encapsulado # controlado( separados de otros procesos en la máquina) en la cual funcionan las aplicaciones . !" tienen la *i*lioteca de clases de la Plataforma .NET el cual podr2a correr sobre nuevos dispositivos 0nternet. !" se refiere a todas las tecnolog0as que constitu#en el nue+o am*iente para crear # ejecutar aplicaciones ro*ustas( escala*les # distri*uidas. $a Plataforma . $a parte de .de clase es la implementación de la a*stracción. !" está dise6ada para cumplir los siguientes o*jeti+os1  !roveer un ambiente consistente de programación orientada a objetos. agentes de información y eti#uetas inteligentes es decir una tecnolog2a #ue automati a hiperligas para información relacionada a palabras y frases en documentos creados por el usuario. !". $os *eneficios de una *uena a*stracción( es dise6arla de manera tal que las modificaciones son minimas( si se conoce *ien el pro*lema a resol+er facilita determinar que métodos necesitara el usuario( tam*ién será un sistema fácil de entender # mantener. o si es ejecutado localmente pero distribuido en 0nternet o si es ejecutado remotamente. !" comprende cuatro componentes fundamentales1  &ervicios de 6lo#ues de Construcción .NET la cual incluye caracter2sticas tales como interfa natural. $a *i*lioteca de clases de la Plataforma . !" inclu#en soporte para cualquiera de los archi+os de entrada=salida # *ase de datos de entrada=salida para R:$ # S2/P.NET la cual comprende la plataforma . Plataforma .Como desarrollador de clases es necesario pensar en terminos de hacer el mejor dise6o de a*stracción para los clientes de clase # permitirles enfocarse a la tarea que de*en reali-ar # no escudri6ar o indagar en los detalles de como funciona la clase( tam*ién es necesario determinar cuales de los miem*ros de la clase de*er0an ser accesi*les pu*licamente. "a 0nfraestructura .

s de una amplia variedad de aplicaciones.. !l código que manipulará el runtime es conocido como código administrado( mientras que el código que no será manipulado por el runtime es conocido como un código no administrado.  !l runtime es una agente que administra el código en tiempo de ejecución al pro+eer de ser+iciones principales como la administración de memoria( administración de hilos( tam*ién implementa tipos estrictos de seguridad # otras formas de +erificación de código que aseguren la seguridad # ro*uste-. "odos los o*jetos son escritos como componentes # los componentes son el centro de acción( por ello que reci*a el nom*re de lenguaje céntrico de componentes &component1centric). es una colección orientada a objetos de tipos reusables #ue pueden utili arse para desarrollar aplicaciones en el rango de aplicaciones tradicionales desde la l2nea de comandos o interfaces de usuario gr$ficas *.80+ hasta aplicaciones basadas en las últimas inovaciones #ue provee /&!.NET.NET "a 6iblioteca de Clases de la !lataforma . !roveer un ambiente de ejecución de código #ue garantice la ejecución de código seguro. C# a#uda en la creación de componentes mediante el runtime # )rame2or3 .NET pueda integrarse con cual#uier otro código. !"( los cuales pro+een un sistema de tipo unificado en el cual todo puede ser tratado como un o*jeto. !" puede almacenar componentes no administrados que son cargados por el C$' en sus procesos e iniciali-ados por la ejecución de código administrado de esta manera se crea un am*iente de soft4are que puede e.    $a Plataforma . $os componentes creados en C# son totalmente auto8descri*i*les # pueden ser utili-ados sin un proceso de registro. . incluyendo el código creado por un desconocido o un tercero semiconfiable.plotar tanto caracter0sitcas de código administrado como las del código no administrado.E/ "ommon +anguage 0untime &$enguage com%n en tiempo de ejecución . 10 . $a plataforma . Construir toda la comunicación sobre est$ndares industriales para asegurar #ue el código basado en la !lataforma . !l concepto de administración de código es principio fundamental del runtime.NET tales como 9eb 5orms y servicios 7eb <'". !roveer un ambiente de ejecución de código #ue elimine los problemas de desempe:o de ambientes de scripts o interpretes. 4acer #ue la e%periencia del desarrollador sea consistente a trav.+ el cual es el fundamento de la !lataforma . !" consiste de dos componentes principales1  El "enguaje Común en Tiempo de Ejecución *C". tal como aplicaciones basadas en 9indo7s y aplicaciones basadas en 9eb. !" Common $anguage 'untime 8 C$' !l . !") es un am*iente *asado en componentes # C# esta dise6ado para facilitar la creación de componentes.

Caracter0sticas del C$' !$ C$' no sólo soporta el compilador de C#( tam*ién el de Qisual Basic # C. $a administración del am*iente del runtime elimina cuestiones de soft4are comunes( li*erando por ejemplo recursos que #a no son utili-ados. !l C$' administra la memoria( ejecución de hilos( ejecución de código( +erificación de código seguro( compilación # otros ser+icios. 'odelo &implificado para la interacción de componentes. !l administrador de memoria elimina las posi*ilidades de fragmentación de memoria e incrementa la referencia de localidad de memoria para impulsar el incremento del desempe6o. !l runtime está dise6ado para incrementar el desempe6o( atra+és del C$' que pro+ee muchos ser+icios estándar( el código administrado nunca es interpretado( una caracter0stica llamada just1in1time &SD") permite compilar todo el código administrado para correr en el lenguaje nati+o de la máquina del sistema o de cualquiera que se este ejecutando. !l C$' pro+ee los *eneficios anteriores( el compilador de*e emitir los metadatos en el managed code.del código implementando una infraestrucutra estricta de +erificación de código llamado Common "#pe S#stem &C"S)( el cual asegura que toda la administración de código se descri*e as0 misma. &eguridad type safety. !l runtime for-a el acceso a código seguro( no es posi*le acceder a datos personales( sistema de archi+os o red. $a seguridad # administración de componentes depende de un n%mero de factores que se inclu#en en su origen como Dnternet red corporati+a( computadora local( es decir( qui-á o qui-á no están disponi*les para desempe6ar operaciones de acceso a archi+os( acceso a registros o funciones sensiti+as( a%n si comien-an a utili-arse en el misma aplicación acti+a. /lgunos de los *eneficios que las aplicaciones o*tienen del C$' son1       0ntegración de lenguajes a trav. 11 . $a +ariedad de compiladores :icrosoft # de terceros genera código administrado que conforma el C"S( es decir( que la administración de código puede consumir otros tipos e instancias administradas( mientras que se for-a estrictamente la fidelidad de tipo # seguridad de tipo.s del Common Language Specification /dministración automatica de memoria.s del recolector de basura. !l runtime tam*ién acelera la producti+idad del desarrollador( no importa el lenguaje que un programador utilice( puede utili-ar las +entajas del runtime( *i*lioteca de clases( # componentes escritos por otros programadores( cualquier compilador que utilice el runtime puede hacer lo mismo( $a interopera*ilidad entre código administrado # no administrado permiten a los desarrolladores continuar utili-ando componentes C2: # C$$s. &oporte de versiones.( el código que generan estos compiladores para ser soportado por C$' es llamado managed code. !l runtime tam*ién for-a la ro*uste. 'anejo de e%cepciones de lenguajes. a trav. !stas caracter0sticas son intr0nsecas a la administración de código que corre so*re el C$'. $os metadatos descri*en los tipos en el código # son empaquetados en el código ejecuta*le..

s de un modelo común #ue puede ser accedido desde cual#uier lenguaje . arreglos.NET y los servicios pueden ser escritos en cual#uier lenguaje .ponen ser+icios 4e* # tratramiento de la intefa. $as clases *ase pro+een tipos de datos *ásicos( clases colección # otras clases generales. pilas y tablas hash. e%isten muchos otros componentes #ue controlan la interfa de usuario *80+ y reali an otras operaciones sofisticadas. $as clases *ase son clases para tratar datos # R:$. !" 'untime !n+ironment !l $enguaje Com%n en "iempo de !jecución pro+ee los ser+icios de ejecución *ásica.de usuario. el entorno o ambiente en gran parte es un lenguaje agnóstico permitiendo la elección de lenguaje. para crear interfaces de usuario Clases Net7or3     5uera de la clase base en tiempo de ejecución. 3na aplicación puede hacer in+ocaciones en cualquier ni+el # utili-ar clases desde cualquier ni+el. esto hace el código f$cil de reusar para el programador y los proveedores de bibliotecas. todos los servicios son ofrecidos a trav. El entorno contiene las 6ibliotecas de Clase 6ase *Base Class Libraries 6C"+ las cuales proveen las funciones tradicionales fundadas en bibliotecas en tiempo de ejecución. . Clases de acceso a bases de datos Clases 0) *input-output+ Clases 9in5orms. la funcionalidad del 6C" incluye=  Clases colección. En el runtime .de 3suario Catos # R:$ Clases Base $enguaje Com%n en "iempo de !jecución /m*iente=!ntorno de !jecución !l am*iente o entorno pro+ee un modelo de programación simple( seguro( soporta de herramientas potentes # a#uda con la distri*ución( empaquetado # soporte1  'odelo de !rogramación &imple. 2rgani-ación . tales como consultas. !" 9rame4orV1 Ser+icios Ae* Dnterfa.NET todos los errores son reportados via e%cepciones. 12 .NET. !n la parte superior de la arquitectura las clases e.!l runtime soporta aplicaciones del lado del ser+idor como :icrosoftT SQ$ Ser+erU e Dnternet Dnformation Ser+ices &DDS)( esta infraestructura permite utili-ar codigo administrado para escri*ir la lógica del negocio.

el modelo de ejecución común hace la depuración de lenguajes simple y directa. un pa#uete puede correr en cual#uier entorno #ue soporte . !" como QB..NET es un entorno administrado o controlado. !l manifiesto tam*ién lista otros ensam*les que dependen de un ensam*le.NET est$ dise:ado para ser un entorno seguro. El runtime . "a depuración en gran medida es enri#uecida por el runtime . !" puede ser utili-ada como una 13 . El runtime . 'icrosoft suministra cuatro lenguajes . !" # ser in+ocadas desde otro lenguaje . &eguridad..  !nsam*laje !n el runtime . $os ensam*les se contienen a s0 mismo( e.s del recolector de basura. Dnteropera*ilidad de $enguaje 3na de las metas del runtime . el entorno del runtime . 3tili-ando +arios archi+os podr0a hacer posi*le un escenario donde las secciones del ensam*le sean descargadas sólo como se necesiten.E/ es ser un lenguaje agnóstico( permitiendo que el código sea utili-ado # escrito desde cualquier lenguaje( no sólo las clases pueden ser escritas en alg%n lenguaje . 1istribución.NET. por#ue los pa#uetes son distribuidos en un formato gen. !l ensamble contiene todos los D$( metadatos # otros archi+os requeridos para que un paquete se ejecute en un paquete completo. el entorno separa los componentes de una aplicación por lo #ue una aplicación sólo corre con los componentes #ue son enviados. lo cual significa #ue el runtime administra la memoria por el programador a trav. en tiempo de ejecución el entorno verifica #ue la ejecución del código sea de tipo segura *typesafe+.iste suficiente información en el ensam*le para ser auto8descrito.NET= (6.NET. esto es posible especificando un re#uerimiento de seguridad para una pie a de código espec2fica. Cada ensam*le contiene un manifiesto que enumera todos los archi+os que están contenidos en el ensam*le( controla que tipos # recursos son e. El runtime . C# y ?&cript.E/ el mecanismo de empaquetado es el ensam*le &assembly)( cuando el código es compilado por uno de los compiladores . !"( es con+ertido a una forma intermedia conocida como D$.  &oporte de herramientas potentes. El sistema de seguridad interactua con el verificador para asegurar #ue el código realice sólo lo #ue tiene permitido hacer. (C>>.NET es un entorno verificado.NET ayuda simplificando la distribución y en algunos casos no e%iste el paso tradicional de instalación. !" como C#( una clase que fué escrita en QB.rico. empa#uetado y soporte.puestos fuera del ensam*le # relaciona las referencias de esos tipos # recursos a los archi+os que contienen los tipos # recursos. Cuando se define un ensam*le( el ensam*le puede ser contenido en un solo archi+o o puede ser di+idido entre +arios archi+os.

isten algunos o*staculos como las propias caracter0sticas del lenguaje( #a que un lenguaje no podr0a soportar ciertas cosas que otro si las soporte( por ejemplo la so*recarga de operadores.tensi*les # permite a los programadores definir atri*utos # utili-arlos. $os atri*utos puede ser utili-ados para1 cam*iar el comportamiento del runtime( pro+eer información acerca de un o*jeto( lle+ar información organi-acional al dise6ador.poner tipos de datos sin signo( porque no todos los lenguajes pueden utili-arlos. Procure que el atri*uto para el elemento sea espec0fico( utili-ando los identificadores siguientes1 Ddentificador assem*l# module t#pe method propert# e+ent field param return Cescripción ensam*le módulo clase o estructura método porpiedad e+ento campo parámetro +alor de regreso 14 . o SScript( es decir( no importaria en que clase sea escrita una clase.. $os atri*utos son e. !l atri*uto información es almacenado con los metadatos del elemento # pueden ser facilmente recuperados en tiempo de ejecución a tra+és de un proceso conocido como reflection.ceso en todo el tiempo de ejecución para almacenar información que modifica como el runtime utili-a las clases.J.?7)F $os atributos son anotaciones que se colocan en elementos de código fuente( como clases( miem*ros( parámetros( etc.E/ soporta atri*utos personali-a*les( los cuales son en cierto sentido un lugar para colocar información descripti+a en los metadatos junto con un o*jeto # entonces recuper después los datos.p%*lica de la clase( por ejemplo el C$S prohi*e e.clase *ase escrita en C# # esa clase podr0a ser utili-ada desde una clase QC.. Para hacer lo anterior posi*le e. Para que una clase sea utili-ada desde un lenguaje . !"( la clase de*e adherir la !specificación Com%n de $enguaje &Common $anguage Specification 8 C$S) la cual descri*e que caracter0sticas pueden ser +isi*les en la interfa. $os atributos pro+een un mecanismo general para hacer esto # son utili-ados en e. "odos los atri*utos deri+an de S#stem. C# utili-a un /tri*uto Condicional para controlar cuando las funciones miem*ro son in+ocadas. /tri*utos !l runtime . $os atri*utos se especifican encerrandolos entre corchetes1 EQersion&7JP=?W=G??I7( Comentario>7J./ttri*ute.?. Por con+ención los atri*utos se agregan al final del nom*re de una clase( con la finalidad de conocer cuales son clases atri*uto # cuales son clases normales.

$os metadatos son *i*liotecas de tipo( entrada de datos al registr#( etc. !s posi*le utili-ar la Plataforma . $a +entaja final del código D$ es que el CP3 es independiente( lo cual significa que se necesita un compilador en la máquina destino para cam*iar el código D$ en el código nati+o. !l D$ # los metadatos son colocados en los archi+os que e.NET &ervicios 9eb <'" &ervicios 9indo7s 'equerimientos de Soft4are "odo lo que se necesita para desarrollar en C# es el Xit de desarrollo &SCX)( del cual solo se utili-ará el C$' # el compilador de C#. !ste código D$ se con+ierte en la entrada para la administración del proceso de ejecución del C$'.trae los metadatos # el D$ de estos. :SD$ en s0 es un lenguaje completo con el cual es posi*le escri*ir aplicaciones. !"( los compiladores toman el código fuente como entrada # producen :SD$ como salida. !l managed code generado por el compilador C# no es código nati+o porque es un código de $enguaje Dntermedio &D$).e # .tienden el formato P! &Porta*le !. !" para desarrollar los siguientes tipos de aplicaciones # ser+icios1      /plicaciones de consola 9indo7s 5orms /plicaciones /&!. !" es una colección de tipos reutili-a*les integradas en el C$'. !l D$ es generado por el compilador( pero no es lo %nico que se pro+ee para el runtime( el compilador tam*ién genera metadatos acerca del código( los cuales dicen más al runtime del código( por ejemplo la definición de cada tipo.$os atri*utos que son aplicados a ensam*les o módulos de*en colocarse después de cualquier cláusula using # antes de cualquier código.primera por el C$'. Cuando se compila una aplicación C# o cualquier aplicación escrita en un C$S( la aplicación es compilada dentro del :SD$( además se compila dentro de las instrucciones nati+as de CP3 cuando la aplicación es ejecutada por +e. Bi*lioteca de Clases de la Plataforma . !" $a Bi*lioteca de Clases de la Plataforma . Para compilar aplicaciones . $os tipos de la Plataforma . $enguaje Dntermedio # :etadatos :icrosoft desarrollo un lenguaje parecido al lenguaje ensam*lador llamado 'icrosoft 0ntermediate "anguage &:SD$).dll( cuando se carga el archi+o P! el runtime coloca # e.e.ecuta*le) utili-ado para archi+os . $os metadatos son empaquetados directamente con el código ejecuta*le # no en localidades separadas. !l proceso es el siguiente1  Código fuente escrito en C# 15 . !" permiten lle+ar a ca*o tareas de programación comunes como manipulación de strings( colecciones de datos( conecti+idad a *ases de datos # acceso a archi+os.

  Cuando la aplicación es ejecutada. Cuando un tipo es cargado( el laoder crea # agrega un stub &pie-a peque6a) a cada método del tipo( as0 cuando el método es in+ocado por +e. !l C$' inclu#e tres diferentes SD"ers que pueden ser usados para con+ertir :SD$ en código nati+o( dependiendo de las circunstancias1  !re?0T *. Cuando el compilador produce o crea la salida tambi. 16 . El código fuente es compilado usando el compilador de C# *csc. el sistema operativo carga el !E como una 1"" dependiente tal como la única #ue e%porta la función BCorE%e'ain *mscoree.e%e+ dentro de un E<E.  SD"ers !l managed code generado por C# es el código D$( aunque el código D$ es empaquetado en un formato de archi+o P! +álido( no es posi*le ejecutarlo sin con+ertirlo a un managed code nati+o. se ejecuta cuando un componente N. El sistema operativo obviamente no puede ejecutar el código '&0".primera( el stu* pasa el control al SD". aun#ue est$ basado sobre el compilador ?0T principal.dll+ justo como lo hace con cual#uier !E v$lido. compila el '&0" usando un compilador just-in-time *?0T o ?0Tter+ dentro de instrucciones C!8 nativas tal como procesa el '&0". El compilador C# produce como salida el código '&0" y un manifiesto en una parte de sólo lectura del E<E #ue tiene un encabe ado est$ndar !E *9in@A-!ortable E%ecutable+.9& es intalado y compila el código 0" a managed code nativo. 1ado #ue el código '&0" no puede ser ejecutado directamente *por#ue no est$ un un formato de m$#uina ejecutable+ el C". !l SD" compila el D$ a código nati+o # cam*ia el stu* para que apunte al código nati+o que está en cache( as0 las su*secuentes in+ocaciones podr0an ejecutar el código nati+o.NET.n importa una función llamada BCorE%e'ain del runtime . El sistema operativo carga y entonces salta al punto dentro del !E el cual es puesto ah2 por el compilador C#.eneración de código 0nstall-time+. opera como un compilador tradicional.dll.   "a función BCorE%e'ain comien a la ejecución del código '&0" #ue fue colocado en el !E. el punto de entrada es un pe#ue:a parte #ue salta a la función BCorE%e'ain en mscoree.

"a compilación se hace en tiempo de instalación. !s posi*le determinar que tipo de SD" esta siendo utili-ado # cuanta memoria utili-a a tra+és de una peque6a utilidad llamada 45/ "ompiler Manager &jitman. "a principal diferencia con un ?00ter regular es la incorporación de algunas invocaciones code pitching. esta especialmente dise:ado para sistemas #ue tienen recursos limitados como memoria.tensiones de sistema tipo( agregando nue+os tipos que pare-can # actuen como tipos de sistemas *uilt. El ?0Tter es invocado en tiempo de ejecución.. /l ser compilado el ensamble entero no hay preocupación referente al desempe:o intermitente cada ve #ue un m.stem 8 Q2S). reali a una conversión muy velo del 0" a managed code nativo Tambi. !l Q2S esta*lece una plataforma que permite la integración de lenguajes # t#pe safet#.e)( que reside en el directorio *in del directorio de instalación del HAS SCX. cuando el usuario final es menos probable para notificar #ue el ensamble esta siendo compilado-?0T. $a *ase de la arquitectura del runtime es la plataforma que puede descri*ir en cuatro áreas1 17 . Sistema de "ipo 3nificado !l runtime de . tal como lo hace el compilador C>>. "a ventaja de la generación de código en tiempo de instalación. !l Sistema Qirtual de 2*jetos 8 Q2S $as reglas que se siguen cuando se declaran( utili-an # administran tipos son modeladas en el Sistema Qirtual de 2*jetos &6irtual -bject S.e. #ue permiten al Econo?0T descartar el código generado o compilado si el sistema comien a a ejecutarse fuera de memoria. es un compilador optimi ado."a generación de código en tiempo de instalación compilar$ un ensamble completo dentro de un código binario de C!8-especifico. /l usar esta utilidad depende del tama:o del sistema y del ambiente de distribución. el cual reali a el an$lisis del flujo de datos.  Econo?0T. compilador por default utili ado por el C". "a desventaja es #ue si el código es pitched *lan ado+ es invocado otra ve por lo #ue debe ser compilado de nuevo.in. es #ue permite compilar el ensamble completo justo una ve antes de ser ejecutado. !" hace más que dar al desarrollador un simple sistema de tipo unificado que es usado a tra+és de todos los lenguajes( tam*ién deja a los lenguajes escri*ir e.todo en el código es ejecutado por primera ve .  ?0T.n es un ?0Tter en tiempo de ejecución. 8n ensamble el código empa#uetado #ue es enviado al compilador. siendo el beneficio el reclamo de memoria. administra el código nativo como salida.

!stos metadatos son similares a los tipos de *i*liotecas generadas con componentes C2: &Component 2*ject :odel). &i una biblioteca de clases es soportada por las reglas del C"&. Common "anguage &pecification .de resol+er como crear o*jetos( in+ocar funciones miem*ro o acceder a los datos de un o*jeto # el compilador puede utili-ar la información para encontrar que o*jetos están disponi*les # como es utili-ado un o*jeto. describe y hace referencia a los tipos definidos por el ()&. garanti a #ue la biblioteca de clases pueda ser utili ada por los dem$s lenguajes #ue implementen el C"&. ()& Type &ystem. $os metadatos por cada o*jeto .    Q2S "#pe S#stem !l Q2S define tipos que descri*en +alores # especifican un contrato en donde todos los +alores de tipo de*en soportar.isten dos entidades1 +alores # o*jetos. !sto permite al runtime configurar apropiadamente el am*iente para ma#or eficiencia al ejecutar la aplicación. !" conocer en tiempo de ejecución que tipos podr0an ser almacenados # que métodos podr0an ser in+ocados. define el subconjunto de tipos del ()&.C"&.. provee un sistema de tipos #ue intenta soportar la implementación completa de una rango amplio de lenguajes de programación. incluyendo tipos par$metro y nombres $os metadatos tam*ién permiten a otras herramientas acceder a la información detallada acerca del código 18 . !l significado por el cual estos metadatos son consultados es llamado re)lection. /demás se mapea el código fuente a secuencias de instrucciones :SD$( el compilador C$S tiene otra tarea importante1 en+ol+er metadatos dentro del !R! resultante.(E&. Para un +alor el tipo descri*e la representación de almacenamiento # las operaciones que puede reali-ar.plicitamente en su representación( cada o*jeto tiene una identidad que lo distingue de los demás o*jetos. $a información inclu#e lo siguiente1    El nombre del objeto "os nombres de todos los campos del objeto y sus tipos "os nombres de todas las funciones miembro. $os 'etadatos son datos que descri*en datos. 'etadata.. !. $os metadatos son la colección de elementos programáticos que constitu#en el !R!( como los tipos declarados # los métodos implementados. $os o*jetos son más poderosos porque el tipo es almacenado e. :etadata !l compilador C$S toma el código fuente como entrada # produce código :SD$ para el runtime para compilar a tra+és de los SD"ters # ejecutar.E/ es capa. es responsable de la carga y ejecución de los programas #ue fueron escritos por el C". !" registran toda la información que es requerida para usar el o*jeto( con esta información el runtime . (irtual E%ecution &ystem . $a ra-ón para usar metadatos es simple #a que permiten al runtime .

Cualquier aplicación que es instalada es automáticamente asociada con los archi+os que son parte de ese ensam*le. !" mantiene el rastreo delos archi+os # de las +ersiones de los archi+os asociados con una aplicación. !"( la seguridad relacionada a factores tales como reglas de accesi*ilidad # requerimientos de consistencia son +erificados. 3na herramienta que toma +entaja de re)lection es el D$C/S: &:icrosoft . Si una aplicación de instalación intenta so*re escri*ir un archi+o necesario para otra aplicación( el runtime . $os assem*lies son paquetes simples de comportamiento semanticamente relacionados que son construidos como un archi+o indi+idual o entidades de archi+os m%ltiples. !" es lo *astante inteligente para permitir que la aplicación de instalación( instale los archi+os necesarios pero el C$' no elimina las +ersiones pre+ias de el archi+o porque toda+0a son requeridas por la primer aplicación.todos. Ceplo#ment $a lla+e para el Ceplo#ment de aplicaciones . !ara sacar las instancias de las clases en memoria. !" 9rame4orV D$ Cisassem*ler)( el cual anali-a la aplicación de metadatos fuente # entonces presenta información acerca de la aplicación en la jerarqu0a del ár*ol. Seguridad $a faceta más importante de cualquier am*iente de desarrollo de aplicaciones distri*uidas es como manejar la seguridad. $a re)lection está disponi*le para usuarios finales para determinar como son los o*jetos( *%squeda de atri*utos o ejecutar métodos en los que los nom*res no son conocidos hasta el tiempo de ejecución. !ara resolver la invocación de m. $os metadatos son utili-ados para +arias tareas1  !ara representar la información #ue el C". !ara for ar la seguridad. utili a para locali ar y cargar clases. $a seguridad comien-a tan pronto como una clase es caragada por el C$' porque la clase loader es parte del esquema de seguridad .     !l encargado de generar los metadatos es el compilador C#( al pasar el código a D$( emitiendo la información *inaria de los metadatos en un archi+o P!. $a especificación de como deplo# una aplicación podr0a +ariar #a que se puede tratar de un desarrollo 4e* o aplicación tradicional de escritorio. Dnteropera*ilidad con código no administrado !l código no administrado no tiene las +entajas que tiene el código administrado( como recolección de *asura( sistema de tipo unificado # metadatos.!. $a principal +entaja de la com*inación de los metadatos con el código ejecuta*le es que la información acerca de los tipos es persistente.  Código administrado invocando funciones 1"" no administradas.iste un proceso llamado reflection donde el código en tiempo de ejecución puede consultar los metadatos para encontrar que o*jetos están disponi*les # que funciones # campos están presentes en la clase. !" es el concepto de &ensambles). cuando la aplicación necesita una interfa para una 1"" en C y la empresa #ue 19 . !l runtime . !ara traducir 0" a código nativo.

por lo #ue el compilador C# es capa de generar el lenguaje intermedio. crea stubs #ue son necesarios para la compilación ?0T.  Código administrado usando componentes C)'.NET. !l C$S define un su*conjunto de tipos del Q2S( si una *i*lioteca de clases sigue las reglas del C$S esta garanti-ando ser utili-ada por clientes de otro lenguaje de programación que tam*ién se adhieren a la C$S.ecution S#stem 8 Q!S !l Sistema Qirtual de !jecución implementa la Q2S # se crea implementando un motor de ejecución &E7ecution Engine !!). estos servicios dependeran de la información producida por el compilador del lenguaje fuente y se emiten dos mapas.arbage Collection+.escribe la 1"" no adopta . el codigo administrado premite rastrear el apilado en el runtime. Carga del Código /dministrado *"oading 'anaged Code+.NET para el componente C)'. Conversión de 0" a Código Nativo via ?0T. el código del lenguaje intermedio no esta dise:ado como un interprete tradicional bytecode o $rbol de código.NET. que la propia especicicación define.cepciones( interfaces( e+entos( atri*utos personali-a*les( delegados( identificadores( etc. &ervicios de debugging. as2 #ue el cliente administrado trabaja con clases . obtiene clases de la memoria. !l C$S se refiere a la interopera*ilidad entre lenguajes( por lo que es necesario seguir los tipos # caracter0sticas del C$S( para ello es necesario conocer los tipos primiti+os( arreglos( tipos( miem*ros tipo( métodos( campos( propiedades( enumeraciones( e. cuando se desea acceder a . "a class loader for a la seguridad. resuelve nombres.NET desde código no administrado.ecolector de 6asura y 'anejo de E%cepciones *. $os componentes de la Q!S son1  "enguaje 0ntermedio * ntermediate Language .0"+.      20 .  Common $anguage Specification 8 C$S !s un conjunto de reglas que un lenguaje de*e adherir para crear aplicaciones . se encarga de checar la seguridad de tipos y la integridad de los m. es posible lograr esto creando un 7rapper .todos.NET ser$ necesario invocar esa 1"" desde una aplicación . dise:ado para ser facilmente traducido a una amplia gama de lenguajes. !" que se ejecutan en el C$'.NET Código no administrado usando servicios . para #ue el runtime entienda el apilado individual de frames un código administrado tiene #ue ser proporcionado por el ?0Ter o por el compilador. la conversión del lenguaje intermedio es realmente una compilación. . Carga de 'etadatos. 3n concepto importante relacionado a la C$' es el código administrado( el código administrado es justo el código que esta ejecutandose *ajo el auspicio de la C$' # por consiguiente comien-a a ser controlado por el C$'. Qirtual !.

$os reference types son asignados al aglomerado.ed8precision num*er 3nicode string 3nicode character Boolean +alue $os tipos de datos son separados en (alue t. 21 .pes # re)erence t. $a en+oltura es marcada por lo que el sistema conoce que contiene por ejemplo int( a este proceso se le conoce como *o.  /dministración de 4ilos. !" su*#acente. "odos los tipos runtime pueden encontrarse en el namespace S#stem del lenguaje com%n en tiempo de ejecución .pes.iste una correspondencia tipo de lenguaje com%n en tiempo de ejecución .ing $a pala*ra reser+ada class es empleada para declarar un tipo referencia &heap allocated)( # la pala*ra reser+ada struct es empleada para declarar un tipo +alor( una estructura es utili-ada para o*jetos ligeros que necesitan actuar como tipos built1in( las clases son utili-adas en cualquier otro caso. $as referencias # tipos de +alores son deri+ados de la %ltima clase *ase o*jet( de esta manera en caso de que un tipo de +alor necesite actuar como un o*ject una en+oltura hace que el tipo de +alor pare-ca una referencia asignandolo al aglomerado( # los tipos de +alores son copiados a estos. !".un mapa del lenguaje fuente de la construcción de direcciones en el flujo de instrucciones y un mapa de las direcciones de las localidades en el apilado de frames. el (E& proprorciona este servicio al código administrado. "ipos de Catos C# soporta el conjunto de tipos de datos usual( para cada tipo de dato que C# soporta( e.ing # el proceso de re+ersa se le conoce como un*o. "ipo *#te s*#te short ushort int uint long ulong float dou*le decimal string char *ool B#te s J J G G P P Y Y P Y Y "ipo runtime B#te SB#te DntJK 3DntJK DntOG 3DntOG DntKP 3DntKP Single dou*le Cecimal String Char Boolean Cescripción 3nsigned *#te Signed *#te Signed short 3nsigned short Signed integer 3nsigned int Signed *ig integer 3nsigned *ig integer 9loating point num*er Cou*le8precision floating point num*er 9i. $os value types son asignados en estructuras de pilas o en l0nea.

J?.Por ejemplo un tipo int es un (alor tipo # un tipo string es un tipo re)erencias( esto tra*ajaria as01 int i > G??I.e generado tendrá el nom*re del archi+o fuente) para ejecutar el programa sólo es necesario escri*ir el nom*re del archi+o ejecuta*le. /lgo interesante es que es posi*le especificar el nom*re del archi+o ejecuta*le a tra+és de un s4itch1 csc =out1nue+o om*re. !l código C# de*e almacenarse en un archi+o con e. !jemplo 5ello Aorld[ !l código C# puede ser escrito en cualquier editor( tam*ién puede escri*irse con Qisual Studio \.7.tensión .J.m. @ @ 22 .e.e( &el archi+o .e%e /segurese de tener esta ruta en el path para poder ejecutar el compilador desde cualquier u*icación.Console. !l archi+o es compilado # ligado a hello4orld. Si e.e.POGG Cop#right &C) :icrosoft Corporation G??J8G??G. string s > 7Septiem*re7. !"9rame4orV+J.de ello es posi*le utili-ar el modificador readonl# el cual está dise6ado para aquellas situaciones en donde las constantes tienen restricción. $a restricción de tipos constantes es que son conoci*les en tiempo de compilación( en +e.iste alg%n error el compilador lo notificará.e nom*re/rchi+o9uente. !" que inclu#e el compilador C#( puede *uscar el ejecuta*le en la ruta1 C1AD C2AS:icrosoft. Para compilar su archi+o .cs es necesario a*rir la consola &C2S) # escri*ir el comando cs seguido del nom*re de su archi+o por ejemplo1 cd hello4orld. /ll rights reser+ed.J.e. i s G??I o88888 888888888888 Z Septiem*re Constantes # Campos Solo $ectura !n C# los +alores pueden ser definidos como constantes # para que un +alor sea constante su +alor de*e ser algo que pueda ser escrito como una constante.Arite$ine&75ello Aorld7). pu*lic const string sCominio > 7informatique. !" Compiler +ersion \.cs $a salida e.P for :icrosoft &') .cs !l siguiente es el ejemplo t0pico de los lenguajes de programación1 class 5elloAorld< pu*lic static +oid :ain&)< S#stem.K??J.POGGcsc. !" 9rame4orV +ersion J.cs Para compilar el código C# es necesario tener instalado la Plataforma .com.itosa de la compilación podr0a ser as01 :icrosoft &') Qisual C# . /plicando el modificador readonl# un +alor puede ser esta*lecido en el constructor o en una iniciali-ación pero no puede ser modificado después.

@ @ !jemplo de /rgs con foreach1 using S#stem. 23 . class /rgs< pu*lic static +oid :ain&stringEF args)< Console. class /pp< pu*lic static +oid :ain&stringEF args)< foreach&string input in args)< Console. itera. "am*ién este método puede especificar argumentos1 pu*lic static +oid :ain&stringEF args) S#stem es el ám*ito del namespace en el cual el o*jeto Console está contenido. /l no e%istir las funciones globales en C#. @ @ @  using &ystemC.Console.!l método :ain de*e estar contenido en la clase # escrito con la primer letra en ma#%scula.Console  class /rgs. itera L args.Arite$ine&input).. el cual contiene entre otras la clase Console la cual es utili ada para comunicarse con la l2nea de comandos.9rite"ine*+C &olamente se escribe= Console. !jemplo /rgs !. por lo #ue en ve de escribir= &ystem.$ength. !s posi*le importar el namespace en las aplicaciones indicandolo al inicio del código con la pala*ra reser+ada using que es una directi+a para el namespace S#stem. using permite al usuario omitir el namespace al utili ar el tipo al #ue es referenciado en este caso &ystem.Arite$ine&7/rgumento <?@ 1 <J@7( itera( argsEiteraF). for&int itera > ?. !" using S#stem. se declara una clase llamada /rgs. define el namespace &ystem.9rite"ine*+C using no puede ser utili ado con un nombre de clase por lo #ue no es permitido escribir using &ystem. !.aminemos el siguiente ejemplo( el cual reci*e los argumentos con los que el componente fue in+ocado1 !jemplo de /rgs con for1 using S#stem.isten más namespaces en la Plataforma . !l tipo de este método puede ser +oid o int.) Console.$ength).Arite$ine&7/rgumentos 1 <?@7( args.

"a primer parte de lo #ue se encierra entre par. argsDiteraE+ #ue como mencionamos anteriormente GHI hace referencia al orden en #ue las variables ser$n escritas.9rite"ine*F/rgumentos = GHIF.ntesis.todo 9rite"ine de la clase Console para escribir en la l2nea de comando lo #ue se indica entre los par. m% &alida = /rgumentos = N /rgumento H = http /rgumento J = = 24 . por cada elemento contenido en el arreglo escribe en la l2nea de comandos lo #ue se indica en *F/rgumento GHI = GJIF.todo indica #ue recibe un arreglo de tipo string llamado args  Console. El m. "ength es un m. public static void 'ain*stringDE args+. en este caso corresponde al iterador y GJI corresponde a argsDiteraE. !ara compilar el componente utilice csc /rgs. este m."ength+C.ntesis es un string donde es necesario destacar #ueGHI. pn !or ejemplo= args http = 777 .todo 'ain*+. es una notación #ue indica entre llaves un 2ndice #ue hace referencia a una variable asociada a este. com .  El ciclo for comien a una iteración desde H hasta el número de elementos #ue contiene el arreglo args. invoca el m.cs !ara ejecutar el componente sin par$metros escriba en la l2nea de comando= csc /rgs &alida = /rgumentos = H    !ara ejecutar el componente con par$metros escriba en la l2nea de comando= csc /rgs pJ pA p@ pK pL pM ."ength.todo de arran#ue debe ser declarado con el modificador static por#ue no est$ asociado con una instancia de un objeto."ength args. /l ser un m.. itera. informati#ue .todo de la clase args el cual obtiene el número de elementos #ue contiene este arreglo. el cual sirve como punto de partida de la ejecución del componente.. "a clase /rgs contiene una función o m."ength. lo cual indica obtener el elemento en cuestión del arreglo args. en este caso asociada con args.todo puede o no ser declarado con argumentos. en este caso es fundamental declarlos por#ue deseamos precisamente leer y escribir estos argumentos proporcionados al invocar el componente. args.

String strCir > Console.Arite$ine&7Catos1 <?@ <J@ <G@ <O@7( str om*re ( int!dad( str"el( strCir)./rgumento A = 777 /rgumento @ = .'ead$ine&). @ @ Note que importar la directi+a S#stem hace posi*le omitir escri*ir el namespace( de esta forma sólo es necesario escri*ir el nom*re del o*jeto seguido del nom*re del método. Console.Arite&7Cirección1 7). String str om*re > Console. /rgumento N = m% !jemplo Dnput=2utput !s posi*le leer datos de la consola utili-ando el método 'ead$ine # es posi*le mostrarlos utili-ando el método Arite o Arite$ine del o*jeto Console1 using S#stem. class in2ut< pu*lic static +oid :ain&)< Console. Console.'ead$ine&).'ead$ine&). /rgumento K = informati#ue /rgumento L = .Arite&7 om*re1 7).Arite&7"eléfono1 7).is <n8mero@ donde n%mero es reempla-ado por la +aria*le correspondiente1 using S#stem.Arite&79echa de acimiento1 7). /rgumento M = com /rgumento O = . Console. String str9ec ac > Console. str9ec ac). @ @ 9unción :ain !s posi*le incluir una función estática en la clase para poder pro*arla( en C# esta función estática puede ser escrita como :ain&) e indica el inicio de la ejecución de un programa1 25 .Arite&7!dad1 7). String str!dad > Console. !jemplo String 9ormat !s posi*le dar formato a la salida de datos a un tipo string( utili-ando la sinta. String str"el > Console.Arite$ine&79ec ac > 7 .'ead$ine&).'ead$ine&). Console. class str9ormat< pu*lic static +oid :ain&)< Console. Console.

class /pp< pu*lic static +oid :ain&)< Console.Arite$ine&7:ain de la clase C7). @ @ /l compilar utilice 1 csc multiplesmain. @ @ !l ejemplo anterior define a la función :ain como +oid lo cual indica que no regresa un +alor( pero es posi*le indicar que si regrese un +alor escri*iendo el tipo de la función como int por ejemplo( que indica que regresa un +alor de tipo entero1 using S#stem.Arite$ine&input).Arite$ine&7:ain de la clase /7).Arite$ine&7:ain de la clase B7). @ @ "am*ién es posi*le que la función :ain reci*a parámetros de la l0nea de comandos( para ello es necesario especificar un arreglo de strings como parámetro1 using S#stem. @ @ class ClaseC< pu*lic static +oid :ain&)< Console. return&J).Arite$ine&75ello 4orld[7).cs =main1ClaseB &alida1 :ain de la clase B 26 . class Clase/< pu*lic static +oid :ain&)< Console.Arite$ine&75ello 4orld[7). class /pp< pu*lic static int :ain&)< Console.using S#stem. @ @ @ :%ltiples 9unciones :ain !s posi*le que e.istan en una aplicación +arias clases que contengan la función :ain&) # por ello al compilar se indicará un error. @ @ class ClaseB< pu*lic static +oid :ain&)< Console. class /pp< pu*lic static +oid :ain&stringEF args)< foreach&string input in args)< Console. Para e+itar el error o indicar que función :ain&) de que clase deseamos que se ejecute( es necesario utili-ar el siguiente s2itch al compilar1 =main1nom*reClase Por ejemplo using S#stem.

TU UT.presión es +erdadera el código de la sección es compilado Si la directi+a anterior no se cumplio el código de la sección es compilado :arca el final de la sección $os identificadores de*en preceder a cualquier código real. es decir.iste el preprocesador( el moti+o por el cual no e.presión es +erdadera Constructor !lse8if( si la directi+a anterior no se cumplio # si la e.presiones preprocesador1      P QQ PQ RR SS !s posi*le utili-ar paréntesis para agrupar e. Comentarios !s posi*le comentar el código( para ello e.  Qalue "#pes 3na +aria*le contiene un +alor de cierto tipo( C# for-a a iniciali-ar las +aria*les antes de utili-arlas en una operación. todo lo #ue sigue a TT es ignorado.Preprocesamiento $o más importante en este punto es que en C# no e. 3n identificador es el nom*re que es usado para alg%n elemento de un programa como una +aria*le o función # de*en tener una letra o guión *ajo como primer caracter.iste es para simplificar la estructura de compilación además de que no ha# necesidad de escri*ir un archi+o de enca*e-ados por separado # mantener en sincronia la implementación( cuando los archi+os fuente C# son compilados el orden de la compilación de archi+os indi+iduales no es importante # es equi+alente a un archi+o de gran tama6o. #ue se utili a para comentar segmentos de código.presiones. C# soporta las siguientes directi+as de preprocesamiento1 "ama6o #define #undef #if #elif #else #endif Qalor Cefine un identificador( los identificadores tam*ién pueden ser definidos +ia la l0nea de comando !limina la definición de un identificador !l código de la sección es compilado si la e.isten dos modalidades1  TT. #ue se utili a para comentar una l2nea. !s posi*le utili-ar los siguientes operadores en e. 27 .

Cuando se asigna un +alor a un +alue t#pe el +alor actual es copiado a diferencia de los reference t#pes lo que se copia es la referencia actual no el +alor. por lo #ue es posible asignar a una variable un valor booleano o el resultado de una e%presión= bool bContinuar Q *a V b+C 28 .epresenta valores booleanos verdadero y falso. $os "ipos Simples de C# se agrupan en1  0ntegral . !"( e.presiones constantes consisten de "ipos Simples e+aluados solamente en tiempo de compilación no en tiempo de ejecución # los "ipos Simples pueden ser iniciali-ados con literales. C# agrupa los +alue t#pes en1    Tipos &imples Tipos Estructura Tipos Enumeración "ipos Simples $os Tipos &imples de C# comparten caracter0sticas como las de alias con los tipos de sistema de .epresenta valores enteros y e%isten nueve tipos integral en C#= "ipo "ama6 o Y *it Y *it JK *it JK *it OG *it OG *it KP *it KP *it Qalor 8JGY a JG\ ? a GII 8OG(\KY a OG(\K\ ? a KI(IOI 8G(JP\(PYO(KPY a G(JP\(PYO(KP\ ? a P(GWP(WK\(GWI 8W(GGO(O\G(?OK(YIP(\\I(Y?Y a 8W(GGO(O\G(?OK(YIP(\\I(Y?\ ? a JY(PPK(\PP(?\O(\?W(IIJ(KJI s*#te *#te short ushort int uint long ulong !ntero con signo !ntero sin signo !ntero con signo !ntero sin signo !ntero con signo !ntero sin signo !ntero con signo !ntero sin signo  6ool .

J?O?Y con una precisión de JI8JK d0gitos /l reali ar operaciones con !loating "oint pueden producirse los siguientes valores=    Cero positivo y negativo 0nfinito positivo y negativo NaN.epresenta un tipo de alta precisión de JAN bit el cual es posible utili arlo para calculos financieros y monetarios.J?8OGP a J. "os valores posibles 29 . esto significa por ejemplo #ue tratar de convertir una variable char a un tipo de dato integral no es posible en C#.P. flotantes *float+ y dobles *double+= "ipo float Qalor J.epresentan dos tipos de datos. no hay una conversión entre el tipo integral a bool #ue force esta conversión.epresenta un caracter 8nicode de JM bit de tama:o.J?8PI a O. por ejemplo= char c&e%o Q W'WC Tambi.  Char .?.En C# el valor verdadero no es posible representarlo con algún valor diferente de cero.I.  1ecimal . Not-a-Number Nota= &i una e%presión un valor es de tipo !loating "oint todos los otros valores son convertidos a tipos !loating "oint antes de reali ar el c$lculo.n es posible asignar un valor he%adecimal utili ando la secuencia de escape % o un valor 8nicode con la secuencia de escape u= char c4e%adecimal Q W%HHMNWC char c8nicode Q WuHHMNWC No e%isten conversiones implicitas de char a otro tipo de datos disponible. por lo #ue se tendr$ #ue hacer un cast e%plicito= char cCaracter Q *char+MLC int nNumero Q *int+W/WC  5loating !oint .J?OY con una precisión de \ d0gitos dou*le I.\.

No hay conversiones implicitas entre decimales y dobles.*G).*O(miDP. @ class ip< pu*lic static +oid :ain&)< DP miDP. $a diferencia entre struct # class en C# es que struct es un (alue t.*P).X%JHAN con una precisión de AN a AX d2gitos.<J@7( miDP. se podr2a generar un o#erflo$ o perder precisión.H%JH-AN a O.*J(miDP.Arite&7<?@. $as estructuras de*er0an ser utili-adas sólo para tipos que son realmente una pie-a de datos. "ipos !structura 3n tipo struct puede declarar constructores( constantes( campos( métodos( propiedades( 0ndices( operadores # tipos anidados. miDP.pe.*O > J. Sinta.pe # class es una re)erence t. por lo #ue es necesario una conversión e%pl2cita con un cast. Console.Hm &i se omite la letra m la variable podr2a ser tratada como double por el compilador antes de ser asignado.Arite&7<?@. $as estructuras actuan de manera similar a una clase # con ma#ores restricciones( por ejemplo no pueden heredar de cualquier otro tipo( ni tampoco otra clase puede heredar de una estructura. !s posi*le esta*lecer el +alor del primer elemento simplemente asignando a este el +alor deseado( as0 como es posi*le especificar el tipo de dato de los +alores contenidos especificandolo después del nom*re de la enumeración aunque están restringidos a los tipos1 long( int( short # *#te. Cuando se define una variable y se le asigna un valor se utili a el sufijo m para denotar #ue es un valor decimal= decimal dec1ecimal Q J.*G > JKY.7( miDP. miDP.<J@. struct DP< pu*lic *#te *J(*G(*O(*P.comprenden los rangos J. using S#stem.is1 enum om*re!numeraciones< constanteJ( constanteG( 30 .( de esta manera se conser+a memoria porque no ha# referencias adicionales que son creadas como se necesiten por o*jetos clase. Console. $a principal idea de utili-ar struct es para crear o*jetos ligeros como Point( 9ileDnfo( etc. @ @ "ipos !numeración !s posi*le esta*lecer un conjunto de constantes relacionadas( por default los elementos de una enumeración son de tipo int donde el primer elemento tiene el +alor ? # cada elemento su*secuente se incrementa en J. miDP.*P > J?J. miDP.*J > JWG.

foreach & string s in !num. pu*lic static +oid :ain&) < "#pe eCias > t#peof&enumCias).pes no almacenan el dato actual que representan( porque almacenan una referencia al dato actual. enum enum9echa <Cia > GJ( :es > W( /6o > JW\J@.Arite$ine&7$os d0as de la semana( # su +alor correspondiente en la enumeración es17).constanteO( . 31 . foreach & string s in !num.Het ames&eCias) ) Console. pu*lic class !numeracion < enum enumCias <Sa*ado( Comingo( $unes( :artes( :iércoles( Sue+es( Qiernes @. "#pe e9echa > t#peof&enum:eses). Console. "ipos 'eferencia !s contraste a (alue t.Arite$ine&7$os meses del a6o( # su +alor correspondiente en la enumeración es17). .Arite$ine& 7<?(8JJ@> <J@7( s( !num. enum enum:eses <!nero(9e*rero(:ar-o(/*ril(:a#o(Sunio(Sulio(/gosto(Septiem*re(] 2ctu*re( o+iem*re(Ciciem*re@.9ormat&e:eses( !num. constanteN @ !jemplo1 using S#stem.Parse&e:eses( s)( 7d7)).Het ames&e:eses) ) Console.Parse&eCias( s)( 7d7)).Arite$ine& 7<?(8JJ@> <J@7( s( !num. Console.pes los re)erence t. $os tipos *ase +álidos para las enumeraciones son1 *#te( s*#te( short( ushort( int( uint( long # ulong.9ormat& eCias( !num. Si el tipo *ase no es especificado( el tipo *ase por default es int. "#pe e:eses > t#peof&enum:eses).Arite$ine&). Console. @ @ Tipos 6ase $os "ipos Base para las enumeraciones se especifican listando el tipo *ase después del nom*re de la enumeración1 enum eCias 1 int< $unes( :artes( :iércoles( Sue+es( Qiernes @.

. 3na clase puede implementar más de una interface. !l "ipo 2*jeto es utili-ado cuando el (alue t. @ @ !s posi*le definir métodos( propiedades e 0ndices en una interface( cuando se define una Clase es posi*le deri+ar de m%ltiples interfaces( mientras que al definir una interface sólo es posi*le deri+ar de sólo una clase.. Sólo e. interface Duno< +oid /ccion3no&). @ @ class /pp< pu*lic static +oid :ain&)< Dmplementa D > ne4 Dmplementa&).7). "ipo Clase !l Tipo Clase contiene datos miem*ro( funciones miem*ro # tipos anidados.iste la firma pero no tiene implementado todo el código( por lo que no es posi*le instanciar una interface( sólo un o*jeto que deri+a de la interface. $os datos miem*ro son constantes( campos # e+entos. 32 . D./ccion3no&). @ class Dmplementa 1 Duno< pu*lic +oid /ccion3no&)< Console.pe esta bo7ed( es decir( que está disponi*le como un o*jeto.$os re)erence t.Arite$ine&7/cción uno. $as interfaces están estrechamente relacionadas a clases a*stractas( se parecen a una clase a*stracta que tiene todos sus miem*ros a*stractos. Dnterfaces 3na interface declara un tipo referencia que tiene sólo miem*ros a*stractos. $as funciones miem*ro inclu#en métodos( propiedades( 0ndices( operadores( constructores # destructores. Cuando un o*jeto implementa una interface( una referencia a la interface puede ser o*tenida por un cast de la interface. Para crear una interface se emplea la pala*ra reser+ada interface1 using S#stem.pes que C# utili-a son1       Tipo )bjeto Tipo Clase 0nterfaces 1elegados Tipo string /rreglos "ipo 2*jeto !l Tipo )bjeto es la Clase Base de todos los tipos( al ser la clase *ase de todos los tipos es posi*le asignarle +alores de cualquier tipo.

uno.pe1sa)e # secure (ersion./ccion3no&). @ @ !s posi*le ocultar al usuario de la clase la implementación de una interfa-( as0 como tam*ién es posi*le crear interfaces *asadas de otras interfaces.Arite$ine&7Colisión resuelta con el nom*re del método Duno7). 3n delegado especifica la forma de una función en +e.Arite$ine&7Colisión resuelta con el nom*re del método Ddos7). dos. !l principal uso de los delegados es con los e+entos no con las clases. !s posi*le encapsular métodos estáticos e instancias en una instancia delegado.de especificar toda una interface. Ddos dos > &Ddos) D. interface Duno< +oid /ccion3no&). 3n delegado es una implementación de )unction pointers orientada a o*jetos # son utili-ados en muchas situaciones donde un componente necesita +ol+er a in+ocar el componente que lo esta usando.class om*reClase 1 Dnterface/( DnterfaceB<@ !. $as interfaces se crean en tiempo de compilación # los delegados son creados en tiempo de ejecución./ccion3no&)< Console. Celegados $os delegados son similares a las interfaces( especifican un contratado entre un caller # un implementer &implementador). $os delegados al ser de naturale-a dinámica se utili-an cuando el usuario desea cam*iar el comportamiento( por ejemplo si deseamos que una clase 2rdenamiento soporte diferentes métodos de ordenación( la ordenación podr0a ser controlada en *ase a un delegado que defina la función de comparación. $a especificación del delegado determina la forma de la función # crea una instancia del delegado( se usa la función que coincide con la forma.iste una técnica llamada 5mplementación de la 5nter)ace E7pl9cita # se utili-a para resol+er colisiones con nom*res de métodos iguales entre interfaces1 using S#stem. 3n delegado encapsula un método con cierta firma( *ásicamente un delegado es un t. @ class Dmplementa 1 Duno( Ddos< +oid Duno. @ interface Ddos< +oid /ccion3no&). @ +oid Ddos. 33 ./ccion3no&)< Console./ccion3no&). @ @ class /pp< pu*lic static +oid :ain&)< Dmplementa D > ne4 Dmplementa&). Duno uno > &Duno) D.

7.com.. !s posi*le hacer un *arrido de los caracteres que componen el string utili-ando la propiedad $ength que poseen los arreglos # porque es posi*le acceder a estos tratando al string como un arreglo1 using S#stem.Nota los delegados siempre son creados a%n si no son usados( pero los delegados podr0an ser creados al +uelo si se reempla-an las funciones estáticas por propiedades( entonces unicamente se crea el delegado solo si se utili-a la propiedad. "ipo string !l Tipo string se utili-a para manipular datos string.m. sAe*Site. 7 1 7 .String # su uso es mu# sencillo1 string sAe*Site > 7http1==444.Arite$ine&7!lemento 7 . Si requiere comparar strings por igualdad utilice el operador de comparación >> /unque string es un re)erence t.7. 'egresa la posición de la primer ocurrencia de un su*string 'egresa la posición de la %ltima ocurrencia de un su*string Concatena dos o más strings u o*jetos( si se pasan o*jetos 34 . Console.iste al final de un string Cetermina cuando un su*string e. $a clase string deri+a directamente de o*ject # no es posi*le deri+arla. class /pp< pu*lic static +oid :ain&)< string sAe*Site > 7http1==444.$ength .)< Console. @ @ @ !s posi*le concatenar strings utili-ando el operador .2f&) Concat&) Cescripción Compara dos strings. $a clase String soporta los sisguientes métodos de comparación # *%squeda1 :étodo Compare&) Compare2rdinal&) Compare"o&) !ndsAith&) StartsAith&) Dnde. Cetermina cuando un su*string e.de modificar la instancia en la cual se in+oco el método. i!lemento L sAe*Site.. Para acceder a un caracter( simplemente acceda a su 0ndice1 sAe*SiteEJJF.$ength. string es un alias para la clase predefinida S#stem. i!lemento .informatique.Arite$ine&7sAe*Site contiene 1 7 . for&int i!lemento > ?.2f&) $astDnde.m. sAe*SiteEi!lementoF).iste al principio de un string.pe la comparación se reali-a comparando los +alores no las referencias.com. "odos los strings en C# son instancias del tipo S#stem. i!lemento. 7 caracteres7). $a clase String es un ejemplo de tipo inmuta*le( es decir( que los caracteres contenidos en el string no puede ser modificados por los usuarios del string( todas las operaciones que son reali-adas por la clase String regresan una +ersión modificada del string en +e.String en el C$'. Compara dos regiones de strings utili-ando una comparación ordinal Compara la instancia actual con otra instancia.informatique.

ima del StringBuilder Cescripción /grega la representación string de un o*jeto /grega la representación string de un o*jeto( utili-ando un formato espec0fico para el o*jeto /segura que StringBuilder tiene suficiente espacio para un n%mero de caracteres espec0fico Dnserta la representación string de un o*jeto espec0fico en una posición espec0fica 35 .Capacit# :étodo /ppend&) /ppend9ormat&) !nsureCapacit#&) Dnsert&) Cescripción 'ecupera o esta*lece el n%mero de caracteres que StringBuilder puede contener ^ndice StringBuilder utili-ado para o*tener o esta*lecer un caracter en la posición espec0fica 'ecupera o esta*lece la longitud 'ecupera la capacidad má. String."oString&)( con+ierte un o*jeto a una representación string.trae un su*string de un string regresa una +ersión de un string en min%sculas regresa una +ersión de un string en ma#%sculas !limina espacios en *lanco de un string !limina un string de caracteres al final de un string !limina un string de caracteres al inicio de un string o*ject.la función "oString es in+ocada Cop#"o&) Dnsert&) Soin&) Pad$eft&) Pad'ight&) 'emo+e&) 'eplace&) Split&) Su*string&) "o$o4er&) "o3pper&) "rim&) "rim!nd&) "rimStart&) Copia un n%mero espec0fico de caracteres de una u*icación del string dentro del arreglo 'egresa un nue+o string con un su*string insertado en la u*icación espec0fica 3ne un arreglo de strings junto con un separador entre cada elemento del arreglo /linea a la i-quierda un string /linea a la derecha un string !limina caracteres de un string 'eempla-a todas las instancias de un caracter con caracteres diferentes Crea un arreglo de strings di+idiendo un string en cualquier ocurrencia de uno o más caracteres !.9ormat&) puede ser utili-ada para crear un string *asado en los +alores de otro string. $a clase StringBuilder soporta las siguientes propiedades # métodos1 Propiedad Capacit# EF $ength :a.

Console.pe no contiene instancias *o. class /rreglo< static pu*lic +oid :ain&)< stringEF a om*res > <75ugo7(7Paco7(7$uis7@. Console.Arite$ine&a om*resEGF).$ength).Arite$ine&a om*resE?F). Note que para definir un arreglo se utili-an los corchetes EF después del tipo del arreglo.F # el compilador podr0a determinar el tama6o de almacenamiento para el arreglo del n%mero de items en la lista de iniciali-ación1 stringEF asPersonas > <7"im Berners8$ee7(7Brendan !ich7(7Cennis 'itchie7(7Sames Hosling7@.is1 tipoEF identificador. Cada elemento de un arreglo de strings es un string con el +alor null1 stringEF as om*res > ne4 stringEIF. !l +alor inicial de un arreglo es null( un arreglo de o*jetos es creado utili-ando ne4. $a dimensión del arreglo puede ser simple o multidimensional( donde cada dimensión comien-a con el 0ndice ?( si requiere hacer un *arrido de todos los elementos del arreglo( comience a partir del 0ndice ? hasta la longitud del arreglo menos uno &nom*re/rreglo. !s posi*le iniciali-ar un arreglo al momento de crearlo1 stringEF asPersonas > ne4 stringEF <7"im Berners8$ee7(7Brendan !ich7(7Cennis 'itchie7(7Sames Hosling7@. @ @ 2tra alternati+a al ejemplo anterior es1 intEF ai umeros > ne4 intEOF. Curante la iniciali-ación es posi*le omitir ne4 tipoE. 36 . Console.'emo+e&) 'eplace&) !limina los caracteres espec0ficos 'eempla-a todas las instancias de un caractes con un nue+o caracter /rreglos 3n arreglo contiene +aria*les a las cuales se accede a tra+és de 0ndices( todas las +aria*les contenidas en el arreglo son referidos como elementos los cuales de*en ser del mismo tipo( por lo que el tipo del arreglo. !jemplo1 stringEF aPersonas. Cuando un arreglo es creado inicialmente contiene los +alores por default para los tipos que este contendrá.ed. ai umerosEGF > PO. 3n arreglo (alue t. using S#stem. ai umerosEJF > OO. $os arreglos en C# son referencias a o*jetos. ai umerosE?F > P.Arite$ine&a om*resEJF). Cada elemento de un arreglo de ints es un int con el +alor ?1 intEF ai umeros > ne4 intEIF.$ength 8 J o nDndice L nom*re/rreglo. Sinta.

is1 tipoE(F identificador. asBidimensionalEJ(?F > 7J?7. asBidimensionalEO(JF > 7OJ7. ai umeros. utilice la pala*re reser+ada ne4 seguido del tipo # entre corchetes el n%mero de elementos que contendrá. Console. asBidimensionalE?(JF > 7?J7.2f&) # Binar#Search podr0an *uscar elementos en un arreglo.Arite$ine&7$ongitud del arreglo ai umeros 1 7 . Para definir un arreglo multidimensional( simplemente defina arreglos como elementos del arreglo1 stringE(F as:ulti > <<7a7(7J7@(<7*7(7G7@(<7c7(7O7@@. ==Cefine P arreglos de G dimensiones int i'englon > P. int iColumna > G. !l método Sort&) podr0a ordenar los elementos de un arreglo( los métodos Dnde. asBidimensionalEG(?F > 7G?7.Arite$ine&7$ongitud del arreglo asPersonas 1 7 .$ength). Sinta. asPersonas. asBidimensionalEJ(JF > 7JJ7. class /pp< pu*lic static +oid :ain&)< stringEF asPersonas > <7"im Berners8$ee7( 7Brendan !ich7( 7Cennis :.2f&) # $astDnde. Console. !l método 'e+erse podr0a in+ertir el orden de los elementos de un arreglo. asBidimensionalEO(?F > 7O?7.E/.$ength). Console. 37 . del arreglo asBidimensional 1 7 . 'itchie7( 7Sames Hosling7@. intEF ai umeros > ne4 intEOF <J( G( O@.$ength). !jemplo1 stringE(F asBidimensional > ne4 stringEG( PF. intE(F aiBidimensional > < <JJ(GG@( <OO(PP@( <II(KK@( <\\(YY@ @.Arite$ine&7$ongitud asBidimensional./rra# del runtime . !s posi*le ordernar # *uscar los elementos de un arreglo gracias a que los arreglos en C# están *asados en el tipo S#stem. stringE(F asBidimensional > ne4 stringEi'englon( iColumnaF. == P renglones M G columnas > Y !lementos asBidimensionalE?(?F > 7??7. asBidimensionalEG(JF > 7GJ7./l declarar el arreglo especifique solamente el n%mero de elementos que este contendrá. !jemplo1 using S#stem. /rreglos :ultidimensionales $os /rreglos 'ultidimensionales son aquellos que tienen más de una dimensión.

@ @ ==5erencia Simple pu*lic class !mpleado 1 Persona< pu*lic !mpleado&string s om*re( int i!dad)1*ase&s om*re( i!dad)<@ pu*lic ne4 string "ipo&)< return 7!mpleado7. 7 1 7 . :e. :e.. 38 . ==Constructor pu*lic Persona&string s om*re( int i!dad)< this. @ @ Console.Arite$ine&7:e.s om*re 1 7 .icano > ne4 Persona&7Herado Nngeles a+a7( OO). j. j L iColumna. Console. Console. i L i'englon.$ength)."ipo 1 7 . i. this.. :e.i!dad 1 7 ."ipo&)). @ @ class /pp< ==/plicación pu*lic static +oid :ain&)< Persona :e. porque no tiene que ser r0gido. aiBidimensionalEi(jF). @ ==:étodos pu*lic string "ipo&)< return 7Persona7. Por ejemplo1 intEFEF aiDCs > ne4 intEOFEF.i!dad).Arite$ine&7:e. @ @ /rreglo de /rreglos 3n /rreglo de /rreglos es tam*ién conocido como jagged arra. aiBidimensional. pu*lic class Persona< ==Propiedades pu*lic string s om*re.)< Console.)< for&int j > ?.icano.icano.icano. !s posi*le declarar # manipular arreglos de o*jetos de la siguiente manera1 using S#stem.s om*re).icano.s om*re > s om*re.icano.i!dad > i!dad.Arite$ine&7:e. 7 elemento 7 . !ste ejemplo define un arreglo de arreglo de tipo int donde su dimensión es O elementos( donde estos elementos son arreglos. pu*lic int i!dad. i . j .for&int i > ?. /rreglos de 2*jetos 3n arreglo de objetos es creado utili-ando ne4. Console.Arite$ine&7$ongitud del arreglo aiBidimensional 1 7 .Arite$ine&7Cimensión 7 .icano.

. aProgramadoresEiF.Sort&a$enguajes).) Console.Arite$ine&7!lemento E7 . aProgramadoresEiF.pl0citamente a los tipos de elementos del otro arreglo. 3na con(ersión e7pl9cita tiene los mismos requerimientos de una con+ersión impl0cita e. !mpleadoEF aProgramadores > ne2 !mpleadoEGF.s om*re 1 7 . @ @ &alida= !lemento E?F > /ctionScript !lemento EJF > C !lemento EGF > C# !lemento EOF > C.$ength. for&int elemento > ?. 7F > 7 .7F.Arite$ine&7aProgramadoresE7 . class /pp< pu*lic static +oid :ain&)< stringEF a$enguajes > <7Sa+a7( 7Pascal7( 7/ctionScript7( 7P5P7( 7C#7( 7SQ$7( 7Sa+aScript7( 7C7( 7Sa+a7( 7Prolog7( 7Qisual Basic7( 7C.i!dad 1 7 . aProgramadoresEiF. Console. /rra#.. Console. i . aProgramadoresE?F > ne4 !mpleado&7Bill Hates7( I?). !lemento EPF > Sa+a !lemento EIF > Sa+a !lemento EKF > Sa+aScript !lemento E\F > Pascal !lemento EYF > P5P !lemento EWF > Prolog !lemento EJ?F > SQ$ !lemento EJJF > Qisual Basic $a función Sort&)( tam*ién se puede utili-ar con n%meros1 using S#stem. !n el siguiente ejemplo se muestra como es ordenado un arreglo de strings1 using S#stem.)< Console. i L aProgramadores..Arite$ine&7888 /rreglo de 2*jetos 8887).$ength. elemento L a$enguajes.. a$enguajesEelementoF). i ."ipo 1 7 .7@.i!dad).Arite$ine&7aProgramadoresE7 . i. for&int i > ?.s om*re). 7F."ipo&)).Arite$ine&7aProgramadoresE7. aProgramadoresEJF > ne4 !mpleado&7!ric S. elemento .Console. 39 . elemento. @ @ @ Con+ersión de /rreglos 3na con(ersión impl9cita es posi*le si los arreglos tienen el mismo n%mero de dimensiones( si los elementos de un arreglo tienen una con+ersión de referencia impl0cita para los tipos de elementos del otro arreglo # am*os arreglos son tipos referencia.cepto que los elementos de un arreglo de*en ser con+erti*les e. 7F. 'a#mond7( K?). Clase /rra# $a clase /rra# pro+ee entre otras( funciones de *%squeda # ordenamiento.i.

/rra#. pu*lic class $enguaje 1 DCompara*le< string nom*re.??G !lemento EOF > ?. a$enguajeEOF > ne4 $enguaje&7Sa+a7(Y). for&int elemento > ?.\( K.G( 8J?G. 40 .??G( WW.I !lemento EGF > 8?. id. pu*lic $enguaje&string nom*re( int id)< this.W( ?. this. @ int DCompara*le.Sort&a umeros). 7F > 7 .W !lemento E\F > Y. if&this. a umerosEelementoF).?J !lemento EPF > J. 7 7 .Arite$ine&7!lemento E7 . elemento L a umeros.?W( J.@ if&this.nom*re > nom*re.\ !lemento EYF > WW.W !lemento EIF > P. a$enguajeEJF > ne4 $enguaje&7/ctionScript7(I).id L lenguajeB.W( 8K. a$enguajeE?F > ne4 $enguaje&7C7(O).I( P.?W !lemento EJF > 8K.$ength. @ @ pu*lic o+erride string "oString&)< return nom*re .Y\ Dnterface DCompara*le $a función sort no tra*aja con clases o estructuras porque no conoce su orden( pero si desea ordenarlas utilice la interface DCompara*le( por ejemplo una ordenación utili-ando una propiedad numérica1 using S#stem.) Console. elemento . a$enguajeEGF > ne4 $enguaje&7Sa+aScript7(G). @ @ class /pp< pu*lic static +oid :ain&)< $enguajeEF a$enguaje > ne4 $enguajeEIF.G !lemento EKF > K. int id.id)< return 8J.id > id.Compare"o&o*ject o)< $enguaje lenguajeB > &$enguaje)o.. elemento.?J( 8?.id)<return J.id Z lenguajeB.Y\@.class /pp< pu*lic static +oid :ain&)< dou*leEF a umeros > <Y. @else< return ?. @ @ &alida1 !lemento E?F > 8J?G.

@else< return ?.nom*re).id)<return J.id > id. @ @ &alida1 P5P J Sa+aScript G CO /ctionScript I Sa+a Y Dnterface DComparer !s posi*le definir m%ltiples tipos de ordenamientos gracias a que el dise6o del :rame2or3 pro+ee esta capacidad.Compare"o&o*ject o)< $enguaje lenguajeB > &$enguaje)o. using S#stem. /rra#. @ @ pu*lic o+erride string "oString&)< return nom*re . this. @ pu*lic class 2rdena om*res 1 DComparer< pu*lic int Compare&o*ject o/( o*ject oB)< $enguaje len/ > &$enguaje)o/.Arite$ine&len).id L lenguajeB.Collections.a$enguajeEPF > ne4 $enguaje&7P5P7(J). 7 7 . pu*lic $enguaje&string nom*re( int id)< this.Compare&len/. @ int DCompara*le. 41 . return String. $enguaje lenB > &$enguaje)oB. id.id Z lenguajeB. @ @ @ class /pp< pu*lic static +oid :ain&)< $enguajeEF a$enguaje > ne4 $enguajeEIF. if&this.Sort&a$enguaje). int id. pu*lic class $enguaje 1 DCompara*le< string nom*re.nom*re(lenB.nom*re > nom*re. Cada clase sólo puede implementar una interface a la +e-( por lo que solamente se podr0a permitir un tipo de ordenamiento( entonces se requiere una clase separada para cada tipo de ordenamiento que implementen DComparer # podr0a tam*ién implementar la función Comapare&)1 using S#stem.id)< return 8J.@ if&this. foreach&$enguaje len in a$enguaje) Console.

@ pu*lic static DComparer 2rdena< get< return &DComparer) ne4 2rdena om*res&). a$ist. pu*lic class $enguaje 1 DCompara*le< string nom*re.id Z lenguajeB./dd&a$enguajeE?F). pu*lic $enguaje&string nom*re( int id)< this.id)<return J.@ if&this./dd&a$enguajeEPF). id. a$ist. @ @ pu*lic class 2rdena om*res 1 DComparer< 42 . a$ist.id > id.2rdena om*res&)). @ int DCompara*le. if&this.Collections. int id. ne4 $enguaje&7Sa+a7(Y). 7 7 .Sort&&DComparer) ne4 $enguaje./dd&a$enguajeEOF). foreach&$enguaje len in a$ist) Console./dd&a$enguajeEJF). @ @ pu*lic o+erride string "oString&)< return nom*re . a$ist. this. a$ist. ne4 $enguaje&7Sa+aScript7(G).nom*re > nom*re.id L lenguajeB.Compare"o&o*ject o)< $enguaje lenguajeB > &$enguaje)o. ne4 $enguaje&7/ctionScript7(I)./dd&a$enguajeEGF). @ @ &alida1 /ctionScript I CO Sa+a Y Sa+aScript G P5P J DComparer Como Propiedad !n el ejemplo anterior el usuario tiene que crear una instancia del ordenamiento deseado # hacer un cast de DComparer( pero es posi*le simplificar esto utili-ando una propiedad estática # hacerlo por el usuario1 using S#stem. using S#stem.id)< return 8J. @else< return ?. ne4 $enguaje&7P5P7(J). a$ist.a$enguajeE?F > a$enguajeEJF > a$enguajeEGF > a$enguajeEOF > a$enguajeEPF > ne4 $enguaje&7C7(O). /rra#$ist a$ist > ne4 /rra#$ist&).Arite$ine&len).

$enguaje lenB > &$enguaje)oB.egulares pro+een un método mu# poderoso para hacer funciones de *usquedas # reempla-amiento. @ @ @ class /pp< pu*lic static +oid :ain&)< $enguajeEF a$enguaje > ne4 $enguajeEIF. Secuencias de !scape Secuencia de !scape _ 7 ` Cescripción Comilla simple Comilla do*le Ciagonal in+ertida ulo a * f /lert 'etroceso 9orm 9eed 43 .pu*lic int Compare&o*ject o/( o*ject oB)< $enguaje len/ > &$enguaje)o/. a$enguajeEPF > ne4 $enguaje&7P5P7(J). a$enguajeE?F > ne4 $enguaje&7C7(O).Sort&a$enguaje( $enguaje.plicitamente a el operador derecho( se o*tiene como resultado el o*jeto con+ertido a el operador derecho( si no puede ser con+ertido la operación falla # regresa null. a$enguajeEOF > ne4 $enguaje&7Sa+a7(Y).presiones 'egulares $as E%presiones . 2perador as !l )perador as checa el tipo del operador i-quierdo # si puede ser con+ertido e. @ @ &alida1 /ctionScript I CO Sa+a Y Sa+aScript G P5P J !. /rra#. a$enguajeEJF > ne4 $enguaje&7/ctionScript7(I). a$enguajeEGF > ne4 $enguaje&7Sa+aScript7(G).Compare&len/.Arite$ine&len). return String. foreach&$enguaje len in a$enguaje) Console.nom*re(lenB.nom*re). !ste operador sólo puede se utili-ado con clases.2rdena).

ing 6o%ing es un mecanismo que crea una liga entre los tipos de (alores # las tipos de re)erencia permitiendo a un tipo de +alor ser con+ertido a un tipo o*jeto # +ice+ersa. int i umero > &int)o umero.ing Bo7ing un +alor se refiere a la con+ersión impl0cita de cualquier tipo de +alor al tipo o*jeto.< pu*lic static +oid :ain&)< int i umero > G?JG. ==cast necesario porque o umero podr0a contener cualquier tipo de o*jeto @ @ Nota( durante la con+ersión unbo7ing el tipo de*e coincidir e. ==in+ocación implicita a una operación bo7ing /l asignar el +alor de la +aria*le entera n umero a una +aria*le o*jeto se reali-a internamente una operación bo7ing( donde el +alor de la +aria*le n umero es copiado al o*jeto o umero( entonces las +aria*les entera # o*jeto e.Arite$ine&o umero). using S#stem.n r t + ue+a l0nea 'etorno de carro "a*ulador "a*ulador +ertical Bo. class /pp< pu*lic static +oid :ain&)< int i!dad > OO. Console.actamente( un +alor de tipo bo7ed no puede ser unbo7ed &con+ertido) a un tipo compati*le. class Bo. @ 44 . o*ject o umero > i umero. Cuando un tipo de +alor es bo7ed se asigna espacio a una instancia de o*jeto # el +alor del (alue t.isten en la pila pero los +alores de los o*jetos residen en el área o espacio asignado( lo que implica que los +alores son independientes # no ha# una liga entre ellos1 using S#stem. o*ject o umero > i!dad. ==in+ocación implicita a una operación bo7ing o umero > G??I.pes. Console.ed)o*jeto. 2*ser+e las siguientes l0neas1 int i umero > G?JG. Si requiere o*tener otro tipo de +alor diferente al que contiene el bo7ed( en ese caso primero o*tenga el +alor correcto # después realice un cast al tipo que requiera1 &+alor'equerido) +alor'equerido +r > &+alor'equerido)&+alorBo. ==3n*o. o*ject o umero > i umero. ==Bo.Arite$ine&i umero). 2tra forma de definir el concepto bo%ing es que este mecanismo permite que los (alue t.pes pare-can o tengan la apariencia de re)erence t.pe es copiado al nue+o o*jeto. Con+ersiones Bo.

==in+ocacion e. Suponga que tiene una +aria*le de tipo int # asigna el +alor de esta +aria*le int a un o*jeto( después declara una +aria*le de tipo dou*le # aplica un cast &dou*le) al o*jeto para asignar su +alor a la +aria*le double( el o*jeto contiene sólo un +alor int # no puede ser asignado a la +aria*le double porque el C$' dispara una e. class om*reClase< pu*lic om*reClase&) 1 *ase&)<@ ==Constructor que pro+ee el compilador @ $as caracter0sticas de un constructor son1      &iempre tiene el mismo nombre #ue la clase. lo cual significa #ue no podr$ ser accesible fuera de la calse o #ue sólo se puede acceder desde la clase.nbo7ing C# checa que el (alue t.@ /l ejecutar el código notará que el +alor de o umero es G??I # el +alor de i umero no cam*io permanece en G?JG. es posible crear un constructor private.pl0cita( por lo que es necesario indicar al compilador que tipo de +alor deseamos e.pe que se requiere este almacenado en la instancia del o*jeto( si la +erificación es e.ing /l contrario que Bo7ing( 8nbo%ing es un mecanismo de una operación e. o*ject o umero > i umero.is *ase. !or lo general tienen el modificador público.E/ el programador no puede controlar la destrucción de o*jetos. ==in+ocación implicita a una operación bo7ing dou*le d umero > &dou*le)o umero. 8n objeto no puede ser instanciado desde la definición de la clase.traer de un o*jeto( al reali-ar la operación .cepción &ystem. No tiene declarado un tipo de regreso.ception)1 int i umero > G?JG.cepción &S#stem. 45 . 3n constructor puede in+ocar un constructor del tipo *ase utili-ando la sinta. $os constructores son in+ocados in+ocados automaticamente sólo cuando una instancia de un o*jeto es creada con ne4. Con+ersiones 3n*o.Dn+alidCast!. No puede ser invocado desde la definición de la clase.itosa el +alor es .pl0cita &cast) ==C$' dispara la e.0nvalidCastE%ception Constructores # Cestructores /ntes de acceder a los métodos o propiedades de una clase( primero se ejecuta el constructor de la clase el cual contiene código de iniciali-ación( si no se escri*e un constructor para la clase el compilador pro+ee automáticamente un constructor de)ault.nbo7ing. &on utili ados para iniciali ar varibles. using S#stem. !n el runtime . &i la clase sólo contiene miembros est$ticos.   /l codificar no se está limitado a los parámetros del constructor( es posi*le en+iar argumentos iniciales para iniciali-ar ciertos miem*ros..

@ set<i'ueda > +alue.@ set<i5elice > +alue. pri+ate string s"ipo.@ set<iQentana > +alue.@ @ pu*lic int Puertas< get<return iPuerta. pri+ate int i5elice.@ @ pu*lic string "ipo< 46 . iPuerta > Puerta. s"ipo > "ipo. i:otor > :otor.@ set<iPuerta > +alue. i/siento > /siento.@ set<i/siento > +alue. pri+ate int iPuerta.class Qehiculo< ==Propiedades1 pri+ate int i'ueda.@ @ pu*lic int Qentanas< get<return iQentana.==/ereo( anfi*io( terrestre( espacial ==Constructor1 pu*lic Qehiculo&int 'ueda( int Puerta( int Qentana( int 5elice( ] int :otor( int /siento( string "ipo)< i'ueda > 'ueda. @ ==$ectura=escritura de propiedades1 pu*lic int 'uedas< get<return i'ueda. pri+ate int i:otor.@ set<i:otor > +alue. iQentana > Qentana.@ @ pu*lic int 5elices< get<return i5elice. pri+ate int i/siento. i5elice > 5elice. pri+ate int iQentana.@ @ pu*lic int :otores< get<return i:otor.@ @ pu*lic int /sientos< get<return i/siento.

Qentanas).Arite$ine&7Puertas 1 7 . Console.Arite$ine&75elices 1 7 . Console.Arite$ine&7'uedas 1 7 . :i/+ion."ipo). Constructor !stático 3n Constructor Est$tico podr0a ser in+ocado antes de ser creada la primer instancia de un o*jeto( # es %til para configurar el tra*ajo que necesita hacerse una +e-. Console.Arite$ine&7"ipo 1 7 .iste un destructor1 pu*lic a om*reClase&)< ==li*erar recursos @ $a ra-ón por la cual se de*er0a escri*ir un método adicional es por el recolector de *asura( el cual no es in+ocado inmediatamente después que las +aria*les quedan fuera de ám*ito( sólo se in+oca el recolector de *asura en ciertos inter+alos o condiciones de memoria.pl0cito 'elease( el cual tam*ién puede ser in+ocado por el destructor1 pu*lic +oid 'elease&)< ==$i*erar recursos @ pu*lic a om*reClase&)< 'elease&).:otores). !n el runtime .@ @ @ ==/plicación1 class /plicConstructor< pu*lic static +oid :ain&)< Qehiculo :i/+ion > ne4 Qehiculo&G(J(J??(?(O(G??(7/ereo7). Console.Arite$ine&7:otores 1 7 .5elices). Para declarar un constructor estático se utili-a el modificador static1 class om*reClase< 47 . @ @ !n un sentido estricto en C# no se tienen destructores( pero el termino destructor se refiere a la li*eración de recursos. :i/+ion.@ set<s"ipo > +alue. Console. :i/+ion. !s posi*le escri*ir un método que li*ere recursos después de ser utili-ados( pero porque escri*ir un método para li*erar recursos si e.Arite$ine&7/sientos 1 7 .get<return s"ipo. :i/+ion.Puertas).'uedas).E/ el usuario no tiene control so*re cuando el constructor estático es in+ocado( #a que el runtime sólo garanti-a que algo es in+ocado después del inicio del programa # antes de ser creada la primer instancia de un o*jeto( lo que significa que no puede ser determinada la instancia que es creada en el constructor estático. Console. @ $a in+ocación del método 'elease en el destructor no es o*ligatoria( la colección garbage de cualquier forma reali-a la li*eración de cualquier o*jeto( pero es una *uena práctica no ol+idar li*erar los recursos.Arite$ine&7Qentanas 1 7 .. :i/+ion. :i/+ion. $o que podr0a suceder es que los recursos se agoten antes de ser utili-ados( entonces es *uena idea pro+eer un método e./sientos). :i/+ion. Console.

. 7=7 . @ @ @ class /plic9echa< pu*lic static +oid :ain&)< 9echa :i9echa > ne4 9echa&). i:es/ . i:esB . J??) . 7=7 . &i/6o/).:a#or&GJ(W(JW\J( GJ(J?(G???)). &i:esB . .Arite$ine&i/ . J??) . @else< return iCiaB . int iB > &iCiaB M J????) . &i/6oB). 7 L 7 . iB). fecha ma#or menor ma#or es es es 1 1 1 7 7 7 . J??) . Console. @ @ pu*lic string :enor&int iCia/(int i:es/(int i/6o/(int iCiaB(int i:esB(int i/6oB)< int i/ > &iCia/ M J????) .:enor&GJ(W(JW\J( GJ(J?(G???)). i/6oB.Arite$ine&7$a :i9echa. .Arite$ine&i/ . J??) . iB). =="est $ine &Celete) if&i/ Z iB)< return iCia/ . 7=7 . Console. i:esB . &i:es/ . =="est $ine &Celete) if&i/ L iB)< return iCia/ . Console. 7=7 . i:es/ . Parámetros Ce alg%n modo se de*en pasar +alores a un método # tam*ién se de*e regresar el resultado de un método( los +alores son manipulados en1 Qalores en Parámetros in Se utili-an +alores en parámetros para pasar una +aria*le por (alor a un método( la +aria*le del método es iniciali-ada con una copia del +alor del caller &quien reali-ó la in+ocación). pu*lic class 9echa< pu*lic string :a#or&int iCia/(int i:es/(int i/6o/(int iCiaB(int i:esB(int i/6oB)< int i/ > &iCia/ M J????) . Console.Arite$ine&7$a fecha :i9echa. 7 Z 7 . &i/6oB). 7=7 . &i/6o/). @ @ om*reClase&)< :étodos $a ma#or parte de la funcionalidad es implementada en los métodos( los métodos son parte del "ipo &class)( pero los métodos no son parte de la instancia &o*ject). i/6o/. int iB > &iCiaB M J????) .Arite$ine&7$a fecha :i9echa. @else< return iCiaB . using S#stem. 7=7 .static . i/6o/. 48 . &i:esB . i/6oB. 7=7 . &i:es/ . 7=7 . Console.:a#or&GJ(J?(G???( GJ(W(JW\J)).

ood !ractice( se recomienda tener dos +aria*les( una en el parámetro # otra en el parámetro ref. pu*lic class Param< pu*lic +oid Parametro'ef&ref int 'efParametro)<== o regresa un +alor e. Console.Parametro'ef&ref iQalor'ef). .:a#or&GJ(J?(G???( GJ(W(G??I)). Si no ha# modificadores los parámetros son siempre pasados por +alor. Qalores en Parámetros re) !s posi*le pasar un +alor como parámetro a un método( modificar el +alor # regresarlo como resultado del método( para ello se utili-a el modificador ref seguido del tipo # del nom*re del parámetro. @ @ .presiones constantes( el resultado de los métodos :a#or # :enor es pasado a el caller como un +alor de regreso # es manipulado sin ser almacenarlo en una +aria*le intermedia. ==Se modifica el +alor directamente == o se regresa un +alor( porque se modifico de manera directa @ @ class Parametros< pu*lic static +oid :ain&)< Param :iParam > ne4 Param&). 49 .:enor&GJ(J?(G???( GJ(W(G??I)). Console. /l pasar un +alor # no una referencia a la +aria*le( es posi*le utili-ar e.pl0cito 'efParametro M> 'efParametro.Arite$ine&7$a :i9echa.Console.isten dos formas de hacerlo1  0niciali ar la variable al declararla. @ @ fecha fecha fecha menor ma#or menor es es es 1 1 1 7 7 7 . iQalor'ef).Arite$ine&7$a :i9echa.Arite$ine&7ref 1 7 . ==Se requiere iniciali-ar el +alor :iParam.==Se in+oca el método pasando la referencia del +alor Console. .Arite$ine&7$a :i9echa. /l contrario de los (alores en parámetros no se pasa una copia del +alor( sino la referencia del +alor # por ello al modificar el +alor se hace la modificación directa( tam*ién es necesario iniciali-ar el +alor que se pasa como paramétro por medio de una +aria*le intermedia # no directamente a tra+és de una e.presión constante1 using S#stem.ecuerde( el compilador de C# no permite utili-ar +aria*les que no han sido iniciali-adas( por lo que antes de utili-ar o esta*lecer los +alores de una +aria*le de*e ser iniciali-ada( para ello e. int iQalor'ef > I. .:enor&GJ(J?(G???( GJ(W(JW\J)).

/signar(alor*ref 'iEdad+C Console.ef!aramC I public static void 'ain*+G 'iClase 'i)bjeto Q ne7 'iClase*+C int 'iEdad Q @@CTT&e iniciali a la variable al declararla 'i)bjeto.'i!ropiedad = F > 'i)bjeto./signar(alor*out 'iEdad+C Console. using &ystemC class 'iClaseG private int 'i!ropiedadC public void /signar(alor*out int 'i)ut!aram+GTT&e cambia la definición de la función 'i)ut!aram Q @@C this.'i!ropiedad = 'i)bjeto.'i!ropiedad+C I I F >  !or ejemplo cambiar la definición de la función y utili ar un par$metro out en ve de un par$metro ref.actamente como los parámetros ref e.9rite"ine*F'iEdad = F > 'iEdad+C Console.9rite"ine*F'i)bjeto.9rite"ine*F'i)bjeto.                using &ystemC class 'iClaseG private int 'i!ropiedadC public void /signar(alor*ref int 'i.de ref.'i!ropiedad Q 'i.'i!ropiedad+C I I                 $os parámetros out son e. Qalores en Parámetros out 50 .9rite"ine*F'iEdad = F > 'iEdad+C Console.ef!aram+G this.'i!ropiedad Q 'i)ut!aramC I public static void 'ain*+G 'iClase 'i)bjeto Q ne7 'iClase*+C int 'iEdadCTTNo se iniciali a la variable 'i)bjeto.cepto que una +aria*le sin iniciali-ar puede ser pasada como parámetro # el caller define un parámetro out en +e.

== o se requiere inicili-ar el +alor :iParam. pu*lic class Param< pu*lic int Parametro n&int DnParametro)< return DnParametro M DnParametro. :iParam. ==Se requiere iniciali-ar el +alor 51 . int iQalor'ef > I.Parametro2ut&out iQalor2ut). iQalor2ut). ==Se in+oca el método con un parámetro out Console.pl0cito 'efParametro M> 'efParametro. pu*lic class Param< pu*lic +oid Parametro2ut&out int 2utParametro)< 2utParametro > P M P.3n parámetro out puede ser utili-ado sólo para contener el resultado de un método( es necesario especificar el modificador out para indicar el tipo de parámetro( a diferencia de los parámetros re) el caller no necesita iniciali-ar la +aria*le antes de in+ocar el método1 using S#stem.ParametroDn&O)).Arite$ine&7out 1 7 .Arite$ine&7 in 1 7 .=='esultado de la in+ocación del método @ @ !jemplo de Parámetros Dn( 'ef # 2ut using S#stem. == o se gregresa un +alor( porque es regresado en el parámetro out @ @ class Parametros< pu*lic static +oid :ain&)< Param :iParam > ne4 Param&). @ pu*lic +oid Parametro%ef&ref int 'efParametro)<== o regresa un +alor e. int iQalor2ut. == o se gregresa un +alor( porque es regresado en el parámetro out @ @ class Parametros< pu*lic static +oid :ain&)< Param :iParam > ne4 Param&). Console. ==Se modifica el +alor directamente == o se regresa un +alor( porque se modifico de manera directa @ pu*lic +oid ParametroOut&out int 2utParametro)< 2utParametro > P M P.

Parametro2ut&out iQalor2ut). ==Se in+oca el método redefinido en la clase deri+ada1 . Cuando se in+oca un método +irtual se está deri+ando el método de clase que es in+ocado # no el método de la clase *ase1 &&ClaseBase)DnstanciaClaseCeri+ada). om*re:etodo]PuedeSer'edefinido&). iQalor2ut). iQalor'ef).Parametro'ef&ref iQalor'ef). ==Se crea una instancia de la clase deri+ada1 ClaseCeri+ada ClsCer > ne4 ClaseCeri+ada&). == o se requiere inicili-ar el +alor :iParam. ==Se in+oca el método con un parámetro out Console. iB.:iParam.==Se pasando la referencia del +alor Console.=='esultado de la in+ocación del método @ @ 'edefinición de :étodos &2+erriding) 3no de los principios *ásicos de la programación orientada a o*jetos es el polimorfismo( el cual hace posi*le que una clase deri+ada pueda redefinir &o(erride) métodos de la clase *ase.Calculo&I(O)).Arite$ine&7ref 1 7 . @ @ class ClaseCeri+ada 1 ClaseBase<==Se deri+a de la clase *ase pu*lic o+erride int Calculo&int i/( int iB)<==Se especifica que el método será redefinido return i/ 8 iB. class ClaseBase< pu*lic +irtual int Calculo&int i/( int iB)< return i/ .Arite$ine&7out 1 7 . Para indicar que una clase deri+a de otra se utili-a el operador 1 el cual denota esta acción1 class ClaseCeri+ada 1 ClaseBase<@ !l siguiente ejemplo muestra como se redefine un método1 using S#stem. 52 . Para indicar que se puede redefinir el método se emplea la pala*ra reser+ada +irtual1 +irtual +oid om*re:etodo]PuedeSer'edefinido Cespués( al deri+ar de la clase *ase se agrega la pala*ra reser+ada o+erride en el nue+o método1 o+erride +oid om*re:etodo]PuedeSer'edefinido&) o es posi*le cam*iar la accesi*ilidad de un método que es redefinido( es decir( no es posi*le cam*iar los modificadores que definen al método. Console.==Se redefine la funcionalidad del método @ @ class 'edefinir:etodos< pu*lic static +oid :ain&)< ClaseBase ClsBase > ne4 ClaseBase&).Arite$ine&7Clase *ase 1 7 ClsBase. in+oca el método int iQalor2ut.

@ @ class 5iding< pu*lic static +oid :ain&)< ClaseCeri+ada :iClaseCeri+ada > ne4 ClaseCeri+ada&).Console. @ @ !l código anterior demuestra que es posi*le deri+ar una clase que implementa un método que la clase *ase no contiene. @ @ 2cultamiento de :étodos &5iding) !s posi*le ocultar métodos de la clase *ase( esto se logra haciendo uso de una caracter0stica especial de la redefinición de métodos llamada ocultamiento de m.Arite$ine&7Clase deri+ada 1 7 .:etodo2culto&). @ @ class ClaseCeri+ada 1 ClaseBase<==Clase deri+ada de la clase *ase pu*lic +oid :etodo2culto&)<==Se implementa un método que si e. class ClaseBase< pu*lic +oid :etodo2culto&)< Console.Arite$ine&75iding :ethods7). class ClaseBase< ==Sin código @ class ClaseCeri+ada 1 ClaseBase<==Clase deri+ada de la clase *ase pu*lic +oid :etodo2culto&)<==:étodo 2culto Console.:etodo2culto&)_ 53 .cs&J?(JP)1 4arning CS?J?Y1 "he Ve#4ord ne4 is required on _ClaseCeri+ada. :iClaseCeri+ada. @ @ class 5iding< pu*lic static +oid :ain&)< ClaseCeri+ada :iClaseCeri+ada > ne4 ClaseCeri+ada&).Arite$ine&75iding :ethods7).todos # al deri+ar de la clase *ase1 using S#stem. @ @ !l compilador indicará un mensaje similar al siguiente1 5iding.Calculo&I(O)). ClsCer.iste Console. :iClaseCeri+ada.Arite$ine&75iding :ethods7).:etodo2culto&). Por otro lado si la clase *ase contiene el método # se trata de deri+ar una clase que trata de implemetar un método que si contiene la clase( se produce un error1 using S#stem.

class ClaseBase< pu*lic +oid :etodo2culto&)<==:étodo 2culto Console.@ @ @ !jemplo1 using S#stem.de un o*jeto de su implementación( en +e. @ @ /l hacer uso del modificador ne4( se le indica al compilador que se está redefiniendo el método de la clase *ase # que de*er0a ocultar este método. @ @ class ClaseCeri+ada 1 ClaseBase<==Clase deri+ada de la clase *ase ne4 pu*lic +oid :etodo2culto&)<==:étodo 2culto Console. class Propiedades< pri+ate int i!dad.:etodo2culto&).:etodo2culto&)_ 5iding.cs&P(JP)1 &$ocation of s#m*ol related to pre+ious 4arning) !l error principal es que no se hace uso del modificador ne4( #a que si es posi*le ocultar un método contenido en la clase *ase1 using S#stem.Arite$ine&75iding :ethods using ne47).de permitir a un usuario acceder directamente a un campo o arreglo( una propiedad permite especificar a un conjunto de sentencias reali-ar el acceso mientras se permita utili-ar el campo o arreglo.@ set<i!dad > +alue. Propiedades $as propiedades son con+enientes para separar la interfa.is1 &&ClaseBase):iClaseCeri+ada). class om*reClase< int i om*rePropiedad.@ 54 .:etodo2culto&). pu*lic int !dad< get<return i!dad.Arite$ine&75iding :ethods7). ==declaración de la propiedad ==!specificación del acceso a la propiedad pu*lic int Nombre"ropiedad< get<return i om*rePropiedad. :iClaseCeri+ada. @ @ class 5idingClass:et< pu*lic static +oid :ain&)< ClaseCeri+ada :iClaseCeri+ada > ne4 ClaseCeri+ada&).@ set<i om*rePropiedad > (alue.*ecause it hides inherited mem*er _ClaseBase. Se puede asegurar de in+ocar el método que redefine la clase deri+ada utili-ando la siguiente sinta.

Arite$ine&7 om*re Ciudadano 1 Ciudadano. $os accessors para la lectura del +alor de una propiedad son marcados con la pala*ra reser+ada get # los accessors para modificar el +alor de una propiedad son marcados con la pala*ra reser+ada set. Ciudadano. Campos *fields+ !ropiedades *properties+ $os atri*utos son implementados como +aria*les miem*ro con acceso p%*lico +ia accessors &get o set). $os accessors &get o set) especifican las sentencias que son ejecutadas cuando se requiere leer o escri*ir el +alor de una propiedad.icano.Arite$ine&7!dad Ciudadano.poner el nom*re de los atri*utos1   Ciudadano 1 7 . Ciudadano. pu*lic int Sueldo< get<return iSueldo.@ set<s om*re > +alue. class Persona< pri+ate int iSueldo. Ciudadano.@ set<iSueldo > +alue.icano< get<return *:e. 7 . Console. om*re). Console. pu*lic *ool :e.icano > +alue.!dad).isten dos maneras de e.icano Ciudadano.Arite$ine&7:e.@ @ pu*lic static +oid :ain&)< Propiedades Ciudadano > ne4 Propiedades&).@ set<*:e.@ pri+ate string s om*re. om*re > 7Herardo Nngeles a+a7.icano).:e.:e. Console. !l siguiente ejemplo muestra como se implentan los accessors para las propiedades1 using S#stem.@ @ @ 55 .icano.!dad > OO.icano > true. @ @ !. Ciudadano 1 7 .@ @ pri+ate *ool *:e. pu*lic string om*re< get<return s om*re.

pu*lic Persona&int piernas( int *ra-os( int ojos)< this. int i2jos. Si en +e. int iBra-os. sólo es posible establecer el valor de la propiedad. this. $as propiedades estáticas pueden ser iniciali-adas hasta que sea necesario hacerlo( el +alor puede ser fa*ricado cuando se necesite sin almacenarlo. get only.Arite$ine&7!dad 1 7 . set only.Sueldo > OO.i2jos > ojos. es posible tener acceso al valor de la propiedad para leerlo y escribirlo.de utili-ar propiedades desea utili-ar campos de*erá dejar fuera los accessors # redefinir la +aria*le como1 pu*lic int Sueldo. using S#stem.iBra-os > *ra-os. !mpleado. this.class /plicPersona< pu*lic static +oid :ain&)< Persona !mpleado > ne4 Persona&).   Propiedades !státicas Propiedades estáticas no pueden ser declaradas con los modificadores +irtual( a*stract u o+erride. /ccessors !s posi*le ocultar los detalles de la estructura de almacenamiento de la clase reordenando los accessors( en este caso el accessors set es pasado en el nue+o +alor para la propiedad en el parámetro +alue.Sueldo). Console. !mpleado.iPiernas > piernas. @ @ pu*lic static Persona Bra-os< get< return&ne4 Persona&?(P(?)). sólo es posible leer el valor de la propiedad. $as operaciones que pueden reali-arse con los atri*utos son1  0mplementar get y set. @ @ pu*lic static Persona 2jos< get< 56 . @ @ Note( que se utili-a el parámetro +alue( #a que el +alor actual es almacenado en este que es accesi*le dentro de la clase. @ pu*lic static Persona Piernas< get< return&ne4 Persona&G(?(?)). class Persona< int iPiernas.

F< get<intrucciones@ set<intrucciones@ @ $as reglas de implementación para get # set son las mismas reglas de las propiedades( la %nica diferencia es que la lista de parámetros se define li*remente entre los corchetes( tam*ién e.7).Arite$ine&!").Het5ostB# ame&str5ost). int iContador > :iC S.Arite$ine&7Se encontro <?@ para el host 7( iContador). using S#stem. @ @ @ class /pp< pu*lic static +oid :ain&)< Persona !" > Persona.com. 57 .is1 atri*utos modificadores declarador<instrucciones@ $os 0ndices o inde7ers regresan o esta*lecen un string en un 0ndice dado( los inde7ers no tienen atri*utos por lo que utili-an el modificador pu*lic.@ @ @ class /plic'esol+erC S< pu*lic static +oid :ain&)< 'esol+erC S :iC S > ne4 'esol+erC S&). Console.ado a la clase tal como si la clase se tratará de un arreglo( para ello se utili-a la caracter0stica de C# inde.isten restricciones como que es necesario especificar al menos un parámetro # los modificadores ref # out no están permitidos.$ength./ddress$ist. pu*lic +oid 'esol+er&string str5ost)< DP5ost!ntr# DP5! > Cns.F.return&ne4 Persona&?(?(Y)). et.'esol+er&7444. :iC S. aDPs > DP5!.==Cirecti+a namespace para la clase C S class 'esol+erC S< DP/ddressEF aDPs.F< get<return aDPsEiDnde. @ @ ^ndices !s posi*le incluir una forma de acceso inde. @ pu*lic DP/ddress thisEint iDnde.@ @ pu*lic int Contador< get<return aDPs.er( sinta.Piernas. !jemplo1 using S#stem.informatique.m. Console. $a parte del declarador consiste del tipo string # la pala*ra reser+ada this para denotar el inde7er de la clase1 pu*lic string thisEint iDnde.Contador.

e /plic'esol+erC S. et. :odificadores $os modificadores pueden clasificarse en1    'odificadores de Clase 'odificadores 'iembro 'odificadores de /cceso :odificadores de Clase !.)< Console. @ @ @ Si el namespace para la clase C S no está contenida en la *i*lioteca central( al compilar inclu#a la referencia a la *i*lioteca que la contiene1 csc =r1S#stem.isten dos tipos de modificadores de clase1  abstract   8na clase abstracta no puede ser iniciali ada &ólo clases derivadas #ue no son abstractas pueden ser iniciali adas "as clases derivadas deben implementar todos los miembros abstractos de la clase base abstracta No puede aplicarse un modificador sealed a una clase abstracta    sealed  Clases sealed no pueden ser heredadas 58 .e. $a rutina o tarea que un e+ento podr0a in+ocar es definida por un delegado..for&int i > ?. $os eventos pueden ser declarados como campos o propiedades de clase( am*os accesos comparten la comodidad de tipo que el e+ento de*e tener delegate. i. Para tratar de manera fácil con e+entos( la con+ención de dise6o para e+entos es emplear dos parámetros( donde el primer parámetro es el o*jeto que lan-a el e+ento # el segundo parámetro es un o*jeto que contiene la información acerca del e+ento el cual siempre deri+a de la clase !+ent/rgs. $os delegados pueden ser implementados como métodos o instancias estáticas. i L iContador.Arite$ine&:iC SEiF). !+entos 3na clase puede usar un e+ento para notificar a otra clase o clases que algo ocurrio( los e+entos usan el idioma 7publish1subscribe7( #a que una clase pu*lica el e+ento que puede lan-ar # las clases que están interesadas en un e+ento espec0fico pueden su*scri*ir al e+ento.cs $os 0ndices pueden tener más que un parámetro para simular un arreglo +irtual multidimensional.dll =out1resol+er. Cada e+ento puede ser utili-ado por cero o más clientes # un cliente puede utili-ar un e+ento en cualquier momento.

 8tilice este modificador para prevenir herencia accidental !jemplo1 using S#stem.  event   1efine un campo o propiedad como tipo event 8tili ado para ligar al código cliente a eventos de la clase  e%tern  0ndica al compilador #ue el m.:i:etodo&). CC.Arite$ine&7Clase sealed7). @ @ :odificadores :iem*ro /lgunos modificadores miem*ro son1  abstract  0ndica #ue un m.   const   Este modificador aplica a campos y variables locales "a e%presión constante es evaluada en tiempo de compilación.todo base debe ser el mismo   readonly 59 .todo o accessor #ue es definido virtual en cual#uiera de las clases base "a firma de redefinición y m. a*stract class Clase/*stracta< a*stract pu*lic +oid :i:etodo&). por lo tanto no puede contener referencias de la clase. #ue son implicitamente virtual. @ sealed class ClaseCeri+ada1Clase/*stracta< pu*lic o+erride +oid :i:etodo&)< Console. "a clase #ue recibe la herencia debe proveer la palabra reservada override.todo es implemetado e%ternamente  override  8tili ado para modificar un m.todo o accessor no contiene una implementación. @ @ pu*lic class :odificadorClase< pu*lic static +oid :ain&)< ClaseCeri+ada CC > ne4 ClaseCeri+ada&).

Sentencias de Control $as &entencias de Control se emplean para controlar la ejecución # flujo del código( las cuales se di+iden en1 60 . $os modificadores de acceso son1  public. "as clases derivadas no pueden acceder al código. !s necesario aplicar el modificador de acceso deseado a cada miem*ro( de otra forma el tipo de acceso por default es impl0cito. este tipo de acceso es otorgado a todo el código #ue es parte del mismo componente *aplicación o biblioteca+ . propiedades. pero no desde las clases fuera de este. el miembro es accesible desde cual#uier parte.   private. operadores y constructores. internal.todo o accessor pueden ser redefinidos por las clases #ue reciben la herencia. m. No es permitido el acceso desde fuera.NET. es visto como público a nivel del componente .  El modificador internal protected provee mayor fle%ibilidad en como una clase es definida y se utili a para indicar #ue un miembro pueder ser accedido desde una clase internal o protected. protected. en otras palabras internal protected permite acceso internal o protected. 8n campo declarado con el modificador readonly puede ser cambiado sólo en su declaración o en el constructor de la clase contenedora  static  'iembros #ue son declarados static pertenecen a la clase y no a una instancia de la clase !ueden utili arse modificadores static con campos. este modificador de acceso es el menos restrictivo. el miembro es accesible en la clase y todas las clases derivadas. :odificadores de /cceso $os modificadores de acceso definen el ni+el de acceso que cierto código tiene en los miem*ros de la clase como métodos # propiedades. sólo el código dentro de la misma clase puede acceder este miembro. El acceso protected permite a otras clases depender de la implementación interna de la clase y por lo tanto deber2an ser otorgados sólo cuando sea necesario.NET y privado fuera de este.   virtual  0ndican #ue un m. Este modificador permite #ue un miembro sea accesible desde las clases en el mismo ensamblaje.todos.

presión.Arite$ine&7se e+aluo +erdadero7).presión8*ooleana)<la e7presión se e(aluo (erdadera@ !s posi*le indicar código alterno en caso de que la e.Arite$ine&7?7).presión8*ooleana)< la e7presión se e(aluo (erdadera @else< la e7presión se e(aluo )alsa @ Nota C# no puede con+ertir +alores numéricos a *ooleanos( solo puede hacer comparaciones entre ellos para e+aluar el resultado de la e. class SeleccionDf< pu*lic static +oid :ain&)< if&J >> J)< Console. @ M= @ @ Nota el operador de igualdad en C# es >>( si está ha*ituado a otra forma( sera cosa tiempo acostum*rarse a escri*irlo correctamente( en la siguiente ta*la se muestran los operadores +álidos en C#1 2perador >> [> !+alua Qerdadero( si am*os +alores son los mismos Qerdadero( si los +alores son diferentes 61 . $as &entencias de selección son aquellas que se utili-an para escri*ir diferentes flujos de acción en *ase a una condición dada( e.isten dos tipos de sentencias de selección1   &entencia if &entencia s7itch Sentencia if /l escri*ir uno o +arios flujos de acción el código contenido en estos se ejecutará siempre # cuando la e+aluación de la e. using S#stem. if&e.presión el cual es un +alor *ooleano.presión *ooleana se e+alue falsa1 if&e.presión en la sentencia if se e+alue como +erdadera &tenga cuidado en C# if&?)<@ o if&J)<@ no es +álido).  &entencias de &elección &entencias de 0teración Sentencias de Selección $as &entencias de selección son aquellas que se utili-an para reali-ar operaciones *asadas en el +alor de una e. @ =M o es soportado por C# if&?)< Console.

@else< !s:a#uscula&ch$etra).Arite$ine&chCaracter . @ s om*re > 7JGO7. 7 min%scula7).Arite$ine&ch$etra . @else< !s:a#uscula&ch$etra). @ @ pu*lic static +oid !s:inuscula&char chCaracter)< if&chCaracter Z> _a_ bb chCaracter L> _-_)< Console.trae el tercer caracter del string if&Char. !s:inuscula&ch$etra). !s:inuscula&ch$etra).trae el segundo caracter del string if&Char.DsCigit&ch$etra))< Console.==!. 7 es un d0gito7).DsCigit&ch$etra))< Console.istir para que el compilador cree el código necesario automáticamente. @ @ a+a7.DsCigit&ch$etra))< Console. !s:inuscula&ch$etra). @ @ pu*lic static +oid !s:a#uscula&char chCaracter)< if&chCaracter Z> _/_ bb chCaracter L> _c_)< Console.==!. ch$etra > s om*reEGF.==!. 'ecuerde que siempre podrá reali-ar un cast e.Arite$ine&ch$etra . @ ch$etra > s om*reEJF.pl0cito.Arite$ine&chCaracter . char ch$etra > s om*reE?F. @else< !s:a#uscula&ch$etra). !jemplo using S#stem. 7 ma#%scula7). 7 es un d0gito7). 7 es un d0gito7).Arite$ine&ch$etra . class Caracteres< pu*lic static +oid :ain&)< string s om*re > 7Herardo /ngeles string if&Char.L( L>( Z( Z> Qerdadero( si el +alor cumple con la condición $os operadores de la ta*la son implementados +ia la so*recarga de operadores # la implementación es especifica para el tipo de dato( si se comparan dos +aria*les de diferente tipo se reali-a una con+ersión impl0cita que de*e e.trae el primer caracter del 62 .

presión de control son s*#te( *#te( short( ushort( uint( long( ulong( char( string o un tipo enumeración &enumeration).@ !n el ejemplo anterior se muestra la aplicación de la sentencia de selección if # el uso del método DsCigit de la clase Char( tam*ién se muestra como determinar si un caracter correponde a las letras ma#%sculas o min%sculas. case e. class SentenciaS4itch< pu*lic static +oid :ain&)< for&int i > ?. *reaV. entonces las sentencias contenidas para ese caso son ejecutadas &i la e%presión constante en las eti#uetas case no coincide con el valor evaluado en la e%presión de control. ¿Cómo funciona la sentencia de selección s4itch?   &e evalua la e%presión de control &i la e%presión constante en las eti#uetas case coincide con el valor evaluado en la e%presión de control.presion8contante1 goto default. i L> JG.presión a >> * se e+alua +erdadera entonces la +aria*le iQalor nunca contendrá el +alor d.presión de control # los flujos de código alternos son ejecutados dependiendo del +alor constante asociado con esta e.presión anterior se e+alue +erdadera1 if&a >> * dd &c >> &iQalor > d)))<@ !n el ejemplo anterior( si la e. s4itch&e. @ 63 . entonces el control es transferido al final del blo#ue s7itch   !jemplo1 using S#stem.presion8contante1 sentencias. Sentencia s4itch $a sentencia de selección s4itch tiene una e.presión.presion8de8control)< case e. i. @ $os tipos de datos permitidos para la e. case e. Hood Practice1 nunca asigne +alores a +aria*les dentro de una condición que utili-a operadores lógicos &bb(dd([)( porque puede que nunca se le asigne el +alor correspondiente a la +aria*le en caso de que una e. entonces el código contenido en el caso por default es ejecutado &i la e%presión constante en las eti#uetas case no coincide con el valor evaluado en la e%presión de control y no e%iste un caso por default.)< :es&i). default1 sentencias..presion8contante1 goto case G.

case Y1 Console. case I1 Console.Arite$ine&7:ar-o7).Arite$ine&72ctu*re7).Arite$ine&7Ciciem*re7). *reaV. *reaV. case JJ1 Console.@ pu*lic static +oid :es&int i:es)< s4itch&i:es)< case J1 Console. *reaV. *reaV. default1 Console. *reaV.Arite$ine&7Sulio7). case J?1 Console. *reaV. 64 .Arite$ine&79e*rero7). case JG1 Console. case G1 Console. case W1 Console. *reaV. *reaV.Arite$ine&7:es no +álido7).Arite$ine&7Septiem*re7). *reaV. case P1 Console.Arite$ine&7/*ril7). case K1 Console.Arite$ine&7:a#o7). case \1 Console. case O1 Console. *reaV. *reaV. *reaV.Arite$ine&7 o+iem*re7). @ @ @ !s posi*le utili-ar sentencias goto dentro del s4itch de la siguiente manera1   goto case e%presion-contante goto default !jemplo1 using S#stem.Arite$ine&7/gosto7).Arite$ine&7Sunio7). *reaV.Arite$ine&7!nero7).

!s posi*le salir de un ciclo for a tra+és de las instrucciones1 65 . 2pcion&i2pcion).Arite$ine&7 seis7). 2pcion&i2pcion). *reaV.presión *ooleana +erdadera( no será posi*le e+aluar otro tipo de e. *reaV.is1 for&iniciali-ador.class SentenciaS4itch< pu*lic static +oid :ain&)< int i2pcion > P. !ste *loque se repetira mientras la condición e+alue una e. case Y1 goto default. iterador) $os componentes de la sentencia for1 iniciali<ador( condición( iterador( no son o*ligatorios. case P1 Console. i2pcion > G. i2pcion > J?.Arite$ine&7 cuatro7). Sinta. condición.Arite$ine&7 die-7). @ @ @ Sentencias de Dteración &repetición) $as &entencias de 0teración &tam*ién conocidas como looping statements) son aquellas que nos permiten ejecutar un *loque de código repetidamente mientras una condic0on espec0fica sea +erdadera1     for foreach 7hile do Sentencia for $a &entencia for se utili-a cuando se conoce pre+iamente cuantas +eces ha de repetirse un *loque de código. case J?1 Console. case K1 Console. i2pcion > Y. 2pcion&i2pcion). default1 Console. 2pcion&i2pcion).presión. *reaV. *reaV.Arite$ine&7 por defecto7). @ pu*lic static +oid 2pcion&int iQalor)< s4itch&iQalor)< case G1 goto case K.

( l9actorial).Parse&a/rgsE?F). for&l/u. @ proporcionar un argumento( long l9actorial > J. class 9actorial< pu*lic static +oid :ain&stringEF a/rgs)< if&a/rgs. long lCalcular > DntKP.Arite$ine&7!lemento 7 . @ @ @ 66 .Arite$ine&7Ce*e !jemplo1 9actorial I7).Arite$ine&7<?@[ es <J@7( lCalcular( l9actorial). =="est $ine Console. long l/u.$ength. > J. class /pp< pu*lic static +oid :ain&stringEF a/rgs)< foreach&String s in a/rgs)< Console.$ength >> ?)< Console.. foreach&"ipo indentificador in e. return. i L a/rgs.. @ @ @ !l ejemplo anterior implementado con foreach1 using S#stem.  brea3 goto !jemplo1 using S#stem. l/u. > J. @ Console.)< Console.Arite$ine&s). 7 > 7 . i . !l siguiente ejemplo muestra el uso de for1 using S#stem..)< l9actorial M> l/u. l/u. a/rgsEiF).Arite$ine&7<?@[ M <J@7( l/u. @ @ Sentencia foreach $a &entencia foreach es un comando para enumerar los elementos de una colección. class /pp< pu*lic static +oid :ain&stringEF a/rgs)< for&int i > ?.presión)<@ $a +aria*le de iteración es declarada por el /ipo( indenti)icador # e7presión correspondiente a la colección. i.. $a +aria*le de iteración representa el elemento de la colección para cada iteración. L> lCalcular.

!s posi*le acceder a las colecciones Xe#s # Qalues de la interfaDCictionar#1 using S#stem.o es posi*le asignar un nue+o +alor a la +aria*le de iteración. @ @ @ Nota( es necesario tener una precaución e.cepción.presión. !n el siguiente ejemplo el método Het!n+ironmentQaria*les&) regresa una interfa. Console.2pen"e. String str$inea > null. @ Stream'eader S' > 9ile. Para que una clase soporte la sentencia foreach( la clase de*e soportar un método con la firma Het!numerator&) # la estructura( clase o interface que regresa de*e tener un método p%*lico :o+e e.Xe#s)< Console. o se puede pasar la +aria*le de iteración como un parámetro ref o out.presión *ooleana +erdadera( no será posi*le e+aluar otro tipo de e. Sentencia do archi+o test. 4hile&condicional)<@ !jemplo1 using S#stem. class SentenciaAhile< pu*lic static +oid :ain&)< if&[9ile. @ @ !s posi*le utili-ar la sentencia *reaV para salir del ciclo o continue para saltar una iteración. using S#stem.Arite$ine&7!l e.isten <?@ +aria*les de am*iente declaradas7( Qars/m*. return.Collections.html7))< Console.de tipo DCictionar#.ists&7test.Arite$ine&str$inea).!.Arite$ine&7<?@ > <J@7( strDterador( Qars/m*EstrDteradorF.Count).t # una propiedad p%*lica Current. !ste *loque se repetira mientras la condición e+alue una e.'ead$ine&)))< Console.iste7).tra al decidir el tipo de +aria*le de iteración( porque un tipo equi+ocado no puede ser detectado por el compilador( pero si detectado en tiempo de ejecución # causar una e.Arite$ine&7!.html no 67 ."oString&)). @ S'. foreach&String strDterador in Qars/m*. 4hile&null [> &str$inea > S'. using S#stem.Het!n+ironmentQaria*les&).Close&).Xe#s. Sentencia 4hile $a &entencia 7hile se utili-a cuando no se conoce pre+iamente cuantas +eces ha de repetirse un *loque de código( por lo que puede ejecutarse ? o más +eces.html7).D2.t&7test. class Sentencia9or!ach< pu*lic static +oid :ain&)< DCictionar# Qars/m* > !n+ironment.

$a diferencia entre la sentencia 4hile # do es que do se e+alua después de su primer iteración( por lo que al menos siempre se ejecuta una +e-1 do< sentencias; @4hile&condición); !s posi*le salir de un ciclo do a tra+és de la sentencia *reaV # es posi*le saltar una iteración utili-ando la sentencia continue !l siguiente ejemplo le la entrada de la consola toma el primer caracter leido( lo con+ierte en un "ipo dou*le # suma su +alor mientras la entrada sea _s_ o hasta que la entrada sea _n_. using S#stem; class Consola< pu*lic static +oid :ain&)< Consola $eerCatos > ne4 Consola&); $eerCatos.'un&); @ pu*lic +oid 'un&)< char chContinuar > _s_; string strCatos; dou*le dSuma > ?; do< Console.Arite&7Proporcione un n%mero1 7); strCatos > Console.'ead$ine&); dSuma ,> Cou*le.Parse&strCatos); Console.Arite&7¿Continuar s=n?7); strCatos > Console.'ead$ine&); chContinuar > strCatosE?F; if&chContinuar >> _n_) *reaV; @4hile&chContinuar >> _s_); Console.Arite$ine&7$a suma de los n%meros es1 7 , dSuma); @ @ Sentencias de Salto $as &entencias de &alto como *reaV( continue( goto # return sir+en para ir de una sentencia a otra *reaV $a &entencia brea3 es utili-ada para salir de la iteración en curso o sentencia s4itch # continuar con la ejecución después de esa sentencia. continue $a &entencia continue salta todas las sentencias siguientes en la iteración en curso # entonces continua la ejecución en la sentencia de iteración &siguiente iteración). goto $a &entencia goto puede ser utili-ada para saltar directamente a una etiqueta. 3na sentencia goto no puede ser utili-ada para saltar adentro de un *loque de sentencias. Su uso podr0a ser empleado en sentencias s4itch o para transferir el control fuera de un loop anidado. Nota( como *uena práctica no se recomienda el uso de goto. return

68

$a &entencia return regresa a la función in+ocadora # opcionalmente retorna un +alor. /signación Cefiniti+a $as reglas de /signación definitiva pre+ienen la o*ser+ación del +alor de una +aria*le no asignada( #a que C# no permite utili-ar +aria*les que no han sido iniciali-adas( as0 como tam*ién no pueden reali-arse operaciones con +aria*les de clase que no han sido iniciali-adas. Puede accederse al elemento de un arreglo a%n si no ha sido iniciali-ado( #a que el compilador no puede rastrear la asignación definiti+a en todas las situcaciones. Precedencia de 2peradores Cuando una e.presión contiene m%ltiples operadores( la precedencia de operadores controla el orden en el cual los elementos de la e.presión son e+aluados. Categor0a 2perador

Primar# 3nar# :ultiplicati+e /dditi+e Shift 'elational !qualit# $ogical / C $ogical R2' $ogical 2' Conditional / C Conditional 2' Conditional /ssignment

&.)( ..#( f&.)( aE.F( .,,( .88( ne4( t#peof( si-eof( checVed( unchecVed ,( 8( [( a( ,,.( 88.( &"). M( =( e ,( 8 LL( ZZ L( Z( L>( Z>( is >>( [> b f d bb dd ?1 >( M>( =>( e>( ,>( 8>( LL>( ZZ>( b>( f>( d>

t#peof !l operador t#peof regresa el tipo del o*jeto( el cual es una instancia de la clase S#stem."#pe 3na instancia #a e.istente puede o*tener el tipo de o*jeto con el método de la instancia Het"#pe&). is !l operador is es utili-ado para determinar cuando una referencia a un o*jeto puede ser con+eritda a un tipo espec0fico o interface. !l operador as es mu# similar al operador is( pero en +e- de determinar cuando un o*jeto es un tipo espec0fico o interface( as tam*ién reali-a la con+ersión e.plicita a ese tipo o interface # si no lo puede con+ertir el operador regresa null. 3tili-ar as es más eficiente que utili-ar is( porque as sólo necesita checar el tipo del o*jeto una +e- e is checa el tipo cuando el operador es utili-ado # lo checa otra +ecuando la con+ersión se reali-a.

69

3tili-ando is if&3n2*jeto is 3n"ipo)< 3n"ipo ut > &3n"ipo) 3n2*jeto; @ 3tili-ando as 3n"ipo ut > 3n2*jeto as 3n"ipo; if&ut [> null)< sentencias; @ Con+ersiones !n C# las conversiones se di+iden en con(ersiones e7pl9citas # con(ersiones impl9citas que son aquellas que podr0an siempre ocurrir1 ==con+ersiones impl0citas s*#te a > II; short * > a; int c > *; long d > c; ==con+ersiones e.pl0citas c > &int) d; * > &short) c; a > &s*#te) *; / continuación se presenta la jerarqu0a de con+ersión en C## :anejo de !.cepciones $as e.cepciones son el método fundamental de manejo de condiciones de error. !jemplo1 using S#stem; class Ci+isionCero< pu*lic static +oid :ain&)< int i/ > OO; int iB > ?; tr#< ==Sentencia que puede lan-ar una e.cepción Console.Arite$ine&7<?@=<J@ > <G@7( i/ (iB( i/=iB); @catch&!.ception e)< ==:anejo de la e.cepción Console.Arite$ine&7$a operación <?@=<J@ genero la e.cepcion 1 <G@7( i/( iB( e); @ Console.Arite$ine&7Continua la ejecución del código...7); @ @ !l ejemplo encierra el *loque de código que podr0a lan-ar una e.cepción con tr#. !n caso de generarse una e.cepción el runtime ..E/ detiene la ejecución del código # *usca el *loque tr# en el cual la e.cepción tu+o lugar( entonces *usca si este *loque tiene relacionado un *loque catch( puede ser que encuentre más de un *loque catch relacionado al *loque tr# que genero la e.cepción( por lo que se determina que *loque catch es el que mejor # ejecuta el código que contiene. !l compilador de C# puede manejar silenciosamente situaciones que podr0an producir un error sin notificarnos e.plicitamente de ello( por ejemplo una situación como un

70

ception es una coincidencia más espec0fica( por lo que es la %nica que será ejecutada( pero si además de escri*ir el catch para Ci+ideB#cero!.cepción # tratar de hacer acciones que dejen la operación como esta*a hasta antes de generarse la e.cepción( lo cual pro+ocará dejar al o*jeto en un estado incorrecto( # causará da6os cuando el caller trate de utili-arla de nue+o. Serarqu0a de !.cepciones #a que un o*jeto de*er0a siempre mantener un estado +álido después de generarse una e.cepción o como podr0a ser solucionada. !l caso del código para calcular un factorial( el compilador no prodruce una ad+ertencia( pero si trata de o*tener el factorial de AHHH dara por resultado ?( el compilador actuo en modo silencioso porque por default el compilador tiene desha*ilitada la opción de chequeo de o(er)lo2.cepciones1 Caller Be4are $a primer forma es no atrapar la e. tr#< Console.cepcion 1 Ci+ideB#cero!.cepciones deri+an de la clase !.iste una e.7). int iB > ?.cepción # entonces relan-ar la e.ception( el compilador le notificara que e.ception7).ceptionCi+ision?< pu*lic static +oid :ain&)< int i/ > OO.o#erflo$ que es cuando el cálculo de una operación e.cepción Ci+ideB#cero!.cepción atrapada es en+uelta en una e.cepción a el nom*re de la e. Caller Confuse $a segunda forma es atrapar la e..cepción1 using S#stem. Se llama "aller "on)use( porque después de generase una e.Arite$ine&7<?@=<J@ > <G@7( i/ (iB( i/=iB).ception( la cual es parte del lenguaje com%n en tiempo de ejecución &C$')( donde la propiedad catch determina por coincidencia el tipo de e.cepciones "odas las e.cede el rango +álido de resultados posi*les para el tipo de dato.cepción. class !.cepciones # esto es porque !.ception escri*e el catch para !.cepción( el caller con frecuencia tiene poca información respecto al entendimiento de los detalles de la e.cepción que atrapa todas las e. @ @ !n este ejemplo el *loque catch que atrapa la e.cepción( esto usualmente es lo menos que se esperaria del manejo de e.cepción generada.. Caller Dnform $as tercer forma "aller 5n)orm agrega información que es de+uelta al usuario( la e.cepciones !.Arite$ine&7Se genero la e.ception ocupa la cima de la jerarqu0a de todas las e.ception)< Console.cepciones.isten tres formas *ásicas de tra*ajar con e. 3n *loque catch con una coincidencia especifica hacen más general la e. 71 . @catch&Ci+ideB#cero!. !s posi*le cam*iar el comportamiento de chequeo de o(er)lo2 utili-ando un s4itch al compilar. "ra*ajar con !.cepción que tiene información adicional1 using S#stem. @ Console.Arite$ine&7Continua la ejecución del código.

class !.cCi+ceroDnf< pu*lic static +oid :ain&)< int i/ > OO; int iB > ?; tr#< Console.Arite$ine&7<?@=<J@ > <G@7( i/ (iB( i/=iB); @catch&Ci+ideB#cero!.ception e)< Console.Arite$ine&7Se genero la e.cepcion 1 Ci+ideB#cero!.ception7); thro4&ne4 Ci+ideB#cero!.ception&7Dnformación adicional...7( e)); @ Console.Arite$ine&7Continua la ejecución del código...7); @ @ Chequeo de 2+erflo4 Si requerimos controlar el chequeo de o(er)lo2 para la aplicación completa( el compilador de C# de*e esta*lecerse como chec3ed. Por default el compilador tiene desha*ilitada la opción de chequeo. Para indicar e.plicitamente que el compilador cheque el o(er)lo2 escri*a1 csc 9actorial.cs =checVed, 3na +e- que se compilo de con la opción de chequeo de o(er)lo2 ha*ilitado( al intentar o*tener el factorial de AHHH de presenta la +entana ?ust-0n-Time-debbuging notificandonos que ocurrio una e.cepción en 9actorial.e.e1 S#stem.2+erflo4!.ception !ste tipo de situaciones es posi*le atraparlas # manejarlas a tra+és de las e.cepciones que se producen. Chequeo programático de 2+erflo4 !.iste otra opción si es que no deseamos acti+ar el Chequeo de 2+erflo4 para la aplicación completa # ha*ilitar sólamente partes especificas de código( para ello se utili-a la sentencia checVed1 using S#stem; class 9actorialChecVed< pu*lic static +oid :ain&stringEF a/rgs)< if&a/rgs.$ength >> ?)< Console.Arite$ine&7Ce*e !jemplo1 9actorial I7); return; @

proporcionar

un

argumento(

long l9actorial > J; long lCalcular > DntKP.Parse&a/rgsE?F); long l/u. > J; for&l/u. > J; l/u. L> lCalcular; l/u.,,)< chec3edGl5actorial UQ l/u%CI TT4abilitar che#ueo de overflo7 =="est $ine Console.Arite$ine&7<?@[ M <J@7( l/u.( l9actorial); @ Console.Arite$ine&7<?@[ es <J@7( lCalcular( l9actorial); @ @

72

"am*ién es posi*le hacer el caso contrario( es decir( indicar que no se realice el chequeo de o(er)lo2 para partes especificas de código( para ello se utili-a la sentencia1 unchecVed<sentencias;@ Sentencias para el :anejo de !.cepciones !s posi*le atrapar( manejar # limpiar las e.cepciones que se producen utili-ando las sentencias siguientes1
  

try - catch try - finally try - catch - finally

tr# 8 catch Para e+itar que se muestre el mensaje que indica que una e.cepción ocurrio( es necesario atrapar la e.cepción # lo mejor de todo es que continue la ejecución del programa( para ello se utili-a tr# # catch. tr# contiene el código que qui-á pueda lan-ar una e.cepción # catch maneja la e.cepción si esta ocurre1 tr#< ==sentencias que pueden lan-ar una e.cepción @catch&nom*re!.cepción)< ==manejo de la e.cepción @ !l siguiente ejemplo maneja la e.cepción 9ile ot9ound!.ception que se produce cuando se intenta manipular un archi+o que no e.iste( si esto ocurre se presenta un mensaje que muestra el nom*re del archi+o que se intento manipular # no se encontro a tra+és de una propiedad p%*lica de la e.cepción llamada 9ile ame. using S#stem; using S#stem.D2; class SentenciaAhile< pu*lic static +oid :ain&)< tr#< Stream'eader S' > 9ile.2pen"e.t&7test.html7); String str$inea > null; 4hile&null [> &str$inea > S'.'ead$ine&)))< Console.Arite$ine&str$inea); @ S'.Close&); @catch&9ile ot9ound!.ception e)<==!n caso de que el archi+o no e.ista Console.Arite$ine&7 o se encontro el archi+o 1 7 , e.9ile ame); return; @ @ @ tr# 8 finall# !s posi*le limpiar el manejo de errores utili-ando tr# # el constructor finall#( sin eliminar el mensaje de error( pero el código contenido en el *loque finall# es ejecutado a%n después de ocurrir una e.cepción.

73

!l siguiente código maneja una +aria*le *ooleana que indica si se produjo un error( simplemente poniendola dentro del *loque tr#( si el código contenido fué ejecutado la +aria*le *ooleana es false lo cual indica que no ocurrieron e.cepciones( si el *loque no se ejecuto la +aria*le *ooleana mantiene su +alor inicial lo cual significa que si ocurrieron e.cepciones # entonces se ejecuta el *loque 9inall# el cual e+alua el +alor de la +aria*le *ooleana # presenta la indicación correspondiente. using S#stem; using S#stem.D2; class Sentencia"r#9inall#< pu*lic static +oid :ain&)< *ool *!.cepcion > true; tr#< Stream'eader S' > 9ile.2pen"e.t&7test.html7); String str$inea > null; 4hile&null [> &str$inea > S'.'ead$ine&)))< Console.Arite$ine&str$inea); @ S'.Close&); *!.cepcion > false; @ finall#< if&*!.cepcion)< Console.Arite$ine&7ZZZ o se encontro el archi+o7); @else< Console.Arite$ine&7ZZZ o ocurrieron e.cepciones7); @ @ @ @ Note que en caso de no e.istir el archi+o se produce una e.cepción # se presenta el mensaje que indica que ha ocurrido una e.cepción pero tam*ién fué ejecutado el *loque finall#( el código que contiene el *loque finall# siempre es ejecutado ocurra o no una e.cepción. Puede emplear la sentencia finall# para reesta*lecer los +alores pre+ios a la generación de la e.cepción. tr# 8 catch 8 finall# Com*inar tr# para controlar el código que puede lan-ar e.cepciones( atrapar la e.cepción con catch # lle+ar aca*o instrucciones necesarias con finall# hacen una mejor solución cuando ocurren las e.cepciones. !s posi*le utili-ar una sentencia catch por cualquier e.cepción que pudiera ocurrir( es decir( tener más de un *loque catch( pero es necesario conocer la jerarqu0a de las e.cepciones porque puede ocurrir que un *loque pre+io catch sea más general # contenga todas las e.cepciones lo cual produciria un error. using S#stem; using S#stem.D2; class Sentencia"r#Catch9inall#< pu*lic static +oid :ain&)< *ool *!.cepcion > true; *ool *:odificacion > false;

74

cepciones7).cepciones propias de esta clase. String str$inea > null.cepcion > false. @ @ @ @ $an-amiento de !.cepción con la sentencia catch primero de*e generarse la e.'ead$ine&)))< Console. Stream'eader S' > 9ile.Arite$ine&7!ntro modificación( ] pero reali-aron7).cepciones estándar que pro+ee el runtime1 "ipo !. @ S'.tr#< *:odificacion > true.ception Clase *ase para todos los errores generados en tiempo de ejecución $an-ada en tiempo de ejecución cuando el 0ndice de un arreglo está fuera de rango Cisparada en tiempo de ejecución cuando un o*jeto null es referenciado o se encontro el las modificaciones no se en modo 75 .Arite$ine&str$inea).2ut'ange!.cepción( pero es posi*le que a tra+és de codigo se lan-e o in+oque una e.2pen"e.cepciones Para atrapar una e.cepcion)< *:odificacion > false.t&7test. @ Console. @else< Console.cepción es util cuando no se ha contemplado cierto escenario o para nue+os escenarios( al crear una clase podrian crearse tam*ién e. @catch&9ile ot9ound!.Close&).9ile ame). / continuación se presenta una ta*la que contiene las e.ception S#stem!. e.ception ullreference!.ception Dnde.cepcion).ception e)<==!n caso de que el archi+o no e.cepción if&[*:odificacion)< Console.ista Console.ception Cescripción Clase *ase para todas los o*jetos e.==Qalor antes de generarse la e.Arite$ine&7 o ocurrieron e.cepción1 thro4 ne4 om*re!. @ finall#< if&*!. *!.htmlR7). return.Arite$ine&7 o se encontro el archi+o 1 7 . !l poder lan-ar o in+ocar una e.cepcion&e. 4hile&null [> &str$inea > S'.Arite$ine&7Causa 1 archi+o7).

l/u. thro4.cepciones que son originadas u ocurren en am*ientes fuera del C$' !.$ength >> ?)< Console.cepciones destructurada AinOG 'elan-amiento de !..Dn+alid2peration!. factorial <?@[ causo una e.ception $an-ada por ciertos métodos cuando in+ocan a métodos que son in+álidos para el estado de los o*jetos actuales Clase *ase de todos los argumentos de las e. l/u.cepción que contiene información 5'!S3$" C2: !.cepción( manejarla # se +ol+erla a in+ocar1 using S#stem. @ proporcionar un argumento( long l9actorial > J.( l9actorial).ception Dnterop!.)< l9actorial M> l/u. long l/u.ception Com!..Parse&a/rgsE?F). tr#< checVed< ==5a*ilitar chequeo de o+erflo4 for&l/u.ception S!5!..cepción que encapsula información del manejo de e.Arite$ine&7Ce*e !jemplo1 9actorial I7).ception /rgument ull!. > J. class 9actorialChecVed'e"hro4< pu*lic static +oid :ain&stringEF a/rgs)< if&a/rgs.cepciones !l siguiente código muestra como es posi*le atrapar una e.cepciones $an-ada por un método( en caso de que un argumento sea null cuando no sea permitido $an-ada por un método cuando un argumento no está en el rango permitido Clase *ase para e.Arite$ine&7<?@[ es <J@7( lCalcular( l9actorial).ception)< Console.Arite$ine&7!l lCalcular). return. @ @ @catch&2+erflo4!.Arite$ine&7<?@[ M <J@7( l/u.ception /rgument2ut2f'ange!. @ Console. =="est $ine Console.cepción7( 76 .ception /rgument!. > J. long lCalcular > DntKP. L> lCalcular.

@ pu*lic static +oid :ain&)< tr#< /plic:is!.ception< pu*lic :i!.Pro*ar&).todo o propiedad envio mal los par$metros "an ar un 0nvalid)perationE%ception cuando la operación invocada no es apropiada para el estado actual de los objetos "an ar la e%cepción m$s apropiada 8sar e%cepciones encadenadas No utili ar e%cepciones para errores esperados o normales No usar e%cepciones para control o flujo normal No lan ar Null.cepciones1   /l lan ar una e%cepción se debe proporcionar un te%to significativo "an ar e%cepciones solo cuando se presente una condición realmente e%cepcional "an ar un /rgumentE%ception si el m. pu*lic class :i!.cepciones para esta clase( esto es con+eniente cuando se utili-a la clase # manejar posi*les escenarios de error con las clases de e.Arite$ine&e).cepciones( para ciertos escenarios es posi*le crear clases de e.cepciones creadas.angeE%ception en m.ception e)< Console. @ @ @ Se de*en tomar ciertas consideraciones al crear e. using S#stem.cepcion&string str)1*ase&str)<@ @ pu*lic class /plic:is!.todos        Componentes /s0 como es posi*le escri*ir clases # hacer uso de estas en un mismo archi+o( tam*ién es posi*le escri*ir en un archi+o &ejecuta*le) unicamente la clase lo cual es 77 . @catch&!.cepcion&7ocurrio un error7).cepciones.cepcion1!.eferenceE%ception o 0nde%)ut)f.ception !s recomenda*le utili-ar las clases predefinidas para e.cepciones< pu*lic static +oid Pro*ar&)< thro4 ne4 :i!.@ @ Creación de Clases !.cepciones apropiadas( por ejemplo cuando creamos una clase( tam*ién podemos crear e.

@ pu*lic string 2*tener om*re&)< return s om*re.nom*reBi*lioteca. Console.@ set<iSueldo > +alue.Arite$ine&7!dad 1 7 .@ @ pu*lic string s om*re.dll om*reComponente.dll =t1li*rar# =out1 om*reComponente. class /plicClsPersona< pu*lic static +oid :ain&)< ClsPersona !mpleado > ne4 ClsPersona&).cs Conde el s2itch =t1li*rar# indica al compilador de C# crear una *i*lioteca # no *uscar el método estático :ain. 78 . Creación de Componentes Para crear un componente unicamente es necesario escri*ir la Clase con todos sus miem*ros &Constructores( Propiedades( :étodos)( almacenarla en un archi+o # compilar el componente. !mpleado.dll ClsPersona. Creación de una /plicación Cliente Para hacer uso de los componentes creados es posi*le crear aplicaciones cliente donde se creen instancias de las clases creadas1 using S#stem. !mpleado.que ha compilado su componente puede escri*ir una /plicación Cliente.Sueldo). 3na +e.conocido como componente # en otro archi+o &tam*ién ejecuta*le) el uso de la clase lo cual es conocido como cliente. Si su clase requirio de nom*res de espacio &namespace) es necesario hacer referencia a estas *i*liotecas mediante el s2itch =r1 om*reBi*lioteca. using S#stem. @ @ Compilación de Componentes /l compilar un componente se crea una *i*lioteca # no se crea una aplicación( como es el caso cuando se tra*aja en un sólo archi+o la clase # la aplicación que hace uso de la clase1 csc =t1li*rar# =out1ClsPersona.Sueldo > OO.dll 'ecuerde que el s2itch =out no es o*ligatorio #a que se utili-a para especificar un nom*re distinto al nom*re del archi+o fuente( aunque es *uena práctica especificarlo #a que algunas aplicaciones no sólo tienen un archi+o fuente( entonces el compilador podr0a llamar a la *i*lioteca con el primer nom*re de archi+o fuente en la lista. pu*lic +oid /signar om*re&string sQalor)< s om*re > sQalor. pu*lic class ClsPersona< pri+ate int iSueldo.cs Si utili-a nom*res de espacio1 csc =r1S#stem. pu*lic int Sueldo< get<return iSueldo.

$os nom*res de espacio son definidos utili-ando la sentencia1 namespace Para m%ltiples ni+eles de organi-ación los namespaces pueden ser anidados1 namespace om*re amespace/< namespace om*re amespaceB< class om*reClase< pu*lic static +oid 9unction&)<@ @ @ @ !l código anterior puede ser simplificado de la siguiente manera1 namespace om*re amespace/. $os namespace en C# se utili-an para organi-ar programas # la jerarqu0a natural de la organi-ación facilita presentar los elementos de un programa a otros programas.Arite$ine&7 om*re 1 7 . om*re amespaceB< class om*reClase< pu*lic static +oid 9unction&)<@ @ @ $as colisiones entre tipos o nom*res de espacio que tienen el mismo nom*re se pueden resol+er utili-ando una +ariante de la cláusula using que permite definir un alias para la clase1 using /lias > S#stem. 3n namespace contiene tipos que pueden ser utili-ados en la construcción de programas1 clases( estructuras( enumeraciones( delegados e interfaces( por ejemplo para poder escri*ir a la consola se utili-a el namespace S#stem. o es o*ligatorio jerarqui-ar los namespace pero es una *uena práctica organi-ar los namespace creados de manera jerarquica para dar claridad a la aplicación. Console. !l propósito del uso de namespace hacen las clases fáciles de usar # pre+enir colisiones con las clases escritas por otros programadores. class om*reClase< pu*lic static +oid :ain&)< /lias.cs Nota para hacer uso de una clase es necesario que tenga el modificador de acceso pu*lic.Console. $os namespace son utiles para la organi-ación interna de aplicaciones. @ @ !n+ol+er Clases en amespace 79 .E/ son utili-ados para organi-ar las clases # otros tipos en una estructura jerarquica.. !mpleado. @ @ Compilación de Clientes !s necesario indicarle al compilador una referencia a la nue+a *i*lioteca de componentes C$$1 csc =r1 om*reComponente./signar om*re&7Herardo Nngeles a+a7). amespaces $os nom*res de espacio namespace en el runtime .dll om*reCliente.2*tener om*re&)).!mpleado.Arite$ine&7/lias de una clase7).

m. @ a+a7).Sueldo).cs 3tili-ar amespace en /plicaciones Cliente /l desarrollar componentes utili-ando namespace la aplicación cliente de*e importarlo1 using om*re!spacio. class i/plicClsPersona< pu*lic static +oid :ain&)< iPersona !mpleado > ne4 iPersona&).m. using om*re2tros!spacios.Arite$ine&7!dad 1 7 . 7 . pu*lic int Sueldo< get<return iSueldo. !mpleado. @ @ @ Compilar1 csc =t1li*rar# =out1iPersona. pu*lic +oid /signar om*re&string sQalor)< s om*re > sQalor.< pu*lic class iPersona< pri+ate int iSueldo. using informatique. @ pu*lic string 2*tener om*re&)< return s om*re.@ @ pu*lic string s om*re.com. namespace om*re!spacio< pu*lic class om*reClase< ==propiedades ==métodos @ @ !jemplo1 using S#stem.!s posi*le en+ol+er &2rapping) las clases en un namespace( para ello sólo es necesario utili-ar la pala*ra reser+ada namespace seguida de un nom*re que lo identifique # encerrar entre lla+es el código que deseamos pertene-ca a este.2*tener om*re&)).Sueldo > OO../signar om*re&7Herardo Nngeles Console. 80 . 2tra posi*ilidad es hacer una referencia a*soluta a los elementos del namespace( aunque para e+itar conflictos es preferi*le utili-ar la directi+a1 !jemplo1 using S#stem. !mpleado. !mpleado. namespace informatique.dll iPersona.@ set<iSueldo > +alue.Arite$ine&7 om*re 1 !mpleado.com. Console.

dll i/plicPersona.com.@ set<i'ueda > +alue. !mpleado. i5elice > 5elice. pri+ate int i:otor.cs archi+o9uenteG.iPersona&).dll archi+o9uenteJ.m.dll i/plicPersona/*s.Arite$ine&7!dad 1 7 ..cs /gregando otra clase al namespace informatique.@ Compilar1 csc =r1iPersona. Console.==/ereo( anfi*io( terrestre( espacial ==Constructor pu*lic iQehiculo&int 'ueda( int Puerta( int Qentana( ] int 5elice( int :otor( int /siento( string "ipo)< i'ueda > 'ueda.com.m.Sueldo > OO. pri+ate int i/siento. @ @ Compilar1 csc =r1iPersona/*s.. pri+ate int iPuerta. !mpleado.m.@ 81 . namespace informatique.m.2*tener om*re&)). !mpleado. iPuerta > Puerta. pri+ate int iQentana.iPersona !mpleado > informatique.cs !specificar de manera a*soluta el namespace1 using S#stem.com./signar om*re&7Herardo Nngeles a+a7). ne4 !mpleado. i/siento > /siento.< class iQehiculo< pri+ate int i'ueda. class i/plicClsPersona/*s< pu*lic static +oid :ain&)< informatique.cs /gregar :%ltiples Clases a 3n amespace !n el punto anterior en+ol+imos una clase a un namespace( pero es posi*le agregar # en+ol+er más clases o componentes al mismo namespace( sin importar que esten contenidos en diferentes archi+os( después de la compilación son parte del mismo namespace1 csc =t1li*rar# =out1 om*reComponente.Sueldo). s"ipo > "ipo. i:otor > :otor. pri+ate int i5elice.com. @ pu*lic int 'uedas< get<return i'ueda. pri+ate string s"ipo.1 using S#stem. Console. iQentana > Qentana.Arite$ine&7 om*re 1 7 .

82 . :i/+ion. class i/plic< pu*lic static +oid :ain&)< iPersona !mpleado > ne4 iPersona&).Puertas).m.@ @ pu*lic int Qentanas< get<return iQentana.Qentanas). Console. Console. !mpleado.2*tener om*re&)).dll iPersona.@ @ pu*lic int 5elices< get<return i5elice.@ set<iQentana > +alue.Arite$ine&7'uedas 1 7 .@ set<i5elice > +alue.Arite$ine&7 om*re 1 !mpleado.@ pu*lic int Puertas< get<return iPuerta.'uedas).@ set<iPuerta > +alue.m.Arite$ine&7Qentanas 1 7 .@ @ @ @ Compilar1 csc =t1li*rar# =out1informatique.com. Console.com. !mpleado. :i/+ion. a+a7).@ @ pu*lic string "ipo< get<return s"ipo./signar om*re&7Herardo Nngeles Console. ==Clase que está contenida en otro archi+o iQehiculo :i/+ion > ne4 iQehiculo&G(J(J??(?(O(G??(7/ereo7). :i/+ion.Sueldo).Arite$ine&7!dad 1 7 . using informatique. Console.cs iQehiculo.cs /plicación Cliente1 using S#stem.Sueldo > OO.@ set<i/siento > +alue..Arite$ine&7Puertas 1 7 . 7 .@ @ pu*lic int :otores< get<return i:otor.@ set<i:otor > +alue.@ @ pu*lic int /sientos< get<return i/siento.. !mpleado.@ set<s"ipo > +alue.

m.dll i/plic.dll Compilación Condicional $a Compilación Condicional permite e.cs . Console.Arite$ine&7"ipo 1 7 .5elices). amespace # !nsam*les 3n o*jeto puede ser utili-ado desde un archi+o fuente C# sólo si ese o*jeto puede ser locali-ado por el compilador C#( por default el compilador sólo a*re el ensam*le conocido como mscorli*. :i/+ion. Console. !l compilador de C# no soporta macros( en cam*io soporta las siguientes directi+as1    1efinición de s2mbolos E%clusión de código basado en s2mbolos "an amiento de errores y advertencias Cefinición de s0m*olos $a 1efinición de s2mbolos es utili-ada para e. 83 .com.cluir o incluir código dependiendo si son o no son definidos ciertos s0m*olos. et residen en el ensam*le S#stem. :i/+ion.ecuerde que sus clases de*en tener el modificador de acceso public( de lo contrario el compilador notificara un error &error "S#*==! is inaccessible due to its protection le(el)( por lo que tendrá que agregar el modificador de acceso # #ol#er a compilar.:otores). Para referenciar o*jetos locali-ados en otros ensam*les( el nom*re del archi+o de ensam*le de*e ser pasado al compilador( esto es posi*le utili-ando un s2itch al compilar1 =r1nom*re!nsam*le !s as0 como se crea un correlación entre el namespace de un o*jeto # el nom*re del ensam*le en el cual reside( por ejemplo los tipos de namespace en el S#stem..isten dos formas de hacer esto1   8so del !reprocesador /tributo conditional 3so del Preprocesador C# el compilador emula el preprocesador( #a que no ha# un preprocesador por separado. et."ipo). 3na forma para definir un s0m*olo es utili-ando la directi+a #define en un archi+o fuente C#( está definición de*erá reali-arse antes de cualquier otra sentencia1 #define C!B3H #define '!$!/S! !n este caso #define C!B3H( define un s0m*olo C!B3H # su ám*ito es el archi+o donde es definido( al igual que el s0m*olo '!$!/S!.cluir o incluir código( en C# e. @ @ Compilar1 csc =r1informatique. :i/+ion.Arite$ine&7:otores 1 7 . Console.Arite$ine&7/sientos 1 7 .Arite$ine&75elices 1 7 .Console.dll( el cual contiene las funciones principales para el C$'. :i/+ion./sientos).

) csc =define1C!B3H('!$!/S!(C!:2Q!'SD2 nom*re/rchi+o. sentencia.clusión de código *asado en s0m*olos !l principal propósito de los s0m*olos es la inclusión o e. #else sentencia.cs Si se requiere definir m%ltiples s0m*olos utili-ando el compilador( es necesario separar cada s0m*olo con una coma &.cs Si el código fuente inclu#e directi+as de definición de s0m*olos( es posi*le desha*ilitarlas utili-ando la directi+a #undef cu#o ám*ito tam*ién corresponde al archi+o donde es definida1 #undef C!B3H !. #elif SD:B2$2]B bb SD:B2$2]C .clusión condicional del código( *asado so*re si son o no son definidos los s0m*olos. #endif @ @ $an-amiento de errores # ad+ertencias !. . #if 2:B'!]SD:B2$2 sentencia.iste otro uso de las directi+as del preprocesador para lan-ar errores del compilador o ad+ertencias dependiendo de ciertos s0m*olos( para ello se utili-an las directi+as1 84 . class om*reClase< pu*lic static +oid :ain&)< #if SD:B2$2]/ . #endif . !l siguiente código no define s0m*olos en el archi+o fuente1 .cs $as directi+as del preprocesador emulado utili-adas para e+aluar el s0m*olo son1 #if( #else # #endif las cuales actuan como su contraparte( la sentencia condicional if C#( es posi*le utili-ar bb( dd # [1 ==#define SD:B2$2]/ #define SD:B2$2]B #define SD:B2$2]C #if SD:B2$2]/ #undef SD:B2$2]C #endif using S#stem. #else . Pero es posi*le definir o no los s0m*olos al compilar la aplicación1 csc =define1 2:B'!]SD:B2$2 om*re/plicacion.2tra forma utili-ada para definir s0m*olos es usar el compilador # es de ám*ito glo*al para todos los archi+os1 csc =define1C!B3H nom*re/rchi+o.

#if SD:B2$2]A/' D H #error Presentar el mensaje de ad+ertencia correspondiente #endif /tri*uto conditional 3n atri*uto conditional e+alua la in+ocación de una función cuando sierto s0m*olo es definido # e+alua a nada cuando una +ersión li*erada es construida. 3n atri*uto conditional de*e tener un tipo +oid de regreso( cualquier otro tipo de regreso no es permitido.L=summar#Z !n caso de requerir más una l0nea para el comentario de documentación utilice el tag1 ===LparaZ ===. Econditional&7 2:B'!]SD:B2$27)F método / Econditional&7 2:B'!]SD:B2$27)F método B . ===L=paraZ !n caso de requerir una referencia a otros elementos utilice el tag1 ===Lsee cref>7 om*re!lemento7=Z !n caso de requerir una referencia a un tópico de interes utilice1 ===Lseealso cref>7S#stem. $a salida que es generada por el compilador es R:$ puro # puede ser utili-ada como entrada para la documentación de un componente.  #7arning #error Por ejemplo #if SD:B2$2]!''2' #error Presentar el mensaje de error correspondiente #endif . et7=Z 3n tag contrario a summar#( para un +olumen ma#or de documentación es1 ===LremarVsZ !s posi*le incluir listas utili-ando los tags 1 ===Llist t#pe>7*ullet7Z 85 . . !lementos R:$ Nota1 todo comentario de documentación son tags R:$ &eRtensi*le :arVup $anguage). Para descri*ir un elemento se utili-a el tag Lsummar#ZL=summar#Z( el cual se escri*e en el código fuente anteponiendo tres diagonales que son indicati+o de un comentario de documentación1 ===Lsummar#ZCescripción.tremadamente importante del soft4are # en especial de los componentes por ser utili-ados por otros desarrolladores. Comentarios de Cocumentación en R:$ !s posi*le construir automáticamente la Cocumentación utili-ando comentarios en el código... $a documentación es una parte e. ===.

..cc !jemplo1 using S#stem.L=+alueZ 3na +e.que el proceso de documentación para un componente es terminado( es posi*le crear un archi+o R:$ *asado en la documentación descrita en el código fuente # hacerla disponi*le a quienes utilicen el componente( para ello simplemente se utili-a al compilar el s2itch =doc1 seguido del documento R:$.ml /plicPersona. csc =doc1Persona. ===3tili-ado para asignar el +alor de la propiedad s om*re 86 . ===L=e. === === Clase Persona === /utor 1 Herardo Nngeles a+a === 9echa 1 J?=?W=G??I === Cescripción 1 Clase que define lo que es # puede hacer una persona === === class Persona< ===$a propiedad iSueldo se emplea para o*tener # asignar el +alor del sueldo de una persona pri+ate int iSueldo.ampleZ === . pu*lic int Sueldo< get<return iSueldo.ampleZ Para descri*ir los parámetros de regreso utilice1 ===LreturnsZ === LparaZtrue1 +alor o*tenidoL=paraZ === LparaZfalse1 +alor no o*tenidoL=paraZ ===L=returnsZ Para descri*ir propiedades de clase se utili-a un tag especial1 ===L+alueZPropiedad.@ set<iSueldo > +alue..=== === LitemZConstructor Lsee cref>7Constructor&)7=Z === Lsee cref>7Constructor&string)7=Z === L=itemZ ===L=listZ Para descri*ir parámetros se utili-a el tag1 ===Lparamref name>7nom*reParametro7=Z !s posi*le encerrar en un tag un ejemplo completo e incluir la descripción # código1 ===Le. === L=codeZ === . === LcodeZ === .@ @ pu*lic string s om*re.

  N. Console. @ @ class /plicPersona< pu*lic static +oid :ain&)< Persona !mpleado > ne4 Persona&).istir errores el compilador lo notificará # a%n as0 el documento R:$ es generado pero tendrá un mensaje de error. 3n Componente . $os parámetros para métodos son encerrados entre paréntesis # separados por comas &.Arite$ine&7 om*re 1 7 .      Si un elemento tiene per0odos en su nom*re( estos son reempla-ados por el s0m*olo #. enumeración o delegado 5.NET es la unidad fundamental reusa*le # compartida en el C$'( un componente . @ @ &alida1 para +er el documento R:$ generado de clic aqu0. identifica un tipo. denota eventos P. '. !mpleado. identifica un m.2*tener om*re&)). !" !l compilador de C# por default siempre crea componentes . incluyendo constructores y operadores. @ pu*lic string 2*tener om*re&)< return s om*re. Componentes ./signar om*re&7Herardo Nngeles a+a7).Sueldo > OO. denota un error el cual provee información acerca de una liga #ue el compilador C# no pudo resolver. estructura. !l compilador reali-ará +alidación so*re los tags R:$ en el archi+o fuente( en caso de e. 3na aplicación puede contener m%ltiples componentes .n puede ser un ind2ce o propiedad 2ndice.pu*lic +oid /signar om*re&string sQalor)< s om*re > sQalor. Console. se refiere a una propiedad la cual tambi. !mpleado.). !" para los ejecuta*les. !" contiene cuatro partes referentes al n%mero de +ersión llamado (ersión compatible1 87 . E. describe un campo o clase !. !l documento R:$ tendrá algunos identificadores seguidos de dos puntos &=) # la ruta del namespace( los cuales por ejemplo tienen los siguiente significados.todo. denota un namespace T. interface.Sueldo). el cual puede ser una clase.!mpleado.Arite$ine&7!dad 1 7 . !" tam*ién es limitante para asegurar la seguridad( permite la distri*ución de clases # resolución de tipos. !mpleado. !" 3n componente .

e.aminar las entradas agregadas al 0egistr.cs !l s2itch =a.J. Se considera una Q9! &QuicV 9i.*uild num*er. !" de*erán ser capaces de in+ocar componentes C2: # componentes C2: de*erán hacer uso de los nue+os componentes . !" que cargará( en caso de e.?( esto puede compro*arse en las propiedades del archi+o.minor +ersion. !" utili-ando el s2itch =reference1nom*reBi*lioteca la información de dependencia registra las herramientas de desarrollo( inclu#endo la +ersión de las *i*liotecas ligadas( este registro se hace en un manifiesto # el C$' los n%meros de +ersión contenidos para cargar la +ersión apropiada de un componente .major +ersion. 3so de Componentes . Se podr0a considerar una versión compatible cuando el *uild num*er es diferente a la +ersión solicitada.. !jemplo1 '!H!CD"P 88 .reg /hora puede e. !" se utili-a regasm.+ersion1J.+ersion crea una *i*lioteca con el (ersion in)ormation J. !" que reside en el directorio de la aplicación es considerado privado # no es (ersion1chec3ed Componentes . Se considera una versión incompatible cuando major +ersion.?.minor +ersion es diferente de la +ersión solicitada.?. !ngineering) compati*le cuando re+ision es diferente.J. # tam*ién crear un archi+o 0egistr. !" Compartidos Si se requiere construir soft4are que se comparta con otras aplicaciones( el componente . /demás del n%mero de +ersión &(ersión compatible) se almacena otro n%mero en el componente llamado in)ormational (ersion( el cual es considerado sólo para propósitos de documentación # su contenido podr0a ser SuperControl Build JYY?( el contenido representa algo humano # no para la máquina. !" de*erá ser instalado como compartido.e( esta herramienta permite registrar un componente .dll. !" en Componentes C2: $a interopera*ilidad permite a clientes C2: utili-ar componentes . !" en el 0egistr.? =t1li*rar# =out1nom*re/rchi+o9uente. Si requiere e. Nota asegurese de que el directorio en el que se encuentra e. !" Pri+ados /l ligar una aplicación a un componente . Cualquier componente .dll o escri*a la ruta completa de su u*icación.dll nom*re/rchi+o9uente.aminar el archi+o generado nom*re/rchi+oComponente.ista el archi+o . !"( esta es una caracter0stica de iteropera*ilidad proporcionada por la plataforma . !"( para hacer esto posi*le en C2: primero es necesario registrar un o*jeto antes de poder ser utili-ado( para registrar un o*jeto C2: se utili-a la aplicación regs+rOG # para registrar un componente . Para indicar al compilador que agregue un (ersion in)ormation al componente se utili-a el s2itch1 csc =a. !" dependiente en tiempo de ejecución.dll =regfile1nom*re/rchi+oComponente. !" para todos los lenguajes de programación que emiten código administrado.re+ision $a (ersión compatible es utili-ada por el class loader para decidir cual es la +ersión del componente . Dnteropera*ilidad C2: C)' es una técnica de interopera*ilidad( por lo que los clientes . escri*a en la l0nea de comandos1 regasm nom*reComponente. Componentes .istir diferentes +ersiones.reg.

#.iPersonaF h>7informatique. 6ersionJ#.*. !"( es necesario en+ol+er el código unsa)e( cuando la en+oltura o 2rapper es in+ocada( un 'CA &0untime "allable Mrapper) es construido desde la información de la *i*lioteca 89 .com. !l Componente .E5X!g]C$/SS!S]'22"informatique. !" tl*e.p nom*reComponente.com.4E==K E5X!g]C$/SS!S]'22"C$SDC<O\I?PGGP8GJO/8OWPO8YPI/8 !I\G\IY!PJ\P@DnprocSer+erOG.iPersona7 E5X!g]C$/SS!S]'22"informatique.#.com.com.iPersona7 >?@EAB"+CSSESB0--/"+S5'DE7$#4==41=*EC1E%4E1F4$C1 E$7=7$FE4*74G5nprocSer(erE=H IJKmscoree.dllK K/hreadingModelKJKBothK K"lassKJKin)ormatique. !l motor de ejecución es responsa*le de pro+eer la CCA &"-M "allable Mrapper) al o*jeto.dll es in+ocado cuando una instancia del o*jeto &componente registrado) es requerida( más no la *i*lioteca por si sóla.m..p la cual permite generar una *i*lioteca tipo para el componente .?F 7Class7>7informatique.?./o3enJnullK K0untime6ersionKJK(*.?...m. "ultureJneutral.#.com.m. !" $os Clientes . Para que sea posi*le in+ocar un componente C2: desde un o*jeto . 3na +e. !" # todas las clases #a están registradas # se tiene una *i*lioteca tipo para am*ientes 3so de Componentes C2: en Componentes ..?( Culture>neutral( Pu*licXe#"oVen>null7 7'untimeQersion7>7+J.iPersona7 E5X!g]C$/SS!S]'22"C$SDC<O\I?PGGP8GJO/8OWPO8YPI/8 !I\G\IY!PJ\P@Dmplemented Categories] <KGCY9!KI8P!BB8PI!\8BPP?8K!OWBGCCB9GW@F !l motor de ejecución mscoree. !" pueden interoperar con o*jetos clásicos C2:( para que un componente utilise C2: de*e tener una *i*lioteca tipo para el C$' esto se traduce a los metadatos que son almacenados con los tipos.iPersonaC$SDCF h>7<O\I?PGGP8GJO/8OWPO8YPI/8!I\G\IY!PJ\P@7 E5X!g]C$/SS!S]'22"C$SDC<O\I?PGGP8GJO/8OWPO8YPI/8 !I\G\IY!PJ\P@F h>7informatique.m.com.iPersona7 7/ssem*l#7>7iPersona( Qersion>?.dll =out1nom*reBi*lioteca.KJKiLersona.. Lublic@e..J.iLersonaK KCssembl.com.tl* !sta *i*lioteca tipo puede ser utili-ada en lenguajes de programación que soporten esta +inculación.?.POGG7 E5X!g]C$/SS!S]'22"C$SDC<O\I?PGGP8GJO/8OWPO8YPI/8 !I\G\IY!PJ\P@ProgDdF h>7informatique.?.registrado el componente puede ser utili-ado por lenguajes de programación que soporten esta +inculación( tam*ién es posi*le emplear la utileria tl*e.m.m.m7.

fi%ed.dll. el cual puede ser aplicado a constructores.dll !sta herramienta importa el tipo de *i*lioteca C2:( crea # almacena un 'CA que puede ser utili-ado en el C$' en el archi+o nom*reBi*lioteca. PDn+oVe se encarga de ejecutar la función correcta # tam*ién de la colocación de los argumentos para # desde sus contrapartes unmanaged.tipo. !" incorpora dos herramientas de depuración de errores1   C). depurador de l2nea de comando &1Y.16. cuando re#uiera reali ar acciones no seguras se debe envolver el código correspondiente con este modificador. 3na herramienta genera el código 2rapper *asado en la información o*tenida de la *i*lioteca tipo. al declarar una variable con este modificador previene al recolector de basura de reacomodarlo. Simplemente utilice el atri*uto s#simport al definir un método e. Dn+ocación de Ser+icios Se se requiere in+ocar una función pro+ista por el AD OG o alguna C$$ unmanaged( se utili-an los &ervicios de invocación de plataforma &PDn+oVe).dll =out1nom*reBi*lioteca.pe librar..e. m.terno1 Es#simport& dll > nom*reC$$( name > punto!ntrada( cgarset > conjuntoCaracteres F 3nicamente el argumento dll es o*ligatorio # los demás opcionales( aunque si se omite el atri*uto name( el nom*re de la función de implementación e. Para +er los metadatos para el 'CA utilice ildasm. !" que utili-a el componente C2:. depurador 80  El depurador &1Y no soporta la depuración de código nativo.  Ce*ugging !l SCX .e( as0 podrá distinguir el nom*re de la clase que fué generada para el o*jeto C2: original( esta información es una a#uda para poder escri*ir el o*jeto . Código o Seguro Si requiere de escri*ir código no seguro( de*erá utili-ar dos pala*ras reser+adas1  unsafe. sólo es posible depurar código administrado.terna de*e coincidir con el nom*re del método estático interno. No es posible la depuración de una m$#uina remota &indo$ register y disassembly aun#ue se implementan no son funcionales   90 . denota un conte%to no seguro. import)1 tl*imp nom*reComponente.todos y propiedades. $a herramienta a utili-ar es tlimp &t.

e # nom*re/rchi+o9uente.cepción no es controlada apropiadamente por el código se muestra la +entana de depuración llamada SD" just in time.cs !stos comandos utili-ados al compilar crea dos archi+os1 nom*re/rchi+o9uente. interrumpe la ejecución cuando una dirección de memoria espec2fica se alcan a    3na +e.que se interrumpe la ejecución( es posi*le continuarla utili-ando los comandos1     &tep )ver &tep 0nto &tep )ut .cepciones son un punto e. interrumpe la ejecución cuando una variable cambia a un valor especifico 5unction.e. interrumpe la ejecución cuando una ubicación espec2fica en el archivo fuente se alcan a 1ata.e.que la aplicación depuradora comien-a se selecciona el programa que se desea depurar en donde será tam*ién posi*le especificar argumentos en la l0nea de comandos( mismos que son pasados a la aplicación cuando la sesión de depuración inicia.pd* Para configurar la sesión de depuración es necesario seleccionar la aplicación que se desea depurar # comen-ar el depurador SCX ejecutando d*gurt.celente de comien-o para una sesión de depuración( cuando una e. nom*re/rchi+o9uente. Para crear una +ersión depurada son necesarios dos s2itches al compilar1 csc =optimi-e8 =de*ug.e( el cual esta almacenado en el directorio Program9iles HASSCXHuiCe*ug 3na +e. $as e. Seguridad 5o# en d0a el código +iene de distintas fuentes( no solo el que es instalado +ia un setup por el ser+idor( tam*ién puede ser instalado +ia una página 4e* o correo electrónico. !s posi*le esta*lecer diferentes tipos de brea3point1  5ile. 91 ./ntes de depurar el código de una aplicación es necesario crear una +ersión depurada( la cual contiene información de depuración no optimi-ada # un archi+o adicional PCB &program database) para depuración # un estado de información del pro#ecto es creado. interrumpe la ejecución en una ubicación espec2fica dentro de una función espec2fica /ddress.un to Cursor !s posi*le modificar +alores de +aria*les simplemente dando do*le clic en la columna +alor de aquella +aria*le que se desea modificar( as0 como tam*ién es posi*le o*ser+ar las +aria*les( para ello es necesario dar clic en la columna nom*re # escri*ir el nom*re de las +aria*les que se desean o*ser+ar.

para ello el código administrado debe ser verificado como tipo seguro. El código C# es de tipo no seguro. es decir. 9unciones de la seguridad de acceso al código1  El administrador puede definir las pol2ticas de seguridad asignando ciertos permisos para definir grupos de código. definiendo operaciones permitidas por las pol2ticas de seguridad. Cada acceso a tipos se reali a sólo en un sentido permitido. evadiendo hoyos de seguridad #ue son creados cuando código menos confiable invoca código altamente confiable. reali ando che#ueos para verificar #ue los permisos otorgados a #uien invoca *caller+ coincidan con el permiso re#uerido para la operación. para determinar cuando el código es seguro. verificar los permisos indispensables. !" plantea dos posi*les soluciones para la seguridad1   &eguridad de acceso al código &eguridad basada en roles Seguridad de acceso al código $a &eguridad de acceso al código controla el acceso protegiendo los recursos # operaciones. El código puede re#uerir #ue #uien invoca *caller+ debe tener permisos especificos "a ejecución de código est$ restringido en tiempo de ejecución.. 92 . pero el 0" y los metadatos son inspeccionados antes de dar el visto bueno del tipo de seguridad del código. El código puede re#uerir los permisos necesarios de ejecución y los permisos #ue podr2an ser utili ados. este otorgamiento esta basado en el re#uerimiento del código. el runtime for a la restricción de seguridad del código administrado. !l código es confia*le en distintos grados( dependiendo su identidad # de donde +iene. Es importante #ue el runtime sea capa de checar los permisos de #uien invoca de manera confiable.isten dos puntos importantes de la seguridad de acceso al código( donde el requerimiento m0nimo para *eneficiarse de la seguridad de acceso al código es para generar un código de tipo seguro.  (erificar el tipo de seguridad del código administrado. "a seguridad de acceso al código otorga permisos cuando un componente es cargado.      !. "os permisos son definidos para representar ciertos derechos para acceder a distintos recursos del sistema.

      93 .  Permisos !stándar $os !ermisos Est$ndar son1  Environment!ermission. el beneficio de activar el re#uerimiento de permisos es conocer cuando se tiene el permiso apropiado para reali ar acciones y cuando no. tiempo de e%piración y almacenamiento de datos. este acceso permite utili ación. seriali ación. de s'lo lectura y escritura al valor de una variable de ambiente. se utili a para restringir vulnerabilidades potenciales.egistry!ermission. 0solated&torage!ermission. 5ile1ialog!ermission. donde son posibles dos tipos de acceso. !ermisos #ue son re#ueridos por el código. "os permisos m2nimos garanti an #ue el código se ejecute con los recursos justos cuando el código re#uiere de muchos permisos sin #ue falle. aun#ue la pol2tica de seguridad lo permita. invocación de código no administrado. permisos #ue no son obligatorios para la ejecución correcta del código. clase #ue define permisos de acceso a variables de ambiente. etc. )ptional.eflection!ermission. 5ile0)!ermission. el acceso lectura incluye acceder a la información del archivo. . $a categoria de los permisos es1   . Control de lectura.eflection. controla el acceso a archivos basado en el sistema de archivos de di$logo. permiso #ue se necesita para #ue el código nunca se otorgue. el tipo escritura incluye eliminar y sobreescribir. colección de permisos simples #ue son utili ados por el sistema de seguridad. el acceso adición no permite leer otros bits. pero #ue podr2a ser bueno tenerlos.e#uired. sobreescritura de che#ueos de seguridad.Emit . es posible especificar tres tipos de acceso a archivos de entrada y salida= lectura. escritura y adici'n. Es posible prevenir al código de el otorgamiento de permisos adicionales #ue no son necesarios. El usuario debe autori ar el acceso al archivo via el cuadro de di$logo. controla la capacidad de leer el tipo de información de tipos miembro no públicos y controla el uso de . tama:o de almacenamiento. creación y escritura en el registry &ecurity!ermission. . controla el acceso a almacenamientos aislados.efused. El tipo de acceso escritura incluye permisos para crear y eliminar variables de ambiente. permiso #ue el código necesita para ejecutarse correctamente. es posible controlar la ejecución de código.

NET provee resistencia de soft7are publisher &trongName0dentity!ermission. permisos derivados basados en 8.isten tres tipos de principal1   . incluyendo el uso de 7indo7s. 94 . define la ona de donde el código tiene origen. define el nombre del componente criptograficamente. define el acceso a varios aspectos de la interfa de usuario. !. un 8. Permisos Ddentidad $os !ermisos 0dentidad son1  !ubilsher0dentity!ermission. 3n role es un nom*re para un conjunto de usuarios quienes comparten los mismos pri+ilegios. 3n principal no necesariamente es un usuario( tam*ién puede ser un agente.  $a clase Principalpermission pro+ee consistencia con la seguridad de acceso( permitiendo al runtime reali-ar la autori-ación en un sentido similar al chequeo de la seguridad de acceso al código( pero es posi*le acceder directamente a la información de identidad principal # reali-ar chequeos de role e identidad en el código cuando sea necesario. definido por una aplicación. Custom principals. !" hacen decisiones *asadas en la identidad principal o su role como miem*ro. 80!ermission. !ueden e%tender la noción b$sica de la identidad y los roles del principal." de donde el código tiene origen     Seguridad *asada en roles $a &eguridad basada en roles representa a un usuario o agente que actua en representación de un usuario dado." puede pertenecer a sólo una ona &ite0dentity!ermission. Zone0dentity!ermission. relación de usuarios 7indo7s y sus roles.eneric principals. 9unción "oString&) /nalice el siguiente ejemplo1 using S#stem. ya #ue el nombre compromete la identidad. 9indo7s principals. "a restricción es #ue la aplicación debe proveer un módulo de autentificación de los tipos #ue el principal puede implementar."0dentity!ermission. $as aplicaciones . el acceso a recursos de otro usuario es permitido. representa usuarios no autentificados. permisos derivados basados en el sitio 7eb de donde el código tiene origen 8. acceso a eventos y uso del portapapeles. la firma de componentes . 3n principal puede ser un miem*ro de m%ltiples roles # de esta manera se puede utili-ar un role para determinar si ciertas acciones requeridas qui-á sean reali-adas por un principal.

string p4d.p4d > p4d. class !mpleado< string usr.p4d > p4d. string p4d. pu*lic !mpleado&string login( string p4d)< this. Console.is del operador( estos operadores de*en ser redefinidos en pares( no pueden ser redefinidos separadamente. @ @ class /pp< pu*lic static +oid :ain&)< !mpleado empleado > ne4 !mpleado&7gangeles7(7JGO7). this. this.usr > login. @ 95 . pu*lic !mpleado&string login( string p4d)< this. p4d). this. !s posi*le especificar algo con ma#or sentido para ello se necesita redefinir la función "oString&)1 using S#stem. @ pu*lic o+erride string "oString&)< return&73suario 1 7 . string p4d. @ @ class /pp< pu*lic static +oid :ain&)< !mpleado empleado > ne4 !mpleado&7gangeles7(7JGO7).class !mpleado< string usr. usr . 7( Pass4ord 1 7 . class !mpleado< string usr. Console.Arite$ine&7!mpleado 1 7 . @ @ &alida1 !mpleado 1 !mpleado $a salida fue el nom*re de la clase !mpleado #a que es la representación más cercana que encontro.usr > login. !jemplo1 using S#stem.usr > login. @ @ &alida1 3suario 1 gangeles( Pass4ord 1 JGO 9unción !quals&) $a función !quals&) es utili-ada para determinar cuando dos o*jetos tienen el mismo contenido. !n el siguiente ejemplo se redefinen las funciones operator>>&) # operator[>&)( para permitir la sinta.p4d > p4d. pu*lic !mpleado&string login( string p4d)< this.Arite$ine&empleado). empleado).

p4d > p4d. !mpleado empleadoG > ne4 !mpleado&7gangeles7(7JGO7).!quals&empB). string p4d. @ pu*lic o+erride string "oString&)< return&73suario 1 7 . class !mpleado< string usr.usr > login. Cuando se in+oca la función !quals&) # dos o*jetos son iguales siempre se de*e regresar el mismo código hash.@ if&p4d [> empB. if&usr [> empB. @ pu*lic o+erride *ool !quals&o*ject o)< !mpleado empB > &!mpleado)o. 7( Pass4ord 1 7 .Arite$ine&7!l empleadoJ es igual al empleadoG1 7.usr)<return false. Console.!quals&empleadoG)).Arite&7empleadoJ >> empleadoG 1 7).@ return true. usr . @ pu*lic static *ool operator>>&!mpleado emp/( !mpleado empB)< return emp/.Arite&empleadoJ >> empleadoG).p4d)<return false. @ pu*lic o+erride *ool !quals&o*ject o)< !mpleado empB > &!mpleado)o. 96 . Si no es redefinido el código hash podr0a ser sólo identico para la misma instancia de un o*jeto # una *%squeda para un o*jeto que es igual pero no la misma instancia podr0a fallar.iste un +alor %nico el código hash de*er0a ser creado fuera de los +alores contenidos en la función. @ pu*lic static *ool operator[>&!mpleado emp/( !mpleado empB)< return [emp/.!quals&empB). 7( Pass4ord 1 7 . Console. pu*lic !mpleado&string login( string p4d)< this.empleadoJ. Si la clase no tiene un identificador %nico pero tiene tiene otros campos( podr0as ser utili-ados por la función hash1 using S#stem. p4d). !s posi*le utili-ar un miem*ro que es %nico para el código hash( pero si no e. Console. @ @ &alida1 !l empleadoJ es igual al empleadoG 1 "rue empleadoJ >> empleadoG 1 "rue /l compilar el ejemplo anterior se presentara un 2arning indicando que no fue redefinada la función Het5ashCode&) #a que los +alores que regresa son requeridos para ser relacionados al +alor de regreso de !quals&). usr . this.pu*lic o+erride string "oString&)< return&73suario 1 7 . @ @ class /pp< pu*lic static +oid :ain&)< !mpleado empleadoJ > ne4 !mpleado&7gangeles7(7JGO7). p4d).

@ if&p4d [> empB. int id. p4d. Console.usr)<return false.empleadoJ.@ return true.nom*re > nom*re. @ pu*lic o+erride int Het5ashCode&)< return usr. pu*lic $enguaje&string nom*re( int id)< this. @ int DCompara*le.id)<return J.Arite$ine&7!l empleadoJ es igual al empleadoG1 7.Collections. Clase 5ashta*le $a clase 5ashta*le es mu# utili-ada para reali-ar una *%squeda de o*jetos por una lla+e. this. !mpleado empleadoG > ne4 !mpleado&7gangeles7(7JGO7).if&usr [> empB.id Z lenguajeB. @ pu*lic static *ool operator[>&!mpleado emp/( !mpleado empB)< return [emp/.Het5ashCode&) .id)< 97 .!quals&empB). Console.Het5ashCode&).p4d)<return false.@ if&this. @ pu*lic static *ool operator>>&!mpleado emp/( !mpleado empB)< return emp/.!quals&empB).id > id. 3na ta*la hash utili-a esta lla+e para limitar drasticamente el n%mero de o*jetos que de*en ser *uscados para encontrar un o*jeto espec0fico en una colección de o*jetos. if&this. using S#stem.Compare"o&o*ject o)< $enguaje lenguajeB > &$enguaje)o. Dnterface D5ashCodePro+ider Si requiere definir diferentes códigos hash para un o*jeto espec0fico( podr0a hacer esto implementado la Dnterface D5ashCodePro+ider para pro+eer una función alterna hash # además de que se requiere una coincidencia de la implementación de DComparer( estas nue+as implementaciones son pasadas al contructor de la 5ashta*le1 using S#stem.Arite&7empleadoJ >> empleadoG 1 7). 3na ta*la hash tra*aja utili-ando una función hash( la cual produce un entero lla+e para una instancia espec0fica de una clase( donde esta lla+e es una +ersión condensada de la instancia.id L lenguajeB. Console. @ @ class /pp< pu*lic static +oid :ain&)< !mpleado empleadoJ > ne4 !mpleado&7gangeles7(7JGO7).Arite&empleadoJ >> empleadoG).!quals&empleadoG)). pu*lic class $enguaje 1 DCompara*le< pu*lic string nom*re. @ @ $a implementación del código Het5ashCode anterior agrega los elementos # los regresa.

@ @ pu*lic o+erride string "oString&)< return nom*re . $enguaje lenB > &$enguaje)oB.return 8J. @ @ @ class 5ash om*reCls 1 D5ashCodePro+ider< pu*lic int Het5ashCode&o*ject o)< $enguaje len > &$enguaje)o. @ pu*lic o+erride int Het5ashCode&)< return id. a$enguajeEJF > ne4 $enguaje&7/ctionScript7(I). return len. a$enguajeEGF > ne4 $enguaje&7Sa+aScript7(G).nom*re. a$enguajeE?F > ne4 $enguaje&7C7(O).Het5ashCode&). @else< return ?. @ @ class /pp< pu*lic static +oid :ain&)< $enguajeEF a$enguaje > ne4 $enguajeEIF.5ash om*re( $enguaje.2rdenaPor om*re). return String. @ @ pu*lic static D5ashCodePro+ider 5ash om*re< get< return &D5ashCodePro+ider) 5ash om*reCls&). id. @ pu*lic static DComparer 2rdenaPor om*re< get< return &DComparer) ne4 2rdena om*res&). @ @ pu*lic class 2rdena om*res 1 DComparer< pu*lic int Compare&o*ject o/( o*ject oB)< $enguaje len/ > &$enguaje)o/. a$enguajeEOF > ne4 $enguaje&7Sa+a7(Y). 5ashta*le lenguajes > ne4 5ashta*le&$enguaje.nom*re(lenB. 7 7 .nom*re). ne4 98 . a$enguajeEPF > ne4 $enguaje&7P5P7(J).Compare&len/.

lenguajes.Arite$ine&7miClon 1 7 .saludo.Arite$ine&7miClase 1 7 .saludo. Console. Console. pu*lic :iClase&string s)<this. @ @ class :iClase< pu*lic Saludo saludo.@ @ class /pp< pu*lic static +oid :ain&)< :iClase miClase > ne4 :iClase&75ello Aorld[7).s). miClase. miClon. @ @ 9unción DClona*le $a función o*ject.saludo./dd&a$enguajeEGF( 7sdf7). Console.saludo. $a implementación por default de esta función produce una copia de un o*jeto( los campos de un o*jeto son copiados e.c7). pu*lic Saludo&string s)< this."oString&)( s).actamente en lugar de ser duplicados1 using S#stem.saludo > ne4 Saludo&s). lenguajes.s > s. string s > &string) lenguajesEcloneF.s).lenguajes. Console.Arite$ine&clone.s). miClase.s > 75ola :undo7. lenguajes.Arite$ine&7miClon 1 7 . class Saludo< pu*lic string s. Console.:em*erAiseClone&) puede ser utili-ada para crear un clon de un o*jeto.saludo. :iClase miClon > miClase. miClon./dd&a$enguajeEOF( 74er7). Dnterface DClonea*le Para crear una copia deep( donde una nue+a instancia de Saludo es creada para para la nue+a instancia de :iClase( para ello se hace una implementación de la interface DClonea*le1 99 . @ @ &alida1 miClase 1 5ello Aorld[ miClon 1 5ello Aorld[ miClase 1 5ola :undo miClon 1 5ola :undo !l resultado anterior es porque la copia hecha por la función :em*erAiseClonre&) es una copia( el +alor de saludo es el mismo en am*os o*jetos por lo que se se cam*ia un +alor dentro del o*jeto Saludo afecta am*as instancias de :iClase.Arite$ine&7miClase 1 7 ./dd&a$enguajeEPF( 7tgh7). $enguaje clone > ne4 $enguaje&7:i$enguaje7( JGOPI)./dd&a$enguajeEJF( 7*nm7)./dd&a$enguajeE?F( 7-.s).Clon&). miClon. lenguajes.@ pu*lic :iClase Clon&)<return &:iClase):em*er4iseClone&).

s > 75ola :undo[7.@KL.saludo > ne4 Saludo&s).YW\\).saludo. !ste formato consiste del formato espec0fico del caracter seguido de la secuencia de precisión espec0fica de digitos( los formatos soportados son1 9ormato Cescripción C( c C( d Currenc# Cecimal !jemplo Console.Clone&).Arite$ine&7?1C\7 ( JGOPI). pu*lic Saludo&string s)< this. :iClase miClon > &:iClase) miClase.using S#stem.9ormat&) la cual in+oca a la función 9ormat&) de cada tipo de dato o Console. 9ormato umérico $os tipos numéricos son formateados a tra+és de la función miem*ro 9ormat&) del tipo de dato( la cual puede ser in+ocada directamente a tra+és de String.Arite$ine&) la cual in+oca a String. Note que en este caso DClonea*le requiere implementar la función Clone&).saludo.s). !.@ @ class /pp< pu*lic static +oid :ain&)< :iClase miClase > ne4 :iClase&75ello Aorld[7).saludo.isten dos tipos de métodos para el formateo espec0fico numérico1 9ormato !stándar String 5ormato Est$ndar &tring( el cual puede ser utili-ado para con+ertir un tipo numérico a una representación espec0fica string. miClon. pu*lic :iClase&string s)<this.s).s).9ormat&).Arite$ine&7miClase 1 7 .Arite$ine&7?1C7( JGO. miClase. miClon.Arite$ine&7miClon 1 7 . miClase.saludo. @ @ class :iClase 1 DClonea*le< pu*lic Saludo saludo.saludo.s). Console.s)).@ pu*lic o*ject Clone&)<return &ne4 :iClase&this. Console.s > s. miClon.XH HHJA@KL 100 .saludo.Arite$ine&7miClon 1 7 . Salida [JA@. @ @ &alida1 miClase 1 5ello Aorld[ miClon 1 5ello Aorld[ miClase 1 5ello Aorld[ miClon 1 5ola :undo $a in+ocación a :em*er4iseclone&) regresa una nue+a instancia de Saludo # su contenido puede ser modificado sin afectar el contenido de miClase. Console.Arite$ine&7miClase 1 7 . class Saludo< pu*lic string s. Console. Console.

Arite$ine&7?1R7( l GII). dou*le dQalue > Cou*le. &alida1 ?JG 'eempla-o de !spacio o Cigito Console.???e@7(WYJPP). Console.Parse&7J.?P). Console.##@7(JGOWP).@@KLXHE>HHK @@@KL.YW\\).ed8point Heneral um*er Console.ponential ) 9i. &alida1 GII# Parseo umérico $os n%meros pueden ser parseados utili-ando el método Parse&)( esto es posi*le #a que lo pro+ee el tipo de dato. &alida1 OJP.NXOO @@. $a lectura # escritura la reali-a la clase Stream( la cual descri*e como los b.D2.Arite$ine&7<?1#####@7(JGO).G).Arite$ine&7<?1???@7(JG).???@7(JGOPI.WI Porcentaje Console. int iQalue > DntOG. 9ormato Personali-ado String !l 5ormato !ersonali ado &tring( son utili-ados para o*tener más control( so*re la con+ersación que está disponi*le a tra+és del formato estándar de strings.tes pueden ser escritos o leidos.@KL.JPJIIOO!.YW\\). &alida1 JGOPI. Scientific &e. &alida1 JGO.Arite$ine&7<?1###. Dnput=2utput !l lenguaje Com%n en "iempo de !jecución . !" pro+ee funciones de entrada=salida en el namespace S#stem.&###.Arite$ine&7<?1###`#@7(GII).Arite$ine&7<?1###.XH 55 5e.II).??.adecima Console.YW\\).Arite$ine&7<?1##(###@7(JJGOPIK\YW). @.Arite$ine&7<?1##.JII!8?G Separador de Sección Console.???!8??@7(O. &alida1 J(JGO(PIK(\YW Separador de Hrupo Console. &alida1 JGO Punto Cecimal Console.Arite$ine&7?1H7( OOOPI.JPPe otación !.GO7).YW\\).!( e !( f H( g (n R( .G?? Separador de Hrupo Console. 'eempla-o de Cero o Cigito Console.ponencial Console. Stream es una clase a*stracta que en la práctica las clases deri+an de Stream para ser utili-adas.@@KLXHE>HHK OOOPI.??)@7(8PIK.Arite$ine&7<?1#####.Arite$ine&7?1 7( OOOPI. &alida1 PI\ !scape # $iterales Console.Arite$ine&7?1!7( @. Console.Parse&7JGO7).?. &alida1 WY. Clases disponi*les1 101 .Arite$ine&7?197( OOOPI.Arite$ine&7<?1???(.

@ s. i um*er$ine.Close&). "hreading &5ilos) 102 .t. i um*er$ine L> J?.ue(o. class /pp< pu*lic static +oid :ain&)< 9ileStream f > ne4 9ileStream&7nue+o.Arite$ine&7$inea 7 .D2.Close&).)< s.t7t cu#o contenido es1 $inea J $inea G $inea O $inea P $inea I $inea K $inea \ $inea Y $inea W $inea J? Seriali-ación $a &eriali ación es el proceso utili-ado por el runtime para o*jetos persistentes en alg%n orden de almacenamiento o para transferirlos de un lugar a otro.que el programa es ejecutado se so*reescri*e el contenido del archi+o en caso de que este e. implementa un buffer en la cima de otro stream. flujo #ue es almacenado en memoria Net7or3&tream. using S#stem.    5ile&tream.t7( 9ile:ode. / continuación se muestra un ejemplo donde( cada +e. f. .iste se crea1 using S#stem. flujo en un archivo de disco 'emory&tream.isten dos formas de o*tener flujos &streams) que conectan a un archi+o( uno utili-ando la clase 9ileStream( la cual pro+ee un control total so*re el acceso de archi+os( inclu#endo modo de acceso( compartido # bu))ering. StreamAriter s > ne4 StreamAriter&f). for&int i um*er$ine > J. flujo en una cone%ión de red 6uffered&tream. i um*er$ine).Create).ista( si no e. $a información de los metadatos en un o*jeto contiene información suficiente para que el runtime serialice los campos( pero es necesario indicar al runtime hacerlo correctamente a tra+és de dos atri*utos ESeriali-a*leF el cual es utili-ado para marcar un o*jeto que es posi*le seriali-ar # E onSeriali-edF que es aplicado para un campo o propiedad para indicar que no de*er0a ser seriali-ado. @ @ &alida( /rchi+o . $ectura # !scritura de /rchi+os !.

m.clusión depende del dise6o del programa( pero C# soporta e.:onitor # pro+ee funcionalidad similar a la in+ocación de CriticalSection en AinOG.clusión simple utili-ando la sentencia locV. 103 ."hreading contiene clases utili-adas para threading # sincroni-ación.!l namespace S#stem."hreading. !l tipo apropiado de sincroni-ación #=o e.com. /gradecimientos a Suan Harcia por en+iar el tutorial original de informatique. locV utili-a la clase S#stem.

You're Reading a Free Preview

Descarga
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->