MANUAL C#

MANUAL DE C#
Qu es C#? C# o C Sharp es un lenguaje de programacin que est incluido en la Plataforma . !" # corre en el $enguaje Com%n en "iempo de !jecucin &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 mtodos # manejo de e.cepciones. Se elimino la complejidad de C,, para hacerlo ms fcil 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 mltiple, solamente el runtime .NET permite la herencia mltiple en la forma de interfaces, las cuales no pueden contener implementacin. No maneja apuntadores, para emular la funcin de los apuntadores se utili a delegates el cual provee las bases para el .NET event model. !or default trabaja con cdigo 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 encapsulacin, herencia y polimorfismo de la programacin 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 progrmacin. 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 mltiple 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+.

"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 cdigo es safe mode, pero es posible declarar clases o slo m,todos unsafe, esta declaracin permite utili ar apuntadores, estructuras y almacenamiento de arreglos est$ticos. C# depende del runtime #ue provee la !lataforma .NET, el runtime administra la ejecucin de cdigo.

$enguaje 2rientado a 2*jetos Seg%n Bjarne Stroustrup autor del lenguaje de programacin 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

Encapsulacin 4erencia !olimorfismo

2*jeto 3n )bjeto es una instancia de un tipo de clase. $a instanciacin es el acto de crear una instancia de un o*jeto( la instancia es un o*jeto( la instanciacin usa el operador ne4( despus la instanciacin es posi*le comunicarnos con el o*jeto a tra+s de sus miem*ros. 3n )bjeto es una coleccin de informacin 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.

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 nue+a clase deri+ada hereda todos los miem*ros de la clase *ase por consiguiente permite reusar el tra*ajo pre+io. !n C# se puede asumir que la clase deri+ada podr0a heredar todos los miem*ros de la clase *ase. $a herencia es un ejemplo del dise6o orientado a o*jetos conocido como una relacin 7is8a7 &es8un)( por ejemplo1 7un empleado es una persona7. /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. 3na clase deri+ada no de*er0a requerir ms ni prometer menos que su clase *ase so*re cualquiera de sus interfaces heredadas. 3na interfa- de clase es un contrato entre esta # los programadores que usan la clase. 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. !n el lenguaje com%n en tiempo de ejecucin . !" todos los o*jetos heredan de la %ltima clase *ase llamada o*ject # e.iste slo una herencia simple de o*jetos. 3n o*jeto puede deri+ar slo de una clase *ase. Clase 3na Clase es una plantilla para un o*jeto. 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 mtodos( e+entos # propiedades. 3na instancia de una clase es un o*jeto( se accede a la funcionalidad de un o*jeto in+ocando sus mtodos # accediendo a sus propiedades( e+entos # campos. 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.isten diferentes tipos de miem*ros. 3na referencia se refiere a una instancia( una instancia es la creacin de un o*jeto del tipo clase que se est declarando. 3na clase utili-a ninguno( uno o ms constructores para a#udar a definir la instancia de una clase. !.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. Cuando se hace referencia a una +aria*le de instancia que tiene el mismo nom*re de un parmetro se de*e utili-ar this.name. /l crear # manipular o*jetos no es necesario administrar la memoria que estos ocupan #a que e.iste un mecanismo que se encarga de esto llamado garbage collector &recolector de *asura)( pero es una *uena prctica no ol+idar li*erar los recursos. 9unciones :iem*ro 3na 5uncin 'iembro puede ser un constructor( es decir( una pie-a de cdigo que es in+ocada en una instancia del o*jeto. Campos !stticos 3n Miembro Esttico definine miem*ros de un o*jeto que no son asociados con una instancia de clase espec0fica. 3n Campo Est$tico es el tipo ms simple de un miem*ro esttico( para declarar un campo esttico se utili-a el modificador static. 3n campo esttico puede accederse a tra+s del nom*re de la clase( en +e- de la instancia de la clase &o*jeto)1 using S#stem;

class :iContador< ==Campo !sttico pu*lic static int iContador > ?; pu*lic :iContador&)< iContador,,; @ @ class /pp< pu*lic static +oid :ain&)< :iContador Contador/ > ne4 :iContador&); Console.Arite$ine&:iContador.iContador); :iContador ContadorB > ne4 :iContador&); Console.Arite$ine&:iContador.iContador); @ @ !l ejemplo determina cuantas instancias del o*jeto han sido creadas. Clase Base 3na Clase base es un o*jeto padre de donde se *asa un nue+o tra*ajo. Clase Ceri+ada 3na Clase derivada es un o*jeto hijo. Clase /*stracta 3na Clase /bstracta define las funciones que una clase deri+ada de*e implementar. 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( adems que la clase padre tam*in se define como a*stract. using S#stem; a*stract pu*lic class Persona<==Dndica que la clase es a*stracta ==Propiedades pu*lic string s om*re; pu*lic int i!dad; ==Constructor pu*lic Persona&string s om*re( int i!dad)< this.s om*re > s om*re; this.i!dad > i!dad; @ ==:todos a*stract pu*lic string "ipo&);==: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; @ @ class /pp< ==/plicacin pu*lic static +oid :ain&)< Console.Arite$ine&7888 /rreglo de 2*jetos 8887); !mpleadoEF aProgramadores > ne4 !mpleadoEGF;

aProgramadoresE?F > ne4 !mpleado&7Bill Hates7( I?); aProgramadoresEJF > ne4 !mpleado&7!ric S. 'a#mond7( K?); for&int i > ?; i L aProgramadores.$ength; i,,)< Console.Arite$ine&7aProgramadoresE7,i,7F.s om*re 1 7 , aProgramadoresEiF.s om*re); Console.Arite$ine&7aProgramadoresE7 , i , 7F.i!dad 1 7 , aProgramadoresEiF.i!dad); Console.Arite$ine&7aProgramadoresE7 , i , 7F."ipo 1 7 , aProgramadoresEiF."ipo&)); @ @ @ 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+acin no planeada. sealed class ClaseBase< ClaseBase&)<@ @ class ClaseCeri+ada 1 ClaseBase< @ class Sellada< pu*lic static +oid :ain&)< ClaseCeri+ada CC > ne4 ClaseCeri+ada&); @ @ /l compilar el cdigo se muestra el siguiente mensaje1

sealed.cs(4,7 ! error "S#$#%! &"lase'eri(ada& ! cannot inherit )rom sealed class &"laseBase& sealed.cs(*,*4 ! (+ocation o) s,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. 2+erloading=So*recarga $a &obrecarga &-(erloading) hace posi*le utili-ar dos o ms clases con el mismo nom*re( pero con parmetros diferentes. $a so*recarga es com%n especialmente para los constructores para definir diferentes maneras de crear una instancia nue+a. Cuando una funcin so*recargada es in+ocada el compilador selecciona la funcin apropiada que coincide con los parmetros. 5erencia Simple $a 4erencia &imple permite deri+ar una clase en una clase nue+a( que contiene la definicin de la clase de la cual deri+a( es decir( hereda todos los miem*ros datos de la clase( aunque pueden e.istir miem*ros a los cuales no se pueda tener acceso por ser pri+ate. $os constructores no pueden ser heredados( por lo que es necesario escri*ir constructores # si funcionalmente no e.iste alguna modificacin se in+oca el constructor de la clase que hereda utili-ando la sinta.is *ase. Si se omite el constructor de la clase *ase # es in+ocado el compilador podr0a in+ocar el constructor de la clase *ase sin parmetros. using S#stem; pu*lic class Persona<

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

Console.Arite$ine&7Programador.i!dad Programador.i!dad);

Programador./signarSueldo&dSueldo); Console.Arite$ine&7Programador.iSueldo 1 7 , Programador.2*tenerSueldo&)); Console.Arite$ine&7Programador."ipo 1 7 , Programador."ipo&)); @ @ Polimorfismo # 9unciones Qirtuales !l polimorfismo es la funcionalidad que permite a cdigo antiguo in+ocar cdigo nue+o( tam*in permite e.tender el sistema sin modificar el cdigo e.istente( esto se logra so*reescri*iendo o redefiniendo el cdigo( para lo cual se utili-an funciones +irtuales # la pala*ra cla+e o+erride. $as funciones a*stractas son automaticamente funciones +irtuales( las cuales permiten al programador usar polimorfismo para hacer su cdigo simple. (irtual significa que cuando una in+ocacin 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 funcin apropiada. using S#stem; pu*lic class Persona< ==Propiedades pu*lic string s om*re; pu*lic int i!dad; ==Constructor pu*lic Persona&string s om*re( int i!dad)< this.s om*re > s om*re; this.i!dad > i!dad; @ ==:todos +irtual pu*lic string "ipo&)< return 7Persona7; @ @ ==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; @ @ class /pp< ==/plicacin pu*lic static +oid :ain&)< Persona :e.icano > ne4 Persona&7Herado Nngeles a+a7( OO); Console.Arite$ine&7:e.icano.s om*re 1 7 , :e.icano.s om*re); Console.Arite$ine&7:e.icano.i!dad 1 7 , :e.icano.i!dad); Console.Arite$ine&7:e.icano."ipo 1 7 , :e.icano."ipo&)); Console.Arite$ine&7888 /rreglo de 2*jetos 8887); !mpleadoEF aProgramadores > ne4 !mpleadoEGF; aProgramadoresE?F > ne4 !mpleado&7Bill Hates7( I?);

aProgramadoresEJF > ne4 !mpleado&7!ric S. 'a#mond7( K?); for&int i > ?; i L aProgramadores.$ength; i,,)< Console.Arite$ine&7aProgramadoresE7,i,7F.s om*re 1 7 , aProgramadoresEiF.s om*re); Console.Arite$ine&7aProgramadoresE7 , i , 7F.i!dad 1 7 , aProgramadoresEiF.i!dad); Console.Arite$ine&7aProgramadoresE7 , i , 7F."ipo 1 7 , aProgramadoresEiF."ipo&)); @ @ @ Cuando una funcin es declarada con la pala*ra reser+ada o+erride significa que es la misma funcin que fue declarada en la clase *ase( si la pala*ra reser+ada o+erride se omite el compilador podr0a asumir que la funcin no est relacionada a la funcin de la clase *ase # no despacha la funcin +irtual &el compilador podr0a sugerir omitir o+erride o agregar ne4) . Cuando e.iste una funcin +irtual el programador puede pasar una referencia a la clase a*stracta aunque la clase deri+ada # el compilador podr0an escri*ir cdigo para in+ocar la +ersin apropiada de la funcin en tiempo de ejecucin. Por ejemplo( el o*jeto *ase o*ject tiene una funcin +irtual llamada "oString&) que con+ierte un o*jeto a string. Si se in+oca la funcin "oString&) en un o*jeto que que no la tiene como +ersin propia( la +ersin de la funcin que es parte de la clase o*ject podr0a ser in+ocada. !ncapsulacin # Qisi*ilidad Encapsulacin &tam*in 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 encapsulacin pro+ee los l0mites entre una interfa- e.terna # los detalles de su implementacin interna. /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. 'a-ones para encapsular # ocultar1

El usuario no puede cambiar lo #ue es privado en el objeto, lo cual reduce la oportunidad de #ue el usuario cambie o dependa de los detalles en el cdigo, si el usuario hace lode detalles dependientes, los cambios reali ados en el objeto #ui $ arruinen el cdigo del usuario. "os cambios reali ados en partes pblicas de un objeto deben permanecer compatibles con la versin previa. "as partes pblicas pueden ser cambiadas sin arruinar el cdigo del usuario. "os campos privados pueden slo ser accesados desde la clase, los campos pblicos pueden ser accesados a trav,s de cual#uier instancia de la clase.

/*straccin 3na /bstraccin se refiere a como un pro*lema dado es representado en el espacio de programa.

Como desarrollador de clases es necesario pensar en terminos de hacer el mejor dise6o de a*straccin 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*in es necesario determinar cuales de los miem*ros de la clase de*er0an ser accesi*les pu*licamente. $os *eneficios de una *uena a*straccin( es dise6arla de manera tal que las modificaciones son minimas( si se conoce *ien el pro*lema a resol+er facilita determinar que mtodos necesitara el usuario( tam*in ser un sistema fcil de entender # mantener. $a interfa- de clase es la implementacin de la a*straccin. Plataforma . !" $a solucin :icrosoft . !" comprende cuatro componentes fundamentales1

&ervicios de 6lo#ues de Construccin .NET o acceso program$tico para ciertos servicios tales como almacenamiento de archivos, calendario y pasaporte .NET el cual es un servicio de verificacin de identidad. 1ispositivos de &oft7are .NET el cual podr2a correr sobre nuevos dispositivos 0nternet. "a E%periencia de 8suario .NET la cual incluye caracter2sticas tales como interfa natural, agentes de informacin y eti#uetas inteligentes es decir una tecnolog2a #ue automati a hiperligas para informacin relacionada a palabras y frases en documentos creados por el usuario. "a 0nfraestructura .NET la cual comprende la plataforma .NET, 'icrosoft &tudio .NET, los &ervidores Corporativos .NET y 'icrosoft 9indo7s .NET

$a Dnfraestructura . !" 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 parte de . !" que permite desarrollar estas aplicaciones es la plataforma . !". $a Plataforma . !" consiste de un $enguaje Com%n en "iempo de !jecucin &C$') # la Bi*lioteca de Clases de la Plataforma . !" algunas +eces llamada la Bi*lioteca de Clases Base &CB$). !l C$' es como una mquina +irtual &el cdigo que corre dentro del C$' en ejecucin en un am*iente encapsulado # controlado( separados de otros procesos en la mquina) en la cual funcionan las aplicaciones . !"( todos los lenguajes . !" tienen la *i*lioteca de clases de la Plataforma . !" a su disposicin. $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. $a Plataforma . !" es una plataforma nue+a que simplifica la aplicacin del desarrollo en am*ientes altamente distri*uidos de Dnternet. $a Plataforma . !" est dise6ada para cumplir los siguientes o*jeti+os1

!roveer un ambiente consistente de programacin orientada a objetos, tanto o si el cdigo objeto es almacenado y ejecutado localmente, o si es ejecutado localmente pero distribuido en 0nternet o si es ejecutado remotamente. !roveer un ambiente de ejecucin de cdigo #ue minimice la distribucin de soft7are y conflictos de versiones.

!roveer un ambiente de ejecucin de cdigo #ue garantice la ejecucin de cdigo seguro, incluyendo el cdigo creado por un desconocido o un tercero semiconfiable. !roveer un ambiente de ejecucin de cdigo #ue elimine los problemas de desempe:o de ambientes de scripts o interpretes. 4acer #ue la e%periencia del desarrollador sea consistente a trav,s de una amplia variedad de aplicaciones, tal como aplicaciones basadas en 9indo7s y aplicaciones basadas en 9eb. Construir toda la comunicacin sobre est$ndares industriales para asegurar #ue el cdigo basado en la !lataforma .NET pueda integrarse con cual#uier otro cdigo.

$a Plataforma . !" consiste de dos componentes principales1

El "enguaje Comn en Tiempo de Ejecucin *C".+ el cual es el fundamento de la !lataforma .NET "a 6iblioteca de Clases de la !lataforma .NET, es una coleccin 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 tales como 9eb 5orms y servicios 7eb <'".

!l runtime es una agente que administra el cdigo en tiempo de ejecucin al pro+eer de ser+iciones principales como la administracin de memoria( administracin de hilos( tam*in implementa tipos estrictos de seguridad # otras formas de +erificacin de cdigo que aseguren la seguridad # ro*uste-. !l concepto de administracin de cdigo es principio fundamental del runtime. !l cdigo que manipular el runtime es conocido como cdigo administrado( mientras que el cdigo que no ser manipulado por el runtime es conocido como un cdigo no administrado. $a plataforma . !" puede almacenar componentes no administrados que son cargados por el C$' en sus procesos e iniciali-ados por la ejecucin de cdigo administrado de esta manera se crea un am*iente de soft4are que puede e.plotar tanto caracter0sitcas de cdigo administrado como las del cdigo no administrado. . !" Common $anguage 'untime 8 C$' !l ..E/ "ommon +anguage 0untime &$enguage com%n en tiempo de ejecucin . !") es un am*iente *asado en componentes # C# esta dise6ado para facilitar la creacin de componentes. "odos los o*jetos son escritos como componentes # los componentes son el centro de accin( por ello que reci*a el nom*re de lenguaje cntrico de componentes &component1centric). $os componentes creados en C# son totalmente auto8descri*i*les # pueden ser utili-ados sin un proceso de registro. C# a#uda en la creacin de componentes mediante el runtime # )rame2or3 . !"( los cuales pro+een un sistema de tipo unificado en el cual todo puede ser tratado como un o*jeto.

10

Caracter0sticas del C$' !$ C$' no slo soporta el compilador de C#( tam*in el de Qisual Basic # C,,( el cdigo que generan estos compiladores para ser soportado por C$' es llamado managed code. /lgunos de los *eneficios que las aplicaciones o*tienen del C$' son1

0ntegracin de lenguajes a trav,s del Common Language Specification /dministracin automatica de memoria, a trav,s del recolector de basura. 'anejo de e%cepciones de lenguajes. &eguridad type safety. &oporte de versiones. 'odelo &implificado para la interaccin de componentes.

!l C$' pro+ee los *eneficios anteriores( el compilador de*e emitir los metadatos en el managed code. $os metadatos descri*en los tipos en el cdigo # son empaquetados en el cdigo ejecuta*le. !l C$' administra la memoria( ejecucin de hilos( ejecucin de cdigo( +erificacin de cdigo seguro( compilacin # otros ser+icios. !stas caracter0sticas son intr0nsecas a la administracin de cdigo que corre so*re el C$'. $a seguridad # administracin 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 estn 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 aplicacin acti+a. !l runtime for-a el acceso a cdigo seguro( no es posi*le acceder a datos personales( sistema de archi+os o red. !l runtime tam*in for-a la ro*uste- del cdigo implementando una infraestrucutra estricta de +erificacin de cdigo llamado Common "#pe S#stem &C"S)( el cual asegura que toda la administracin de cdigo se descri*e as0 misma. $a +ariedad de compiladores :icrosoft # de terceros genera cdigo administrado que conforma el C"S( es decir( que la administracin de cdigo puede consumir otros tipos e instancias administradas( mientras que se for-a estrictamente la fidelidad de tipo # seguridad de tipo. $a administracin del am*iente del runtime elimina cuestiones de soft4are comunes( li*erando por ejemplo recursos que #a no son utili-ados. !l runtime tam*in 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 cdigo administrado # no administrado permiten a los desarrolladores continuar utili-ando componentes C2: # C$$s. !l runtime est dise6ado para incrementar el desempe6o( atra+s del C$' que pro+ee muchos ser+icios estndar( el cdigo administrado nunca es interpretado( una caracter0stica llamada just1in1time &SD") permite compilar todo el cdigo administrado para correr en el lenguaje nati+o de la mquina del sistema o de cualquiera que se este ejecutando. !l administrador de memoria elimina las posi*ilidades de fragmentacin de memoria e incrementa la referencia de localidad de memoria para impulsar el incremento del desempe6o.

11

!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 lgica del negocio. . !" 'untime !n+ironment !l $enguaje Com%n en "iempo de !jecucin pro+ee los ser+icios de ejecucin *sica. $as clases *ase pro+een tipos de datos *sicos( clases coleccin # otras clases generales. $as clases *ase son clases para tratar datos # R:$. !n la parte superior de la arquitectura las clases e.ponen ser+icios 4e* # tratramiento de la intefa- de usuario. 3na aplicacin puede hacer in+ocaciones en cualquier ni+el # utili-ar clases desde cualquier ni+el. 2rgani-acin . !" 9rame4orV1 Ser+icios Ae* Dnterfa- de 3suario

Catos # R:$ Clases Base $enguaje Com%n en "iempo de !jecucin /m*iente=!ntorno de !jecucin !l am*iente o entorno pro+ee un modelo de programacin simple( seguro( soporta de herramientas potentes # a#uda con la distri*ucin( empaquetado # soporte1

'odelo de !rogramacin &imple, todos los servicios son ofrecidos a trav,s de un modelo comn #ue puede ser accedido desde cual#uier lenguaje .NET y los servicios pueden ser escritos en cual#uier lenguaje .NET, el entorno o ambiente en gran parte es un lenguaje agnstico permitiendo la eleccin de lenguaje, esto hace el cdigo f$cil de reusar para el programador y los proveedores de bibliotecas. En el runtime .NET todos los errores son reportados via e%cepciones. El entorno contiene las 6ibliotecas de Clase 6ase *Base Class Libraries 6C"+ las cuales proveen las funciones tradicionales fundadas en bibliotecas en tiempo de ejecucin, la funcionalidad del 6C" incluye=

Clases coleccin, tales como consultas, arreglos, pilas y tablas hash. Clases de acceso a bases de datos Clases 0) *input-output+ Clases 9in5orms, para crear interfaces de usuario Clases Net7or3

5uera de la clase base en tiempo de ejecucin, e%isten muchos otros componentes #ue controlan la interfa de usuario *80+ y reali an otras operaciones sofisticadas.

12

&eguridad, el entorno del runtime .NET est$ dise:ado para ser un entorno seguro. El runtime .NET es un entorno administrado o controlado, lo cual significa #ue el runtime administra la memoria por el programador a trav,s del recolector de basura. El runtime .NET es un entorno verificado, en tiempo de ejecucin el entorno verifica #ue la ejecucin del cdigo sea de tipo segura *typesafe+. El sistema de seguridad interactua con el verificador para asegurar #ue el cdigo realice slo lo #ue tiene permitido hacer, esto es posible especificando un re#uerimiento de seguridad para una pie a de cdigo espec2fica.

&oporte de herramientas potentes, 'icrosoft suministra cuatro lenguajes .NET= (6, (C>>, C# y ?&cript. "a depuracin en gran medida es enri#uecida por el runtime .NET, el modelo de ejecucin comn hace la depuracin de lenguajes simple y directa. 1istribucin, empa#uetado y soporte, El runtime .NET ayuda simplificando la distribucin y en algunos casos no e%iste el paso tradicional de instalacin, por#ue los pa#uetes son distribuidos en un formato gen,rico, un pa#uete puede correr en cual#uier entorno #ue soporte .NET, el entorno separa los componentes de una aplicacin por lo #ue una aplicacin slo corre con los componentes #ue son enviados.

!nsam*laje !n el runtime ..E/ el mecanismo de empaquetado es el ensam*le &assembly)( cuando el cdigo es compilado por uno de los compiladores . !"( es con+ertido a una forma intermedia conocida como D$. !l ensamble contiene todos los D$( metadatos # otros archi+os requeridos para que un paquete se ejecute en un paquete completo. Cada ensam*le contiene un manifiesto que enumera todos los archi+os que estn contenidos en el ensam*le( controla que tipos # recursos son e.puestos fuera del ensam*le # relaciona las referencias de esos tipos # recursos a los archi+os que contienen los tipos # recursos. !l manifiesto tam*in lista otros ensam*les que dependen de un ensam*le. $os ensam*les se contienen a s0 mismo( e.iste suficiente informacin en el ensam*le para ser auto8descrito. 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. 3tili-ando +arios archi+os podr0a hacer posi*le un escenario donde las secciones del ensam*le sean descargadas slo como se necesiten. Dnteropera*ilidad de $enguaje 3na de las metas del runtime ..E/ es ser un lenguaje agnstico( permitiendo que el cdigo sea utili-ado # escrito desde cualquier lenguaje( no slo las clases pueden ser escritas en alg%n lenguaje . !" como QB. !" # ser in+ocadas desde otro lenguaje . !" como C#( una clase que fu escrita en QB. !" puede ser utili-ada como una

13

clase *ase escrita en C# # esa clase podr0a ser utili-ada desde una clase QC,, o SScript( es decir( no importaria en que clase sea escrita una clase. Para hacer lo anterior posi*le e.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. Para que una clase sea utili-ada desde un lenguaje . !"( la clase de*e adherir la !specificacin Com%n de $enguaje &Common $anguage Specification 8 C$S) la cual descri*e que caracter0sticas pueden ser +isi*les en la interfa- p%*lica de la clase( por ejemplo el C$S prohi*e e.poner tipos de datos sin signo( porque no todos los lenguajes pueden utili-arlos. /tri*utos !l runtime ..E/ soporta atri*utos personali-a*les( los cuales son en cierto sentido un lugar para colocar informacin descripti+a en los metadatos junto con un o*jeto # entonces recuper despus los datos. $os atributos pro+een un mecanismo general para hacer esto # son utili-ados en e.ceso en todo el tiempo de ejecucin para almacenar informacin que modifica como el runtime utili-a las clases. $os atri*utos son e.tensi*les # permite a los programadores definir atri*utos # utili-arlos. $os atri*utos se especifican encerrandolos entre corchetes1 EQersion&7JP=?W=G??I7( Comentario>7J.?.J.?7)F $os atributos son anotaciones que se colocan en elementos de cdigo fuente( como clases( miem*ros( parmetros( etc. $os atri*utos puede ser utili-ados para1 cam*iar el comportamiento del runtime( pro+eer informacin acerca de un o*jeto( lle+ar informacin organi-acional al dise6ador. !l atri*uto informacin es almacenado con los metadatos del elemento # pueden ser facilmente recuperados en tiempo de ejecucin a tra+s de un proceso conocido como reflection. C# utili-a un /tri*uto Condicional para controlar cuando las funciones miem*ro son in+ocadas. Por con+encin 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. "odos los atri*utos deri+an de S#stem./ttri*ute. 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 Cescripcin ensam*le mdulo clase o estructura mtodo porpiedad e+ento campo parmetro +alor de regreso

14

$os atri*utos que son aplicados a ensam*les o mdulos de*en colocarse despus de cualquier clusula using # antes de cualquier cdigo. Bi*lioteca de Clases de la Plataforma . !" $a Bi*lioteca de Clases de la Plataforma . !" es una coleccin de tipos reutili-a*les integradas en el C$'. $os tipos de la Plataforma . !" permiten lle+ar a ca*o tareas de programacin comunes como manipulacin de strings( colecciones de datos( conecti+idad a *ases de datos # acceso a archi+os. !s posi*le utili-ar la Plataforma . !" para desarrollar los siguientes tipos de aplicaciones # ser+icios1

/plicaciones de consola 9indo7s 5orms /plicaciones /&!.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#. $enguaje Dntermedio # :etadatos :icrosoft desarrollo un lenguaje parecido al lenguaje ensam*lador llamado 'icrosoft 0ntermediate "anguage &:SD$). Para compilar aplicaciones . !"( los compiladores toman el cdigo fuente como entrada # producen :SD$ como salida. :SD$ en s0 es un lenguaje completo con el cual es posi*le escri*ir aplicaciones. !l managed code generado por el compilador C# no es cdigo nati+o porque es un cdigo de $enguaje Dntermedio &D$). !ste cdigo D$ se con+ierte en la entrada para la administracin del proceso de ejecucin del C$'. $a +entaja final del cdigo D$ es que el CP3 es independiente( lo cual significa que se necesita un compilador en la mquina destino para cam*iar el cdigo D$ en el cdigo nati+o. !l D$ es generado por el compilador( pero no es lo %nico que se pro+ee para el runtime( el compilador tam*in genera metadatos acerca del cdigo( los cuales dicen ms al runtime del cdigo( por ejemplo la definicin de cada tipo. $os metadatos son *i*liotecas de tipo( entrada de datos al registr#( etc. $os metadatos son empaquetados directamente con el cdigo ejecuta*le # no en localidades separadas. !l D$ # los metadatos son colocados en los archi+os que e.tienden el formato P! &Porta*le !.ecuta*le) utili-ado para archi+os .e.e # .dll( cuando se carga el archi+o P! el runtime coloca # e.trae los metadatos # el D$ de estos. Cuando se compila una aplicacin C# o cualquier aplicacin escrita en un C$S( la aplicacin es compilada dentro del :SD$( adems se compila dentro de las instrucciones nati+as de CP3 cuando la aplicacin es ejecutada por +e- primera por el C$'. !l proceso es el siguiente1

Cdigo fuente escrito en C#

15

El cdigo fuente es compilado usando el compilador de C# *csc.e%e+ dentro de un E<E. El compilador C# produce como salida el cdigo '&0" y un manifiesto en una parte de slo lectura del E<E #ue tiene un encabe ado est$ndar !E *9in@A-!ortable E%ecutable+. Cuando el compilador produce o crea la salida tambi,n importa una funcin llamada BCorE%e'ain del runtime .NET.

Cuando la aplicacin es ejecutada, el sistema operativo carga el !E como una 1"" dependiente tal como la nica #ue e%porta la funcin BCorE%e'ain *mscoree.dll+ justo como lo hace con cual#uier !E v$lido. El sistema operativo carga y entonces salta al punto dentro del !E el cual es puesto ah2 por el compilador C#. El sistema operativo obviamente no puede ejecutar el cdigo '&0", el punto de entrada es un pe#ue:a parte #ue salta a la funcin BCorE%e'ain en mscoree.dll.

"a funcin BCorE%e'ain comien a la ejecucin del cdigo '&0" #ue fue colocado en el !E. 1ado #ue el cdigo '&0" no puede ser ejecutado directamente *por#ue no est$ un un formato de m$#uina ejecutable+ el C". compila el '&0" usando un compilador just-in-time *?0T o ?0Tter+ dentro de instrucciones C!8 nativas tal como procesa el '&0".

SD"ers !l managed code generado por C# es el cdigo D$( aunque el cdigo 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. Cuando un tipo es cargado( el laoder crea # agrega un stub &pie-a peque6a) a cada mtodo del tipo( as0 cuando el mtodo es in+ocado por +e- primera( el stu* pasa el control al SD". !l SD" compila el D$ a cdigo nati+o # cam*ia el stu* para que apunte al cdigo nati+o que est en cache( as0 las su*secuentes in+ocaciones podr0an ejecutar el cdigo nati+o. !l C$' inclu#e tres diferentes SD"ers que pueden ser usados para con+ertir :SD$ en cdigo nati+o( dependiendo de las circunstancias1

!re?0T *;eneracin de cdigo 0nstall-time+, opera como un compilador tradicional, aun#ue est$ basado sobre el compilador ?0T principal, se ejecuta cuando un componente N;9& es intalado y compila el cdigo 0" a managed code nativo.

16

"a generacin de cdigo en tiempo de instalacin compilar$ un ensamble completo dentro de un cdigo binario de C!8-especifico, tal como lo hace el compilador C>>. 8n ensamble el cdigo empa#uetado #ue es enviado al compilador. "a compilacin se hace en tiempo de instalacin, cuando el usuario final es menos probable para notificar #ue el ensamble esta siendo compilado-?0T. "a ventaja de la generacin de cdigo en tiempo de instalacin, es #ue permite compilar el ensamble completo justo una ve antes de ser ejecutado. /l ser compilado el ensamble entero no hay preocupacin referente al desempe:o intermitente cada ve #ue un m,todo en el cdigo es ejecutado por primera ve . /l usar esta utilidad depende del tama:o del sistema y del ambiente de distribucin.

?0T, compilador por default utili ado por el C"., es un compilador optimi ado, el cual reali a el an$lisis del flujo de datos, administra el cdigo nativo como salida. El ?0Tter es invocado en tiempo de ejecucin.

Econo?0T, reali a una conversin muy velo del 0" a managed code nativo

Tambi,n es un ?0Tter en tiempo de ejecucin, esta especialmente dise:ado para sistemas #ue tienen recursos limitados como memoria. "a principal diferencia con un ?00ter regular es la incorporacin de algunas invocaciones code pitching, #ue permiten al Econo?0T descartar el cdigo generado o compilado si el sistema comien a a ejecutarse fuera de memoria, siendo el beneficio el reclamo de memoria. "a desventaja es #ue si el cdigo es pitched *lan ado+ es invocado otra ve por lo #ue debe ser compilado de nuevo. !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.e.e)( que reside en el directorio *in del directorio de instalacin del HAS SCX. Sistema de "ipo 3nificado !l runtime de . !" hace ms que dar al desarrollador un simple sistema de tipo unificado que es usado a tra+s de todos los lenguajes( tam*in deja a los lenguajes escri*ir e.tensiones de sistema tipo( agregando nue+os tipos que pare-can # actuen como tipos de sistemas *uilt.in. !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,stem 8 Q2S). !l Q2S esta*lece una plataforma que permite la integracin de lenguajes # t#pe safet#. $a *ase de la arquitectura del runtime es la plataforma que puede descri*ir en cuatro reas1

17

()& Type &ystem, provee un sistema de tipos #ue intenta soportar la implementacin completa de una rango amplio de lenguajes de programacin. 'etadata, describe y hace referencia a los tipos definidos por el ()&. Common "anguage &pecification - C"&, define el subconjunto de tipos del ()&. &i una biblioteca de clases es soportada por las reglas del C"&, garanti a #ue la biblioteca de clases pueda ser utili ada por los dem$s lenguajes #ue implementen el C"&. (irtual E%ecution &ystem - (E&, es responsable de la carga y ejecucin de los programas #ue fueron escritos por el C"..

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. Para un +alor el tipo descri*e la representacin de almacenamiento # las operaciones que puede reali-ar. $os o*jetos son ms poderosos porque el tipo es almacenado e.plicitamente en su representacin( cada o*jeto tiene una identidad que lo distingue de los dems o*jetos. :etadata !l compilador C$S toma el cdigo fuente como entrada # produce cdigo :SD$ para el runtime para compilar a tra+s de los SD"ters # ejecutar. /dems se mapea el cdigo fuente a secuencias de instrucciones :SD$( el compilador C$S tiene otra tarea importante1 en+ol+er metadatos dentro del !R! resultante. $os 'etadatos son datos que descri*en datos. $os metadatos son la coleccin de elementos programticos que constitu#en el !R!( como los tipos declarados # los mtodos implementados. !stos metadatos son similares a los tipos de *i*liotecas generadas con componentes C2: &Component 2*ject :odel). $a ra-n para usar metadatos es simple #a que permiten al runtime . !" conocer en tiempo de ejecucin que tipos podr0an ser almacenados # que mtodos podr0an ser in+ocados. !sto permite al runtime configurar apropiadamente el am*iente para ma#or eficiencia al ejecutar la aplicacin. !l significado por el cual estos metadatos son consultados es llamado re)lection. $os metadatos por cada o*jeto . !" registran toda la informacin que es requerida para usar el o*jeto( con esta informacin el runtime ..E/ es capa- 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 informacin para encontrar que o*jetos estn disponi*les # como es utili-ado un o*jeto. $a informacin 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, incluyendo tipos par$metro y nombres

$os metadatos tam*in permiten a otras herramientas acceder a la informacin detallada acerca del cdigo

18

!.iste un proceso llamado reflection donde el cdigo en tiempo de ejecucin puede consultar los metadatos para encontrar que o*jetos estn disponi*les # que funciones # campos estn presentes en la clase. $a re)lection est disponi*le para usuarios finales para determinar como son los o*jetos( *%squeda de atri*utos o ejecutar mtodos en los que los nom*res no son conocidos hasta el tiempo de ejecucin. $os metadatos son utili-ados para +arias tareas1

!ara representar la informacin #ue el C". utili a para locali ar y cargar clases. !ara sacar las instancias de las clases en memoria. !ara resolver la invocacin de m,todos. !ara traducir 0" a cdigo nativo. !ara for ar la seguridad.

!l encargado de generar los metadatos es el compilador C#( al pasar el cdigo a D$( emitiendo la informacin *inaria de los metadatos en un archi+o P!. $a principal +entaja de la com*inacin de los metadatos con el cdigo ejecuta*le es que la informacin acerca de los tipos es persistente. 3na herramienta que toma +entaja de re)lection es el D$C/S: &:icrosoft . !" 9rame4orV D$ Cisassem*ler)( el cual anali-a la aplicacin de metadatos fuente # entonces presenta informacin acerca de la aplicacin en la jerarqu0a del r*ol. Seguridad $a faceta ms importante de cualquier am*iente de desarrollo de aplicaciones distri*uidas es como manejar la seguridad. $a seguridad comien-a tan pronto como una clase es caragada por el C$' porque la clase loader es parte del esquema de seguridad . !"( la seguridad relacionada a factores tales como reglas de accesi*ilidad # requerimientos de consistencia son +erificados. Ceplo#ment $a lla+e para el Ceplo#ment de aplicaciones . !" es el concepto de &ensambles). $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. $a especificacin de como deplo# una aplicacin podr0a +ariar #a que se puede tratar de un desarrollo 4e* o aplicacin tradicional de escritorio. !l runtime . !" mantiene el rastreo delos archi+os # de las +ersiones de los archi+os asociados con una aplicacin. Cualquier aplicacin que es instalada es automticamente asociada con los archi+os que son parte de ese ensam*le. Si una aplicacin de instalacin intenta so*re escri*ir un archi+o necesario para otra aplicacin( el runtime . !" es lo *astante inteligente para permitir que la aplicacin de instalacin( 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 aplicacin. Dnteropera*ilidad con cdigo no administrado !l cdigo no administrado no tiene las +entajas que tiene el cdigo administrado( como recoleccin de *asura( sistema de tipo unificado # metadatos.

Cdigo administrado invocando funciones 1"" no administradas, cuando la aplicacin necesita una interfa para una 1"" en C y la empresa #ue

19

escribe la 1"" no adopta .NET ser$ necesario invocar esa 1"" desde una aplicacin .NET.

Cdigo administrado usando componentes C)', es posible lograr esto creando un 7rapper .NET para el componente C)', as2 #ue el cliente administrado trabaja con clases .NET Cdigo no administrado usando servicios .NET, cuando se desea acceder a .NET desde cdigo no administrado.

Common $anguage Specification 8 C$S !s un conjunto de reglas que un lenguaje de*e adherir para crear aplicaciones . !" que se ejecutan en el C$'. 3n concepto importante relacionado a la C$' es el cdigo administrado( el cdigo administrado es justo el cdigo que esta ejecutandose *ajo el auspicio de la C$' # por consiguiente comien-a a ser controlado por el C$'. !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 programacin que tam*in se adhieren a la C$S. !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( mtodos( campos( propiedades( enumeraciones( e.cepciones( interfaces( e+entos( atri*utos personali-a*les( delegados( identificadores( etc. que la propia especicicacin define. Qirtual !.ecution S#stem 8 Q!S !l Sistema Qirtual de !jecucin implementa la Q2S # se crea implementando un motor de ejecucin &E7ecution Engine !!). $os componentes de la Q!S son1

"enguaje 0ntermedio * ntermediate Language - 0"+, dise:ado para ser facilmente traducido a una amplia gama de lenguajes, por lo #ue el compilador C# es capa de generar el lenguaje intermedio. Carga del Cdigo /dministrado *"oading 'anaged Code+, resuelve nombres, obtiene clases de la memoria, crea stubs #ue son necesarios para la compilacin ?0T. "a class loader for a la seguridad. Conversin de 0" a Cdigo Nativo via ?0T, el cdigo del lenguaje intermedio no esta dise:ado como un interprete tradicional bytecode o $rbol de cdigo, la conversin del lenguaje intermedio es realmente una compilacin. Carga de 'etadatos, se encarga de checar la seguridad de tipos y la integridad de los m,todos. .ecolector de 6asura y 'anejo de E%cepciones *;arbage Collection+, el codigo administrado premite rastrear el apilado en el runtime, para #ue el runtime entienda el apilado individual de frames un cdigo administrado tiene #ue ser proporcionado por el ?0Ter o por el compilador. &ervicios de debugging, estos servicios dependeran de la informacin producida por el compilador del lenguaje fuente y se emiten dos mapas,

20

un mapa del lenguaje fuente de la construccin de direcciones en el flujo de instrucciones y un mapa de las direcciones de las localidades en el apilado de frames.

/dministracin de 4ilos, el (E& proprorciona este servicio al cdigo administrado.

"ipos de Catos C# soporta el conjunto de tipos de datos usual( para cada tipo de dato que C# soporta( e.iste una correspondencia tipo de lenguaje com%n en tiempo de ejecucin . !" su*#acente. "odos los tipos runtime pueden encontrarse en el namespace S#stem del lenguaje com%n en tiempo de ejecucin . !". "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 Cescripcin 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.ed8precision num*er 3nicode string 3nicode character Boolean +alue

$os tipos de datos son separados en (alue t,pes # re)erence t,pes. $os value types son asignados en estructuras de pilas o en l0nea. $os reference types son asignados al aglomerado. $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. $a en+oltura es marcada por lo que el sistema conoce que contiene por ejemplo int( a este proceso se le conoce como *o.ing # el proceso de re+ersa se le conoce como un*o.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.

21

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; string s > 7Septiem*re7; 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. pu*lic const string sCominio > 7informatique.com.m.7; $a restriccin de tipos constantes es que son conoci*les en tiempo de compilacin( en +e- de ello es posi*le utili-ar el modificador readonl# el cual est dise6ado para aquellas situaciones en donde las constantes tienen restriccin. /plicando el modificador readonl# un +alor puede ser esta*lecido en el constructor o en una iniciali-acin pero no puede ser modificado despus. !jemplo 5ello Aorld[ !l cdigo C# puede ser escrito en cualquier editor( tam*in puede escri*irse con Qisual Studio \. !l cdigo C# de*e almacenarse en un archi+o con e.tensin .cs Para compilar el cdigo C# es necesario tener instalado la Plataforma . !" que inclu#e el compilador C#( puede *uscar el ejecuta*le en la ruta1 C1AD C2AS:icrosoft. !"9rame4orV+J.J.POGGcsc.e%e /segurese de tener esta ruta en el path para poder ejecutar el compilador desde cualquier u*icacin. 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.cs $a salida e.itosa de la compilacin podr0a ser as01 :icrosoft &') Qisual C# . !" Compiler +ersion \.J?.K??J.P for :icrosoft &') . !" 9rame4orV +ersion J.J.POGG Cop#right &C) :icrosoft Corporation G??J8G??G. /ll rights reser+ed. Si e.iste alg%n error el compilador lo notificar. !l archi+o es compilado # ligado a hello4orld.e.e( &el archi+o .e.e generado tendr el nom*re del archi+o fuente) para ejecutar el programa slo 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.e.e nom*re/rchi+o9uente.cs !l siguiente es el ejemplo t0pico de los lenguajes de programacin1 class 5elloAorld< pu*lic static +oid :ain&)< S#stem.Console.Arite$ine&75ello Aorld7); @ @

22

!l mtodo :ain de*e estar contenido en la clase # escrito con la primer letra en ma#%scula. !l tipo de este mtodo puede ser +oid o int. "am*in este mtodo 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. !s posi*le importar el namespace en las aplicaciones indicandolo al inicio del cdigo con la pala*ra reser+ada using que es una directi+a para el namespace S#stem. !.isten ms namespaces en la Plataforma . !" using S#stem; !jemplo /rgs !.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; class /rgs< pu*lic static +oid :ain&stringEF args)< Console.Arite$ine&7/rgumentos 1 <?@7( args.$ength); for&int itera > ?; itera L args.$ength; itera,,) Console.Arite$ine&7/rgumento <?@ 1 <J@7( itera( argsEiteraF); @ @ !jemplo de /rgs con foreach1 using S#stem; class /pp< pu*lic static +oid :ain&stringEF args)< foreach&string input in args)< Console.Arite$ine&input); @ @ @

using &ystemC, define el namespace &ystem, el cual contiene entre otras la clase Console la cual es utili ada para comunicarse con la l2nea de comandos. using permite al usuario omitir el namespace al utili ar el tipo al #ue es referenciado en este caso &ystem, por lo #ue en ve de escribir= &ystem.Console.9rite"ine*+C &olamente se escribe= Console.9rite"ine*+C using no puede ser utili ado con un nombre de clase por lo #ue no es permitido escribir using &ystem.Console

class /rgs, /l no e%istir las funciones globales en C#, se declara una clase llamada /rgs.

23

public static void 'ain*stringDE args+, "a clase /rgs contiene una funcin o m,todo 'ain*+, el cual sirve como punto de partida de la ejecucin del componente, este m,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. /l ser un m,todo de arran#ue debe ser declarado con el modificador static por#ue no est$ asociado con una instancia de un objeto. El m,todo indica #ue recibe un arreglo de tipo string llamado args

Console.9rite"ine*F/rgumentos = GHIF, args."ength+C, invoca el m,todo 9rite"ine de la clase Console para escribir en la l2nea de comando lo #ue se indica entre los par,ntesis. "a primer parte de lo #ue se encierra entre par,ntesis es un string donde es necesario destacar #ueGHI, es una notacin #ue indica entre llaves un 2ndice #ue hace referencia a una variable asociada a este, en este caso asociada con args."ength args."ength, "ength es un m,todo de la clase args el cual obtiene el nmero de elementos #ue contiene este arreglo.

El ciclo for comien a una iteracin desde H hasta el nmero de elementos #ue contiene el arreglo args."ength, por cada elemento contenido en el arreglo escribe en la l2nea de comandos lo #ue se indica en *F/rgumento GHI = GJIF, itera, argsDiteraE+ #ue como mencionamos anteriormente GHI hace referencia al orden en #ue las variables ser$n escritas, en este caso corresponde al iterador y GJI corresponde a argsDiteraE, lo cual indica obtener el elemento en cuestin del arreglo args. !ara compilar el componente utilice csc /rgs.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 ... pn !or ejemplo= args http = 777 . informati#ue . com . m% &alida = /rgumentos = N /rgumento H = http /rgumento J = =

24

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

25

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

26

Preprocesamiento $o ms importante en este punto es que en C# no e.iste el preprocesador( el moti+o por el cual no e.iste es para simplificar la estructura de compilacin adems de que no ha# necesidad de escri*ir un archi+o de enca*e-ados por separado # mantener en sincronia la implementacin( cuando los archi+os fuente C# son compilados el orden de la compilacin de archi+os indi+iduales no es importante # es equi+alente a un archi+o de gran tama6o. 3n identificador es el nom*re que es usado para alg%n elemento de un programa como una +aria*le o funcin # de*en tener una letra o guin *ajo como primer caracter. C# soporta las siguientes directi+as de preprocesamiento1 "ama6o #define #undef #if #elif #else #endif Qalor Cefine un identificador( los identificadores tam*in pueden ser definidos +ia la l0nea de comando !limina la definicin de un identificador !l cdigo de la seccin es compilado si la e.presin es +erdadera Constructor !lse8if( si la directi+a anterior no se cumplio # si la e.presin es +erdadera el cdigo de la seccin es compilado Si la directi+a anterior no se cumplio el cdigo de la seccin es compilado :arca el final de la seccin

$os identificadores de*en preceder a cualquier cdigo real. !s posi*le utili-ar los siguientes operadores en e.presiones preprocesador1

P QQ PQ RR SS

!s posi*le utili-ar parntesis para agrupar e.presiones. Comentarios !s posi*le comentar el cdigo( para ello e.isten dos modalidades1

TT, #ue se utili a para comentar una l2nea, es decir, todo lo #ue sigue a TT es ignorado. TU UT, #ue se utili a para comentar segmentos de cdigo.

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 operacin.

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. C# agrupa los +alue t#pes en1

Tipos &imples Tipos Estructura Tipos Enumeracin

"ipos Simples $os Tipos &imples de C# comparten caracter0sticas como las de alias con los tipos de sistema de . !"( e.presiones constantes consisten de "ipos Simples e+aluados solamente en tiempo de compilacin no en tiempo de ejecucin # los "ipos Simples pueden ser iniciali-ados con literales. $os "ipos Simples de C# se agrupan en1

0ntegral .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 .epresenta valores booleanos verdadero y falso, por lo #ue es posible asignar a una variable un valor booleano o el resultado de una e%presin= bool bContinuar Q *a V b+C

28

En C# el valor verdadero no es posible representarlo con algn valor diferente de cero, no hay una conversin entre el tipo integral a bool #ue force esta conversin.

Char .epresenta un caracter 8nicode de JM bit de tama:o, por ejemplo= char c&e%o Q W'WC Tambi,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, esto significa por ejemplo #ue tratar de convertir una variable char a un tipo de dato integral no es posible en C#, por lo #ue se tendr$ #ue hacer un cast e%plicito= char cCaracter Q *char+MLC int nNumero Q *int+W/WC

5loating !oint .epresentan dos tipos de datos, flotantes *float+ y dobles *double+= "ipo float Qalor J.I.J?8PI a O.P.J?OY con una precisin de \ d0gitos

dou*le I.?.J?8OGP a J.\.J?O?Y con una precisin de JI8JK d0gitos /l reali ar operaciones con !loating "oint pueden producirse los siguientes valores=

Cero positivo y negativo 0nfinito positivo y negativo NaN, Not-a-Number

Nota= &i una e%presin un valor es de tipo !loating "oint todos los otros valores son convertidos a tipos !loating "oint antes de reali ar el c$lculo.

1ecimal .epresenta un tipo de alta precisin de JAN bit el cual es posible utili arlo para calculos financieros y monetarios. "os valores posibles

29

comprenden los rangos J.H%JH-AN a O.X%JHAN con una precisin de AN a AX d2gitos. No hay conversiones implicitas entre decimales y dobles, se podr2a generar un o#erflo$ o perder precisin, por lo #ue es necesario una conversin e%pl2cita con un cast. 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.Hm &i se omite la letra m la variable podr2a ser tratada como double por el compilador antes de ser asignado. "ipos !structura 3n tipo struct puede declarar constructores( constantes( campos( mtodos( propiedades( 0ndices( operadores # tipos anidados. $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. $as estructuras de*er0an ser utili-adas slo para tipos que son realmente una pie-a de datos. $a diferencia entre struct # class en C# es que struct es un (alue t,pe # class es una re)erence t,pe. $a principal idea de utili-ar struct es para crear o*jetos ligeros como Point( 9ileDnfo( etc.( de esta manera se conser+a memoria porque no ha# referencias adicionales que son creadas como se necesiten por o*jetos clase. using S#stem; struct DP< pu*lic *#te *J(*G(*O(*P; @ class ip< pu*lic static +oid :ain&)< DP miDP; miDP.*J > JWG; miDP.*G > JKY; miDP.*O > J; miDP.*P > J?J; Console.Arite&7<?@.<[email protected]( miDP.*J(miDP.*G); Console.Arite&7<?@.<J@7( miDP.*O(miDP.*P); @ @ "ipos !numeracin !s posi*le esta*lecer un conjunto de constantes relacionadas( por default los elementos de una enumeracin son de tipo int donde el primer elemento tiene el +alor ? # cada elemento su*secuente se incrementa en J. !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 despus del nom*re de la enumeracin aunque estn restringidos a los tipos1 long( int( short # *#te. Sinta.is1 enum om*re!numeraciones< constanteJ( constanteG(

30

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

31

$os re)erence t,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. !l "ipo 2*jeto es utili-ado cuando el (alue t,pe esta bo7ed( es decir( que est disponi*le como un o*jeto. "ipo Clase !l Tipo Clase contiene datos miem*ro( funciones miem*ro # tipos anidados. $os datos miem*ro son constantes( campos # e+entos. $as funciones miem*ro inclu#en mtodos( propiedades( 0ndices( operadores( constructores # destructores. Dnterfaces 3na interface declara un tipo referencia que tiene slo miem*ros a*stractos. Slo e.iste la firma pero no tiene implementado todo el cdigo( por lo que no es posi*le instanciar una interface( slo un o*jeto que deri+a de la interface. Para crear una interface se emplea la pala*ra reser+ada interface1 using S#stem; interface Duno< +oid /ccion3no&); @ class Dmplementa 1 Duno< pu*lic +oid /ccion3no&)< Console.Arite$ine&7/ccin uno...7); @ @ class /pp< pu*lic static +oid :ain&)< Dmplementa D > ne4 Dmplementa&); D./ccion3no&); @ @ !s posi*le definir mtodos( 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 slo es posi*le deri+ar de slo una clase. $as interfaces estn estrechamente relacionadas a clases a*stractas( se parecen a una clase a*stracta que tiene todos sus miem*ros a*stractos. Cuando un o*jeto implementa una interface( una referencia a la interface puede ser o*tenida por un cast de la interface. 3na clase puede implementar ms de una interface.

32

class om*reClase 1 Dnterface/( DnterfaceB<@ !.iste una tcnica llamada 5mplementacin de la 5nter)ace E7pl9cita # se utili-a para resol+er colisiones con nom*res de mtodos iguales entre interfaces1 using S#stem; interface Duno< +oid /ccion3no&); @ interface Ddos< +oid /ccion3no&); @ class Dmplementa 1 Duno( Ddos< +oid Duno./ccion3no&)< Console.Arite$ine&7Colisin resuelta con el nom*re del mtodo Duno7); @ +oid Ddos./ccion3no&)< Console.Arite$ine&7Colisin resuelta con el nom*re del mtodo Ddos7); @ @ class /pp< pu*lic static +oid :ain&)< Dmplementa D > ne4 Dmplementa&); Duno uno > &Duno) D; uno./ccion3no&); Ddos dos > &Ddos) D; dos./ccion3no&); @ @ !s posi*le ocultar al usuario de la clase la implementacin de una interfa-( as0 como tam*in es posi*le crear interfaces *asadas de otras interfaces. Celegados $os delegados son similares a las interfaces( especifican un contratado entre un caller # un implementer &implementador). 3n delegado especifica la forma de una funcin en +e- de especificar toda una interface. $as interfaces se crean en tiempo de compilacin # los delegados son creados en tiempo de ejecucin. 3n delegado encapsula un mtodo con cierta firma( *sicamente un delegado es un t,pe1sa)e # secure (ersion. 3n delegado es una implementacin 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. !s posi*le encapsular mtodos estticos e instancias en una instancia delegado. !l principal uso de los delegados es con los e+entos no con las clases. $a especificacin del delegado determina la forma de la funcin # crea una instancia del delegado( se usa la funcin que coincide con la forma. $os delegados al ser de naturale-a dinmica se utili-an cuando el usuario desea cam*iar el comportamiento( por ejemplo si deseamos que una clase 2rdenamiento soporte diferentes mtodos de ordenacin( la ordenacin podr0a ser controlada en *ase a un delegado que defina la funcin de comparacin.

33

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 estticas 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. $a clase string deri+a directamente de o*ject # no es posi*le deri+arla. "odos los strings en C# son instancias del tipo S#stem.String en el C$'. string es un alias para la clase predefinida S#stem.String # su uso es mu# sencillo1 string sAe*Site > 7http1==444.informatique.com.m.7; Para acceder a un caracter( simplemente acceda a su 0ndice1 sAe*SiteEJJF; !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; class /pp< pu*lic static +oid :ain&)< string sAe*Site > 7http1==444.informatique.com.m.7; Console.Arite$ine&7sAe*Site contiene 1 7 , sAe*Site.$ength , 7 caracteres7); for&int i!lemento > ?; i!lemento L sAe*Site.$ength; i!lemento,,)< Console.Arite$ine&7!lemento 7 , i!lemento , 7 1 7 , sAe*SiteEi!lementoF); @ @ @ !s posi*le concatenar strings utili-ando el operador ,. Si requiere comparar strings por igualdad utilice el operador de comparacin >> /unque string es un re)erence t,pe la comparacin se reali-a comparando los +alores no las referencias. $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 +ersin modificada del string en +e- de modificar la instancia en la cual se in+oco el mtodo. $a clase String soporta los sisguientes mtodos de comparacin # *%squeda1 :todo Compare&) Compare2rdinal&) Compare"o&) !ndsAith&) StartsAith&) Dnde.2f&) $astDnde.2f&) Concat&) Cescripcin Compara dos strings. Compara dos regiones de strings utili-ando una comparacin ordinal Compara la instancia actual con otra instancia. Cetermina cuando un su*string e.iste al final de un string Cetermina cuando un su*string e.iste al principio de un string. 'egresa la posicin de la primer ocurrencia de un su*string 'egresa la posicin de la %ltima ocurrencia de un su*string Concatena dos o ms strings u o*jetos( si se pasan o*jetos

34

la funcin "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*icacin del string dentro del arreglo 'egresa un nue+o string con un su*string insertado en la u*icacin 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 ms caracteres !.trae un su*string de un string regresa una +ersin de un string en min%sculas regresa una +ersin 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."oString&)( con+ierte un o*jeto a una representacin string. String.9ormat&) puede ser utili-ada para crear un string *asado en los +alores de otro string. $a clase StringBuilder soporta las siguientes propiedades # mtodos1 Propiedad Capacit# EF $ength :a.Capacit# :todo /ppend&) /ppend9ormat&) !nsureCapacit#&) Dnsert&) Cescripcin '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 posicin espec0fica 'ecupera o esta*lece la longitud 'ecupera la capacidad m.ima del StringBuilder Cescripcin /grega la representacin string de un o*jeto /grega la representacin 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 representacin string de un o*jeto espec0fico en una posicin espec0fica

35

'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. $os arreglos en C# son referencias a o*jetos. 3n arreglo (alue t,pe no contiene instancias *o.ed. !l +alor inicial de un arreglo es null( un arreglo de o*jetos es creado utili-ando ne4. Cuando un arreglo es creado inicialmente contiene los +alores por default para los tipos que este contendr. Sinta.is1 tipoEF identificador; Note que para definir un arreglo se utili-an los corchetes EF despus del tipo del arreglo. !jemplo1 stringEF aPersonas; !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@; Curante la iniciali-acin es posi*le omitir ne4 tipoE.F # el compilador podr0a determinar el tama6o de almacenamiento para el arreglo del n%mero de items en la lista de iniciali-acin1 stringEF asPersonas > <7"im Berners8$ee7(7Brendan !ich7(7Cennis 'itchie7(7Sames Hosling7@; Cada elemento de un arreglo de ints es un int con el +alor ?1 intEF ai umeros > ne4 intEIF; Cada elemento de un arreglo de strings es un string con el +alor null1 stringEF as om*res > ne4 stringEIF; $a dimensin del arreglo puede ser simple o multidimensional( donde cada dimensin 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.$ength 8 J o nDndice L nom*re/rreglo.$ength); using S#stem; class /rreglo< static pu*lic +oid :ain&)< stringEF a om*res > <75ugo7(7Paco7(7$uis7@; Console.Arite$ine&a om*resE?F); Console.Arite$ine&a om*resEJF); Console.Arite$ine&a om*resEGF); @ @ 2tra alternati+a al ejemplo anterior es1 intEF ai umeros > ne4 intEOF; ai umerosE?F > P; ai umerosEJF > OO; ai umerosEGF > PO;

36

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

intE(F aiBidimensional > < <JJ(GG@( <OO(PP@( <II(KK@( <\\(YY@ @;

37

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

38

Console.Arite$ine&7888 /rreglo de 2*jetos 8887); !mpleadoEF aProgramadores > ne2 !mpleadoEGF; aProgramadoresE?F > ne4 !mpleado&7Bill Hates7( I?); aProgramadoresEJF > ne4 !mpleado&7!ric S. 'a#mond7( K?); for&int i > ?; i L aProgramadores.$ength; i,,)< Console.Arite$ine&7aProgramadoresE7,i,7F.s om*re 1 7 , aProgramadoresEiF.s om*re); Console.Arite$ine&7aProgramadoresE7 , i , 7F.i!dad 1 7 , aProgramadoresEiF.i!dad); Console.Arite$ine&7aProgramadoresE7 , i , 7F."ipo 1 7 , aProgramadoresEiF."ipo&)); @ @ @ Con+ersin de /rreglos 3na con(ersin impl9cita es posi*le si los arreglos tienen el mismo n%mero de dimensiones( si los elementos de un arreglo tienen una con+ersin de referencia impl0cita para los tipos de elementos del otro arreglo # am*os arreglos son tipos referencia. 3na con(ersin e7pl9cita tiene los mismos requerimientos de una con+ersin impl0cita e.cepto que los elementos de un arreglo de*en ser con+erti*les e.pl0citamente a los tipos de elementos del otro arreglo. Clase /rra# $a clase /rra# pro+ee entre otras( funciones de *%squeda # ordenamiento. !n el siguiente ejemplo se muestra como es ordenado un arreglo de strings1 using S#stem; 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,,7@; /rra#.Sort&a$enguajes); for&int elemento > ?; elemento L a$enguajes.$ength; elemento,,) Console.Arite$ine&7!lemento E7 , elemento , 7F > 7 , a$enguajesEelementoF); @ @ &alida= !lemento E?F > /ctionScript !lemento EJF > C !lemento EGF > C# !lemento EOF > C,, !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 funcin Sort&)( tam*in se puede utili-ar con n%meros1 using S#stem;

39

class /pp< pu*lic static +oid :ain&)< dou*leEF a umeros > <Y.\( K.W( 8K.I( P.G( 8J?G.?W( J.W( ?.?J( 8?.??G( WW.Y\@; /rra#.Sort&a umeros); for&int elemento > ?; elemento L a umeros.$ength; elemento,,) Console.Arite$ine&7!lemento E7 , elemento , 7F > 7 , a umerosEelementoF); @ @ &alida1 !lemento E?F > 8J?G.?W !lemento EJF > 8K.I !lemento EGF > 8?.??G !lemento EOF > ?.?J !lemento EPF > J.W !lemento EIF > P.G !lemento EKF > K.W !lemento E\F > Y.\ !lemento EYF > WW.Y\ Dnterface DCompara*le $a funcin 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 ordenacin utili-ando una propiedad numrica1 using S#stem; pu*lic class $enguaje 1 DCompara*le< string nom*re; int id; pu*lic $enguaje&string nom*re( int id)< this.nom*re > nom*re; this.id > id; @ int DCompara*le.Compare"o&o*ject o)< $enguaje lenguajeB > &$enguaje)o; if&this.id Z lenguajeB.id)<return J;@ if&this.id L lenguajeB.id)< return 8J; @else< return ?; @ @ pu*lic o+erride string "oString&)< return nom*re , 7 7 , id; @ @ class /pp< pu*lic static +oid :ain&)< $enguajeEF a$enguaje > ne4 $enguajeEIF; a$enguajeE?F > ne4 $enguaje&7C7(O); a$enguajeEJF > ne4 $enguaje&7/ctionScript7(I); a$enguajeEGF > ne4 $enguaje&7Sa+aScript7(G); a$enguajeEOF > ne4 $enguaje&7Sa+a7(Y);

40

a$enguajeEPF > ne4 $enguaje&7P5P7(J); /rra#.Sort&a$enguaje); foreach&$enguaje len in a$enguaje) Console.Arite$ine&len); @ @ &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. Cada clase slo 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*in implementar la funcin Comapare&)1 using S#stem; using S#stem.Collections; pu*lic class $enguaje 1 DCompara*le< string nom*re; int id; pu*lic $enguaje&string nom*re( int id)< this.nom*re > nom*re; this.id > id; @ int DCompara*le.Compare"o&o*ject o)< $enguaje lenguajeB > &$enguaje)o; if&this.id Z lenguajeB.id)<return J;@ if&this.id L lenguajeB.id)< return 8J; @else< return ?; @ @ pu*lic o+erride string "oString&)< return nom*re , 7 7 , id; @ pu*lic class 2rdena om*res 1 DComparer< pu*lic int Compare&o*ject o/( o*ject oB)< $enguaje len/ > &$enguaje)o/; $enguaje lenB > &$enguaje)oB; return String.Compare&len/.nom*re(lenB.nom*re); @ @ @ class /pp< pu*lic static +oid :ain&)< $enguajeEF a$enguaje > ne4 $enguajeEIF;

41

a$enguajeE?F > a$enguajeEJF > a$enguajeEGF > a$enguajeEOF > a$enguajeEPF >

ne4 $enguaje&7C7(O); ne4 $enguaje&7/ctionScript7(I); ne4 $enguaje&7Sa+aScript7(G); ne4 $enguaje&7Sa+a7(Y); ne4 $enguaje&7P5P7(J);

/rra#$ist a$ist > ne4 /rra#$ist&); a$ist./dd&a$enguajeE?F); a$ist./dd&a$enguajeEJF); a$ist./dd&a$enguajeEGF); a$ist./dd&a$enguajeEOF); a$ist./dd&a$enguajeEPF); a$ist.Sort&&DComparer) ne4 $enguaje.2rdena om*res&)); foreach&$enguaje len in a$ist) Console.Arite$ine&len); @ @ &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 esttica # hacerlo por el usuario1 using S#stem; using S#stem.Collections; pu*lic class $enguaje 1 DCompara*le< string nom*re; int id; pu*lic $enguaje&string nom*re( int id)< this.nom*re > nom*re; this.id > id; @ int DCompara*le.Compare"o&o*ject o)< $enguaje lenguajeB > &$enguaje)o; if&this.id Z lenguajeB.id)<return J;@ if&this.id L lenguajeB.id)< return 8J; @else< return ?; @ @ pu*lic o+erride string "oString&)< return nom*re , 7 7 , id; @ pu*lic static DComparer 2rdena< get< return &DComparer) ne4 2rdena om*res&); @ @ pu*lic class 2rdena om*res 1 DComparer<

42

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

43

n r t +

ue+a l0nea 'etorno de carro "a*ulador "a*ulador +ertical

Bo.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. using S#stem; class /pp< pu*lic static +oid :ain&)< int i!dad > OO; o*ject o umero > i!dad; ==Bo. int i umero > &int)o umero; ==3n*o. ==cast necesario porque o umero podr0a contener cualquier tipo de o*jeto @ @ Nota( durante la con+ersin unbo7ing el tipo de*e coincidir e.actamente( un +alor de tipo bo7ed no puede ser unbo7ed &con+ertido) a un tipo compati*le. Si requiere o*tener otro tipo de +alor diferente al que contiene el bo7ed( en ese caso primero o*tenga el +alor correcto # despus realice un cast al tipo que requiera1 &+alor'equerido) +alor'equerido +r > &+alor'equerido)&+alorBo.ed)o*jeto; 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,pes. Con+ersiones Bo.ing Bo7ing un +alor se refiere a la con+ersin impl0cita de cualquier tipo de +alor al tipo o*jeto. Cuando un tipo de +alor es bo7ed se asigna espacio a una instancia de o*jeto # el +alor del (alue t,pe es copiado al nue+o o*jeto. 2*ser+e las siguientes l0neas1 int i umero > G?JG; o*ject o umero > i umero; ==in+ocacin implicita a una operacin bo7ing /l asignar el +alor de la +aria*le entera n umero a una +aria*le o*jeto se reali-a internamente una operacin 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.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; class Bo.< pu*lic static +oid :ain&)< int i umero > G?JG; o*ject o umero > i umero; ==in+ocacin implicita a una operacin bo7ing o umero > G??I; Console.Arite$ine&i umero); Console.Arite$ine&o umero); @

44

@ /l ejecutar el cdigo notar que el +alor de o umero es G??I # el +alor de i umero no cam*io permanece en G?JG. Con+ersiones 3n*o.ing /l contrario que Bo7ing( 8nbo%ing es un mecanismo de una operacin e.pl0cita( por lo que es necesario indicar al compilador que tipo de +alor deseamos e.traer de un o*jeto( al reali-ar la operacin ;nbo7ing C# checa que el (alue t,pe que se requiere este almacenado en la instancia del o*jeto( si la +erificacin es e.itosa el +alor es ;nbo7ing. Suponga que tiene una +aria*le de tipo int # asigna el +alor de esta +aria*le int a un o*jeto( despus 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 slo un +alor int # no puede ser asignado a la +aria*le double porque el C$' dispara una e.cepcin &S#stem.Dn+alidCast!.ception)1 int i umero > G?JG; o*ject o umero > i umero; ==in+ocacin implicita a una operacin bo7ing dou*le d umero > &dou*le)o umero; ==in+ocacion e.pl0cita &cast) ==C$' dispara la e.cepcin &ystem.0nvalidCastE%ception Constructores # Cestructores /ntes de acceder a los mtodos o propiedades de una clase( primero se ejecuta el constructor de la clase el cual contiene cdigo de iniciali-acin( si no se escri*e un constructor para la clase el compilador pro+ee automticamente un constructor de)ault. !n el runtime ..E/ el programador no puede controlar la destruccin de o*jetos. 3n constructor puede in+ocar un constructor del tipo *ase utili-ando la sinta.is *ase. $os constructores son in+ocados in+ocados automaticamente slo cuando una instancia de un o*jeto es creada con ne4. 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. No tiene declarado un tipo de regreso. !or lo general tienen el modificador pblico. &on utili ados para iniciali ar varibles. &i la clase slo contiene miembros est$ticos, es posible crear un constructor private, lo cual significa #ue no podr$ ser accesible fuera de la calse o #ue slo se puede acceder desde la clase. No puede ser invocado desde la definicin de la clase. 8n objeto no puede ser instanciado desde la definicin de la clase.

/l codificar no se est limitado a los parmetros del constructor( es posi*le en+iar argumentos iniciales para iniciali-ar ciertos miem*ros. using S#stem;

45

class Qehiculo< ==Propiedades1 pri+ate int i'ueda; pri+ate int iPuerta; pri+ate int iQentana; pri+ate int i5elice; pri+ate int i:otor; pri+ate int i/siento; pri+ate string s"ipo;==/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; iPuerta > Puerta; iQentana > Qentana; i5elice > 5elice; i:otor > :otor; i/siento > /siento; s"ipo > "ipo; @ ==$ectura=escritura de propiedades1 pu*lic int 'uedas< get<return i'ueda;@ set<i'ueda > +alue;@ @ pu*lic int Puertas< get<return iPuerta;@ set<iPuerta > +alue;@ @ pu*lic int Qentanas< get<return iQentana;@ set<iQentana > +alue;@ @ pu*lic int 5elices< get<return i5elice;@ set<i5elice > +alue;@ @ pu*lic int :otores< get<return i:otor;@ set<i:otor > +alue;@ @ pu*lic int /sientos< get<return i/siento;@ set<i/siento > +alue;@ @ pu*lic string "ipo<

46

get<return s"ipo;@ set<s"ipo > +alue;@ @ @ ==/plicacin1 class /plicConstructor< pu*lic static +oid :ain&)< Qehiculo :i/+ion > ne4 Qehiculo&G(J(J??(?(O(G??(7/ereo7); Console.Arite$ine&7'uedas 1 7 , :i/+ion.'uedas); Console.Arite$ine&7Puertas 1 7 , :i/+ion.Puertas); Console.Arite$ine&7Qentanas 1 7 , :i/+ion.Qentanas); Console.Arite$ine&75elices 1 7 , :i/+ion.5elices); Console.Arite$ine&7:otores 1 7 , :i/+ion.:otores); Console.Arite$ine&7/sientos 1 7 , :i/+ion./sientos); Console.Arite$ine&7"ipo 1 7 , :i/+ion."ipo); @ @ !n un sentido estricto en C# no se tienen destructores( pero el termino destructor se refiere a la li*eracin de recursos. !s posi*le escri*ir un mtodo que li*ere recursos despus de ser utili-ados( pero porque escri*ir un mtodo para li*erar recursos si e.iste un destructor1 pu*lic a om*reClase&)< ==li*erar recursos @ $a ra-n por la cual se de*er0a escri*ir un mtodo adicional es por el recolector de *asura( el cual no es in+ocado inmediatamente despus que las +aria*les quedan fuera de m*ito( slo se in+oca el recolector de *asura en ciertos inter+alos o condiciones de memoria. $o que podr0a suceder es que los recursos se agoten antes de ser utili-ados( entonces es *uena idea pro+eer un mtodo e.pl0cito 'elease( el cual tam*in puede ser in+ocado por el destructor1 pu*lic +oid 'elease&)< ==$i*erar recursos @ pu*lic a om*reClase&)< 'elease&); @ $a in+ocacin del mtodo 'elease en el destructor no es o*ligatoria( la coleccin garbage de cualquier forma reali-a la li*eracin de cualquier o*jeto( pero es una *uena prctica no ol+idar li*erar los recursos. Constructor !sttico 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-. !n el runtime ..E/ el usuario no tiene control so*re cuando el constructor esttico es in+ocado( #a que el runtime slo garanti-a que algo es in+ocado despus 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 esttico. Para declarar un constructor esttico se utili-a el modificador static1 class om*reClase<

47

static . . @ @

om*reClase&)<

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

ma#or menor ma#or

es es es

1 1 1

7 7 7

, , ,

48

Console.Arite$ine&7$a :i9echa.:enor&GJ(J?(G???( GJ(W(JW\J)); Console.Arite$ine&7$a :i9echa.:a#or&GJ(J?(G???( GJ(W(G??I)); Console.Arite$ine&7$a :i9echa.:enor&GJ(J?(G???( GJ(W(G??I)); @ @

fecha fecha fecha

menor ma#or menor

es es es

1 1 1

7 7 7

, , ,

/l pasar un +alor # no una referencia a la +aria*le( es posi*le utili-ar e.presiones constantes( el resultado de los mtodos :a#or # :enor es pasado a el caller como un +alor de regreso # es manipulado sin ser almacenarlo en una +aria*le intermedia. Si no ha# modificadores los parmetros son siempre pasados por +alor. Qalores en Parmetros re) !s posi*le pasar un +alor como parmetro a un mtodo( modificar el +alor # regresarlo como resultado del mtodo( para ello se utili-a el modificador ref seguido del tipo # del nom*re del parmetro. /l contrario de los (alores en parmetros no se pasa una copia del +alor( sino la referencia del +alor # por ello al modificar el +alor se hace la modificacin directa( tam*in es necesario iniciali-ar el +alor que se pasa como paramtro por medio de una +aria*le intermedia # no directamente a tra+s de una e.presin constante1 using S#stem; pu*lic class Param< pu*lic +oid Parametro'ef&ref int 'efParametro)<== o regresa un +alor e.pl0cito 'efParametro M> 'efParametro; ==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&); int iQalor'ef > I; ==Se requiere iniciali-ar el +alor :iParam.Parametro'ef&ref iQalor'ef);==Se in+oca el mtodo pasando la referencia del +alor Console.Arite$ine&7ref 1 7 , iQalor'ef); @ @ ;ood !ractice( se recomienda tener dos +aria*les( una en el parmetro # otra en el parmetro ref. .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.isten dos formas de hacerlo1

0niciali ar la variable al declararla.

49

using &ystemC class 'iClaseG private int 'i!ropiedadC public void /signar(alor*ref int 'i.ef!aram+G this.'i!ropiedad Q 'i.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./signar(alor*ref 'iEdad+C Console.9rite"ine*F'iEdad = F > 'iEdad+C Console.9rite"ine*F'i)bjeto.'i!ropiedad = 'i)bjeto.'i!ropiedad+C I I

>

!or ejemplo cambiar la definicin de la funcin y utili ar un par$metro out en ve de un par$metro ref. using &ystemC class 'iClaseG private int 'i!ropiedadC public void /signar(alor*out int 'i)ut!aram+GTT&e cambia la definicin de la funcin 'i)ut!aram Q @@C 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./signar(alor*out 'iEdad+C Console.9rite"ine*F'iEdad = F > 'iEdad+C Console.9rite"ine*F'i)bjeto.'i!ropiedad = F > 'i)bjeto.'i!ropiedad+C I I

$os parmetros out son e.actamente como los parmetros ref e.cepto que una +aria*le sin iniciali-ar puede ser pasada como parmetro # el caller define un parmetro out en +e- de ref. Qalores en Parmetros out

50

3n parmetro out puede ser utili-ado slo para contener el resultado de un mtodo( es necesario especificar el modificador out para indicar el tipo de parmetro( a diferencia de los parmetros re) el caller no necesita iniciali-ar la +aria*le antes de in+ocar el mtodo1 using S#stem; pu*lic class Param< pu*lic +oid Parametro2ut&out int 2utParametro)< 2utParametro > P M P; == o se gregresa un +alor( porque es regresado en el parmetro out @ @ class Parametros< pu*lic static +oid :ain&)< Param :iParam > ne4 Param&); int iQalor2ut; == o se requiere inicili-ar el +alor :iParam.Parametro2ut&out iQalor2ut); ==Se in+oca el mtodo con un parmetro out Console.Arite$ine&7out 1 7 , iQalor2ut);=='esultado de la in+ocacin del mtodo @ @ !jemplo de Parmetros Dn( 'ef # 2ut using S#stem; pu*lic class Param< pu*lic int Parametro n&int DnParametro)< return DnParametro M DnParametro; @ pu*lic +oid Parametro%ef&ref int 'efParametro)<== o regresa un +alor e.pl0cito 'efParametro M> 'efParametro; ==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; == o se gregresa un +alor( porque es regresado en el parmetro out @ @ class Parametros< pu*lic static +oid :ain&)< Param :iParam > ne4 Param&); Console.Arite$ine&7 in 1 7 , :iParam.ParametroDn&O)); int iQalor'ef > I; ==Se requiere iniciali-ar el +alor

51

:iParam.Parametro'ef&ref iQalor'ef);==Se pasando la referencia del +alor Console.Arite$ine&7ref 1 7 , iQalor'ef);

in+oca

el

mtodo

int iQalor2ut; == o se requiere inicili-ar el +alor :iParam.Parametro2ut&out iQalor2ut); ==Se in+oca el mtodo con un parmetro out Console.Arite$ine&7out 1 7 , iQalor2ut);=='esultado de la in+ocacin del mtodo @ @ 'edefinicin de :todos &2+erriding) 3no de los principios *sicos de la programacin orientada a o*jetos es el polimorfismo( el cual hace posi*le que una clase deri+ada pueda redefinir &o(erride) mtodos de la clase *ase. Para indicar que se puede redefinir el mtodo se emplea la pala*ra reser+ada +irtual1 +irtual +oid om*re:etodo]PuedeSer'edefinido Cespus( al deri+ar de la clase *ase se agrega la pala*ra reser+ada o+erride en el nue+o mtodo1 o+erride +oid om*re:etodo]PuedeSer'edefinido&) o es posi*le cam*iar la accesi*ilidad de un mtodo que es redefinido( es decir( no es posi*le cam*iar los modificadores que definen al mtodo. Cuando se in+oca un mtodo +irtual se est deri+ando el mtodo de clase que es in+ocado # no el mtodo de la clase *ase1 &&ClaseBase)DnstanciaClaseCeri+ada). om*re:etodo]PuedeSer'edefinido&); Para indicar que una clase deri+a de otra se utili-a el operador 1 el cual denota esta accin1 class ClaseCeri+ada 1 ClaseBase<@ !l siguiente ejemplo muestra como se redefine un mtodo1 using S#stem; class ClaseBase< pu*lic +irtual int Calculo&int i/( int iB)< return i/ , iB; @ @ 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 mtodo ser redefinido return i/ 8 iB;==Se redefine la funcionalidad del mtodo @ @ class 'edefinir:etodos< pu*lic static +oid :ain&)< ClaseBase ClsBase > ne4 ClaseBase&); Console.Arite$ine&7Clase *ase 1 7 ClsBase.Calculo&I(O)); ==Se crea una instancia de la clase deri+ada1 ClaseCeri+ada ClsCer > ne4 ClaseCeri+ada&); ==Se in+oca el mtodo redefinido en la clase deri+ada1

52

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

53

*ecause it hides inherited mem*er _ClaseBase.: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 mtodo contenido en la clase *ase1 using S#stem; class ClaseBase< pu*lic +oid :etodo2culto&)<==:todo 2culto Console.Arite$ine&75iding :ethods7); @ @ class ClaseCeri+ada 1 ClaseBase<==Clase deri+ada de la clase *ase ne4 pu*lic +oid :etodo2culto&)<==:todo 2culto Console.Arite$ine&75iding :ethods using ne47); @ @ class 5idingClass:et< pu*lic static +oid :ain&)< ClaseCeri+ada :iClaseCeri+ada > ne4 ClaseCeri+ada&); :iClaseCeri+ada.:etodo2culto&); @ @ /l hacer uso del modificador ne4( se le indica al compilador que se est redefiniendo el mtodo de la clase *ase # que de*er0a ocultar este mtodo. Se puede asegurar de in+ocar el mtodo que redefine la clase deri+ada utili-ando la siguiente sinta.is1 &&ClaseBase):iClaseCeri+ada).:etodo2culto&); Propiedades $as propiedades son con+enientes para separar la interfa- de un o*jeto de su implementacin( en +e- 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. class om*reClase< int i om*rePropiedad; ==declaracin de la propiedad ==!specificacin del acceso a la propiedad pu*lic int Nombre"ropiedad< get<return i om*rePropiedad;@ set<i om*rePropiedad > (alue;@ @ @ !jemplo1 using S#stem; class Propiedades< pri+ate int i!dad; pu*lic int !dad< get<return i!dad;@ set<i!dad > +alue;@

54

@ pri+ate string s om*re; pu*lic string om*re< get<return s om*re;@ set<s om*re > +alue;@ @ pri+ate *ool *:e.icano; pu*lic *ool :e.icano< get<return *:e.icano;@ set<*:e.icano > +alue;@ @ pu*lic static +oid :ain&)< Propiedades Ciudadano > ne4 Propiedades&); Ciudadano.!dad > OO; Console.Arite$ine&7!dad Ciudadano.!dad); Ciudadano. om*re > 7Herardo Nngeles a+a7; Console.Arite$ine&7 om*re Ciudadano 1 Ciudadano. om*re); Ciudadano.:e.icano > true; Console.Arite$ine&7:e.icano Ciudadano.:e.icano); @ @ !.isten dos maneras de e.poner el nom*re de los atri*utos1

Ciudadano

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. $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. !l siguiente ejemplo muestra como se implentan los accessors para las propiedades1 using S#stem; class Persona< pri+ate int iSueldo; pu*lic int Sueldo< get<return iSueldo;@ set<iSueldo > +alue;@ @ @

55

class /plicPersona< pu*lic static +oid :ain&)< Persona !mpleado > ne4 Persona&); !mpleado.Sueldo > OO; Console.Arite$ine&7!dad 1 7 , !mpleado.Sueldo); @ @ Note( que se utili-a el parmetro +alue( #a que el +alor actual es almacenado en este que es accesi*le dentro de la clase. Si en +e- de utili-ar propiedades desea utili-ar campos de*er dejar fuera los accessors # redefinir la +aria*le como1 pu*lic int Sueldo; /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 parmetro +alue. $as operaciones que pueden reali-arse con los atri*utos son1

0mplementar get y set, es posible tener acceso al valor de la propiedad para leerlo y escribirlo. get only, slo es posible leer el valor de la propiedad. set only, slo es posible establecer el valor de la propiedad.

Propiedades !stticas Propiedades estticas no pueden ser declaradas con los modificadores +irtual( a*stract u o+erride. $as propiedades estticas pueden ser iniciali-adas hasta que sea necesario hacerlo( el +alor puede ser fa*ricado cuando se necesite sin almacenarlo. using S#stem; class Persona< int iPiernas; int iBra-os; int i2jos; pu*lic Persona&int piernas( int *ra-os( int ojos)< this.iPiernas > piernas; this.iBra-os > *ra-os; this.i2jos > ojos; @ pu*lic static Persona Piernas< get< return&ne4 Persona&G(?(?)); @ @ pu*lic static Persona Bra-os< get< return&ne4 Persona&?(P(?)); @ @ pu*lic static Persona 2jos< get<

56

return&ne4 Persona&?(?(Y)); @ @ @ class /pp< pu*lic static +oid :ain&)< Persona !" > Persona.Piernas; Console.Arite$ine&!"); @ @ ^ndices !s posi*le incluir una forma de acceso inde.ado a la clase tal como si la clase se tratar de un arreglo( para ello se utili-a la caracter0stica de C# inde.er( sinta.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. $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.F< get<intrucciones@ set<intrucciones@ @ $as reglas de implementacin para get # set son las mismas reglas de las propiedades( la %nica diferencia es que la lista de parmetros se define li*remente entre los corchetes( tam*in e.isten restricciones como que es necesario especificar al menos un parmetro # los modificadores ref # out no estn permitidos. !jemplo1 using S#stem; using S#stem. et;==Cirecti+a namespace para la clase C S class 'esol+erC S< DP/ddressEF aDPs; pu*lic +oid 'esol+er&string str5ost)< DP5ost!ntr# DP5! > Cns.Het5ostB# ame&str5ost); aDPs > DP5!./ddress$ist; @ pu*lic DP/ddress thisEint iDnde.F< get<return aDPsEiDnde.F;@ @ pu*lic int Contador< get<return aDPs.$ength;@ @ @ class /plic'esol+erC S< pu*lic static +oid :ain&)< 'esol+erC S :iC S > ne4 'esol+erC S&); :iC S.'esol+er&7444.informatique.com.m.7); int iContador > :iC S.Contador; Console.Arite$ine&7Se encontro <?@ para el host 7( iContador);

57

for&int i > ?; i L iContador; i,,)< Console.Arite$ine&:iC SEiF); @ @ @ 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. et.dll =out1resol+er.e.e /plic'esol+erC S.cs $os 0ndices pueden tener ms que un parmetro para simular un arreglo +irtual multidimensional. !+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 estn interesadas en un e+ento espec0fico pueden su*scri*ir al e+ento. $a rutina o tarea que un e+ento podr0a in+ocar es definida por un delegado. Para tratar de manera fcil con e+entos( la con+encin de dise6o para e+entos es emplear dos parmetros( donde el primer parmetro es el o*jeto que lan-a el e+ento # el segundo parmetro es un o*jeto que contiene la informacin acerca del e+ento el cual siempre deri+a de la clase !+ent/rgs. $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. Cada e+ento puede ser utili-ado por cero o ms clientes # un cliente puede utili-ar un e+ento en cualquier momento. $os delegados pueden ser implementados como mtodos o instancias estticas. :odificadores $os modificadores pueden clasificarse en1

'odificadores de Clase 'odificadores 'iembro 'odificadores de /cceso

:odificadores de Clase !.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

8tilice este modificador para prevenir herencia accidental

!jemplo1 using S#stem; a*stract class Clase/*stracta< a*stract pu*lic +oid :i:etodo&); @ sealed class ClaseCeri+ada1Clase/*stracta< pu*lic o+erride +oid :i:etodo&)< Console.Arite$ine&7Clase sealed7); @ @ pu*lic class :odificadorClase< pu*lic static +oid :ain&)< ClaseCeri+ada CC > ne4 ClaseCeri+ada&); CC.:i:etodo&); @ @ :odificadores :iem*ro /lgunos modificadores miem*ro son1

abstract

0ndica #ue un m,todo o accessor no contiene una implementacin, #ue son implicitamente virtual. "a clase #ue recibe la herencia debe proveer la palabra reservada override.

const

Este modificador aplica a campos y variables locales "a e%presin constante es evaluada en tiempo de compilacin, por lo tanto no puede contener referencias de la clase.

event

1efine un campo o propiedad como tipo event 8tili ado para ligar al cdigo cliente a eventos de la clase

e%tern

0ndica al compilador #ue el m,todo es implemetado e%ternamente

override

8tili ado para modificar un m,todo o accessor #ue es definido virtual en cual#uiera de las clases base "a firma de redefinicin y m,todo base debe ser el mismo

readonly

59

8n campo declarado con el modificador readonly puede ser cambiado slo en su declaracin 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, m,todos, propiedades, operadores y constructores.

virtual

0ndican #ue un m,todo o accessor pueden ser redefinidos por las clases #ue reciben la herencia.

:odificadores de /cceso $os modificadores de acceso definen el ni+el de acceso que cierto cdigo tiene en los miem*ros de la clase como mtodos # propiedades. !s necesario aplicar el modificador de acceso deseado a cada miem*ro( de otra forma el tipo de acceso por default es impl0cito. $os modificadores de acceso son1

public, el miembro es accesible desde cual#uier parte, este modificador de acceso es el menos restrictivo. protected, el miembro es accesible en la clase y todas las clases derivadas. No es permitido el acceso desde fuera. El acceso protected permite a otras clases depender de la implementacin interna de la clase y por lo tanto deber2an ser otorgados slo cuando sea necesario.

private, slo el cdigo dentro de la misma clase puede acceder este miembro. "as clases derivadas no pueden acceder al cdigo. internal, este tipo de acceso es otorgado a todo el cdigo #ue es parte del mismo componente *aplicacin o biblioteca+ .NET, es visto como pblico a nivel del componente .NET y privado fuera de este. Este modificador permite #ue un miembro sea accesible desde las clases en el mismo ensamblaje, pero no desde las clases fuera de este.

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, en otras palabras internal protected permite acceso internal o protected. Sentencias de Control $as &entencias de Control se emplean para controlar la ejecucin # flujo del cdigo( las cuales se di+iden en1

60

&entencias de &eleccin &entencias de 0teracin

Sentencias de Seleccin $as &entencias de seleccin son aquellas que se utili-an para reali-ar operaciones *asadas en el +alor de una e.presin. $as &entencias de seleccin son aquellas que se utili-an para escri*ir diferentes flujos de accin en *ase a una condicin dada( e.isten dos tipos de sentencias de seleccin1

&entencia if &entencia s7itch

Sentencia if /l escri*ir uno o +arios flujos de accin el cdigo contenido en estos se ejecutar siempre # cuando la e+aluacin de la e.presin en la sentencia if se e+alue como +erdadera &tenga cuidado en C# if&?)<@ o if&J)<@ no es +lido). if&e.presin8*ooleana)<la e7presin se e(aluo (erdadera@ !s posi*le indicar cdigo alterno en caso de que la e.presin *ooleana se e+alue falsa1 if&e.presin8*ooleana)< la e7presin se e(aluo (erdadera @else< la e7presin se e(aluo )alsa @ Nota C# no puede con+ertir +alores numricos a *ooleanos( solo puede hacer comparaciones entre ellos para e+aluar el resultado de la e.presin el cual es un +alor *ooleano. using S#stem; class SeleccionDf< pu*lic static +oid :ain&)< if&J >> J)< Console.Arite$ine&7se e+aluo +erdadero7); @ =M o es soportado por C# if&?)< Console.Arite$ine&7?7); @ 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

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

a+a7;

char ch$etra > s om*reE?F;==!.trae el primer caracter del

62

@ !n el ejemplo anterior se muestra la aplicacin de la sentencia de seleccin if # el uso del mtodo DsCigit de la clase Char( tam*in se muestra como determinar si un caracter correponde a las letras ma#%sculas o min%sculas. Hood Practice1 nunca asigne +alores a +aria*les dentro de una condicin que utili-a operadores lgicos &bb(dd([)( porque puede que nunca se le asigne el +alor correspondiente a la +aria*le en caso de que una e.presin anterior se e+alue +erdadera1 if&a >> * dd &c >> &iQalor > d)))<@ !n el ejemplo anterior( si la e.presin a >> * se e+alua +erdadera entonces la +aria*le iQalor nunca contendr el +alor d. Sentencia s4itch $a sentencia de seleccin s4itch tiene una e.presin de control # los flujos de cdigo alternos son ejecutados dependiendo del +alor constante asociado con esta e.presin. s4itch&e.presion8de8control)< case e.presion8contante1 sentencias; *reaV; case e.presion8contante1 goto case G; case e.presion8contante1 goto default; default1 sentencias; @ $os tipos de datos permitidos para la e.presin de control son s*#te( *#te( short( ushort( uint( long( ulong( char( string o un tipo enumeracin &enumeration). Cmo funciona la sentencia de seleccin s4itch?

&e evalua la e%presin de control &i la e%presin constante en las eti#uetas case coincide con el valor evaluado en la e%presin de control, entonces las sentencias contenidas para ese caso son ejecutadas &i la e%presin constante en las eti#uetas case no coincide con el valor evaluado en la e%presin de control, entonces el cdigo contenido en el caso por default es ejecutado &i la e%presin constante en las eti#uetas case no coincide con el valor evaluado en la e%presin de control y no e%iste un caso por default, entonces el control es transferido al final del blo#ue s7itch

!jemplo1 using S#stem; class SentenciaS4itch< pu*lic static +oid :ain&)< for&int i > ?; i L> JG; i,,)< :es&i); @

63

@ pu*lic static +oid :es&int i:es)< s4itch&i:es)< case J1 Console.Arite$ine&7!nero7); *reaV; case G1 Console.Arite$ine&79e*rero7); *reaV; case O1 Console.Arite$ine&7:ar-o7); *reaV; case P1 Console.Arite$ine&7/*ril7); *reaV; case I1 Console.Arite$ine&7:a#o7); *reaV; case K1 Console.Arite$ine&7Sunio7); *reaV; case \1 Console.Arite$ine&7Sulio7); *reaV; case Y1 Console.Arite$ine&7/gosto7); *reaV; case W1 Console.Arite$ine&7Septiem*re7); *reaV; case J?1 Console.Arite$ine&72ctu*re7); *reaV; case JJ1 Console.Arite$ine&7 o+iem*re7); *reaV; case JG1 Console.Arite$ine&7Ciciem*re7); *reaV; default1 Console.Arite$ine&7:es no +lido7); *reaV; @ @ @ !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;

64

class SentenciaS4itch< pu*lic static +oid :ain&)< int i2pcion > P; 2pcion&i2pcion); i2pcion > G; 2pcion&i2pcion); i2pcion > Y; 2pcion&i2pcion); i2pcion > J?; 2pcion&i2pcion); @ pu*lic static +oid 2pcion&int iQalor)< s4itch&iQalor)< case G1 goto case K; case P1 Console.Arite$ine&7 cuatro7); *reaV; case K1 Console.Arite$ine&7 seis7); *reaV; case Y1 goto default; case J?1 Console.Arite$ine&7 die-7); *reaV; default1 Console.Arite$ine&7 por defecto7); *reaV; @ @ @ Sentencias de Dteracin &repeticin) $as &entencias de 0teracin &tam*in conocidas como looping statements) son aquellas que nos permiten ejecutar un *loque de cdigo 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 cdigo. !ste *loque se repetira mientras la condicin e+alue una e.presin *ooleana +erdadera( no ser posi*le e+aluar otro tipo de e.presin. Sinta.is1 for&iniciali-ador; condicin; iterador) $os componentes de la sentencia for1 iniciali<ador( condicin( iterador( no son o*ligatorios. !s posi*le salir de un ciclo for a tra+s de las instrucciones1

65

brea3 goto

!jemplo1 using S#stem; class 9actorial< 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.,,)< l9actorial M> l/u.; =="est $ine Console.Arite$ine&7<?@[ M <J@7( l/u.( l9actorial); @ Console.Arite$ine&7<?@[ es <J@7( lCalcular( l9actorial); @ @ Sentencia foreach $a &entencia foreach es un comando para enumerar los elementos de una coleccin. foreach&"ipo indentificador in e.presin)<@ $a +aria*le de iteracin es declarada por el /ipo( indenti)icador # e7presin correspondiente a la coleccin. $a +aria*le de iteracin representa el elemento de la coleccin para cada iteracin. !l siguiente ejemplo muestra el uso de for1 using S#stem; class /pp< pu*lic static +oid :ain&stringEF a/rgs)< for&int i > ?; i L a/rgs.$ength; i,,)< Console.Arite$ine&7!lemento 7 , i , 7 > 7 , a/rgsEiF); @ @ @ !l ejemplo anterior implementado con foreach1 using S#stem; class /pp< pu*lic static +oid :ain&stringEF a/rgs)< foreach&String s in a/rgs)< Console.Arite$ine&s); @ @ @

66

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

archi+o

test.html

no

67

$a diferencia entre la sentencia 4hile # do es que do se e+alua despus de su primer iteracin( por lo que al menos siempre se ejecuta una +e-1 do< sentencias; @4hile&condicin); !s posi*le salir de un ciclo do a tra+s de la sentencia *reaV # es posi*le saltar una iteracin 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&7Continuar 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 iteracin en curso o sentencia s4itch # continuar con la ejecucin despus de esa sentencia. continue $a &entencia continue salta todas las sentencias siguientes en la iteracin en curso # entonces continua la ejecucin en la sentencia de iteracin &siguiente iteracin). 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 prctica no se recomienda el uso de goto. return

68

$a &entencia return regresa a la funcin in+ocadora # opcionalmente retorna un +alor. /signacin Cefiniti+a $as reglas de /signacin definitiva pre+ienen la o*ser+acin 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*in 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 asignacin definiti+a en todas las situcaciones. Precedencia de 2peradores Cuando una e.presin contiene m%ltiples operadores( la precedencia de operadores controla el orden en el cual los elementos de la e.presin 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 mtodo 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*in reali-a la con+ersin e.plicita a ese tipo o interface # si no lo puede con+ertir el operador regresa null. 3tili-ar as es ms eficiente que utili-ar is( porque as slo 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+ersin 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) *; / continuacin se presenta la jerarqu0a de con+ersin en C## :anejo de !.cepciones $as e.cepciones son el mtodo 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.cepcin Console.Arite$ine&7<?@=<J@ > <G@7( i/ (iB( i/=iB); @catch&!.ception e)< ==:anejo de la e.cepcin Console.Arite$ine&7$a operacin <?@=<J@ genero la e.cepcion 1 <G@7( i/( iB( e); @ Console.Arite$ine&7Continua la ejecucin del cdigo...7); @ @ !l ejemplo encierra el *loque de cdigo que podr0a lan-ar una e.cepcin con tr#. !n caso de generarse una e.cepcin el runtime ..E/ detiene la ejecucin del cdigo # *usca el *loque tr# en el cual la e.cepcin tu+o lugar( entonces *usca si este *loque tiene relacionado un *loque catch( puede ser que encuentre ms de un *loque catch relacionado al *loque tr# que genero la e.cepcin( por lo que se determina que *loque catch es el que mejor # ejecuta el cdigo que contiene. !l compilador de C# puede manejar silenciosamente situaciones que podr0an producir un error sin notificarnos e.plicitamente de ello( por ejemplo una situacin como un

70

o#erflo$ que es cuando el clculo de una operacin e.cede el rango +lido de resultados posi*les para el tipo de dato. !l caso del cdigo 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 opcin de chequeo de o(er)lo2. !s posi*le cam*iar el comportamiento de chequeo de o(er)lo2 utili-ando un s4itch al compilar. Serarqu0a de !.cepciones "odas las e.cepciones deri+an de la clase !.ception( la cual es parte del lenguaje com%n en tiempo de ejecucin &C$')( donde la propiedad catch determina por coincidencia el tipo de e.cepcin a el nom*re de la e.cepcin generada. 3n *loque catch con una coincidencia especifica hacen ms general la e.cepcin1 using S#stem; class !.ceptionCi+ision?< 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)< Console.Arite$ine&7Se genero la e.cepcion 1 Ci+ideB#cero!.ception7); @ Console.Arite$ine&7Continua la ejecucin del cdigo...7); @ @ !n este ejemplo el *loque catch que atrapa la e.cepcin Ci+ideB#cero!.ception es una coincidencia ms espec0fica( por lo que es la %nica que ser ejecutada( pero si adems de escri*ir el catch para Ci+ideB#cero!.ception escri*e el catch para !.ception( el compilador le notificara que e.iste una e.cepcin que atrapa todas las e.cepciones # esto es porque !.ception ocupa la cima de la jerarqu0a de todas las e.cepciones. "ra*ajar con !.cepciones !.isten tres formas *sicas de tra*ajar con e.cepciones1 Caller Be4are $a primer forma es no atrapar la e.cepcin( lo cual pro+ocar dejar al o*jeto en un estado incorrecto( # causar da6os cuando el caller trate de utili-arla de nue+o. Caller Confuse $a segunda forma es atrapar la e.cepcin # tratar de hacer acciones que dejen la operacin como esta*a hasta antes de generarse la e.cepcin # entonces relan-ar la e.cepcin( esto usualmente es lo menos que se esperaria del manejo de e.cepciones #a que un o*jeto de*er0a siempre mantener un estado +lido despus de generarse una e.cepcin. Se llama "aller "on)use( porque despus de generase una e.cepcin( el caller con frecuencia tiene poca informacin respecto al entendimiento de los detalles de la e.cepcin o como podr0a ser solucionada. Caller Dnform $as tercer forma "aller 5n)orm agrega informacin que es de+uelta al usuario( la e.cepcin atrapada es en+uelta en una e.cepcin que tiene informacin adicional1 using S#stem;

71

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&7Dnformacin adicional...7( e)); @ Console.Arite$ine&7Continua la ejecucin del cdigo...7); @ @ Chequeo de 2+erflo4 Si requerimos controlar el chequeo de o(er)lo2 para la aplicacin completa( el compilador de C# de*e esta*lecerse como chec3ed. Por default el compilador tiene desha*ilitada la opcin 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 opcin 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.cepcin 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 programtico de 2+erflo4 !.iste otra opcin si es que no deseamos acti+ar el Chequeo de 2+erflo4 para la aplicacin completa # ha*ilitar slamente partes especificas de cdigo( 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*in es posi*le hacer el caso contrario( es decir( indicar que no se realice el chequeo de o(er)lo2 para partes especificas de cdigo( 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.cepcin ocurrio( es necesario atrapar la e.cepcin # lo mejor de todo es que continue la ejecucin del programa( para ello se utili-a tr# # catch. tr# contiene el cdigo que qui- pueda lan-ar una e.cepcin # catch maneja la e.cepcin si esta ocurre1 tr#< ==sentencias que pueden lan-ar una e.cepcin @catch&nom*re!.cepcin)< ==manejo de la e.cepcin @ !l siguiente ejemplo maneja la e.cepcin 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.cepcin 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 cdigo contenido en el *loque finall# es ejecutado a%n despus de ocurrir una e.cepcin.

73

!l siguiente cdigo maneja una +aria*le *ooleana que indica si se produjo un error( simplemente poniendola dentro del *loque tr#( si el cdigo 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 indicacin 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.cepcin # se presenta el mensaje que indica que ha ocurrido una e.cepcin pero tam*in fu ejecutado el *loque finall#( el cdigo que contiene el *loque finall# siempre es ejecutado ocurra o no una e.cepcin. Puede emplear la sentencia finall# para reesta*lecer los +alores pre+ios a la generacin de la e.cepcin. tr# 8 catch 8 finall# Com*inar tr# para controlar el cdigo que puede lan-ar e.cepciones( atrapar la e.cepcin con catch # lle+ar aca*o instrucciones necesarias con finall# hacen una mejor solucin cuando ocurren las e.cepciones. !s posi*le utili-ar una sentencia catch por cualquier e.cepcin que pudiera ocurrir( es decir( tener ms de un *loque catch( pero es necesario conocer la jerarqu0a de las e.cepciones porque puede ocurrir que un *loque pre+io catch sea ms 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

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

75

Dn+alid2peration!.ception /rgument!.ception /rgument ull!.ception /rgument2ut2f'ange!.ception Dnterop!.ception Com!.ception S!5!.ception

$an-ada por ciertos mtodos cuando in+ocan a mtodos que son in+lidos para el estado de los o*jetos actuales Clase *ase de todos los argumentos de las e.cepciones $an-ada por un mtodo( en caso de que un argumento sea null cuando no sea permitido $an-ada por un mtodo cuando un argumento no est en el rango permitido Clase *ase para e.cepciones que son originadas u ocurren en am*ientes fuera del C$' !.cepcin que contiene informacin 5'!S3$" C2: !.cepcin que encapsula informacin del manejo de e.cepciones destructurada AinOG

'elan-amiento de !.cepciones !l siguiente cdigo muestra como es posi*le atrapar una e.cepcin( manejarla # se +ol+erla a in+ocar1 using S#stem; class 9actorialChecVed'e"hro4< 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; tr#< checVed< ==5a*ilitar chequeo de o+erflo4 for&l/u. > J; l/u. L> lCalcular; l/u.,,)< l9actorial M> l/u.; =="est $ine Console.Arite$ine&7<?@[ M <J@7( l/u.( l9actorial); @ @ @catch&2+erflo4!.ception)< Console.Arite$ine&7!l lCalcular); thro4; @ Console.Arite$ine&7<?@[ es <J@7( lCalcular( l9actorial);

factorial

<?@[

causo

una

e.cepcin7(

76

@ @ Creacin de Clases !.ception !s recomenda*le utili-ar las clases predefinidas para e.cepciones( para ciertos escenarios es posi*le crear clases de e.cepciones apropiadas( por ejemplo cuando creamos una clase( tam*in podemos crear e.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.cepciones creadas. using S#stem; pu*lic class :i!.cepcion1!.ception< pu*lic :i!.cepcion&string str)1*ase&str)<@ @ pu*lic class /plic:is!.cepciones< pu*lic static +oid Pro*ar&)< thro4 ne4 :i!.cepcion&7ocurrio un error7); @ pu*lic static +oid :ain&)< tr#< /plic:is!.cepciones.Pro*ar&); @catch&!.ception e)< Console.Arite$ine&e); @ @ @ Se de*en tomar ciertas consideraciones al crear e.cepciones1

/l lan ar una e%cepcin se debe proporcionar un te%to significativo "an ar e%cepciones solo cuando se presente una condicin realmente e%cepcional "an ar un /rgumentE%ception si el m,todo o propiedad envio mal los par$metros "an ar un 0nvalid)perationE%ception cuando la operacin invocada no es apropiada para el estado actual de los objetos "an ar la e%cepcin 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.eferenceE%ception o 0nde%)ut)f.angeE%ception en m,todos

Componentes /s0 como es posi*le escri*ir clases # hacer uso de estas en un mismo archi+o( tam*in es posi*le escri*ir en un archi+o &ejecuta*le) unicamente la clase lo cual es

77

conocido como componente # en otro archi+o &tam*in ejecuta*le) el uso de la clase lo cual es conocido como cliente. Creacin 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. using S#stem; pu*lic class ClsPersona< pri+ate int iSueldo; pu*lic int Sueldo< get<return iSueldo;@ set<iSueldo > +alue;@ @ pu*lic string s om*re; pu*lic +oid /signar om*re&string sQalor)< s om*re > sQalor; @ pu*lic string 2*tener om*re&)< return s om*re; @ @ Compilacin de Componentes /l compilar un componente se crea una *i*lioteca # no se crea una aplicacin( como es el caso cuando se tra*aja en un slo archi+o la clase # la aplicacin que hace uso de la clase1 csc =t1li*rar# =out1ClsPersona.dll ClsPersona.cs Si utili-a nom*res de espacio1 csc =r1S#stem.nom*reBi*lioteca.dll =t1li*rar# =out1 om*reComponente.dll om*reComponente.cs Conde el s2itch =t1li*rar# indica al compilador de C# crear una *i*lioteca # no *uscar el mtodo esttico :ain. 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.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 prctica especificarlo #a que algunas aplicaciones no slo 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. 3na +e- que ha compilado su componente puede escri*ir una /plicacin Cliente. Creacin de una /plicacin 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; class /plicClsPersona< pu*lic static +oid :ain&)< ClsPersona !mpleado > ne4 ClsPersona&); !mpleado.Sueldo > OO; Console.Arite$ine&7!dad 1 7 , !mpleado.Sueldo);

78

!mpleado./signar om*re&7Herardo Nngeles a+a7); Console.Arite$ine&7 om*re 1 7 , !mpleado.2*tener om*re&)); @ @ Compilacin de Clientes !s necesario indicarle al compilador una referencia a la nue+a *i*lioteca de componentes C$$1 csc =r1 om*reComponente.dll om*reCliente.cs Nota para hacer uso de una clase es necesario que tenga el modificador de acceso pu*lic. amespaces $os nom*res de espacio namespace en el runtime ..E/ son utili-ados para organi-ar las clases # otros tipos en una estructura jerarquica. !l propsito del uso de namespace hacen las clases fciles de usar # pre+enir colisiones con las clases escritas por otros programadores. $os namespace en C# se utili-an para organi-ar programas # la jerarqu0a natural de la organi-acin facilita presentar los elementos de un programa a otros programas. $os namespace son utiles para la organi-acin interna de aplicaciones. 3n namespace contiene tipos que pueden ser utili-ados en la construccin 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 prctica organi-ar los namespace creados de manera jerarquica para dar claridad a la aplicacin. $os nom*res de espacio son definidos utili-ando la sentencia1 namespace Para m%ltiples ni+eles de organi-acin los namespaces pueden ser anidados1 namespace om*re amespace/< namespace om*re amespaceB< class om*reClase< pu*lic static +oid 9unction&)<@ @ @ @ !l cdigo anterior puede ser simplificado de la siguiente manera1 namespace om*re amespace/. 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 clusula using que permite definir un alias para la clase1 using /lias > S#stem.Console; class om*reClase< pu*lic static +oid :ain&)< /lias.Arite$ine&7/lias de una clase7); @ @ !n+ol+er Clases en amespace

79

!s posi*le en+ol+er &2rapping) las clases en un namespace( para ello slo es necesario utili-ar la pala*ra reser+ada namespace seguida de un nom*re que lo identifique # encerrar entre lla+es el cdigo que deseamos pertene-ca a este. using om*re2tros!spacios; namespace om*re!spacio< pu*lic class om*reClase< ==propiedades ==mtodos @ @ !jemplo1 using S#stem; namespace informatique.com.m.< pu*lic class iPersona< pri+ate int iSueldo; pu*lic int Sueldo< get<return iSueldo;@ set<iSueldo > +alue;@ @ pu*lic string s om*re; pu*lic +oid /signar om*re&string sQalor)< s om*re > sQalor; @ pu*lic string 2*tener om*re&)< return s om*re; @ @ @ Compilar1 csc =t1li*rar# =out1iPersona.dll iPersona.cs 3tili-ar amespace en /plicaciones Cliente /l desarrollar componentes utili-ando namespace la aplicacin cliente de*e importarlo1 using om*re!spacio; 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; using informatique.com.m.; class i/plicClsPersona< pu*lic static +oid :ain&)< iPersona !mpleado > ne4 iPersona&); !mpleado.Sueldo > OO; Console.Arite$ine&7!dad 1 7 , !mpleado.Sueldo); !mpleado./signar om*re&7Herardo Nngeles Console.Arite$ine&7 om*re 1 !mpleado.2*tener om*re&)); @ a+a7); 7 ,

80

@ Compilar1 csc =r1iPersona.dll i/plicPersona.cs !specificar de manera a*soluta el namespace1 using S#stem; class i/plicClsPersona/*s< pu*lic static +oid :ain&)< informatique.com.m..iPersona !mpleado > informatique.com.m..iPersona&); !mpleado.Sueldo > OO; Console.Arite$ine&7!dad 1 7 , !mpleado.Sueldo);

ne4

!mpleado./signar om*re&7Herardo Nngeles a+a7); Console.Arite$ine&7 om*re 1 7 , !mpleado.2*tener om*re&)); @ @ Compilar1 csc =r1iPersona/*s.dll i/plicPersona/*s.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 ms clases o componentes al mismo namespace( sin importar que esten contenidos en diferentes archi+os( despus de la compilacin son parte del mismo namespace1 csc =t1li*rar# =out1 om*reComponente.dll archi+o9uenteJ.cs archi+o9uenteG.cs /gregando otra clase al namespace informatique.com.m.1 using S#stem; namespace informatique.com.m.< class iQehiculo< pri+ate int i'ueda; pri+ate int iPuerta; pri+ate int iQentana; pri+ate int i5elice; pri+ate int i:otor; pri+ate int i/siento; pri+ate string s"ipo;==/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; iPuerta > Puerta; iQentana > Qentana; i5elice > 5elice; i:otor > :otor; i/siento > /siento; s"ipo > "ipo; @ pu*lic int 'uedas< get<return i'ueda;@ set<i'ueda > +alue;@

81

@ pu*lic int Puertas< get<return iPuerta;@ set<iPuerta > +alue;@ @ pu*lic int Qentanas< get<return iQentana;@ set<iQentana > +alue;@ @ pu*lic int 5elices< get<return i5elice;@ set<i5elice > +alue;@ @ pu*lic int :otores< get<return i:otor;@ set<i:otor > +alue;@ @ pu*lic int /sientos< get<return i/siento;@ set<i/siento > +alue;@ @ pu*lic string "ipo< get<return s"ipo;@ set<s"ipo > +alue;@ @ @ @ Compilar1 csc =t1li*rar# =out1informatique.com.m..dll iPersona.cs iQehiculo.cs /plicacin Cliente1 using S#stem; using informatique.com.m.; class i/plic< pu*lic static +oid :ain&)< iPersona !mpleado > ne4 iPersona&); !mpleado.Sueldo > OO; Console.Arite$ine&7!dad 1 7 , !mpleado.Sueldo); !mpleado./signar om*re&7Herardo Nngeles Console.Arite$ine&7 om*re 1 !mpleado.2*tener om*re&)); a+a7); 7 ,

==Clase que est contenida en otro archi+o iQehiculo :i/+ion > ne4 iQehiculo&G(J(J??(?(O(G??(7/ereo7); Console.Arite$ine&7'uedas 1 7 , :i/+ion.'uedas); Console.Arite$ine&7Puertas 1 7 , :i/+ion.Puertas); Console.Arite$ine&7Qentanas 1 7 , :i/+ion.Qentanas);

82

Console.Arite$ine&75elices 1 7 , :i/+ion.5elices); Console.Arite$ine&7:otores 1 7 , :i/+ion.:otores); Console.Arite$ine&7/sientos 1 7 , :i/+ion./sientos); Console.Arite$ine&7"ipo 1 7 , :i/+ion."ipo); @ @ Compilar1 csc =r1informatique.com.m..dll i/plic.cs .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. amespace # !nsam*les 3n o*jeto puede ser utili-ado desde un archi+o fuente C# slo si ese o*jeto puede ser locali-ado por el compilador C#( por default el compilador slo a*re el ensam*le conocido como mscorli*.dll( el cual contiene las funciones principales para el C$'. 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 correlacin 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. et residen en el ensam*le S#stem. et.dll Compilacin Condicional $a Compilacin Condicional permite e.cluir o incluir cdigo( en C# e.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. !l compilador de C# no soporta macros( en cam*io soporta las siguientes directi+as1

1efinicin de s2mbolos E%clusin de cdigo basado en s2mbolos "an amiento de errores y advertencias

Cefinicin de s0m*olos $a 1efinicin de s2mbolos es utili-ada para e.cluir o incluir cdigo dependiendo si son o no son definidos ciertos s0m*olos. 3na forma para definir un s0m*olo es utili-ando la directi+a #define en un archi+o fuente C#( est definicin 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!.

83

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.cs Si se requiere definir m%ltiples s0m*olos utili-ando el compilador( es necesario separar cada s0m*olo con una coma &,) csc =define1C!B3H('!$!/S!(C!:2Q!'SD2 nom*re/rchi+o.cs Si el cdigo fuente inclu#e directi+as de definicin de s0m*olos( es posi*le desha*ilitarlas utili-ando la directi+a #undef cu#o m*ito tam*in corresponde al archi+o donde es definida1 #undef C!B3H !.clusin de cdigo *asado en s0m*olos !l principal propsito de los s0m*olos es la inclusin o e.clusin condicional del cdigo( *asado so*re si son o no son definidos los s0m*olos. !l siguiente cdigo no define s0m*olos en el archi+o fuente1 . sentencia; . #if 2:B'!]SD:B2$2 sentencia; #else sentencia; #endif . Pero es posi*le definir o no los s0m*olos al compilar la aplicacin1 csc =define1 2:B'!]SD:B2$2 om*re/plicacion.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; class om*reClase< pu*lic static +oid :ain&)< #if SD:B2$2]/ . #elif SD:B2$2]B bb SD:B2$2]C . #else . #endif @ @ $an-amiento de errores # ad+ertencias !.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

#7arning #error

Por ejemplo #if SD:B2$2]!''2' #error Presentar el mensaje de error correspondiente #endif . #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+ocacin de una funcin cuando sierto s0m*olo es definido # e+alua a nada cuando una +ersin li*erada es construida. 3n atri*uto conditional de*e tener un tipo +oid de regreso( cualquier otro tipo de regreso no es permitido. . Econditional&7 2:B'!]SD:B2$27)F mtodo / Econditional&7 2:B'!]SD:B2$27)F mtodo B . Comentarios de Cocumentacin en R:$ !s posi*le construir automticamente la Cocumentacin utili-ando comentarios en el cdigo. $a salida que es generada por el compilador es R:$ puro # puede ser utili-ada como entrada para la documentacin de un componente. $a documentacin es una parte e.tremadamente importante del soft4are # en especial de los componentes por ser utili-ados por otros desarrolladores. !lementos R:$ Nota1 todo comentario de documentacin 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 cdigo fuente anteponiendo tres diagonales que son indicati+o de un comentario de documentacin1 ===Lsummar#ZCescripcin...L=summar#Z !n caso de requerir ms una l0nea para el comentario de documentacin utilice el tag1 ===LparaZ ===. ===. ===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 tpico de interes utilice1 ===Lseealso cref>7S#stem. et7=Z 3n tag contrario a summar#( para un +olumen ma#or de documentacin es1 ===LremarVsZ !s posi*le incluir listas utili-ando los tags 1 ===Llist t#pe>7*ullet7Z

85

=== ===

LitemZConstructor Lsee cref>7Constructor&)7=Z

=== Lsee cref>7Constructor&string)7=Z === L=itemZ ===L=listZ Para descri*ir parmetros se utili-a el tag1 ===Lparamref name>7nom*reParametro7=Z !s posi*le encerrar en un tag un ejemplo completo e incluir la descripcin # cdigo1 ===Le.ampleZ === . === LcodeZ === . === L=codeZ === . ===L=e.ampleZ Para descri*ir los parmetros 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...L=+alueZ 3na +e- que el proceso de documentacin para un componente es terminado( es posi*le crear un archi+o R:$ *asado en la documentacin descrita en el cdigo fuente # hacerla disponi*le a quienes utilicen el componente( para ello simplemente se utili-a al compilar el s2itch =doc1 seguido del documento R:$. csc =doc1Persona..ml /plicPersona.cc !jemplo1 using S#stem; === === Clase Persona === /utor 1 Herardo Nngeles a+a === 9echa 1 J?=?W=G??I === Cescripcin 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; pu*lic int Sueldo< get<return iSueldo;@ set<iSueldo > +alue;@ @ pu*lic string s om*re; ===3tili-ado para asignar el +alor de la propiedad s om*re

86

pu*lic +oid /signar om*re&string sQalor)< s om*re > sQalor; @ pu*lic string 2*tener om*re&)< return s om*re; @ @ class /plicPersona< pu*lic static +oid :ain&)< Persona !mpleado > ne4 Persona&); !mpleado.Sueldo > OO; Console.Arite$ine&7!dad 1 7 , !mpleado.Sueldo); !mpleado./signar om*re&7Herardo Nngeles a+a7); Console.Arite$ine&7 om*re 1 7 ,!mpleado.2*tener om*re&)); @ @ &alida1 para +er el documento R:$ generado de clic aqu0. !l compilador reali-ar +alidacin so*re los tags R:$ en el archi+o fuente( en caso de e.istir errores el compilador lo notificar # a%n as0 el documento R:$ es generado pero tendr un mensaje de error. !l documento R:$ tendr algunos identificadores seguidos de dos puntos &=) # la ruta del namespace( los cuales por ejemplo tienen los siguiente significados.

N, denota un namespace T, identifica un tipo, el cual puede ser una clase, interface, estructura, enumeracin o delegado 5, describe un campo o clase !, se refiere a una propiedad la cual tambi,n puede ser un ind2ce o propiedad 2ndice. ', identifica un m,todo, incluyendo constructores y operadores. E, denota eventos P, denota un error el cual provee informacin acerca de una liga #ue el compilador C# no pudo resolver.

Si un elemento tiene per0odos en su nom*re( estos son reempla-ados por el s0m*olo #. $os parmetros para mtodos son encerrados entre parntesis # separados por comas &,). Componentes . !" !l compilador de C# por default siempre crea componentes . !" para los ejecuta*les. 3n Componente .NET es la unidad fundamental reusa*le # compartida en el C$'( un componente . !" tam*in es limitante para asegurar la seguridad( permite la distri*ucin de clases # resolucin de tipos. 3na aplicacin puede contener m%ltiples componentes . !" 3n componente . !" contiene cuatro partes referentes al n%mero de +ersin llamado (ersin compatible1

87

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

88

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

89

tipo. 3na herramienta genera el cdigo 2rapper *asado en la informacin o*tenida de la *i*lioteca tipo. $a herramienta a utili-ar es tlimp &t,pe librar, import)1 tl*imp nom*reComponente.dll =out1nom*reBi*lioteca.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.dll. Para +er los metadatos para el 'CA utilice ildasm.e.e( as0 podr distinguir el nom*re de la clase que fu generada para el o*jeto C2: original( esta informacin es una a#uda para poder escri*ir el o*jeto . !" que utili-a el componente C2:. Dn+ocacin de Ser+icios Se se requiere in+ocar una funcin pro+ista por el AD OG o alguna C$$ unmanaged( se utili-an los &ervicios de invocacin de plataforma &PDn+oVe). PDn+oVe se encarga de ejecutar la funcin correcta # tam*in de la colocacin de los argumentos para # desde sus contrapartes unmanaged. Simplemente utilice el atri*uto s#simport al definir un mtodo e.terno1 Es#simport& dll > nom*reC$$( name > punto!ntrada( cgarset > conjuntoCaracteres F 3nicamente el argumento dll es o*ligatorio # los dems opcionales( aunque si se omite el atri*uto name( el nom*re de la funcin de implementacin e.terna de*e coincidir con el nom*re del mtodo esttico interno. Cdigo o Seguro Si requiere de escri*ir cdigo no seguro( de*er utili-ar dos pala*ras reser+adas1

unsafe, denota un conte%to no seguro, cuando re#uiera reali ar acciones no seguras se debe envolver el cdigo correspondiente con este modificador, el cual puede ser aplicado a constructores, m,todos y propiedades. fi%ed, al declarar una variable con este modificador previene al recolector de basura de reacomodarlo.

Ce*ugging !l SCX . !" incorpora dos herramientas de depuracin de errores1

C).16;, depurador de l2nea de comando &1Y, depurador 80

El depurador &1Y no soporta la depuracin de cdigo nativo, slo es posible depurar cdigo administrado. No es posible la depuracin de una m$#uina remota &indo$ register y disassembly aun#ue se implementan no son funcionales

90

/ntes de depurar el cdigo de una aplicacin es necesario crear una +ersin depurada( la cual contiene informacin de depuracin no optimi-ada # un archi+o adicional PCB &program database) para depuracin # un estado de informacin del pro#ecto es creado. Para crear una +ersin depurada son necesarios dos s2itches al compilar1 csc =optimi-e8 =de*ug, nom*re/rchi+o9uente.cs !stos comandos utili-ados al compilar crea dos archi+os1 nom*re/rchi+o9uente.e.e # nom*re/rchi+o9uente.pd* Para configurar la sesin de depuracin es necesario seleccionar la aplicacin que se desea depurar # comen-ar el depurador SCX ejecutando d*gurt.e.e( el cual esta almacenado en el directorio Program9iles HASSCXHuiCe*ug 3na +e- que la aplicacin depuradora comien-a se selecciona el programa que se desea depurar en donde ser tam*in posi*le especificar argumentos en la l0nea de comandos( mismos que son pasados a la aplicacin cuando la sesin de depuracin inicia. !s posi*le esta*lecer diferentes tipos de brea3point1

5ile, interrumpe la ejecucin cuando una ubicacin espec2fica en el archivo fuente se alcan a 1ata, interrumpe la ejecucin cuando una variable cambia a un valor especifico 5unction, interrumpe la ejecucin en una ubicacin espec2fica dentro de una funcin espec2fica /ddress, interrumpe la ejecucin cuando una direccin de memoria espec2fica se alcan a

3na +e- que se interrumpe la ejecucin( es posi*le continuarla utili-ando los comandos1

&tep )ver &tep 0nto &tep )ut .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*in 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. $as e.cepciones son un punto e.celente de comien-o para una sesin de depuracin( cuando una e.cepcin no es controlada apropiadamente por el cdigo se muestra la +entana de depuracin llamada SD" just in time. Seguridad 5o# en d0a el cdigo +iene de distintas fuentes( no solo el que es instalado +ia un setup por el ser+idor( tam*in puede ser instalado +ia una pgina 4e* o correo electrnico.

91

. !" plantea dos posi*les soluciones para la seguridad1

&eguridad de acceso al cdigo &eguridad basada en roles

Seguridad de acceso al cdigo $a &eguridad de acceso al cdigo controla el acceso protegiendo los recursos # operaciones. !l cdigo es confia*le en distintos grados( dependiendo su identidad # de donde +iene. 9unciones de la seguridad de acceso al cdigo1

El administrador puede definir las pol2ticas de seguridad asignando ciertos permisos para definir grupos de cdigo. El cdigo puede re#uerir #ue #uien invoca *caller+ debe tener permisos especificos "a ejecucin de cdigo est$ restringido en tiempo de ejecucin, reali ando che#ueos para verificar #ue los permisos otorgados a #uien invoca *caller+ coincidan con el permiso re#uerido para la operacin. El cdigo puede re#uerir los permisos necesarios de ejecucin y los permisos #ue podr2an ser utili ados, es decir, verificar los permisos indispensables. "os permisos son definidos para representar ciertos derechos para acceder a distintos recursos del sistema. "a seguridad de acceso al cdigo otorga permisos cuando un componente es cargado, este otorgamiento esta basado en el re#uerimiento del cdigo, definiendo operaciones permitidas por las pol2ticas de seguridad.

!.isten dos puntos importantes de la seguridad de acceso al cdigo( donde el requerimiento m0nimo para *eneficiarse de la seguridad de acceso al cdigo es para generar un cdigo de tipo seguro.

(erificar el tipo de seguridad del cdigo administrado, el runtime for a la restriccin de seguridad del cdigo administrado, para determinar cuando el cdigo es seguro. Es importante #ue el runtime sea capa de checar los permisos de #uien invoca de manera confiable, evadiendo hoyos de seguridad #ue son creados cuando cdigo menos confiable invoca cdigo altamente confiable, para ello el cdigo administrado debe ser verificado como tipo seguro. Cada acceso a tipos se reali a slo en un sentido permitido. El cdigo C# es de tipo no seguro, pero el 0" y los metadatos son inspeccionados antes de dar el visto bueno del tipo de seguridad del cdigo.

92

!ermisos #ue son re#ueridos por el cdigo, el beneficio de activar el re#uerimiento de permisos es conocer cuando se tiene el permiso apropiado para reali ar acciones y cuando no. Es posible prevenir al cdigo de el otorgamiento de permisos adicionales #ue no son necesarios. "os permisos m2nimos garanti an #ue el cdigo se ejecute con los recursos justos cuando el cdigo re#uiere de muchos permisos sin #ue falle.

$a categoria de los permisos es1

.e#uired, permiso #ue el cdigo necesita para ejecutarse correctamente. )ptional, permisos #ue no son obligatorios para la ejecucin correcta del cdigo, pero #ue podr2a ser bueno tenerlos. .efused, permiso #ue se necesita para #ue el cdigo nunca se otorgue, aun#ue la pol2tica de seguridad lo permita, se utili a para restringir vulnerabilidades potenciales.

Permisos !stndar $os !ermisos Est$ndar son1

Environment!ermission, clase #ue define permisos de acceso a variables de ambiente, donde son posibles dos tipos de acceso, de s'lo lectura y escritura al valor de una variable de ambiente. El tipo de acceso escritura incluye permisos para crear y eliminar variables de ambiente. 5ile1ialog!ermission, controla el acceso a archivos basado en el sistema de archivos de di$logo. El usuario debe autori ar el acceso al archivo via el cuadro de di$logo. 5ile0)!ermission, es posible especificar tres tipos de acceso a archivos de entrada y salida= lectura, escritura y adici'n, el acceso lectura incluye acceder a la informacin del archivo, el tipo escritura incluye eliminar y sobreescribir, el acceso adicin no permite leer otros bits. 0solated&torage!ermission, controla el acceso a almacenamientos aislados, este acceso permite utili acin, tama:o de almacenamiento, tiempo de e%piracin y almacenamiento de datos. .eflection!ermission, controla la capacidad de leer el tipo de informacin de tipos miembro no pblicos y controla el uso de .eflection.Emit .egistry!ermission, Control de lectura, creacin y escritura en el registry &ecurity!ermission, coleccin de permisos simples #ue son utili ados por el sistema de seguridad, es posible controlar la ejecucin de cdigo, sobreescritura de che#ueos de seguridad, invocacin de cdigo no administrado, seriali acin, etc.

93

80!ermission, define el acceso a varios aspectos de la interfa de usuario, incluyendo el uso de 7indo7s, acceso a eventos y uso del portapapeles.

Permisos Ddentidad $os !ermisos 0dentidad son1

!ubilsher0dentity!ermission, la firma de componentes .NET provee resistencia de soft7are publisher &trongName0dentity!ermission, define el nombre del componente criptograficamente, ya #ue el nombre compromete la identidad. Zone0dentity!ermission, define la ona de donde el cdigo tiene origen, un 8." puede pertenecer a slo una ona &ite0dentity!ermission, permisos derivados basados en el sitio 7eb de donde el cdigo tiene origen 8."0dentity!ermission, permisos derivados basados en 8." de donde el cdigo tiene origen

Seguridad *asada en roles $a &eguridad basada en roles representa a un usuario o agente que actua en representacin de un usuario dado. $as aplicaciones . !" hacen decisiones *asadas en la identidad principal o su role como miem*ro. 3n role es un nom*re para un conjunto de usuarios quienes comparten los mismos pri+ilegios. 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. 3n principal no necesariamente es un usuario( tam*in puede ser un agente. !.isten tres tipos de principal1

;eneric principals, representa usuarios no autentificados. 9indo7s principals, relacin de usuarios 7indo7s y sus roles, el acceso a recursos de otro usuario es permitido. Custom principals, definido por una aplicacin. !ueden e%tender la nocin b$sica de la identidad y los roles del principal. "a restriccin es #ue la aplicacin debe proveer un mdulo de autentificacin de los tipos #ue el principal puede implementar.

$a clase Principalpermission pro+ee consistencia con la seguridad de acceso( permitiendo al runtime reali-ar la autori-acin en un sentido similar al chequeo de la seguridad de acceso al cdigo( pero es posi*le acceder directamente a la informacin de identidad principal # reali-ar chequeos de role e identidad en el cdigo cuando sea necesario. 9uncin "oString&) /nalice el siguiente ejemplo1 using S#stem;

94

class !mpleado< string usr; string p4d; pu*lic !mpleado&string login( string p4d)< this.usr > login; this.p4d > p4d; @ @ class /pp< pu*lic static +oid :ain&)< !mpleado empleado > ne4 !mpleado&7gangeles7(7JGO7); Console.Arite$ine&7!mpleado 1 7 , empleado); @ @ &alida1 !mpleado 1 !mpleado $a salida fue el nom*re de la clase !mpleado #a que es la representacin ms cercana que encontro. !s posi*le especificar algo con ma#or sentido para ello se necesita redefinir la funcin "oString&)1 using S#stem; class !mpleado< string usr; string p4d; pu*lic !mpleado&string login( string p4d)< this.usr > login; this.p4d > p4d; @ pu*lic o+erride string "oString&)< return&73suario 1 7 , usr , 7( Pass4ord 1 7 , p4d); @ @ class /pp< pu*lic static +oid :ain&)< !mpleado empleado > ne4 !mpleado&7gangeles7(7JGO7); Console.Arite$ine&empleado); @ @ &alida1 3suario 1 gangeles( Pass4ord 1 JGO 9uncin !quals&) $a funcin !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.is del operador( estos operadores de*en ser redefinidos en pares( no pueden ser redefinidos separadamente. !jemplo1 using S#stem; class !mpleado< string usr; string p4d; pu*lic !mpleado&string login( string p4d)< this.usr > login; this.p4d > p4d; @

95

pu*lic o+erride string "oString&)< return&73suario 1 7 , usr , 7( Pass4ord 1 7 , p4d); @ pu*lic o+erride *ool !quals&o*ject o)< !mpleado empB > &!mpleado)o; if&usr [> empB.usr)<return false;@ if&p4d [> empB.p4d)<return false;@ return true; @ pu*lic static *ool operator>>&!mpleado emp/( !mpleado empB)< return emp/.!quals&empB); @ pu*lic static *ool operator[>&!mpleado emp/( !mpleado empB)< return [emp/.!quals&empB); @ @ class /pp< pu*lic static +oid :ain&)< !mpleado empleadoJ > ne4 !mpleado&7gangeles7(7JGO7); !mpleado empleadoG > ne4 !mpleado&7gangeles7(7JGO7); Console.Arite$ine&7!l empleadoJ es igual al empleadoG1 7,empleadoJ.!quals&empleadoG)); Console.Arite&7empleadoJ >> empleadoG 1 7); Console.Arite&empleadoJ >> empleadoG); @ @ &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 funcin Het5ashCode&) #a que los +alores que regresa son requeridos para ser relacionados al +alor de regreso de !quals&). Cuando se in+oca la funcin !quals&) # dos o*jetos son iguales siempre se de*e regresar el mismo cdigo hash. Si no es redefinido el cdigo hash podr0a ser slo 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. !s posi*le utili-ar un miem*ro que es %nico para el cdigo hash( pero si no e.iste un +alor %nico el cdigo hash de*er0a ser creado fuera de los +alores contenidos en la funcin. Si la clase no tiene un identificador %nico pero tiene tiene otros campos( podr0as ser utili-ados por la funcin hash1 using S#stem; class !mpleado< string usr; string p4d; pu*lic !mpleado&string login( string p4d)< this.usr > login; this.p4d > p4d; @ pu*lic o+erride string "oString&)< return&73suario 1 7 , usr , 7( Pass4ord 1 7 , p4d); @ pu*lic o+erride *ool !quals&o*ject o)< !mpleado empB > &!mpleado)o;

96

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

97

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

ne4

98

lenguajes./dd&a$enguajeE?F( 7-.c7); lenguajes./dd&a$enguajeEJF( 7*nm7); lenguajes./dd&a$enguajeEGF( 7sdf7); lenguajes./dd&a$enguajeEOF( 74er7); lenguajes./dd&a$enguajeEPF( 7tgh7); $enguaje clone > ne4 $enguaje&7:i$enguaje7( JGOPI); string s > &string) lenguajesEcloneF; Console.Arite$ine&clone."oString&)( s); @ @ 9uncin DClona*le $a funcin o*ject.:em*erAiseClone&) puede ser utili-ada para crear un clon de un o*jeto. $a implementacin por default de esta funcin produce una copia de un o*jeto( los campos de un o*jeto son copiados e.actamente en lugar de ser duplicados1 using S#stem; class Saludo< pu*lic string s; pu*lic Saludo&string s)< this.s > s; @ @ class :iClase< pu*lic Saludo saludo; pu*lic :iClase&string s)<this.saludo > ne4 Saludo&s);@ pu*lic :iClase Clon&)<return &:iClase):em*er4iseClone&);@ @ class /pp< pu*lic static +oid :ain&)< :iClase miClase > ne4 :iClase&75ello Aorld[7); :iClase miClon > miClase.Clon&); Console.Arite$ine&7miClase 1 7 , miClase.saludo.s); Console.Arite$ine&7miClon 1 7 , miClon.saludo.s); miClon.saludo.s > 75ola :undo7; Console.Arite$ine&7miClase 1 7 , miClase.saludo.s); Console.Arite$ine&7miClon 1 7 , miClon.saludo.s); @ @ &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 funcin :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. 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 implementacin de la interface DClonea*le1

99

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

100

!( e !( f H( g (n R( .

Scientific &e.ponential ) 9i.ed8point Heneral um*er

Console.Arite$ine&7?1!7( @.@@KLXHE>HHK OOOPI.YW\\); Console.Arite$ine&7?197( OOOPI.YW\\); Console.Arite$ine&7?1H7( OOOPI.YW\\); Console.Arite$ine&7?1 7( OOOPI.YW\\); @.@@KLXHE>HHK @@@KL.NXOO @@,@KL.XH 55

5e.adecima Console.Arite$ine&7?1R7( l GII);

9ormato Personali-ado String !l 5ormato !ersonali ado &tring( son utili-ados para o*tener ms control( so*re la con+ersacin que est disponi*le a tra+s del formato estndar de strings. 'eempla-o de Cero o Cigito Console.Arite$ine&7<?1???@7(JG); &alida1 ?JG 'eempla-o de !spacio o Cigito Console.Arite$ine&7<?1#####@7(JGO); &alida1 JGO Punto Cecimal Console.Arite$ine&7<?1#####.???@7(JGOPI.G); &alida1 JGOPI.G?? Separador de Hrupo Console.Arite$ine&7<?1##(###@7(JJGOPIK\YW); &alida1 J(JGO(PIK(\YW Separador de Hrupo Console.Arite$ine&7<?1???(.##@7(JGOWP); &alida1 JGO.WI Porcentaje Console.Arite$ine&7<?1##.???e@7(WYJPP); &alida1 WY.JPPe otacin !.ponencial Console.Arite$ine&7<?1###.???!8??@7(O.JPJIIOO!,?P); &alida1 OJP.JII!8?G Separador de Seccin Console.Arite$ine&7<?1###.??;?;&###.??)@7(8PIK.II); &alida1 PI\ !scape # $iterales Console.Arite$ine&7<?1###`#@7(GII); &alida1 GII# Parseo umrico $os n%meros pueden ser parseados utili-ando el mtodo Parse&)( esto es posi*le #a que lo pro+ee el tipo de dato. int iQalue > DntOG.Parse&7JGO7); dou*le dQalue > Cou*le.Parse&7J.GO7); Dnput=2utput !l lenguaje Com%n en "iempo de !jecucin . !" pro+ee funciones de entrada=salida en el namespace S#stem.D2. $a lectura # escritura la reali-a la clase Stream( la cual descri*e como los b,tes pueden ser escritos o leidos. Stream es una clase a*stracta que en la prctica las clases deri+an de Stream para ser utili-adas. Clases disponi*les1

101

5ile&tream, flujo en un archivo de disco 'emory&tream, flujo #ue es almacenado en memoria Net7or3&tream, flujo en una cone%in de red 6uffered&tream, implementa un buffer en la cima de otro stream.

$ectura # !scritura de /rchi+os !.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. / continuacin se muestra un ejemplo donde( cada +e- que el programa es ejecutado se so*reescri*e el contenido del archi+o en caso de que este e.ista( si no e.iste se crea1 using S#stem; using S#stem.D2; class /pp< pu*lic static +oid :ain&)< 9ileStream f > ne4 9ileStream&7nue+o.t.t7( 9ile:ode.Create); StreamAriter s > ne4 StreamAriter&f); for&int i um*er$ine > J; i um*er$ine L> J?; i um*er$ine, ,)< s.Arite$ine&7$inea 7 , i um*er$ine); @ s.Close&); f.Close&); @ @ &alida( /rchi+o .ue(o.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-acin $a &eriali acin 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. $a informacin de los metadatos en un o*jeto contiene informacin 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. "hreading &5ilos)

102

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

103