Índice Temático<br />Básico » Intermedio » Avanzado<br />¿Qué es C#? <br />Lenguaje Orientado a Objetos <br />Objeto <br /...
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Csharp
Upcoming SlideShare
Loading in …5
×

Csharp

2,285 views

Published on

mnanual que sirve de guia en c srap

0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
2,285
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
195
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide

Csharp

  1. 1. Índice Temático<br />Básico » Intermedio » Avanzado<br />¿Qué es C#? <br />Lenguaje Orientado a Objetos <br />Objeto <br />Herencia <br />Clase <br />Funciones Miembro <br />Campos Estáticos <br />Clase Base <br />Clase Derivada <br />Clase Abstracta <br />Clase Sealed <br />Overloading/Sobrecarga <br />Herencia Simple <br />Polimorfismo y Funciones Virtuales <br />Encapsulación y Visibilidad <br />Abstracción <br />Plataforma .NET <br />.NET Common Language Runtime - CLR <br />Características del CLR <br />.NET Runtime Environment <br />Ambiente/Entorno de Ejecución <br />Ensamblaje <br />Interoperabilidad de Lenguaje <br />Atributos <br />Biblioteca de Clases de la Plataforma .NET <br />Requerimientos de Software <br />Lenguaje Intermedio y Metadatos <br />JIT <br />Sistema de Tipo Unificado <br />El Sistema Virtual de Objetos - VOS <br />VOS Type System <br />Metadata y Reflection <br />Seguridad <br />Deployment <br />Interoperabilidad con código no administrado <br />Common Language Specification - CLS <br />Virtual Execution System - VES <br />Tipos de Datos <br />Constantes y Campos Solo Lectura <br />Ejemplo Hello World! <br />Ejemplo Args <br />Ejemplo Input/Output <br />Ejemplo String Format <br />Función Main <br />Múltiples Funciones Main <br />Preprocesamiento <br />Comentarios <br />Value Types <br />Tipos simples <br />Integral <br />Bool <br />Char <br />Floating Point <br />Decimal <br />Tipos Estructura <br />Tipos Enumeración <br />Tipos Referencia <br />Tipo Objeto <br />Tipo Clase <br />Interfaces <br />Delegados <br />Tipo string <br />Arreglos <br />Arreglos Multidimensionales <br />Arreglo de Arreglos <br />Arreglos de Objetos <br />Conversión de Arreglos <br />Clase Array <br />Interface IComparable <br />Interface IComparer <br />IComparer Como Propiedad <br />Expresiones Regulares <br />Operador as <br />Secuencias de Escape <br />Boxing <br />Conversiones Boxing <br />Conversiones Unboxing <br />Constructores y Destructores <br />Constructor Estático <br />Métodos <br />Parámetros <br />Valores en Parámetros in <br />Valores en Parámetros ref <br />Valores en Parámetros out <br />Ejemplo de Parámetros In, Ref y Out <br />Redefinición de Métodos (Overriding) <br />Ocultamiento de Métodos (Hiding) <br />Propiedades <br />Accessors <br />Propiedades Estáticas <br />Índices <br />Eventos <br />Modificadores <br />Modificadores de Clase <br />Modificadores Miembro <br />Modificadores de Acceso <br />public <br />protected <br />private <br />internal <br />Sentencias de Control <br />Sentencias de Selección <br />Sentencia if <br />Sentencia switch <br />Sentencias de Iteración (repetición) <br />Sentencia for <br />Sentencia foreach <br />Sentencia while <br />Sentencia do <br />Sentencias de Salto <br />break <br />continue <br />goto <br />return <br />Asignación Definitiva <br />Precedencia de Operadores <br />typeof <br />is <br />Conversiones <br />Básico » Intermedio » Avanzado<br />Manejo de Excepciones <br />Jerarquía de Excepciones <br />Trabajar con Excepciones <br />Chequeo de Overflow <br />Chequeo programático de Overflow <br />Sentencias para el Manejo de Excepciones <br />try - catch <br />try - finally <br />try - catch - finally <br />Lanzamiento de Excepciones <br />Relanzamiento de Excepciones <br />Creación de Clases Exception <br />Componentes <br />Creación de Componentes <br />Compilación de Componentes <br />Creación de una Aplicación Cliente <br />Compilación de Clientes <br />Namespaces <br />Envolver Clases en Namespace <br />Utilizar Namespace en Aplicaciones Cliente <br />Agregar Múltiples Clases a Un Namespace <br />Namespace y Ensambles <br />Compilación Condicional <br />Uso del Preprocesador <br />Definición de símbolos <br />Exclusión de código basado en símbolos <br />Lanzamiento de errores y advertencias <br />Atributo conditional <br />Comentarios de Documentación en XML <br />Elementos XML <br />Componentes .NET <br />Componentes .NET Privados <br />Componentes .NET Compartidos <br />Interoperabilidad COM <br />Uso de Componentes .NET en Componentes .COM <br />Uso de Componentes COM en Componentes .NET <br />Invocación de Servicios <br />Código No Seguro <br />Debugging <br />Seguridad <br />Seguridad de acceso al código <br />Permisos Estándar <br />Permisos Identidad <br />Seguridad basada en roles <br />Función ToString() <br />Función Equals() <br />Básico » Intermedio » Avanzado<br />Clase Hashtable <br />Interface IHashCodeProvider <br />Función ICloneable <br />Formato Numérico <br />Formato Personalizado String <br />Formato Estándar String <br />Parseo Numérico <br />Input/Output <br />Lectura y Escritura de Archivos <br />Serialización <br />Threading (Hilos) <br />¿Qué es C#? <br />C# o C Sharp es un lenguaje de programación que está incluido en la Plataforma .NET y corre en el Lenguaje Común en Tiempo de Ejecución (CLR, Common Language Runtime). El primer lenguaje en importancia para el CLR es C#, mucho de lo que soporta la Plataforma .NET está escrito en C#. <br />C# intenta ser el lenguaje base para escribir aplicaciones .NET <br />C# deriva de C y C++, es moderno, simple y enteramente orientado a objetos, simplifica y moderniza a C++ en las áreas de clases, namespaces, sobrecarga de métodos y manejo de excepciones. Se elimino la complejidad de C++ para hacerlo más fácil de utilizar y menos propenso a errores. <br />Algunas características de C# son:<br />C# provee el beneficio de un ambiente elegante y unificado. <br />No soporta herencia múltiple, solamente el runtime .NET permite la herencia múltiple en la forma de interfaces, las cuales no pueden contener implementación. <br />No maneja apuntadores, para emular la función de los apuntadores se utiliza delegates el cual provee las bases para el .NET event model. <br />Por default trabaja con código administrado. <br />La Plataforma .NET provee un colector de basura que es responsable de administrar la memoria en los programas C#. <br />El manejo de errores está basado en excepciones. <br />Soporta los conceptos como encapsulación, herencia y polimorfismo de la programación orientada a objetos. <br />El Modelo completo de clases está construido en la cima del .NET Virtual Object System (VOS). El modelo de objetos es parte de la infraestructura y ya no forma parte del lenguaje de progrmación. <br />No existen 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). <br />Los métodos que se definen en las clases son por default no virtuales (no pueden ser sobre escritos al derivar clases) <br />Soporta los modificadores de acceso private, protected, public y agrega un cuarto modificador internal. <br />Solamente se permite una base clase, si se requiere herencia múltiple es posible implementar intefaces. <br />No es posible utilizar variables no inicializadas. <br />No es posible hacer el cast de un entero a un tipo de referencia (objeto). <br />Los parámetros que son pasados son type-safe. <br />El soporte de versiones lo provee el CLR. <br />Permite acceder a diferentes APIs a través de .NET Common Language Specification, el cual define el estádar de interoperabilidad entre lenguajes que se adhieran a este estándar. <br />La Plataforma .NET provee un acceso transparente a COM. <br />Soporta OLE <br />Permite la interoperabilidad con APIs al estilo C y DLLs, esta característica para acceder a APIs nativas es llamada Platform Invocation Services (PInvoke) <br />Por default el código es safe mode, pero es posible declarar clases o sólo métodos unsafe, esta declaración permite utilizar apuntadores, estructuras y almacenamiento de arreglos estáticos. <br />C# depende del runtime que provee la Plataforma .NET, el runtime administra la ejecución de código. <br />Lenguaje Orientado a Objetos<br />Según Bjarne Stroustrup autor del lenguaje de programación C++, para que un lenguaje sea llamado Orientado a Objetos debe soportar tres conceptos: objetos, clases y herencia. <br />Aunque los lenguajes orientados a objetos se construyen sobre los conceptos de : <br />Encapsulación <br />Herencia <br />Polimorfismo <br />Objeto<br />Un Objeto es una instancia de un tipo de clase. <br />La instanciación es el acto de crear una instancia de un objeto, la instancia es un objeto, la instanciación usa el operador new, después la instanciación es posible comunicarnos con el objeto a través de sus miembros. <br />Un Objeto es una colección de información relacionada y funcional. <br />Un objeto se compone de: <br />Datos que describen el objeto y <br />Operaciones que pueden ser realizadas por el objeto <br />Herencia<br />La Herencia es la habilidad para heredar datos y funcionalidad de un objeto padre, la herencia es una característica fundamental de un sistema orientado a objetos. <br />A través de la herencia es posible crear o derivar una nueva clase basada en una clase existente. <br />Una clase derivada es la nueva clase que esta siendo creada y la clase base es una de las cuales la nueva clase es derivada. La nueva clase derivada hereda todos los miembros de la clase base por consiguiente permite reusar el trabajo previo. <br />En C# se puede asumir que la clase derivada podría heredar todos los miembros de la clase base. <br />La herencia es un ejemplo del diseño orientado a objetos conocido como una relación "is-a" (es-un), por ejemplo: <br />"un empleado es una persona".<br />Al utilizar la herencia la clase base necesita ser diseñada teniendo en mente la herencia, si los objetos no tienen la estructura apropiada la herencia no podría funcionar correctamente. <br />Una clase derivada no debería requerir más ni prometer menos que su clase base sobre cualquiera de sus interfaces heredadas. <br />Una interfaz de clase es un contrato entre esta y los programadores que usan la clase. <br />upcasting, cuando un programador tiene una referencia a la clase derivada, el programador siempre puede tratar a esa clase como si fuera la clase base. <br />En el lenguaje común en tiempo de ejecución .NET todos los objetos heredan de la última clase base llamada object y existe sólo una herencia simple de objetos. <br />Un objeto puede derivar sólo de una clase base.<br />Clase<br />Una Clase es una plantilla para un objeto.<br />Una Clase define las operaciones que un objeto puede realizar y define un valor que mantiene el estado del objeto, los componentes principales de una clase son: métodos, eventos y propiedades. <br />Una instancia de una clase es un objeto, se accede a la funcionalidad de un objeto invocando sus métodos y accediendo a sus propiedades, eventos y campos. <br />Una clase utiliza modificadores para especificar la accesibilidad de la clase y sus componentes, los componentes de una clase son llamados miembros por lo que existen diferentes tipos de miembros. Una referencia se refiere a una instancia, una instancia es la creación de un objeto del tipo clase que se está declarando. Una clase utiliza ninguno, uno o más constructores para ayudar a definir la instancia de una clase. Existe una palabra reservada llamada this que sirve para hacer referencia a la clase actual en el ámbito en el cual es utilizada. Cuando se hace referencia a una variable de instancia que tiene el mismo nombre de un parámetro se debe utilizar this.name. <br />Al crear y manipular objetos no es necesario administrar la memoria que estos ocupan ya que existe un mecanismo que se encarga de esto llamado garbage collector (recolector de basura), pero es una buena práctica no olvidar liberar los recursos. <br />Funciones Miembro<br />Una Función Miembro puede ser un constructor, es decir, una pieza de código que es invocada en una instancia del objeto. <br />Campos Estáticos<br />Un Miembro Estático definine miembros de un objeto que no son asociados con una instancia de clase específica. <br />Un Campo Estático es el tipo más simple de un miembro estático, para declarar un campo estático se utiliza el modificador static. <br />Un campo estático puede accederse a través del nombre de la clase, en vez de la instancia de la clase (objeto): <br />using System;<br />class MiContador{<br />//Campo Estático<br />public static int iContador = 0;<br />public MiContador(){<br />iContador++;<br />}<br />}<br />class App{<br />public static void Main(){<br />MiContador ContadorA = new MiContador();<br />Console.WriteLine(MiContador.iContador);<br />MiContador ContadorB = new MiContador();<br />Console.WriteLine(MiContador.iContador);<br />}<br />}<br />El ejemplo determina cuantas instancias del objeto han sido creadas. <br />Clase Base<br />Una Clase base es un objeto padre de donde se basa un nuevo trabajo. <br />Clase Derivada<br />Una Clase derivada es un objeto hijo. <br />Clase Abstracta<br />Una Clase Abstracta define las funciones que una clase derivada debe implementar. <br />Una Clase Abstracta define un contrato en donde las clases derivadas deben definir las funciones que la clase padre marca utilizando la palabra reservada abstract, además que la clase padre también se define como abstract. <br />using System;<br />abstract public class Persona{//Indica que la clase es abstracta<br />//Propiedades<br />public string sNombre;<br />public int iEdad;<br />//Constructor<br />public Persona(string sNombre, int iEdad){<br />this.sNombre = sNombre;<br />this.iEdad = iEdad;<br />}<br />//Métodos<br />abstract public string Tipo();//Método que la clase derivada debe implementar<br />}<br />//Herencia Simple<br />public class Empleado : Persona{<br />public Empleado(string sNombre, int iEdad):base(sNombre, iEdad){}<br />override public string Tipo(){<br />return "Empleado";<br />}<br />}<br />class App{<br />//Aplicación<br />public static void Main(){<br />Console.WriteLine("--- Arreglo de Objetos ---");<br />Empleado[] aProgramadores = new Empleado[2];<br />aProgramadores[0] = new Empleado("Bill Gates", 50);<br />aProgramadores[1] = new Empleado("Eric S. Raymond", 60);<br />for(int i = 0; i < aProgramadores.Length; i++){<br /> Console.WriteLine("aProgramadores["+i+"].sNombre : " + aProgramadores[i].sNombre);<br /> Console.WriteLine("aProgramadores[" + i + "].iEdad : " + aProgramadores[i].iEdad);<br /> Console.WriteLine("aProgramadores[" + i + "].Tipo : " + aProgramadores[i].Tipo());<br />}<br />}<br />}<br />Clase Sealed<br />Una Clase sealed se utiliza para prevenir que una clase sea utilizada como una clase base, su principal uso es para prevenir la derivación no planeada. <br />sealed class ClaseBase{<br />ClaseBase(){}<br />}<br />class ClaseDerivada : ClaseBase{<br />}<br />class Sellada{<br />public static void Main(){<br />ClaseDerivada CD = new ClaseDerivada();<br />}<br />}<br />Al compilar el código se muestra el siguiente mensaje: <br />sealed.cs(4,7): error CS0509: 'ClaseDerivada' : cannot inherit from sealed class 'ClaseBase'<br />sealed.cs(1,14): (Location of symbol related to previous error)<br />El error es porque ClaseDerivada no puede utilizar ClaseBase como una clase base porque ClaseBase es sealed, es decir, no permite derivaciones. <br />Overloading/Sobrecarga<br />La Sobrecarga (Overloading) hace posible utilizar dos o más clases con el mismo nombre, pero con parámetros diferentes. La sobrecarga es común especialmente para los constructores para definir diferentes maneras de crear una instancia nueva. <br />Cuando una función sobrecargada es invocada el compilador selecciona la función apropiada que coincide con los parámetros. <br />Herencia Simple<br />La Herencia Simple permite derivar una clase en una clase nueva, que contiene la definición de la clase de la cual deriva, es decir, hereda todos los miembros datos de la clase, aunque pueden existir miembros a los cuales no se pueda tener acceso por ser private. <br />Los constructores no pueden ser heredados, por lo que es necesario escribir constructores y si funcionalmente no existe alguna modificación se invoca el constructor de la clase que hereda utilizando la sintaxis base. Si se omite el constructor de la clase base y es invocado el compilador podría invocar el constructor de la clase base sin parámetros. <br />using System;<br />public class Persona{<br />//Propiedades<br />public string sNombre;<br />public int iEdad;<br />private double dSueldo;<br />//Constructor<br />public Persona(string sNombre, int iEdad){<br />this.sNombre = sNombre;<br />this.iEdad = iEdad;<br />}<br />//Métodos<br />public string Tipo(){<br />return "Persona";<br />}<br />public void AsignarSueldo(double dSueldo){<br />this.dSueldo = dSueldo;<br />}<br />public double ObtenerSueldo(){<br />return this.dSueldo;<br />}<br />}<br />//Herencia Simple<br />public class Empleado : Persona{<br />public Empleado(string sNombre, int iEdad):base(sNombre, iEdad){}<br />public new string Tipo(){<br />return "Empleado";<br />}<br />double dSueldo;<br />public new void AsignarSueldo(double dSueldo){<br />this.dSueldo = dSueldo * dSueldo;<br />}<br />public new double ObtenerSueldo(){<br />return this.dSueldo;<br />}<br />}<br />class App{<br />//Aplicación<br />public static void Main(){<br />Persona Mexicano = new Persona("Gerado Ángeles Nava", 33);<br />Console.WriteLine("Mexicano.sNombre : " + Mexicano.sNombre);<br />Console.WriteLine("Mexicano.iEdad : " + Mexicano.iEdad);<br />double dSueldo = 123.456;<br />Mexicano.AsignarSueldo(dSueldo);<br />Console.WriteLine("Mexicano.iSueldo : " + Mexicano.ObtenerSueldo());<br />Console.WriteLine("Mexicano.Tipo : " + Mexicano.Tipo());<br />Console.WriteLine("--- Herencia Simple ---");<br />Empleado Programador = new Empleado("Carlos Salinas G.", 53);<br />Console.WriteLine("Programador.sNombre : " + Programador.sNombre);<br />Console.WriteLine("Programador.iEdad : " + Programador.iEdad);<br />Programador.AsignarSueldo(dSueldo);<br />Console.WriteLine("Programador.iSueldo : " + Programador.ObtenerSueldo());<br />Console.WriteLine("Programador.Tipo : " + Programador.Tipo());<br />}<br />}<br />Polimorfismo y Funciones Virtuales<br />El polimorfismo es la funcionalidad que permite a código antiguo invocar código nuevo, también permite extender el sistema sin modificar el código existente, esto se logra sobreescribiendo o redefiniendo el código, para lo cual se utilizan funciones virtuales y la palabra clave override. <br />Las funciones abstractas son automaticamente funciones virtuales, las cuales permiten al programador usar polimorfismo para hacer su código simple. <br />Virtual significa que cuando una invocación a funciones miembro, el compilador debería buscar por el tipo real del objeto y no por el tipo de la referencia, e invocar en base al tipo la función apropiada. <br />using System;<br />public class Persona{<br />//Propiedades<br />public string sNombre;<br />public int iEdad;<br />//Constructor<br />public Persona(string sNombre, int iEdad){<br />this.sNombre = sNombre;<br />this.iEdad = iEdad;<br />}<br />//Métodos<br />virtual public string Tipo(){<br />return "Persona";<br />}<br />}<br />//Herencia Simple<br />public class Empleado : Persona{<br />public Empleado(string sNombre, int iEdad):base(sNombre, iEdad){}<br />override public string Tipo(){<br />return "Empleado";<br />}<br />}<br />class App{<br />//Aplicación<br /> public static void Main(){<br />Persona Mexicano = new Persona("Gerado Ángeles Nava", 33);<br />Console.WriteLine("Mexicano.sNombre : " + Mexicano.sNombre);<br />Console.WriteLine("Mexicano.iEdad : " + Mexicano.iEdad);<br />Console.WriteLine("Mexicano.Tipo : " + Mexicano.Tipo());<br />Console.WriteLine("--- Arreglo de Objetos ---");<br />Empleado[] aProgramadores = new Empleado[2];<br />aProgramadores[0] = new Empleado("Bill Gates", 50);<br />aProgramadores[1] = new Empleado("Eric S. Raymond", 60);<br />for(int i = 0; i < aProgramadores.Length; i++){<br /> Console.WriteLine("aProgramadores["+i+"].sNombre : " + aProgramadores[i].sNombre);<br /> Console.WriteLine("aProgramadores[" + i + "].iEdad : " + aProgramadores[i].iEdad);<br /> Console.WriteLine("aProgramadores[" + i + "].Tipo : " + aProgramadores[i].Tipo());<br />}<br /> }<br />}<br />Cuando una función es declarada con la palabra reservada override significa que es la misma función que fue declarada en la clase base, si la palabra reservada override se omite el compilador podría asumir que la función no está relacionada a la función de la clase base y no despacha la función virtual (el compilador podría sugerir omitir override o agregar new) . <br />Cuando existe una función virtual el programador puede pasar una referencia a la clase abstracta aunque la clase derivada y el compilador podrían escribir código para invocar la versión apropiada de la función en tiempo de ejecución. <br />Por ejemplo, el objeto base object tiene una función virtual llamada ToString() que convierte un objeto a string. Si se invoca la función ToString() en un objeto que que no la tiene como versión propia, la versión de la función que es parte de la clase object podría ser invocada. <br />Encapsulación y Visibilidad<br />Encapsulación (también llamada information hiding), habilidad de un objeto para ocultar sus datos internos o parte interna de sus usuarios y provee una interface que hace las partes importantes del objeto accesible programaticamente. <br />La encapsulación provee los límites entre una interfaz externa y los detalles de su implementación interna. <br />Al diseñar objetos el programador decide que objetos son visibles al usuario y que es privado dentro del objeto, los detalles que no son visibles al usuario son señalados para ser encapsulados en la clase. <br />Razones para encapsular y ocultar:<br />El usuario no puede cambiar lo que es privado en el objeto, lo cual reduce la oportunidad de que el usuario cambie o dependa de los detalles en el código, si el usuario hace lode detalles dependientes, los cambios realizados en el objeto quizá arruinen el código del usuario. <br />Los cambios realizados en partes públicas de un objeto deben permanecer compatibles con la versión previa. Las partes públicas pueden ser cambiadas sin arruinar el código del usuario. <br />Los campos privados pueden sólo ser accesados desde la clase, los campos públicos pueden ser accesados a través de cualquier instancia de la clase. <br />Abstracción<br />Una Abstracción se refiere a como un problema dado es representado en el espacio de programa. <br />Como desarrollador de clases es necesario pensar en terminos de hacer el mejor diseño de abstracción para los clientes de clase y permitirles enfocarse a la tarea que deben realizar y no escudriñar o indagar en los detalles de como funciona la clase, también es necesario determinar cuales de los miembros de la clase deberían ser accesibles publicamente. <br />Los beneficios de una buena abstracción, es diseñarla de manera tal que las modificaciones son minimas, si se conoce bien el problema a resolver facilita determinar que métodos necesitara el usuario, también será un sistema fácil de entender y mantener. <br />La interfaz de clase es la implementación de la abstracción. <br />Plataforma .NET<br />La solución Microsoft .NET comprende cuatro componentes fundamentales: <br />Servicios de Bloques de Construcción .NET o acceso programático para ciertos servicios tales como almacenamiento de archivos, calendario y pasaporte .NET el cual es un servicio de verificación de identidad. <br />Dispositivos de Software .NET el cual podría correr sobre nuevos dispositivos Internet. <br />La Experiencia de Usuario .NET la cual incluye características tales como interfaz natural, agentes de información y etiquetas inteligentes es decir una tecnología que automatiza hiperligas para información relacionada a palabras y frases en documentos creados por el usuario. <br />La Infraestructura .NET la cual comprende la plataforma .NET, Microsoft Studio .NET, los Servidores Corporativos .NET y Microsoft Windows .NET <br />La Infraestructura .NET se refiere a todas las tecnologías que constituyen el nuevo ambiente para crear y ejecutar aplicaciones robustas, escalables y distribuidas. La parte de .NET que permite desarrollar estas aplicaciones es la plataforma .NET. <br />La Plataforma .NET consiste de un Lenguaje Común en Tiempo de Ejecución (CLR) y la Biblioteca de Clases de la Plataforma .NET algunas veces llamada la Biblioteca de Clases Base (CBL). <br />El CLR es como una máquina virtual (el código que corre dentro del CLR en ejecución en un ambiente encapsulado y controlado, separados de otros procesos en la máquina) en la cual funcionan las aplicaciones .NET, todos los lenguajes .NET tienen la biblioteca de clases de la Plataforma .NET a su disposición. <br />La biblioteca de clases de la Plataforma .NET incluyen soporte para cualquiera de los archivos de entrada/salida y base de datos de entrada/salida para XML y SOAP. <br />La Plataforma .NET es una plataforma nueva que simplifica la aplicación del desarrollo en ambientes altamente distribuidos de Internet. La Plataforma .NET está diseñada para cumplir los siguientes objetivos: <br />Proveer un ambiente consistente de programación orientada a objetos, tanto o si el código objeto es almacenado y ejecutado localmente, o si es ejecutado localmente pero distribuido en Internet o si es ejecutado remotamente. <br />Proveer un ambiente de ejecución de código que minimice la distribución de software y conflictos de versiones. <br />Proveer un ambiente de ejecución de código que garantice la ejecución de código seguro, incluyendo el código creado por un desconocido o un tercero semiconfiable. <br />Proveer un ambiente de ejecución de código que elimine los problemas de desempeño de ambientes de scripts o interpretes. <br />Hacer que la experiencia del desarrollador sea consistente a través de una amplia variedad de aplicaciones, tal como aplicaciones basadas en Windows y aplicaciones basadas en Web. <br />Construir toda la comunicación sobre estándares industriales para asegurar que el código basado en la Plataforma .NET pueda integrarse con cualquier otro código. <br />La Plataforma .NET consiste de dos componentes principales: <br />El Lenguaje Común en Tiempo de Ejecución (CLR) el cual es el fundamento de la Plataforma .NET <br />La Biblioteca de Clases de la Plataforma .NET, es una colección orientada a objetos de tipos reusables que pueden utilizarse para desarrollar aplicaciones en el rango de aplicaciones tradicionales desde la línea de comandos o interfaces de usuario gráficas (GUI) hasta aplicaciones basadas en las últimas inovaciones que provee ASP.NET tales como Web Forms y servicios web XML. <br />El runtime es una agente que administra el código en tiempo de ejecución al proveer de serviciones principales como la administración de memoria, administración de hilos, también implementa tipos estrictos de seguridad y otras formas de verificación de código que aseguren la seguridad y robustez. <br />El concepto de administración de código es principio fundamental del runtime. El código que manipulará el runtime es conocido como código administrado, mientras que el código que no será manipulado por el runtime es conocido como un código no administrado. <br />La plataforma .NET puede almacenar componentes no administrados que son cargados por el CLR en sus procesos e inicializados por la ejecución de código administrado de esta manera se crea un ambiente de software que puede explotar tanto caracterísitcas de código administrado como las del código no administrado. <br />.NET Common Language Runtime - CLR<br />El .NET Common Language Runtime (Lenguage común en tiempo de ejecución .NET) es un ambiente basado en componentes y C# esta diseñado para facilitar la creación de componentes. Todos los objetos son escritos como componentes y los componentes son el centro de acción, por ello que reciba el nombre de lenguaje céntrico de componentes (component-centric). <br />Los componentes creados en C# son totalmente auto-describibles y pueden ser utilizados sin un proceso de registro. <br />C# ayuda en la creación de componentes mediante el runtime y framework .NET, los cuales proveen un sistema de tipo unificado en el cual todo puede ser tratado como un objeto. <br />Características del CLR<br />EL CLR no sólo soporta el compilador de C#, también el de Visual Basic y C++, el código que generan estos compiladores para ser soportado por CLR es llamado managed code. <br />Algunos de los beneficios que las aplicaciones obtienen del CLR son: <br />Integración de lenguajes a través del Common Language Specification <br />Administración automatica de memoria, a través del recolector de basura. <br />Manejo de excepciones de lenguajes. <br />Seguridad type safety. <br />Soporte de versiones. <br />Modelo Simplificado para la interacción de componentes. <br />El CLR provee los beneficios anteriores, el compilador debe emitir los metadatos en el managed code. Los metadatos describen los tipos en el código y son empaquetados en el código ejecutable. <br />El CLR administra la memoria, ejecución de hilos, ejecución de código, verificación de código seguro, compilación y otros servicios. Estas características son intrínsecas a la administración de código que corre sobre el CLR. <br />La seguridad y administración de componentes depende de un número de factores que se incluyen en su origen como Internet red corporativa, computadora local, es decir, quizá o quizá no están disponibles para desempeñar operaciones de acceso a archivos, acceso a registros o funciones sensitivas, aún si comienzan a utilizarse en el misma aplicación activa. <br />El runtime forza el acceso a código seguro, no es posible acceder a datos personales, sistema de archivos o red. <br />El runtime también forza la robustez del código implementando una infraestrucutra estricta de verificación de código llamado Common Type System (CTS), el cual asegura que toda la administración de código se describe así misma. La variedad de compiladores Microsoft y de terceros genera código administrado que conforma el CTS, es decir, que la administración de código puede consumir otros tipos e instancias administradas, mientras que se forza estrictamente la fidelidad de tipo y seguridad de tipo. <br />La administración del ambiente del runtime elimina cuestiones de software comunes, liberando por ejemplo recursos que ya no son utilizados. <br />El runtime también acelera la productividad del desarrollador, no importa el lenguaje que un programador utilice, puede utilizar las ventajas del runtime, biblioteca de clases, y componentes escritos por otros programadores, cualquier compilador que utilice el runtime puede hacer lo mismo, <br />La interoperabilidad entre código administrado y no administrado permiten a los desarrolladores continuar utilizando componentes COM y DLLs. <br />El runtime está diseñado para incrementar el desempeño, através del CLR que provee muchos servicios estándar, el código administrado nunca es interpretado, una característica llamada just-in-time (JIT) permite compilar todo el código administrado para correr en el lenguaje nativo de la máquina del sistema o de cualquiera que se este ejecutando. El administrador de memoria elimina las posibilidades de fragmentación de memoria e incrementa la referencia de localidad de memoria para impulsar el incremento del desempeño. <br />El runtime soporta aplicaciones del lado del servidor como Microsoft® SQL Server™ e Internet Information Services (IIS), esta infraestructura permite utilizar codigo administrado para escribir la lógica del negocio. <br />.NET Runtime Environment<br />El Lenguaje Común en Tiempo de Ejecución provee los servicios de ejecución básica. Las clases base proveen tipos de datos básicos, clases colección y otras clases generales. Las clases base son clases para tratar datos y XML. En la parte superior de la arquitectura las clases exponen servicios web y tratramiento de la intefaz de usuario. Una aplicación puede hacer invocaciones en cualquier nivel y utilizar clases desde cualquier nivel. <br />Organización .NET Framework: <br />Servicios WebInterfaz de UsuarioDatos y XMLClases Base Lenguaje Común en Tiempo de Ejecución<br />Ambiente/Entorno de Ejecución<br />El ambiente o entorno provee un modelo de programación simple, seguro, soporta de herramientas potentes y ayuda con la distribución, empaquetado y soporte: <br />Modelo de Programación Simple, todos los servicios son ofrecidos a través de un modelo común que puede ser accedido desde cualquier lenguaje .NET y los servicios pueden ser escritos en cualquier lenguaje .NET, el entorno o ambiente en gran parte es un lenguaje agnóstico permitiendo la elección de lenguaje, esto hace el código fácil de reusar para el programador y los proveedores de bibliotecas. <br />En el runtime .NET todos los errores son reportados via excepciones. <br />El entorno contiene las Bibliotecas de Clase Base (Base Class Libraries - BCL) las cuales proveen las funciones tradicionales fundadas en bibliotecas en tiempo de ejecución, la funcionalidad del BCL incluye: <br />Clases colección, tales como consultas, arreglos, pilas y tablas hash. <br />Clases de acceso a bases de datos <br />Clases IO (input-output) <br />Clases WinForms, para crear interfaces de usuario <br />Clases Network <br />Fuera de la clase base en tiempo de ejecución, existen muchos otros componentes que controlan la interfaz de usuario (UI) y realizan otras operaciones sofisticadas. <br />Seguridad, 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 que el runtime administra la memoria por el programador a través del recolector de basura. <br />El runtime .NET es un entorno verificado, en tiempo de ejecución el entorno verifica que la ejecución del código sea de tipo segura (type-safe). <br />El sistema de seguridad interactua con el verificador para asegurar que el código realice sólo lo que tiene permitido hacer, esto es posible especificando un requerimiento de seguridad para una pieza de código específica. <br />Soporte de herramientas potentes, Microsoft suministra cuatro lenguajes .NET: VB, VC++, C# y JScript. La depuración en gran medida es enriquecida por el runtime .NET, el modelo de ejecución común hace la depuración de lenguajes simple y directa. <br />Distribución, empaquetado y soporte, El runtime .NET ayuda simplificando la distribución y en algunos casos no existe el paso tradicional de instalación, porque los paquetes son distribuidos en un formato genérico, un paquete puede correr en cualquier entorno que soporte .NET, el entorno separa los componentes de una aplicación por lo que una aplicación sólo corre con los componentes que son enviados. <br />Ensamblaje<br />En el runtime .NET el mecanismo de empaquetado es el ensamble (assembly), cuando el código es compilado por uno de los compiladores .NET, es convertido a una forma intermedia conocida como IL. <br />El ensamble contiene todos los IL, metadatos y otros archivos requeridos para que un paquete se ejecute en un paquete completo. <br />Cada ensamble contiene un manifiesto que enumera todos los archivos que están contenidos en el ensamble, controla que tipos y recursos son expuestos fuera del ensamble y relaciona las referencias de esos tipos y recursos a los archivos que contienen los tipos y recursos. <br />El manifiesto también lista otros ensambles que dependen de un ensamble. <br />Los ensambles se contienen a sí mismo, existe suficiente información en el ensamble para ser auto-descrito. <br />Cuando se define un ensamble, el ensamble puede ser contenido en un solo archivo o puede ser dividido entre varios archivos. Utilizando varios archivos podría hacer posible un escenario donde las secciones del ensamble sean descargadas sólo como se necesiten. <br />Interoperabilidad de Lenguaje<br />Una de las metas del runtime .NET es ser un lenguaje agnóstico, permitiendo que el código sea utilizado y escrito desde cualquier lenguaje, no sólo las clases pueden ser escritas en algún lenguaje .NET como VB.NET y ser invocadas desde otro lenguaje .NET como C#, una clase que fué escrita en VB.NET puede ser utilizada como una clase base escrita en C# y esa clase podría ser utilizada desde una clase VC++ o JScript, es decir, no importaria en que clase sea escrita una clase. <br />Para hacer lo anterior posible existen algunos obstaculos como las propias características del lenguaje, ya que un lenguaje no podría soportar ciertas cosas que otro si las soporte, por ejemplo la sobrecarga de operadores. <br />Para que una clase sea utilizada desde un lenguaje .NET, la clase debe adherir la Especificación Común de Lenguaje (Common Language Specification - CLS) la cual describe que características pueden ser visibles en la interfaz pública de la clase, por ejemplo el CLS prohibe exponer tipos de datos sin signo, porque no todos los lenguajes pueden utilizarlos. <br />Atributos<br />El runtime .NET soporta atributos personalizables, los cuales son en cierto sentido un lugar para colocar información descriptiva en los metadatos junto con un objeto y entonces recuper después los datos. Los atributos proveen un mecanismo general para hacer esto y son utilizados en exceso en todo el tiempo de ejecución para almacenar información que modifica como el runtime utiliza las clases. <br />Los atributos son extensibles y permite a los programadores definir atributos y utilizarlos. <br />Los atributos se especifican encerrandolos entre corchetes: <br />[Version("14/09/2005", Comentario="1.0.1.0")]<br />Los atributos son anotaciones que se colocan en elementos de código fuente, como clases, miembros, parámetros, etc. <br />Los atributos puede ser utilizados para: cambiar el comportamiento del runtime, proveer información acerca de un objeto, llevar información organizacional al diseñador. <br />El atributo información es almacenado con los metadatos del elemento y pueden ser facilmente recuperados en tiempo de ejecución a través de un proceso conocido como reflection. <br />C# utiliza un Atributo Condicional para controlar cuando las funciones miembro son invocadas. <br />Por convención los atributos se agregan al final del nombre de una clase, con la finalidad de conocer cuales son clases atributo y cuales son clases normales. Todos los atributos derivan de System.Attribute. <br />Procure que el atributo para el elemento sea específico, utilizando los identificadores siguientes: <br />IdentificadorDescripciónassemblyensamblemodulemódulotypeclase o estructuramethodmétodopropertyporpiedadeventeventofieldcampoparamparámetroreturnvalor de regreso<br />Los atributos que son aplicados a ensambles o módulos deben colocarse después de cualquier cláusula using y antes de cualquier código. <br />Biblioteca de Clases de la Plataforma .NET<br />La Biblioteca de Clases de la Plataforma .NET es una colección de tipos reutilizables integradas en el CLR. <br />Los tipos de la Plataforma .NET permiten llevar a cabo tareas de programación comunes como manipulación de strings, colecciones de datos, conectividad a bases de datos y acceso a archivos. <br />Es posible utilizar la Plataforma .NET para desarrollar los siguientes tipos de aplicaciones y servicios: <br />Aplicaciones de consola <br />Windows Forms <br />Aplicaciones ASP.NET <br />Servicios Web XML <br />Servicios Windows <br />Requerimientos de Software<br />Todo lo que se necesita para desarrollar en C# es el Kit de desarrollo (SDK), del cual solo se utilizará el CLR y el compilador de C#. <br />Lenguaje Intermedio y Metadatos<br />Microsoft desarrollo un lenguaje parecido al lenguaje ensamblador llamado Microsoft Intermediate Language (MSIL). <br />Para compilar aplicaciones .NET, los compiladores toman el código fuente como entrada y producen MSIL como salida. <br />MSIL en sí es un lenguaje completo con el cual es posible escribir aplicaciones. <br />El managed code generado por el compilador C# no es código nativo porque es un código de Lenguaje Intermedio (IL). Este código IL se convierte en la entrada para la administración del proceso de ejecución del CLR. La ventaja final del código IL es que el CPU es independiente, lo cual significa que se necesita un compilador en la máquina destino para cambiar el código IL en el código nativo. <br />El IL es generado por el compilador, pero no es lo único que se provee para el runtime, el compilador también genera metadatos acerca del código, los cuales dicen más al runtime del código, por ejemplo la definición de cada tipo. Los metadatos son bibliotecas de tipo, entrada de datos al registry, etc. Los metadatos son empaquetados directamente con el código ejecutable y no en localidades separadas. <br />El IL y los metadatos son colocados en los archivos que extienden el formato PE (Portable Executable) utilizado para archivos .exe y .dll, cuando se carga el archivo PE el runtime coloca y extrae los metadatos y el IL de estos. <br />Cuando se compila una aplicación C# o cualquier aplicación escrita en un CLS, la aplicación es compilada dentro del MSIL, además se compila dentro de las instrucciones nativas de CPU cuando la aplicación es ejecutada por vez primera por el CLR. <br />El proceso es el siguiente:<br />Código fuente escrito en C# <br />El código fuente es compilado usando el compilador de C# (csc.exe) dentro de un EXE. <br />El compilador C# produce como salida el código MSIL y un manifiesto en una parte de sólo lectura del EXE que tiene un encabezado estándar PE (Win32-Portable Executable). <br />Cuando el compilador produce o crea la salida también importa una función llamada _CorExeMain del runtime .NET. <br />Cuando la aplicación es ejecutada, el sistema operativo carga el PE como una DLL dependiente tal como la única que exporta la función _CorExeMain (mscoree.dll) justo como lo hace con cualquier PE válido. <br />El sistema operativo carga y entonces salta al punto dentro del PE el cual es puesto ahí por el compilador C#. <br />El sistema operativo obviamente no puede ejecutar el código MSIL, el punto de entrada es un pequeña parte que salta a la función _CorExeMain en mscoree.dll. <br />La función _CorExeMain comienza la ejecución del código MSIL que fue colocado en el PE. <br />Dado que el código MSIL no puede ser ejecutado directamente (porque no está un un formato de máquina ejecutable) el CLR compila el MSIL usando un compilador just-in-time (JIT o JITter) dentro de instrucciones CPU nativas tal como procesa el MSIL. <br />JITers<br />El managed code generado por C# es el código IL, aunque el código IL es empaquetado en un formato de archivo PE válido, no es posible ejecutarlo sin convertirlo a un managed code nativo. <br />Cuando un tipo es cargado, el laoder crea y agrega un stub (pieza pequeña) a cada método del tipo, así cuando el método es invocado por vez primera, el stub pasa el control al JIT. <br />El JIT compila el IL a código nativo y cambia el stub para que apunte al código nativo que está en cache, así las subsecuentes invocaciones podrían ejecutar el código nativo. <br />El CLR incluye tres diferentes JITers que pueden ser usados para convertir MSIL en código nativo, dependiendo de las circunstancias:<br />PreJIT (Generación de código Install-time), opera como un compilador tradicional, aunque está basado sobre el compilador JIT principal, se ejecuta cuando un componente NGWS es intalado y compila el código IL a managed code nativo. <br />La generación de código en tiempo de instalación compilará un ensamble completo dentro de un código binario de CPU-especifico, tal como lo hace el compilador C++. Un ensamble el código empaquetado que es enviado al compilador. La compilación se hace en tiempo de instalación, cuando el usuario final es menos probable para notificar que el ensamble esta siendo compilado-JIT. <br />La ventaja de la generación de código en tiempo de instalación, es que permite compilar el ensamble completo justo una vez antes de ser ejecutado. Al ser compilado el ensamble entero no hay preocupación referente al desempeño intermitente cada vez que un método en el código es ejecutado por primera vez. <br />Al usar esta utilidad depende del tamaño del sistema y del ambiente de distribución. <br />JIT, compilador por default utilizado por el CLR, es un compilador optimizado, el cual realiza el análisis del flujo de datos, administra el código nativo como salida. <br />El JITter es invocado en tiempo de ejecución. <br />EconoJIT, realiza una conversión muy veloz del IL a managed code nativo <br />También es un JITter en tiempo de ejecución, esta especialmente diseñado para sistemas que tienen recursos limitados como memoria. La principal diferencia con un JIIter regular es la incorporación de algunas invocaciones code pitching, que permiten al EconoJIT descartar el código generado o compilado si el sistema comienza a ejecutarse fuera de memoria, siendo el beneficio el reclamo de memoria. La desventaja es que si el código es pitched (lanzado) es invocado otra vez por lo que debe ser compilado de nuevo. <br />Es posible determinar que tipo de JIT esta siendo utilizado y cuanta memoria utiliza a través de una pequeña utilidad llamada JIT Compiler Manager (jitman.exe), que reside en el directorio bin del directorio de instalación del NGWS SDK. <br />Sistema de Tipo Unificado<br />El runtime de .NET hace más que dar al desarrollador un simple sistema de tipo unificado que es usado a través de todos los lenguajes, también deja a los lenguajes escribir extensiones de sistema tipo, agregando nuevos tipos que parezcan y actuen como tipos de sistemas built.in. <br />El Sistema Virtual de Objetos - VOS<br />Las reglas que se siguen cuando se declaran, utilizan y administran tipos son modeladas en el Sistema Virtual de Objetos (Virtual Object System - VOS). <br />El VOS establece una plataforma que permite la integración de lenguajes y type safety. <br />La base de la arquitectura del runtime es la plataforma que puede describir en cuatro áreas: <br />VOS Type System, provee un sistema de tipos que intenta soportar la implementación completa de una rango amplio de lenguajes de programación. <br />Metadata, describe y hace referencia a los tipos definidos por el VOS. <br />Common Language Specification - CLS, define el subconjunto de tipos del VOS. Si una biblioteca de clases es soportada por las reglas del CLS, garantiza que la biblioteca de clases pueda ser utilizada por los demás lenguajes que implementen el CLS. <br />Virtual Execution System - VES, es responsable de la carga y ejecución de los programas que fueron escritos por el CLR. <br />VOS Type System<br />El VOS define tipos que describen valores y especifican un contrato en donde todos los valores de tipo deben soportar. Existen dos entidades: valores y objetos. <br />Para un valor el tipo describe la representación de almacenamiento y las operaciones que puede realizar. <br />Los objetos son más poderosos porque el tipo es almacenado explicitamente en su representación, cada objeto tiene una identidad que lo distingue de los demás objetos. <br />Metadata<br />El compilador CLS toma el código fuente como entrada y produce código MSIL para el runtime para compilar a través de los JITters y ejecutar. Además se mapea el código fuente a secuencias de instrucciones MSIL, el compilador CLS tiene otra tarea importante: envolver metadatos dentro del EXE resultante. <br />Los Metadatos son datos que describen datos.<br />Los metadatos son la colección de elementos programáticos que constituyen el EXE, como los tipos declarados y los métodos implementados. <br />Estos metadatos son similares a los tipos de bibliotecas generadas con componentes COM (Component Object Model). <br />La razón para usar metadatos es simple ya que permiten al runtime .NET conocer en tiempo de ejecución que tipos podrían ser almacenados y que métodos podrían ser invocados. Esto permite al runtime configurar apropiadamente el ambiente para mayor eficiencia al ejecutar la aplicación. El significado por el cual estos metadatos son consultados es llamado reflection. <br />Los metadatos por cada objeto .NET registran toda la información que es requerida para usar el objeto, con esta información el runtime .NET es capaz de resolver como crear objetos, invocar funciones miembro o acceder a los datos de un objeto y el compilador puede utilizar la información para encontrar que objetos están disponibles y como es utilizado un objeto. La información incluye lo siguiente: <br />El nombre del objeto <br />Los nombres de todos los campos del objeto y sus tipos <br />Los nombres de todas las funciones miembro, incluyendo tipos parámetro y nombres <br />Los metadatos también permiten a otras herramientas acceder a la información detallada acerca del código <br />Existe un proceso llamado reflection donde el código en tiempo de ejecución puede consultar los metadatos para encontrar que objetos están disponibles y que funciones y campos están presentes en la clase. La reflection está disponible para usuarios finales para determinar como son los objetos, búsqueda de atributos o ejecutar métodos en los que los nombres no son conocidos hasta el tiempo de ejecución. <br />Los metadatos son utilizados para varias tareas: <br />Para representar la información que el CLR utiliza para localizar y cargar clases. <br />Para sacar las instancias de las clases en memoria. <br />Para resolver la invocación de métodos. <br />Para traducir IL a código nativo. <br />Para forzar la seguridad. <br />El encargado de generar los metadatos es el compilador C#, al pasar el código a IL, emitiendo la información binaria de los metadatos en un archivo PE. <br />La principal ventaja de la combinación de los metadatos con el código ejecutable es que la información acerca de los tipos es persistente. <br />Una herramienta que toma ventaja de reflection es el ILDASM (Microsoft .NET Framework IL Disassembler), el cual analiza la aplicación de metadatos fuente y entonces presenta información acerca de la aplicación en la jerarquía del árbol. <br />Seguridad<br />La faceta más importante de cualquier ambiente de desarrollo de aplicaciones distribuidas es como manejar la seguridad. <br />La seguridad comienza tan pronto como una clase es caragada por el CLR porque la clase loader es parte del esquema de seguridad .NET, la seguridad relacionada a factores tales como reglas de accesibilidad y requerimientos de consistencia son verificados. <br />Deployment<br />La llave para el Deployment de aplicaciones .NET es el concepto de (ensambles). Los assemblies son paquetes simples de comportamiento semanticamente relacionados que son construidos como un archivo individual o entidades de archivos múltiples. <br />La especificación de como deploy una aplicación podría variar ya que se puede tratar de un desarrollo web o aplicación tradicional de escritorio. <br />El runtime .NET mantiene el rastreo delos archivos y de las versiones de los archivos asociados con una aplicación. Cualquier aplicación que es instalada es automáticamente asociada con los archivos que son parte de ese ensamble. <br />Si una aplicación de instalación intenta sobre escribir un archivo necesario para otra aplicación, el runtime .NET es lo bastante inteligente para permitir que la aplicación de instalación, instale los archivos necesarios pero el CLR no elimina las versiones previas de el archivo porque todavía son requeridas por la primer aplicación. <br />Interoperabilidad con código no administrado<br />El código no administrado no tiene las ventajas que tiene el código administrado, como recolección de basura, sistema de tipo unificado y metadatos. <br />Código administrado invocando funciones DLL no administradas, cuando la aplicación necesita una interfaz para una DLL en C y la empresa que escribe la DLL no adopta .NET será necesario invocar esa DLL desde una aplicación .NET. <br />Código administrado usando componentes COM, es posible lograr esto creando un wrapper .NET para el componente COM, así que el cliente administrado trabaja con clases .NET <br />Código no administrado usando servicios .NET, cuando se desea acceder a .NET desde código no administrado. <br />Common Language Specification - CLS<br />Es un conjunto de reglas que un lenguaje debe adherir para crear aplicaciones .NET que se ejecutan en el CLR. <br />Un concepto importante relacionado a la CLR es el código administrado, el código administrado es justo el código que esta ejecutandose bajo el auspicio de la CLR y por consiguiente comienza a ser controlado por el CLR. <br />El CLS define un subconjunto de tipos del VOS, si una biblioteca de clases sigue las reglas del CLS esta garantizando ser utilizada por clientes de otro lenguaje de programación que también se adhieren a la CLS. <br />El CLS se refiere a la interoperabilidad entre lenguajes, por lo que es necesario seguir los tipos y características del CLS, para ello es necesario conocer los tipos primitivos, arreglos, tipos, miembros tipo, métodos, campos, propiedades, enumeraciones, excepciones, interfaces, eventos, atributos personalizables, delegados, identificadores, etc. que la propia especicicación define. <br />Virtual Execution System - VES<br />El Sistema Virtual de Ejecución implementa la VOS y se crea implementando un motor de ejecución (Execution Engine EE). Los componentes de la VES son: <br />Lenguaje Intermedio (Intermediate Language - IL), diseñado para ser facilmente traducido a una amplia gama de lenguajes, por lo que el compilador C# es capaz de generar el lenguaje intermedio. <br />Carga del Código Administrado (Loading Managed Code), resuelve nombres, obtiene clases de la memoria, crea stubs que son necesarios para la compilación JIT. La class loader forza la seguridad. <br />Conversión de IL a Código Nativo via JIT, el código del lenguaje intermedio no esta diseñado como un interprete tradicional bytecode o árbol de código, la conversión del lenguaje intermedio es realmente una compilación. <br />Carga de Metadatos, se encarga de checar la seguridad de tipos y la integridad de los métodos. <br />Recolector de Basura y Manejo de Excepciones (Garbage Collection), el codigo administrado premite rastrear el apilado en el runtime, para que el runtime entienda el apilado individual de frames un código administrado tiene que ser proporcionado por el JITer o por el compilador. <br />Servicios de debugging, estos servicios dependeran de la información producida por el compilador del lenguaje fuente y se emiten dos mapas, un mapa del lenguaje fuente de la construcción de direcciones en el flujo de instrucciones y un mapa de las direcciones de las localidades en el apilado de frames. <br />Administración de Hilos, el VES proprorciona este servicio al código administrado. <br />Tipos de Datos<br />C# soporta el conjunto de tipos de datos usual, para cada tipo de dato que C# soporta, existe una correspondencia tipo de lenguaje común en tiempo de ejecución .NET subyacente. <br />Todos los tipos runtime pueden encontrarse en el namespace System del lenguaje común en tiempo de ejecución .NET. <br />TipoBytesTipo runtimeDescripciónbyte1ByteUnsigned bytesbyte1SByteSigned byteshort2Int16Signed shortushort2UInt16Unsigned shortint4Int32Signed integeruint4UInt32Unsigned intlong8Int64Signed big integerulong8UInt64Unsigned big integerfloat4SingleFloating point numberdouble8doubleDouble-precision floating point numberdecimal8DecimalFixed-precision numberstring StringUnicode stringchar CharUnicode characterbool BooleanBoolean value<br />Los tipos de datos son separados en value types y reference types. Los value types son asignados en estructuras de pilas o en línea. Los reference types son asignados al aglomerado. <br />Las referencias y tipos de valores son derivados de la última clase base objet, de esta manera en caso de que un tipo de valor necesite actuar como un object una envoltura hace que el tipo de valor parezca una referencia asignandolo al aglomerado, y los tipos de valores son copiados a estos. La envoltura es marcada por lo que el sistema conoce que contiene por ejemplo int, a este proceso se le conoce como boxing y el proceso de reversa se le conoce como unboxing <br />La palabra reservada class es empleada para declarar un tipo referencia (heap allocated), y la palabra reservada struct es empleada para declarar un tipo valor, una estructura es utilizada para objetos ligeros que necesitan actuar como tipos built-in, las clases son utilizadas en cualquier otro caso. <br />Por ejemplo un tipo int es un valor tipo y un tipo string es un tipo referencias, esto trabajaria así: <br />int i = 2005;<br />string s = "Septiembre";<br />i2005  so----------------->Septiembre<br />Constantes y Campos Solo Lectura<br />En C# los valores pueden ser definidos como constantes y para que un valor sea constante su valor debe ser algo que pueda ser escrito como una constante. <br />public const string sDominio = "informatique.com.mx";<br />La restricción de tipos constantes es que son conocibles en tiempo de compilación, en vez de ello es posible utilizar el modificador readonly el cual está diseñado para aquellas situaciones en donde las constantes tienen restricción. <br />Aplicando el modificador readonly un valor puede ser establecido en el constructor o en una inicialización pero no puede ser modificado después. <br />Ejemplo Hello World!<br />El código C# puede ser escrito en cualquier editor, también puede escribirse con Visual Studio 7. <br />El código C# debe almacenarse en un archivo con extensión .cs <br />Para compilar el código C# es necesario tener instalado la Plataforma .NET que incluye el compilador C#, puede buscar el ejecutable en la ruta: <br />C:WINDOWSMicrosoft.NETFrameworkv1.1.4322csc.exe <br />Asegurese de tener esta ruta en el path para poder ejecutar el compilador desde cualquier ubicación. <br />Para compilar su archivo .cs es necesario abrir la consola (DOS) y escribir el comando cs seguido del nombre de su archivo por ejemplo: <br />cd helloworld.cs <br />La salida exitosa de la compilación podría ser así: <br />Microsoft (R) Visual C# .NET Compiler version 7.10.6001.4<br />for Microsoft (R) .NET Framework version 1.1.4322<br />Copyright (C) Microsoft Corporation 2001-2002. All rights reserved.<br />Si existe algún error el compilador lo notificará. El archivo es compilado y ligado a helloworld.exe, (el archivo .exe generado tendrá el nombre del archivo fuente) para ejecutar el programa sólo es necesario escribir el nombre del archivo ejecutable. <br />Algo interesante es que es posible especificar el nombre del archivo ejecutable a través de un switch: <br />csc /out:nuevoNombre.exe nombreArchivoFuente.cs<br />El siguiente es el ejemplo típico de los lenguajes de programación: <br />class HelloWorld{<br />public static void Main(){<br />System.Console.WriteLine("Hello World");<br />}<br />}<br />El método Main debe estar contenido en la clase y escrito con la primer letra en mayúscula. El tipo de este método puede ser void o int. También este método puede especificar argumentos: <br />public static void Main(string[] args)<br />System es el ámbito del namespace en el cual el objeto Console está contenido. <br />Es posible importar el namespace en las aplicaciones indicandolo al inicio del código con la palabra reservada using que es una directiva para el namespace System. Existen más namespaces en la Plataforma .NET <br />using System;<br />Ejemplo Args<br />Examinemos el siguiente ejemplo, el cual recibe los argumentos con los que el componente fue invocado: <br />Ejemplo de Args con for:<br />using System;<br />class Args{<br />public static void Main(string[] args){<br />Console.WriteLine("Argumentos : {0}", args.Length);<br />for(int itera = 0; itera < args.Length; itera++)<br />Console.WriteLine("Argumento {0} : {1}", itera, args[itera]);<br />}<br />}<br />Ejemplo de Args con foreach:<br />using System;<br />class App{<br />public static void Main(string[] args){<br />foreach(string input in args){<br />Console.WriteLine(input);<br />}<br />}<br />}<br />using System;, define el namespace System, el cual contiene entre otras la clase Console la cual es utilizada para comunicarse con la línea de comandos. <br />using permite al usuario omitir el namespace al utilizar el tipo al que es referenciado en este caso System, por lo que en vez de escribir: <br />System.Console.WriteLine();<br />Solamente se escribe:<br />Console.WriteLine();<br />using no puede ser utilizado con un nombre de clase por lo que no es permitido escribir using System.Console <br />class Args, Al no existir las funciones globales en C#, se declara una clase llamada Args. <br />public static void Main(string[] args), La clase Args contiene una función o método Main(), el cual sirve como punto de partida de la ejecución del componente, este método puede o no ser declarado con argumentos, en este caso es fundamental declarlos porque deseamos precisamente leer y escribir estos argumentos proporcionados al invocar el componente. <br />Al ser un método de arranque debe ser declarado con el modificador static porque no está asociado con una instancia de un objeto. <br />El método indica que recibe un arreglo de tipo string llamado args <br />Console.WriteLine("Argumentos : {0}", args.Length);, invoca el método WriteLine de la clase Console para escribir en la línea de comando lo que se indica entre los paréntesis. <br />La primer parte de lo que se encierra entre paréntesis es un string donde es necesario destacar que{0}, es una notación que indica entre llaves un índice que hace referencia a una variable asociada a este, en este caso asociada con args.Length <br />args.Length, Length es un método de la clase args el cual obtiene el número de elementos que contiene este arreglo. <br />El ciclo for comienza una iteración desde 0 hasta el número de elementos que contiene el arreglo args.Length, por cada elemento contenido en el arreglo escribe en la línea de comandos lo que se indica en ("Argumento {0} : {1}", itera, args[itera]) que como mencionamos anteriormente {0} hace referencia al orden en que las variables serán escritas, en este caso corresponde al iterador y {1} corresponde a args[itera], lo cual indica obtener el elemento en cuestión del arreglo args. <br />Para compilar el componente utilice csc Args.cs <br />Para ejecutar el componente sin parámetros escriba en la línea de comando: csc Args <br />Salida : Argumentos : 0<br />Para ejecutar el componente con parámetros escriba en la línea de comando: <br />csc Args p1 p2 p3 p4 p5 p6 ... pn<br />Por ejemplo: args http : www . informatique . com . mx<br />Salida : <br />Argumentos : 8<br />Argumento 0 : http<br />Argumento 1 : :<br />Argumento 2 : www<br />Argumento 3 : .<br />Argumento 4 : informatique<br />Argumento 5 : .<br />Argumento 6 : com<br />Argumento 7 : .<br />Argumento 8 : mx<br />Ejemplo Input/Output<br />Es posible leer datos de la consola utilizando el método ReadLine y es posible mostrarlos utilizando el método Write o WriteLine del objeto Console: <br />using System;<br />class inOut{<br />public static void Main(){<br />Console.Write("Fecha de Nacimiento: ");<br />String strFecNac = Console.ReadLine();<br />Console.WriteLine("FecNac = " + strFecNac);<br />}<br />}<br />Note que importar la directiva System hace posible omitir escribir el namespace, de esta forma sólo es necesario escribir el nombre del objeto seguido del nombre del método. <br />Ejemplo String Format<br />Es posible dar formato a la salida de datos a un tipo string, utilizando la sintaxis {número} donde número es reemplazado por la variable correspondiente: <br />using System;<br />class strFormat{<br />public static void Main(){<br />Console.Write("Nombre: ");<br />String strNombre = Console.ReadLine();<br />Console.Write("Edad: ");<br />String strEdad = Console.ReadLine();<br />Console.Write("Teléfono: ");<br />String strTel = Console.ReadLine();<br />Console.Write("Dirección: ");<br />String strDir = Console.ReadLine();<br />Console.WriteLine("Datos: {0} {1} {2} {3}", strNombre<br />, intEdad, strTel, strDir);<br />}<br />}<br />Función Main<br />Es posible incluir una función estática en la clase para poder probarla, en C# esta función estática puede ser escrita como Main() e indica el inicio de la ejecución de un programa: <br />using System;<br />class App{<br />public static void Main(){<br />Console.WriteLine("Hello world!");<br />}<br />}<br />El ejemplo anterior define a la función Main como void lo cual indica que no regresa un valor, pero es posible indicar que si regrese un valor escribiendo el tipo de la función como int por ejemplo, que indica que regresa un valor de tipo entero: <br />using System;<br />class App{<br />public static int Main(){<br />Console.WriteLine("Hello world!");<br />return(1);<br />}<br />}<br />También es posible que la función Main reciba parámetros de la línea de comandos, para ello es necesario especificar un arreglo de strings como parámetro:<br />using System;<br />class App{<br />public static void Main(string[] args){<br />foreach(string input in args){<br />Console.WriteLine(input);<br />}<br />}<br />}<br />Múltiples Funciones Main<br />Es posible que existan en una aplicación varias clases que contengan la función Main() y por ello al compilar se indicará un error. <br />Para evitar el error o indicar que función Main() de que clase deseamos que se ejecute, es necesario utilizar el siguiente switch al compilar: <br />/main:nombreClase<br />Por ejemplo<br />using System;<br />class ClaseA{<br />public static void Main(){<br />Console.WriteLine("Main de la clase A");<br />}<br />}<br />class ClaseB{<br />public static void Main(){<br />Console.WriteLine("Main de la clase B");<br />}<br />}<br />class ClaseC{<br />public static void Main(){<br />Console.WriteLine("Main de la clase C");<br />}<br />}<br />Al compilar utilice : csc multiplesmain.cs /main:ClaseB<br />Salida: Main de la clase B<br />Preprocesamiento<br />Lo más importante en este punto es que en C# no existe el preprocesador, el motivo por el cual no existe es para simplificar la estructura de compilación además de que no hay necesidad de escribir un archivo de encabezados por separado y mantener en sincronia la implementación, cuando los archivos fuente C# son compilados el orden de la compilación de archivos individuales no es importante y es equivalente a un archivo de gran tamaño. <br />Un identificador es el nombre que es usado para algún elemento de un programa como una variable o función y deben tener una letra o guión bajo como primer caracter. <br />C# soporta las siguientes directivas de preprocesamiento:<br />TamañoValor#defineDefine un identificador, los identificadores también pueden ser definidos via la línea de comando#undefElimina la definición de un identificador#ifEl código de la sección es compilado si la expresión es verdadera#elifConstructor Else-if, si la directiva anterior no se cumplio y si la expresión es verdadera el código de la sección es compilado#elseSi la directiva anterior no se cumplio el código de la sección es compilado#endifMarca el final de la sección<br />Los identificadores deben preceder a cualquier código real. <br />Es posible utilizar los siguientes operadores en expresiones preprocesador: <br />! <br />== <br />!= <br />&& <br />|| <br />Es posible utilizar paréntesis para agrupar expresiones.<br />Comentarios<br />Es posible comentar el código, para ello existen dos modalidades: <br />//, que se utiliza para comentar una línea, es decir, todo lo que sigue a // es ignorado. <br />/* */, que se utiliza para comentar segmentos de código. <br />Value Types<br />Una variable contiene un valor de cierto tipo, C# forza a inicializar las variables antes de utilizarlas en una operación. <br />Cuando se asigna un valor a un value type el valor actual es copiado a diferencia de los reference types lo que se copia es la referencia actual no el valor. <br />C# agrupa los value types en: <br />Tipos Simples <br />Tipos Estructura <br />Tipos Enumeración <br />Tipos Simples<br />Los Tipos Simples de C# comparten características como las de alias con los tipos de sistema de .NET, expresiones constantes consisten de Tipos Simples evaluados solamente en tiempo de compilación no en tiempo de ejecución y los Tipos Simples pueden ser inicializados con literales. <br />Los Tipos Simples de C# se agrupan en: <br />Integral <br />Representa valores enteros y existen nueve tipos integral en C#: <br />TipoTamañoValorsbyteEntero con signo8 bit-128 a 127byteEntero sin signo8 bit0 a 255shortEntero con signo16 bit-32,768 a 32,767ushortEntero sin signo16 bit0 a 65,535intEntero con signo32 bit-2,147,483,648 a 2,147,483,647uintEntero sin signo32 bit0 a 4,294,967,295longEntero con signo64 bit-9,223,372,036,854,775,808 a -9,223,372,036,854,775,807ulongEntero sin signo64 bit0 a 18,446,744,073,709,551,615<br />Bool <br />Representa valores booleanos verdadero y falso, por lo que es posible asignar a una variable un valor booleano o el resultado de una expresión: <br />bool bContinuar = (a > b);<br />En C# el valor verdadero no es posible representarlo con algún valor diferente de cero, no hay una conversión entre el tipo integral a bool que force esta conversión. <br />Char <br />Representa un caracter Unicode de 16 bit de tamaño, por ejemplo: <br />char cSexo = 'M';<br />También es posible asignar un valor hexadecimal utilizando la secuencia de escape x o un valor Unicode con la secuencia de escape u: <br />char cHexadecimal = 'x0068';<br />char cUnicode = 'u0068';<br />No existen conversiones implicitas de char a otro tipo de datos disponible, esto significa por ejemplo que tratar de convertir una variable char a un tipo de dato integral no es posible en C#, por lo que se tendrá que hacer un cast explicito: <br />char cCaracter = (char)65;<br />int nNumero = (int)'A';<br />Floating Point <br />Representan dos tipos de datos, flotantes (float) y dobles (double): <br />TipoValorfloat1.5x10-45 a 3.4x1038 con una precisión de 7 dígitosdouble5.0x10-324 a 1.7x10308 con una precisión de 15-16 dígitos<br />Al realizar operaciones con Floating Point pueden producirse los siguientes valores: <br />Cero positivo y negativo <br />Infinito positivo y negativo <br />NaN, Not-a-Number <br />Nota: Si una expresión un valor es de tipo Floating Point todos los otros valores son convertidos a tipos Floating Point antes de realizar el cálculo. <br />Decimal <br />Representa un tipo de alta precisión de 128 bit el cual es posible utilizarlo para calculos financieros y monetarios. Los valores posibles comprenden los rangos 1.0x10-28 a 7.9x1028 con una precisión de 28 a 29 dígitos. <br />No hay conversiones implicitas entre decimales y dobles, se podría generar un overflow o perder precisión, por lo que es necesario una conversión explícita con un cast. <br />Cuando se define una variable y se le asigna un valor se utiliza el sufijo m para denotar que es un valor decimal: <br />decimal decDecimal = 1.0m<br />Si se omite la letra m la variable podría ser tratada como double por el compilador antes de ser asignado. <br />Tipos Estructura<br />Un tipo struct puede declarar constructores, constantes, campos, métodos, propiedades, índices, operadores y tipos anidados. Las estructuras actuan de manera similar a una clase y con mayores restricciones, por ejemplo no pueden heredar de cualquier otro tipo, ni tampoco otra clase puede heredar de una estructura. <br />Las estructuras deberían ser utilizadas sólo para tipos que son realmente una pieza de datos. <br />La diferencia entre struct y class en C# es que struct es un value type y class es una reference type. <br />La principal idea de utilizar struct es para crear objetos ligeros como Point, FileInfo, etc., de esta manera se conserva memoria porque no hay referencias adicionales que son creadas como se necesiten por objetos clase. <br />using System;<br />struct IP{<br />public byte b1,b2,b3,b4;<br />}<br />class ip{<br />public static void Main(){<br />IP miIP;<br />miIP.b1 = 192;<br />miIP.b2 = 168;<br />miIP.b3 = 1;<br />miIP.b4 = 101;<br />Console.Write("{0}.{1}.", miIP.b1,miIP.b2);<br />Console.Write("{0}.{1}", miIP.b3,miIP.b4);<br />}<br />}<br />Tipos Enumeración<br />Es posible establecer un conjunto de constantes relacionadas, por default los elementos de una enumeración son de tipo int donde el primer elemento tiene el valor 0 y cada elemento subsecuente se incrementa en 1. Es posible establecer el valor del primer elemento simplemente asignando a este el valor deseado, así como es posible especificar el tipo de dato de los valores contenidos especificandolo después del nombre de la enumeración aunque están restringidos a los tipos: long, int, short y byte. <br />Sintaxis:<br />enum NombreEnumeraciones{<br />constante1,<br />constante2,<br />constante3,<br />.<br />.<br />constanteN<br />}<br />Ejemplo:<br />using System;<br />public class Enumeracion {<br />enum enumDias {Sabado, Domingo, Lunes, Martes, Miércoles, Jueves, Viernes };<br />enum enumMeses {Enero,Febrero,Marzo,Abril,Mayo,Junio,Julio,Agosto,Septiembre,_<br />Octubre,Noviembre,Diciembre};<br />enum enumFecha {Dia = 21, Mes = 9, Año = 1971};<br /> public static void Main() {<br /> Type eDias = typeof(enumDias);<br /> Type eMeses = typeof(enumMeses);<br />Type eFecha = typeof(enumMeses);<br /> Console.WriteLine("Los días de la semana, y su valor correspondiente en la enumeración es:");<br /> foreach ( string s in Enum.GetNames(eDias) )<br /> Console.WriteLine( "{0,-11}= {1}", s, Enum.Format( eDias, Enum.Parse(eDias, s), "d"));<br /> Console.WriteLine();<br /> Console.WriteLine("Los meses del año, y su valor correspondiente en la enumeración es:");<br /> foreach ( string s in Enum.GetNames(eMeses) )<br /> Console.WriteLine( "{0,-11}= {1}", s, Enum.Format(eMeses, Enum.Parse(eMeses, s), "d"));<br /> }<br />}<br />Tipos Base<br />Los Tipos Base para las enumeraciones se especifican listando el tipo base después del nombre de la enumeración: <br />enum eDias : int{<br />Lunes,<br />Martes,<br />Miércoles,<br />Jueves,<br />Viernes<br />};<br />Los tipos base válidos para las enumeraciones son: byte, sbyte, short, ushort, int, uint, long y ulong. <br />Si el tipo base no es especificado, el tipo base por default es int. <br />Tipos Referencia<br />Es contraste a value types los reference types no almacenan el dato actual que representan, porque almacenan una referencia al dato actual. <br />Los reference types que C# utiliza son: <br />Tipo Objeto <br />Tipo Clase <br />Interfaces <br />Delegados <br />Tipo string <br />Arreglos <br />Tipo Objeto<br />El Tipo Objeto es la Clase Base de todos los tipos, al ser la clase base de todos los tipos es posible asignarle valores de cualquier tipo. <br />El Tipo Objeto es utilizado cuando el value type esta boxed, es decir, que está disponible como un objeto. <br />Tipo Clase<br />El Tipo Clase contiene datos miembro, funciones miembro y tipos anidados. Los datos miembro son constantes, campos y eventos. Las funciones miembro incluyen métodos, propiedades, índices, operadores, constructores y destructores. <br />Interfaces<br />Una interface declara un tipo referencia que tiene sólo miembros abstractos. Sólo existe la firma pero no tiene implementado todo el código, por lo que no es posible instanciar una interface, sólo un objeto que deriva de la interface. Para crear una interface se emplea la palabra reservada interface: <br />using System;<br />interface Iuno{<br />void AccionUno();<br />}<br />class Implementa : Iuno{<br />public void AccionUno(){<br />Console.WriteLine("Acción uno...");<br />}<br />} <br />class App{<br />public static void Main(){<br />Implementa I = new Implementa();<br />I.AccionUno();<br />}<br />}<br />Es posible definir métodos, propiedades e índices en una interface, cuando se define una Clase es posible derivar de múltiples interfaces, mientras que al definir una interface sólo es posible derivar de sólo una clase. <br />Las interfaces están estrechamente relacionadas a clases abstractas, se parecen a una clase abstracta que tiene todos sus miembros abstractos. <br />Cuando un objeto implementa una interface, una referencia a la interface puede ser obtenida por un cast de la interface. <br />Una clase puede implementar más de una interface. <br />class NombreClase : InterfaceA, InterfaceB{}<br />Existe una técnica llamada Implementación de la Interface Explícita y se utiliza para resolver colisiones con nombres de métodos iguales entre interfaces: <br />using System;<br />interface Iuno{<br />void AccionUno();<br />}<br />interface Idos{<br />void AccionUno();<br />}<br />class Implementa : Iuno, Idos{<br />void Iuno.AccionUno(){<br />Console.WriteLine("Colisión resuelta con el nombre del método Iuno");<br />}<br />void Idos.AccionUno(){<br />Console.WriteLine("Colisión resuelta con el nombre del método Idos");<br />}<br />} <br />class App{<br />public static void Main(){<br />Implementa I = new Implementa();<br />Iuno uno = (Iuno) I;<br />uno.AccionUno();<br />Idos dos = (Idos) I;<br />dos.AccionUno();<br />}<br />}<br />Es posible ocultar al usuario de la clase la implementación de una interfaz, así como también es posible crear interfaces basadas de otras interfaces. <br />Delegados<br />Los delegados son similares a las interfaces, especifican un contratado entre un caller y un implementer (implementador). <br />Un delegado especifica la forma de una función en vez de especificar toda una interface.<br />Las interfaces se crean en tiempo de compilación y los delegados son creados en tiempo de ejecución.<br />Un delegado encapsula un método con cierta firma, básicamente un delegado es un type-safe y secure version. Un delegado es una implementación de function pointers orientada a objetos y son utilizados en muchas situaciones donde un componente necesita volver a invocar el componente que lo esta usando. <br />Es posible encapsular métodos estáticos e instancias en una instancia delegado. <br />El principal uso de los delegados es con los eventos no con las clases. <br />La especificación del delegado determina la forma de la función y crea una instancia del delegado, se usa la función que coincide con la forma. <br />Los delegados al ser de naturaleza dinámica se utilizan cuando el usuario desea cambiar el comportamiento, por ejemplo si deseamos que una clase Ordenamiento soporte diferentes métodos de ordenación, la ordenación podría ser controlada en base a un delegado que defina la función de comparación. <br />Nota los delegados siempre son creados aún si no son usados, pero los delegados podrían ser creados al vuelo si se reemplazan las funciones estáticas por propiedades, entonces unicamente se crea el delegado solo si se utiliza la propiedad. <br />Tipo string<br />El Tipo string se utiliza para manipular datos string. La clase string deriva directamente de object y no es posible derivarla. <br />Todos los strings en C# son instancias del tipo System.String en el CLR. <br />string es un alias para la clase predefinida System.String y su uso es muy sencillo: <br />string sWebSite = "http://www.informatique.com.mx";<br />Para acceder a un caracter, simplemente acceda a su índice: <br />sWebSite[11];<br />Es posible hacer un barrido de los caracteres que componen el string utilizando la propiedad Length que poseen los arreglos y porque es posible acceder a estos tratando al string como un arreglo: <br />using System;<br />class App{<br /> public static void Main(){<br />string sWebSite = "http://www.informatique.com.mx";<br />Console.WriteLine("sWebSite contiene : " + sWebSite.Length + " caracteres");<br />for(int iElemento = 0; iElemento < sWebSite.Length; iElemento++){<br />Console.WriteLine("Elemento " + iElemento + " : " + sWebSite[iElemento]);<br />}<br /> }<br />}<br />Es posible concatenar strings utilizando el operador +. <br />Si requiere comparar strings por igualdad utilice el operador de comparación == <br />Aunque string es un reference type la comparación se realiza comparando los valores no las referencias. <br />La clase String es un ejemplo de tipo inmutable, es decir, que los caracteres contenidos en el string no puede ser modificados por los usuarios del string, todas las operaciones que son realizadas por la clase String regresan una versión modificada del string en vez de modificar la instancia en la cual se invoco el método. <br />La clase String soporta los sisguientes métodos de comparación y búsqueda: <br />MétodoDescripciónCompare()Compara dos strings.CompareOrdinal()Compara dos regiones de strings utilizando una comparación ordinalCompareTo()Compara la instancia actual con otra instancia.EndsWith()Determina cuando un substring existe al final de un stringStartsWith()Determina cuando un substring existe al principio de un string.IndexOf()Regresa la posición de la primer ocurrencia de un substringLastIndexOf()Regresa la posición de la última ocurrencia de un substringConcat()Concatena dos o más strings u objetos, si se pasan objetos la función ToString es invocadaCopyTo()Copia un número específico de caracteres de una ubicación del string dentro del arregloInsert()Regresa un nuevo string con un substring insertado en la ubicación específicaJoin()Une un arreglo de strings junto con un separador entre cada elemento del arregloPadLeft()Alinea a la izquierda un stringPadRight()Alinea a la derecha un stringRemove()Elimina caracteres de un stringReplace()Reemplaza todas las instancias de un caracter con caracteres diferentesSplit()Crea un arreglo de strings dividiendo un string en cualquier ocurrencia de uno o más caracteresSubstring()Extrae un substring de un stringToLower()regresa una versión de un string en minúsculasToUpper()regresa una versión de un string en mayúsculasTrim()Elimina espacios en blanco de un stringTrimEnd()Elimina un string de caracteres al final de un stringTrimStart()Elimina un string de caracteres al inicio de un string<br />object.ToString(), convierte un objeto a una representación string. String.Format() puede ser utilizada para crear un string basado en los valores de otro string. <br />La clase StringBuilder soporta las siguientes propiedades y métodos:<br />PropiedadDescripciónCapacityRecupera o establece el número de caracteres que StringBuilder puede contener[]Índice StringBuilder utilizado para obtener o establecer un caracter en la posición específicaLengthRecupera o establece la longitudMaxCapacityRecupera la capacidad máxima del StringBuilder<br />MétodoDescripciónAppend()Agrega la representación string de un objetoAppendFormat()Agrega la representación string de un objeto, utilizando un formato específico para el objetoEnsureCapacity()Asegura que StringBuilder tiene suficiente espacio para un número de caracteres específicoInsert()Inserta la representación string de un objeto específico en una posición específicaRemove()Elimina los caracteres específicosReplace()Reemplaza todas las instancias de un caractes con un nuevo caracter<br />Arreglos<br />Un arreglo contiene variables a las cuales se accede a través de índices, todas las variables contenidas en el arreglo son referidos como elementos los cuales deben ser del mismo tipo, por lo que el tipo del arreglo. <br />Los arreglos en C# son referencias a objetos. Un arreglo value type no contiene instancias boxed.<br />El valor inicial de un arreglo es null, un arreglo de objetos es creado utilizando new.<br />Cuando un arreglo es creado inicialmente contiene los valores por default para los tipos que este contendrá.<br />Sintaxis:<br />tipo[] identificador;<br />Note que para definir un arreglo se utilizan los corchetes [] después del tipo del arreglo.<br />Ejemplo:<br />string[] aPersonas;<br />Es posible inicializar un arreglo al momento de crearlo:<br />string[] asPersonas = new string[] {"Tim Berners-Lee","Brendan Eich","Dennis Ritchie","James Gosling"};<br />Durante la inicialización es posible omitir new tipo[x] y el compilador podría determinar el tamaño de almacenamiento para el arreglo del número de items en la lista de inicialización: <br />string[] asPersonas = {"Tim Berners-Lee","Brendan Eich","Dennis Ritchie","James Gosling"};<br />Cada elemento de un arreglo de ints es un int con el valor 0:<br />int[] aiNumeros = new int[5];<br />Cada elemento de un arreglo de strings es un string con el valor null:<br />string[] asNombres = new string[5];<br />La dimensión del arreglo puede ser simple o multidimensional, donde cada dimensión comienza con el índice 0, si requiere hacer un barrido de todos los elementos del arreglo, comience a partir del índice 0 hasta la longitud del arreglo menos uno (nombreArreglo.Length - 1 o nIndice < nombreArreglo.Length); <br />using System;<br />class Arreglo{<br />static public void Main(){<br />string[] aNombres = {"Hugo","Paco","Luis"};<br />Console.WriteLine(aNombres[0]);<br />Console.WriteLine(aNombres[1]);<br />Console.WriteLine(aNombres[2]);<br />}<br />}<br />Otra alternativa al ejemplo anterior es: <br />int[] aiNumeros = new int[3];<br />aiNumeros[0] = 4;<br />aiNumeros[1] = 33;<br />aiNumeros[2] = 43;<br />Al declarar el arreglo especifique solamente el número de elementos que este contendrá. utilice la palabre reservada new seguido del tipo y entre corchetes el número de elementos que contendrá. <br />Es posible ordernar y buscar los elementos de un arreglo gracias a que los arreglos en C# están basados en el tipo System.Array del runtime NET. El método Sort() podría ordenar los elementos de un arreglo, los métodos IndexOf() y LastIndexOf() y BinarySearch podrían buscar elementos en un arreglo. El método Reverse podría invertir el orden de los elementos de un arreglo. <br />Arreglos Multidimensionales<br />Los Arreglos Multidimensionales son aquellos que tienen más de una dimensión.<br />Sintaxis:<br />tipo[,] identificador;<br />Ejemplo:<br />string[,] asBidimensional = new string[2, 4];<br />Para definir un arreglo multidimensional, simplemente defina arreglos como elementos del arreglo:<br />string[,] asMulti = {{"a","1"},{"b","2"},{"c","3"}};<br />Ejemplo:<br /> using System;<br /> class App{<br /> public static void Main(){<br />string[] asPersonas = {"Tim Berners-Lee", "Brendan Eich", "Dennis M. Ritchie", "James Gosling"};<br />Console.WriteLine("Longitud del arreglo asPersonas : " + asPersonas.Length);<br />int[] aiNumeros = new int[3] {1, 2, 3};<br />Console.WriteLine("Longitud del arreglo aiNumeros : " + aiNumeros.Length);<br />//Define 4 arreglos de 2 dimensiones<br />int iRenglon = 4;<br />int iColumna = 2;<br />string[,] asBidimensional = new string[iRenglon, iColumna];<br />// 4 renglones * 2 columnas = 8 Elementos<br />asBidimensional[0,0] = "00";<br />asBidimensional[0,1] = "01";<br />asBidimensional[1,0] = "10";<br />asBidimensional[1,1] = "11";<br />asBidimensional[2,0] = "20";<br />asBidimensional[2,1] = "21";<br />asBidimensional[3,0] = "30";<br />asBidimensional[3,1] = "31";<br />Console.WriteLine("Longitud del arreglo asBidimensional : " + asBidimensional.Length);<br />int[,] aiBidimensional = { {11,22}, {33,44}, {55,66}, {77,88} };<br />for(int i = 0; i < iRenglon; i++){<br /> for(int j = 0; j < iColumna; j++){<br />Console.WriteLine("Dimensión " + i + " elemento " + j + " : " + aiBidimensional[i,j]);<br /> }<br />}<br />Console.WriteLine("Longitud del arreglo aiBidimensional : " + aiBidimensional.Length);<br /> }<br /> }<br />Arreglo de Arreglos<br />Un Arreglo de Arreglos es también conocido como jagged array porque no tiene que ser rígido. <br />Por ejemplo:<br />int[][] aiIDs = new int[3][];<br />Este ejemplo define un arreglo de arreglo de tipo int donde su dimensión es 3 elementos, donde estos elementos son arreglos. <br />Arreglos de Objetos<br />Un arreglo de objetos es creado utilizando new.<br />Es posible declarar y manipular arreglos de objetos de la siguiente manera: <br />using System;<br />public class Persona{<br />//Propiedades<br />public string sNombre;<br />public int iEdad;<br />//Constructor<br />public Persona(string sNombre, int iEdad){<br />this.sNombre = sNombre;<br />this.iEdad = iEdad;<br />}<br />//Métodos<br />public string Tipo(){<br />return "Persona";<br />}<br />}<br />//Herencia Simple<br />public class Empleado : Persona{<br />public Empleado(string sNombre, int iEdad):base(sNombre, iEdad){}<br />public new string Tipo(){<br />return "Empleado";<br />}<br />}<br />class App{<br />//Aplicación<br /> public static void Main(){<br />Persona Mexicano = new Persona("Gerado Ángeles Nava", 33);<br />Console.WriteLine("Mexicano.sNombre : " + Mexicano.sNombre);<br />Console.WriteLine("Mexicano.iEdad : " + Mexicano.iEdad);<br />Console.WriteLine("Mexicano.Tipo : " + Mexicano.Tipo());<br />Console.WriteLine("--- Arreglo de Objetos ---");<br />Empleado[] aProgramadores = new Empleado[2];<br />aProgramadores[0] = new Empleado("Bill Gates", 50);<br />aProgramadores[1] = new Empleado("Eric S. Raymond", 60);<br />for(int i = 0; i < aProgramadores.Length; i++){<br /> Console.WriteLine("aProgramadores["+i+"].sNombre : " + aProgramadores[i].sNombre);<br /> Console.WriteLine("aProgramadores[" + i + "].iEdad : " + aProgramadores[i].iEdad);<br /> Console.WriteLine("aProgramadores[" + i + "].Tipo : " + aProgramadores[i].Tipo());<br />}<br /> }<br />}<br />Conversión de Arreglos<br />Una conversión implícita es posible si los arreglos tienen el mismo número de dimensiones, si los elementos de un arreglo tienen una conversión de referencia implícita para los tipos de elementos del otro arreglo y ambos arreglos son tipos referencia. <br />Una conversión explícita tiene los mismos requerimientos de una conversión implícita excepto que los elementos de un arreglo deben ser convertibles explícitamente a los tipos de elementos del otro arreglo. <br />Clase Array<br />La clase Array provee entre otras, funciones de búsqueda y ordenamiento. <br />En el siguiente ejemplo se muestra como es ordenado un arreglo de strings: <br />using System;<br />class App{<br /> public static void Main(){<br />string[] aLenguajes = {"Java", "Pascal", "ActionScript", "PHP", "C#", "SQL", <br />"JavaScript", "C", "Java", "Prolog", "Visual Basic", "C++"};<br />Array.Sort(aLenguajes);<br />for(int elemento = 0; elemento < aLenguajes.Length; elemento++)<br />Console.WriteLine("Elemento [" + elemento + "] = " + aLenguajes[elemento]);<br /> }<br />}<br />Salida:<br />Elemento [0] = ActionScript<br />Elemento [1] = C<br />Elemento [2] = C#<br />Elemento [3] = C++<br />Elemento [4] = Java<br />Elemento [5] = Java<br />Elemento [6] = JavaScript<br />Elemento [7] = Pascal<br />Elemento [8] = PHP<br />Elemento [9] = Prolog<br />Elemento [10] = SQL<br />Elemento [11] = Visual Basic<br />La función Sort(), también se puede utilizar con números:<br />using System;<br />class App{<br /> public static void Main(){<br />double[] aNumeros = {8.7, 6.9, -6.5, 4.2, -102.09, 1.9, 0.01, -0.002, 99.87};<br />Array.Sort(aNumeros);<br />for(int elemento = 0; elemento < aNumeros.Length; elemento++)<br />Console.WriteLine("Elemento [" + elemento + "] = " + aNumeros[elemento]);<br /> }<br />}<br />Salida:<br />Elemento [0] = -102.09<br />Elemento [1] = -6.5<br />Elemento [2] = -0.002<br />Elemento [3] = 0.01<br />Elemento [4] = 1.9<br />Elemento [5] = 4.2<br />Elemento [6] = 6.9<br />Elemento [7] = 8.7<br />Elemento [

×