Académique Documents
Professionnel Documents
Culture Documents
Recursos Visual Basic.NET, VB.NET, Manuales de programacin, Tutoriales, Foros de programacin, Comunidad de programadores Usuarios activos: 63
Foros
General Visual Basic Visual Basic .NET Bases de datos Crystal reports C/C++ C# C Sharp ASP.NET Java PHP ABAP
Manuales .NET
Manual VB.NET ADO.NET Manual C#
Manuales
Metodologa Inicio con Visual Basic Manual Visual Basic Acceso a datos DAO Anlisis BBDD Bases de datos POO SQL SQL Server
Descargas
Bases de datos Disco Ficheros Grficos Juegos Multimedia Controles OCX Manuales
Atributos Biblioteca de Clases de la Plataforma .NET Requerimientos de Software Lenguaje Intermedio y Metadatos JIT Sistema de Tipo Unificado El Sistema Virtual de Objetos - VOS VOS Type System Metadata y Reflection Seguridad Deployment Interoperabilidad con cdigo no administrado Common Language Specification - CLS Virtual Execution System - VES Tipos de Datos Constantes y Campos Solo Lectura Ejemplo Hello World! Ejemplo Args
Varios
Guia API Trucos VB TCP/IP Sistemas operativos Redes Delphi
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
1/51
23/11/11
Data Warehousing C++ Ensamblador Blog de literatura Juegos online Camisetas online Series de televisin Noticias de juegos
Software
Blog de software Descargar Microsoft Office Descargar Firefox 3 Descargar eMule Descargar Nero Descargar Ares Descargar Windows Live Messenger Descargar Photoshop Descargar CorelDraw Descargar Virtual DJ Descargar NOD32 Antivirus
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
2/51
23/11/11
goto return
Asignacin Definitiva Precedencia de Operadores typeof is Conversiones Bsico Intermedio Avanzado Manejo de Excepciones Jerarqua de Excepciones Trabajar con Excepciones Chequeo de Overflow Chequeo programtico de Overflow Sentencias para el Manejo de Excepciones try - catch try - finally try - catch - finally Lanzamiento de Excepciones Relanzamiento de Excepciones Creacin de Clases Exception Componentes Creacin de Componentes Compilacin de Componentes Creacin de una Aplicacin Cliente Compilacin de Clientes Namespaces Envolver Clases en Namespace Utilizar Namespace en Aplicaciones Cliente Agregar Mltiples Clases a Un Namespace Namespace y Ensambles Compilacin Condicional Uso del Preprocesador Definicin de smbolos Exclusin de cdigo basado en smbolos Lanzamiento de errores y advertencias Atributo conditional Comentarios de Documentacin en XML Elementos XML Componentes .NET Componentes .NET Privados Componentes .NET Compartidos Interoperabilidad COM Uso de Componentes .NET en Componentes .COM Uso de Componentes COM en Componentes .NET Invocacin de Servicios Cdigo No Seguro Debugging Seguridad Seguridad de acceso al cdigo Permisos Estndar Permisos Identidad Seguridad basada en roles Funcin ToString() Funcin Equals() Bsico Intermedio Avanzado Clase Hashtable Interface IHashCodeProvider Funcin ICloneable Formato Numrico Formato Personalizado String Formato Estndar String Parseo Numrico Input/Output Lectura y Escritura de Archivos Serializacin Threading (Hilos) Qu es C#? C# o C Sharp es un lenguaje de programacin que est incluido en la Plataforma .NET y corre en el Lenguaje Comn en Tiempo de Ejecucin (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#. C# intenta ser el lenguaje base para escribir aplicaciones .NET 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 mtodos y manejo de excepciones. Se elimino la complejidad de C++ para hacerlo ms fcil de utilizar y menos propenso a errores.
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
3/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
4/51
23/11/11
sealed.cs(4,7): error CS0509: 'ClaseDerivada' : cannot inherit from sealed class 'ClaseBase' sealed.cs(1,14): (Location of symbol related to previous error)
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
5/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
6/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
7/51
23/11/11
Ambiente/Entorno de Ejecucin El ambiente o entorno provee un modelo de programacin simple, seguro, soporta de herramientas potentes y ayuda con la
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
8/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
9/51
23/11/11
Los atributos que son aplicados a ensambles o mdulos deben colocarse despus de cualquier clusula using y antes de cualquier cdigo. Biblioteca de Clases de la Plataforma .NET La Biblioteca de Clases de la Plataforma .NET es una coleccin de tipos reutilizables integradas en el CLR. Los tipos de la Plataforma .NET permiten llevar a cabo tareas de programacin comunes como manipulacin de strings, colecciones de datos, conectividad a bases de datos y acceso a archivos. Es posible utilizar la Plataforma .NET para desarrollar los siguientes tipos de aplicaciones y servicios: Aplicaciones de consola Windows Forms Aplicaciones ASP.NET Servicios Web XML Servicios Windows Requerimientos de Software 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#. Lenguaje Intermedio y Metadatos Microsoft desarrollo un lenguaje parecido al lenguaje ensamblador llamado Microsoft Intermediate Language (MSIL). Para compilar aplicaciones .NET, los compiladores toman el cdigo fuente como entrada y producen MSIL como salida. MSIL en s es un lenguaje completo con el cual es posible escribir aplicaciones. El managed code generado por el compilador C# no es cdigo nativo porque es un cdigo de Lenguaje Intermedio (IL). Este cdigo IL se convierte en la entrada para la administracin del proceso de ejecucin del CLR. La ventaja final del cdigo IL es que el CPU es independiente, lo cual significa que se necesita un compilador en la mquina destino para cambiar el cdigo IL en el cdigo nativo. El IL es generado por el compilador, pero no es lo nico que se provee para el runtime, el compilador tambin genera metadatos acerca del cdigo, los cuales dicen ms al runtime del cdigo, por ejemplo la definicin de cada tipo. Los metadatos son bibliotecas de tipo, entrada de datos al registry, etc. Los metadatos son empaquetados directamente con el cdigo ejecutable y no en localidades separadas. 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. Cuando se compila una aplicacin C# o cualquier aplicacin escrita en un CLS, la aplicacin es compilada dentro del MSIL, adems se compila dentro de las instrucciones nativas de CPU cuando la aplicacin es ejecutada por vez primera por el CLR. El proceso es el siguiente: Cdigo fuente escrito en C# El cdigo fuente es compilado usando el compilador de C# (csc.exe) dentro de un EXE. El compilador C# produce como salida el cdigo MSIL y un manifiesto en una parte de slo lectura del EXE que tiene un encabezado estndar PE (Win32-Portable Executable). Cuando el compilador produce o crea la salida tambin importa una funcin llamada _CorExeMain del runtime .NET. Cuando la aplicacin es ejecutada, el sistema operativo carga el PE como una DLL dependiente tal como la nica que exporta la funcin _CorExeMain (mscoree.dll) justo como lo hace con cualquier PE vlido. El sistema operativo carga y entonces salta al punto dentro del PE el cual es puesto ah por el compilador C#. El sistema operativo obviamente no puede ejecutar el cdigo MSIL, el punto de entrada es un pequea parte que salta a la funcin _CorExeMain en mscoree.dll. La funcin _CorExeMain comienza la ejecucin del cdigo MSIL que fue colocado en el PE. Dado que el cdigo MSIL no puede ser ejecutado directamente (porque no est un un formato de mquina 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. JITers El managed code generado por C# es el cdigo IL, aunque el cdigo IL es empaquetado en un formato de archivo PE vlido, no es posible ejecutarlo sin convertirlo a un managed code nativo. Cuando un tipo es cargado, el laoder crea y agrega un stub (pieza pequea) a cada mtodo del tipo, as cuando el mtodo es invocado por vez primera, el stub pasa el control al JIT. El JIT compila el IL a cdigo nativo y cambia el stub para que apunte al cdigo nativo que est en cache, as las subsecuentes invocaciones podran ejecutar el cdigo nativo. El CLR incluye tres diferentes JITers que pueden ser usados para convertir MSIL en cdigo nativo, dependiendo de las circunstancias: PreJIT (Generacin de cdigo 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 cdigo IL a managed code nativo. La generacin de cdigo en tiempo de instalacin compilar un ensamble completo dentro de un cdigo binario de CPU-especifico, tal como lo hace el compilador C++. Un ensamble el cdigo empaquetado que es enviado al compilador. La compilacin se hace en tiempo de instalacin, cuando el usuario final es menos probable para notificar que el ensamble esta siendo compilado-JIT. La ventaja de la generacin de cdigo en tiempo de instalacin, es que permite compilar el ensamble completo justo una vez antes de ser ejecutado. Al ser compilado el ensamble entero no hay preocupacin referente al desempeo intermitente cada vez que un mtodo en el cdigo es ejecutado por primera vez. Al usar esta utilidad depende del tamao del sistema y del ambiente de distribucin. JIT, compilador por default utilizado por el CLR, es un compilador optimizado, el cual realiza el anlisis del flujo de datos, administra el cdigo nativo como salida. El JITter es invocado en tiempo de ejecucin. EconoJIT, realiza una conversin muy veloz del IL a managed code nativo Tambin es un JITter en tiempo de ejecucin, esta especialmente diseado para sistemas que tienen recursos limitados como memoria. La principal diferencia con un JIIter regular es la incorporacin de algunas invocaciones code pitching, que permiten al EconoJIT descartar el cdigo 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 cdigo es pitched (lanzado) es invocado otra vez por lo que debe ser compilado de nuevo. Es posible determinar que tipo de JIT esta siendo utilizado y cuanta memoria utiliza a travs de una pequea utilidad llamada
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
10/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
11/51
23/11/11
Los tipos de datos son separados en value types y reference types. Los value types son asignados en estructuras de pilas o en lnea. Los reference types son asignados al aglomerado. 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 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 builtin, las clases son utilizadas en cualquier otro caso. Por ejemplo un tipo int es un valor tipo y un tipo string es un tipo referencias, esto trabajaria as: int i = 2005; string s = "Septiembre";
i 2005
o----- ------------>
Septiembre
Constantes y Campos Solo Lectura 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. public const string sDominio = "informatique.com.mx"; La restriccin de tipos constantes es que son conocibles en tiempo de compilacin, en vez de ello es posible utilizar el modificador readonly el cual est diseado para aquellas situaciones en donde las constantes tienen restriccin. Aplicando el modificador readonly un valor puede ser establecido en el constructor o en una inicializacin pero no puede ser modificado despus. Ejemplo Hello World! El cdigo C# puede ser escrito en cualquier editor, tambin puede escribirse con Visual Studio 7.
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
12/51
23/11/11
El cdigo C# puede ser escrito en cualquier editor, tambin puede escribirse con Visual Studio 7. El cdigo C# debe almacenarse en un archivo con extensin .cs Para compilar el cdigo C# es necesario tener instalado la Plataforma .NET que incluye el compilador C#, puede buscar el ejecutable en la ruta: C:WINDOWSMicrosoft.NETFrameworkv1.1.4322csc.exe Asegurese de tener esta ruta en el path para poder ejecutar el compilador desde cualquier ubicacin. Para compilar su archivo .cs es necesario abrir la consola (DOS) y escribir el comando cs seguido del nombre de su archivo por ejemplo: cd helloworld.cs La salida exitosa de la compilacin podra ser as: Microsoft (R) Visual C# .NET Compiler version 7.10.6001.4 for Microsoft (R) .NET Framework version 1.1.4322 Copyright (C) Microsoft Corporation 2001-2002. All rights reserved. Si existe algn 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 slo es necesario escribir el nombre del archivo ejecutable. Algo interesante es que es posible especificar el nombre del archivo ejecutable a travs de un switch: csc /out:nuevoNombre.exe nombreArchivoFuente.cs El siguiente es el ejemplo tpico de los lenguajes de programacin: class HelloWorld{ public static void Main(){ System.Console.WriteLine("Hello World"); } } El mtodo Main debe estar contenido en la clase y escrito con la primer letra en mayscula. El tipo de este mtodo puede ser void o int. Tambin este mtodo puede especificar argumentos: public static void Main(string[] args) System es el mbito del namespace en el cual el objeto Console est contenido. Es posible importar el namespace en las aplicaciones indicandolo al inicio del cdigo con la palabra reservada using que es una directiva para el namespace System. Existen ms namespaces en la Plataforma .NET using System; Ejemplo Args Examinemos el siguiente ejemplo, el cual recibe los argumentos con los que el componente fue invocado: Ejemplo de Args con for: using System; class Args{ public static void Main(string[] args){ Console.WriteLine("Argumentos : {0}", args.Length); for(int itera = 0; itera < args.Length; itera++) Console.WriteLine("Argumento {0} : {1}", itera, args[itera]); } } Ejemplo de Args con foreach: using System; class App{ public static void Main(string[] args){ foreach(string input in args){ Console.WriteLine(input); } } } using System;, define el namespace System, el cual contiene entre otras la clase Console la cual es utilizada para comunicarse con la lnea de comandos. 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: System.Console.WriteLine(); Solamente se escribe: Console.WriteLine(); using no puede ser utilizado con un nombre de clase por lo que no es permitido escribir using System.Console class Args, Al no existir las funciones globales en C#, se declara una clase llamada Args. public static void Main(string[] args), La clase Args contiene una funcin o mtodo Main(), el cual sirve como punto de partida de la ejecucin del componente, este mtodo 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. Al ser un mtodo de arranque debe ser declarado con el modificador static porque no est asociado con una instancia de un objeto. El mtodo indica que recibe un arreglo de tipo string llamado args Console.WriteLine("Argumentos : {0}", args.Length);, invoca el mtodo WriteLine de la clase Console para escribir en la lnea de comando lo que se indica entre los parntesis. La primer parte de lo que se encierra entre parntesis es un string donde es necesario destacar que{0}, es una notacin que indica entre llaves un ndice que hace referencia a una variable asociada a este, en este caso asociada con args.Length args.Length, Length es un mtodo de la clase args el cual obtiene el nmero de elementos que contiene este arreglo. El ciclo for comienza una iteracin desde 0 hasta el nmero de elementos que contiene el arreglo args.Length, por cada elemento contenido en el arreglo escribe en la lnea 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 sern escritas, en este caso corresponde al iterador y {1} corresponde a args[itera], lo cual indica obtener el elemento en cuestin del arreglo args. Para compilar el componente utilice csc Args.cs Para ejecutar el componente sin parmetros escriba en la lnea de comando: csc Args
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
13/51
23/11/11
Para ejecutar el componente sin parmetros escriba en la lnea de comando: csc Args Salida : Argumentos : 0 Para ejecutar el componente con parmetros escriba en la lnea de comando: csc Args p1 p2 p3 p4 p5 p6 ... pn Por ejemplo: args http : www . informatique . com . mx Salida : Argumentos : 8 Argumento 0 : http Argumento 1 : : Argumento 2 : www Argumento 3 : . Argumento 4 : informatique Argumento 5 : . Argumento 6 : com Argumento 7 : . Argumento 8 : mx Ejemplo Input/Output Es posible leer datos de la consola utilizando el mtodo ReadLine y es posible mostrarlos utilizando el mtodo Write o WriteLine del objeto Console: using System; class inOut{ public static void Main(){ Console.Write("Fecha de Nacimiento: "); String strFecNac = Console.ReadLine(); Console.WriteLine("FecNac = " + strFecNac); } } Note que importar la directiva System hace posible omitir escribir el namespace, de esta forma slo es necesario escribir el nombre del objeto seguido del nombre del mtodo. Ejemplo String Format Es posible dar formato a la salida de datos a un tipo string, utilizando la sintaxis {nmero} donde nmero es reemplazado por la variable correspondiente: using System; class strFormat{ public static void Main(){ Console.Write("Nombre: "); String strNombre = Console.ReadLine(); Console.Write("Edad: "); String strEdad = Console.ReadLine(); Console.Write("Telfono: "); String strTel = Console.ReadLine(); Console.Write("Direccin: "); String strDir = Console.ReadLine(); Console.WriteLine("Datos: {0} {1} {2} {3}", strNombre , intEdad, strTel, strDir); } } Funcin Main Es posible incluir una funcin esttica en la clase para poder probarla, en C# esta funcin esttica puede ser escrita como Main() e indica el inicio de la ejecucin de un programa: using System; class App{ public static void Main(){ Console.WriteLine("Hello world!"); } } El ejemplo anterior define a la funcin 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 funcin como int por ejemplo, que indica que regresa un valor de tipo entero: using System; class App{ public static int Main(){ Console.WriteLine("Hello world!"); return(1); } } Tambin es posible que la funcin Main reciba parmetros de la lnea de comandos, para ello es necesario especificar un arreglo de strings como parmetro: using System; class App{ public static void Main(string[] args){ foreach(string input in args){ Console.WriteLine(input); } } } Mltiples Funciones Main Es posible que existan en una aplicacin varias clases que contengan la funcin Main() y por ello al compilar se indicar un error. Para evitar el error o indicar que funcin Main() de que clase deseamos que se ejecute, es necesario utilizar el siguiente switch al compilar: /main:nombreClase Por ejemplo
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
14/51
23/11/11
Por ejemplo using System; class ClaseA{ public static void Main(){ Console.WriteLine("Main de la clase A"); } } class ClaseB{ public static void Main(){ Console.WriteLine("Main de la clase B"); } } class ClaseC{ public static void Main(){ Console.WriteLine("Main de la clase C"); } } Al compilar utilice : csc multiplesmain.cs /main:ClaseB Salida: Main de la clase B Preprocesamiento Lo ms 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 compilacin adems de que no hay necesidad de escribir un archivo de encabezados por separado y mantener en sincronia la implementacin, cuando los archivos fuente C# son compilados el orden de la compilacin de archivos individuales no es importante y es equivalente a un archivo de gran tamao. Un identificador es el nombre que es usado para algn elemento de un programa como una variable o funcin y deben tener una letra o guin bajo como primer caracter. C# soporta las siguientes directivas de preprocesamiento:
Tamao Valor #define Define un identificador, los identificadores tambin pueden ser definidos via la lnea de comando #undef #if #elif #else #endif Elimina la definicin de un identificador El cdigo de la seccin es compilado si la expresin es verdadera Constructor Else-if, si la directiva anterior no se cumplio y si la expresin es verdadera el cdigo de la seccin es compilado Si la directiva anterior no se cumplio el cdigo de la seccin es compilado Marca el final de la seccin
Los identificadores deben preceder a cualquier cdigo real. Es posible utilizar los siguientes operadores en expresiones preprocesador: ! == != && || Es posible utilizar parntesis para agrupar expresiones. Comentarios Es posible comentar el cdigo, para ello existen dos modalidades: //, que se utiliza para comentar una lnea, es decir, todo lo que sigue a // es ignorado. /* */, que se utiliza para comentar segmentos de cdigo. Value Types Una variable contiene un valor de cierto tipo, C# forza a inicializar las variables antes de utilizarlas en una operacin. 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. C# agrupa los value types en: Tipos Simples Tipos Estructura Tipos Enumeracin Tipos Simples Los Tipos Simples de C# comparten caractersticas como las de alias con los tipos de sistema de .NET, expresiones constantes consisten de Tipos Simples evaluados solamente en tiempo de compilacin no en tiempo de ejecucin y los Tipos Simples pueden ser inicializados con literales. Los Tipos Simples de C# se agrupan en: Integral Representa valores enteros y existen nueve tipos integral en C#:
Tipo sbyte Entero con signo byte short int uint long Entero sin signo Entero con signo Entero con signo Entero sin signo Entero con signo Tamao 8 bit 8 bit 16 bit 16 bit 32 bit 32 bit 64 bit 64 bit -128 a 127 0 a 255 -32,768 a 32,767 0 a 65,535 -2,147,483,648 a 2,147,483,647 0 a 4,294,967,295 -9,223,372,036,854,775,808 a -9,223,372,036,854,775,807 0 a 18,446,744,073,709,551,615 Valor
Bool Representa valores booleanos verdadero y falso, por lo que es posible asignar a una variable un valor booleano o el resultado de una expresin: bool bContinuar = (a > b); En C# el valor verdadero no es posible representarlo con algn valor diferente de cero, no hay una conversin entre el tipo integral a bool que force esta conversin. Char
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
15/51
23/11/11
char cSexo = 'M';
Al realizar operaciones con Floating Point pueden producirse los siguientes valores: Cero positivo y negativo Infinito positivo y negativo NaN, Not-a-Number Nota: Si una expresin un valor es de tipo Floating Point todos los otros valores son convertidos a tipos Floating Point antes de realizar el clculo. Decimal Representa un tipo de alta precisin de 128 bit el cual es posible utilizarlo para calculos financieros y monetarios. Los valores posibles comprenden los rangos 1.0x10 -28 a 7.9x10 28 con una precisin de 28 a 29 dgitos. No hay conversiones implicitas entre decimales y dobles, se podra generar un overflow o perder precisin, por lo que es necesario una conversin explcita con un cast. Cuando se define una variable y se le asigna un valor se utiliza el sufijo m para denotar que es un valor decimal: decimal decDecimal = 1.0m Si se omite la letra m la variable podra ser tratada como double por el compilador antes de ser asignado. Tipos Estructura Un tipo struct puede declarar constructores, constantes, campos, mtodos, 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. Las estructuras deberan ser utilizadas slo para tipos que son realmente una pieza de datos. La diferencia entre struct y class en C# es que struct es un value type y class es una reference type. 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. using System; struct IP{ public byte b1,b2,b3,b4; } class ip{ public static void Main(){ IP miIP; miIP.b1 = 192; miIP.b2 = 168; miIP.b3 = 1; miIP.b4 = 101; Console.Write("{0}.{1}.", miIP.b1,miIP.b2); Console.Write("{0}.{1}", miIP.b3,miIP.b4); } } Tipos Enumeracin Es posible establecer un conjunto de constantes relacionadas, por default los elementos de una enumeracin 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 despus del nombre de la enumeracin aunque estn restringidos a los tipos: long, int, short y byte. Sintaxis: enum NombreEnumeraciones{ constante1, constante2, constante3, . . constanteN } Ejemplo: using System; public class Enumeracion { enum enumDias {Sabado, Domingo, Lunes, Martes, Mircoles, Jueves, Viernes }; enum enumMeses {Enero,Febrero,Marzo,Abril,Mayo,Junio,Julio,Agosto,Septiembre,_ Octubre,Noviembre,Diciembre}; enum enumFecha {Dia = 21, Mes = 9, Ao = 1971}; public static void Main() { Type eDias = typeof(enumDias); Type eMeses = typeof(enumMeses); Type eFecha = typeof(enumMeses);
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
16/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
17/51
23/11/11
object.ToString(), convierte un objeto a una representacin string. String.Format() puede ser utilizada para crear un string basado en los valores de otro string. La clase StringBuilder soporta las siguientes propiedades y mtodos:
Propiedad Capacity [] Descripcin Recupera o establece el nmero de caracteres que StringBuilder puede contener ndice StringBuilder utilizado para obtener o establecer un caracter en la posicin especfica
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
18/51
23/11/11
[] Length
MaxCapacity Recupera la capacidad mxima del StringBuilder Mtodo Append() AppendFormat() Insert() Remove() Replace() Descripcin Agrega la representacin string de un objeto Agrega la representacin string de un objeto, utilizando un formato especfico para el objeto Inserta la representacin string de un objeto especfico en una posicin especfica Elimina los caracteres especficos Reemplaza todas las instancias de un caractes con un nuevo caracter
EnsureCapacity() Asegura que StringBuilder tiene suficiente espacio para un nmero de caracteres especfico
Arreglos Un arreglo contiene variables a las cuales se accede a travs 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. Los arreglos en C# son referencias a objetos. Un arreglo value type no contiene instancias boxed. El valor inicial de un arreglo es null, un arreglo de objetos es creado utilizando new. Cuando un arreglo es creado inicialmente contiene los valores por default para los tipos que este contendr. Sintaxis: tipo[] identificador; Note que para definir un arreglo se utilizan los corchetes [] despus del tipo del arreglo. Ejemplo: string[] aPersonas; Es posible inicializar un arreglo al momento de crearlo: string[] asPersonas = new string[] {"Tim Berners-Lee","Brendan Eich","Dennis Ritchie","James Gosling"}; Durante la inicializacin es posible omitir new tipo[x] y el compilador podra determinar el tamao de almacenamiento para el arreglo del nmero de items en la lista de inicializacin: string[] asPersonas = {"Tim Berners-Lee","Brendan Eich","Dennis Ritchie","James Gosling"}; Cada elemento de un arreglo de ints es un int con el valor 0: int[] aiNumeros = new int[5]; Cada elemento de un arreglo de strings es un string con el valor null: string[] asNombres = new string[5]; La dimensin del arreglo puede ser simple o multidimensional, donde cada dimensin 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); using System; class Arreglo{ static public void Main(){ string[] aNombres = {"Hugo","Paco","Luis"}; Console.WriteLine(aNombres[0]); Console.WriteLine(aNombres[1]); Console.WriteLine(aNombres[2]); } } Otra alternativa al ejemplo anterior es: int[] aiNumeros = new int[3]; aiNumeros[0] = 4; aiNumeros[1] = 33; aiNumeros[2] = 43; Al declarar el arreglo especifique solamente el nmero de elementos que este contendr. utilice la palabre reservada new seguido del tipo y entre corchetes el nmero de elementos que contendr. Es posible ordernar y buscar los elementos de un arreglo gracias a que los arreglos en C# estn basados en el tipo System.Array del runtime NET. El mtodo Sort() podra ordenar los elementos de un arreglo, los mtodos IndexOf() y LastIndexOf() y BinarySearch podran buscar elementos en un arreglo. El mtodo Reverse podra invertir el orden de los elementos de un arreglo. Arreglos Multidimensionales Los Arreglos Multidimensionales son aquellos que tienen ms de una dimensin. Sintaxis: tipo[,] identificador; Ejemplo: string[,] asBidimensional = new string[2, 4]; Para definir un arreglo multidimensional, simplemente defina arreglos como elementos del arreglo: string[,] asMulti = {{"a","1"},{"b","2"},{"c","3"}}; Ejemplo: using System; class App{ public static void Main(){ string[] asPersonas = {"Tim Berners-Lee", "Brendan Eich", "Dennis M. Ritchie", "James Gosling"}; Console.WriteLine("Longitud del arreglo asPersonas : " + asPersonas.Length); int[] aiNumeros = new int[3] {1, 2, 3}; Console.WriteLine("Longitud del arreglo aiNumeros : " + aiNumeros.Length); //Define 4 arreglos de 2 dimensiones int iRenglon = 4; int iColumna = 2; string[,] asBidimensional = new string[iRenglon, iColumna]; // 4 renglones * 2 columnas = 8 Elementos asBidimensional[0,0] = "00"; asBidimensional[0,1] = "01"; asBidimensional[1,0] = "10"; asBidimensional[1,1] = "11"; asBidimensional[2,0] = "20";
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
19/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
20/51
23/11/11
Elemento Elemento Elemento Elemento Elemento Elemento Elemento Elemento La funcin Sort(),
using System; class App{ public static void Main(){ double[] aNumeros = {8.7, 6.9, -6.5, 4.2, -102.09, 1.9, 0.01, -0.002, 99.87}; Array.Sort(aNumeros); for(int elemento = 0; elemento < aNumeros.Length; elemento++) Console.WriteLine("Elemento [" + elemento + "] = " + aNumeros[elemento]); } } Salida: Elemento [0] Elemento [1] Elemento [2] Elemento [3] Elemento [4] Elemento [5] Elemento [6] Elemento [7] Elemento [8] Interface IComparable = = = = = = = = = -102.09 -6.5 -0.002 0.01 1.9 4.2 6.9 8.7 99.87
La funcin sort no trabaja con clases o estructuras porque no conoce su orden, pero si desea ordenarlas utilice la interface IComparable, por ejemplo una ordenacin utilizando una propiedad numrica: using System; public class Lenguaje : IComparable{ string nombre; int id; public Lenguaje(string nombre, int id){ this.nombre = nombre; this.id = id; } int IComparable.CompareTo(object o){ Lenguaje lenguajeB = (Lenguaje)o; if(this.id > lenguajeB.id){return 1;} if(this.id < lenguajeB.id){ return -1; }else{ return 0; } } public override string ToString(){ return nombre + " " + id; } } class App{ public static void Main(){ Lenguaje[] aLenguaje = new Lenguaje[5]; aLenguaje[0] = new Lenguaje("C",3); aLenguaje[1] = new Lenguaje("ActionScript",5); aLenguaje[2] = new Lenguaje("JavaScript",2); aLenguaje[3] = new Lenguaje("Java",8); aLenguaje[4] = new Lenguaje("PHP",1); Array.Sort(aLenguaje); foreach(Lenguaje len in aLenguaje) Console.WriteLine(len); } } Salida: PHP 1 JavaScript 2 C 3 ActionScript 5 Java 8 Interface IComparer Es posible definir mltiples tipos de ordenamientos gracias a que el diseo del Framework provee esta capacidad. Cada clase slo puede implementar una interface a la vez, por lo que solamente se podra permitir un tipo de ordenamiento, entonces se requiere una clase separada para cada tipo de ordenamiento que implementen IComparer y podra tambin implementar la funcin Comapare(): using System; using System.Collections; public class Lenguaje : IComparable{ string nombre; int id; public Lenguaje(string nombre, int id){ this.nombre = nombre; this.id = id; } int IComparable.CompareTo(object o){ Lenguaje lenguajeB = (Lenguaje)o; if(this.id > lenguajeB.id){return 1;} if(this.id < lenguajeB.id){ return -1; }else{ return 0; } } public override string ToString(){
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
21/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
22/51
23/11/11
Operador as
Boxing Boxing es un mecanismo que crea una liga entre los tipos de valores y las tipos de referencia permitiendo a un tipo de valor ser convertido a un tipo objeto y viceversa. using System; class App{ public static void Main(){ int iEdad = 33; object oNumero = iEdad; //Box int iNumero = (int)oNumero; //Unbox //cast necesario porque oNumero podra contener cualquier tipo de objeto } } Nota, durante la conversin unboxing el tipo debe coincidir exactamente, un valor de tipo boxed no puede ser unboxed (convertido) a un tipo compatible. Si requiere obtener otro tipo de valor diferente al que contiene el boxed, en ese caso primero obtenga el valor correcto y despus realice un cast al tipo que requiera: (valorRequerido) valorRequerido vr = (valorRequerido)(valorBoxed)objeto; Otra forma de definir el concepto boxing es que este mecanismo permite que los value types parezcan o tengan la apariencia de reference types. Conversiones Boxing Boxing un valor se refiere a la conversin implcita de cualquier tipo de valor al tipo objeto. Cuando un tipo de valor es boxed se asigna espacio a una instancia de objeto y el valor del value type es copiado al nuevo objeto. Observe las siguientes lneas: int object iNumero = 2012; oNumero = iNumero; //invocacin implicita a una operacin boxing
Al asignar el valor de la variable entera nNumero a una variable objeto se realiza internamente una operacin boxing, donde el valor de la variable nNumero es copiado al objeto oNumero, entonces las variables entera y objeto existen en la pila pero los valores de los objetos residen en el rea o espacio asignado, lo que implica que los valores son independientes y no hay una liga entre ellos: using System; class Box{ public static void Main(){ int iNumero = 2012; object oNumero = iNumero; //invocacin implicita a una operacin boxing oNumero = 2005; Console.WriteLine(iNumero); Console.WriteLine(oNumero); } } Al ejecutar el cdigo notar que el valor de oNumero es 2005 y el valor de iNumero no cambio permanece en 2012. Conversiones Unboxing Al contrario que Boxing, Unboxing es un mecanismo de una operacin explcita, por lo que es necesario indicar al compilador que tipo de valor deseamos extraer de un objeto, al realizar la operacin Unboxing C# checa que el value type que se requiere este almacenado en la instancia del objeto, si la verificacin es exitosa el valor es Unboxing. Suponga que tiene una variable de tipo int y asigna el valor de esta variable int a un objeto, despus declara una variable de tipo double y aplica un cast (double) al objeto para asignar su valor a la variable double, el objeto contiene slo un valor int y no puede ser asignado a la variable double porque el CLR dispara una excepcin (System.InvalidCastException): int iNumero = 2012; object oNumero = iNumero; //invocacin implicita a una operacin boxing double dNumero = (double)oNumero; //invocacion explcita (cast) //CLR dispara la excepcin System.InvalidCastException Constructores y Destructores Antes de acceder a los mtodos o propiedades de una clase, primero se ejecuta el constructor de la clase el cual contiene cdigo de inicializacin, si no se escribe un constructor para la clase el compilador provee automticamente un constructor default. En el runtime .NET el programador no puede controlar la destruccin de objetos. Un constructor puede invocar un constructor del tipo base utilizando la sintaxis base. Los constructores son invocados invocados automaticamente slo cuando una instancia de un objeto es creada con new. class NombreClase{ public NombreClase() : base(){} //Constructor que provee el compilador } Las caractersticas de un constructor son: Siempre tiene el mismo nombre que la clase. No tiene declarado un tipo de regreso. Por lo general tienen el modificador pblico. Son utilizados para inicializar varibles. Si la clase slo contiene miembros estticos, es posible crear un constructor private, lo cual significa que no
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
23/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
24/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
25/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
26/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
27/51
23/11/11
class ClaseBase{ public void MetodoOculto(){//Mtodo Oculto Console.WriteLine("Hiding Methods"); } } class ClaseDerivada : ClaseBase{//Clase derivada de la clase base new public void MetodoOculto(){//Mtodo Oculto Console.WriteLine("Hiding Methods using new"); } } class HidingClassMet{ public static void Main(){ ClaseDerivada MiClaseDerivada = new ClaseDerivada(); MiClaseDerivada.MetodoOculto(); } } Al hacer uso del modificador new, se le indica al compilador que se est redefiniendo el mtodo de la clase base y que debera ocultar este mtodo. Se puede asegurar de invocar el mtodo que redefine la clase derivada utilizando la siguiente sintaxis: ((ClaseBase)MiClaseDerivada).MetodoOculto(); Propiedades Las propiedades son convenientes para separar la interfaz de un objeto de su implementacin, en vez de permitir a un usuario acceder directamente a un campo o arreglo, una propiedad permite especificar a un conjunto de sentencias realizar el acceso mientras se permita utilizar el campo o arreglo. class NombreClase{ int iNombrePropiedad; //declaracin de la propiedad //Especificacin del acceso a la propiedad public int NombrePropiedad{ get{return iNombrePropiedad;} set{iNombrePropiedad = value;} } } Ejemplo: using System; class Propiedades{ private int iEdad; public int Edad{ get{return iEdad;} set{iEdad = value;} } private string sNombre; public string Nombre{ get{return sNombre;} set{sNombre = value;} } private bool bMexicano; public bool Mexicano{ get{return bMexicano;} set{bMexicano = value;} } public static void Main(){ Propiedades Ciudadano = new Propiedades(); Ciudadano.Edad = 33; Console.WriteLine("Edad Ciudadano : " + Ciudadano.Edad); Ciudadano.Nombre = "Gerardo ngeles Nava"; Console.WriteLine("Nombre Ciudadano : " + Ciudadano.Nombre); Ciudadano.Mexicano = true; Console.WriteLine("Mexicano Ciudadano : " + Ciudadano.Mexicano); } } Existen dos maneras de exponer el nombre de los atributos: Campos (fields) Propiedades (properties) Los atributos son implementados como variables miembro con acceso pblico via accessors (get o set). Los accessors (get o set) especifican las sentencias que son ejecutadas cuando se requiere leer o escribir el valor de una propiedad. Los accessors para la lectura del valor de una propiedad son marcados con la palabra reservada get y los accessors para modificar el valor de una propiedad son marcados con la palabra reservada set. El siguiente ejemplo muestra como se implentan los accessors para las propiedades: using System; class Persona{ private int iSueldo; public int Sueldo{ get{return iSueldo;} set{iSueldo = value;} } } class AplicPersona{ public static void Main(){ Persona Empleado = new Persona(); Empleado.Sueldo = 33; Console.WriteLine("Edad : " + Empleado.Sueldo);
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
28/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
29/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
30/51
23/11/11
Los operadores de la tabla son implementados via la sobrecarga de operadores y la implementacin es especifica para el tipo de dato, si se comparan dos variables de diferente tipo se realiza una conversin implcita que debe existir para que el compilador cree el cdigo necesario automticamente. Recuerde que siempre podr realizar un cast explcito. Ejemplo using System; class Caracteres{ public static void Main(){ string sNombre = "Gerardo Angeles Nava"; char chLetra = sNombre[0];//Extrae el primer caracter del string if(Char.IsDigit(chLetra)){ Console.WriteLine(chLetra + " es un dgito"); }else{ EsMayuscula(chLetra); EsMinuscula(chLetra); } chLetra = sNombre[1];//Extrae el segundo caracter del string if(Char.IsDigit(chLetra)){ Console.WriteLine(chLetra + " es un dgito"); }else{ EsMayuscula(chLetra); EsMinuscula(chLetra); } sNombre = "123"; chLetra = sNombre[2];//Extrae el tercer caracter del string
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
31/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
32/51
23/11/11
cuatro"); seis");
diez");
por defecto");
Las Sentencias de Iteracin (tambin conocidas como looping statements) son aquellas que nos permiten ejecutar un bloque de cdigo repetidamente mientras una condicon especfica sea verdadera: for foreach while do Sentencia for La Sentencia for se utiliza cuando se conoce previamente cuantas veces ha de repetirse un bloque de cdigo. Este bloque se repetira mientras la condicin evalue una expresin booleana verdadera, no ser posible evaluar otro tipo de expresin. Sintaxis: for(inicializador; condicin; iterador) Los componentes de la sentencia for: inicializador, condicin, iterador, no son obligatorios. Es posible salir de un ciclo for a travs de las instrucciones: break goto Ejemplo: using System; class Factorial{ public static void Main(string[] aArgs){ if(aArgs.Length == 0){ Console.WriteLine("Debe proporcionar un argumento, Ejemplo: Factorial 5"); return; } long lFactorial = 1; long lCalcular = Int64.Parse(aArgs[0]); long lAux = 1; for(lAux = 1; lAux <= lCalcular; lAux++){ lFactorial *= lAux; //Test Line Console.WriteLine("{0}! * {1}", lAux, lFactorial); } Console.WriteLine("{0}! es {1}", lCalcular, lFactorial); } } Sentencia foreach La Sentencia foreach es un comando para enumerar los elementos de una coleccin. foreach(Tipo indentificador in expresin){} La variable de iteracin es declarada por el Tipo, indentificador y expresin correspondiente a la coleccin. La variable de iteracin representa el elemento de la coleccin para cada iteracin. El siguiente ejemplo muestra el uso de for: using System;
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
33/51
23/11/11
using System; class App{ public static void Main(string[] aArgs){ for(int i = 0; i < aArgs.Length; i++){ Console.WriteLine("Elemento " + i + " = " + aArgs[i]); } } } El ejemplo anterior implementado con foreach: using System; class App{ public static void Main(string[] aArgs){ foreach(String s in aArgs){ Console.WriteLine(s); } } } No es posible asignar un nuevo valor a la variable de iteracin. No se puede pasar la variable de iteracin como un parmetro ref o out. Para que una clase soporte la sentencia foreach, la clase debe soportar un mtodo con la firma GetEnumerator() y la estructura, clase o interface que regresa debe tener un mtodo pblico MoveNext y una propiedad pblica Current. En el siguiente ejemplo el mtodo GetEnvironmentVariables() regresa una interfaz de tipo IDictionary. Es posible acceder a las colecciones Keys y Values de la interfaz IDictionary: using System; using System.Collections; class SentenciaForEach{ public static void Main(){ IDictionary VarsAmb = Environment.GetEnvironmentVariables(); Console.WriteLine("Existen {0} variables de ambiente declaradas", VarsAmb.Keys.Count); foreach(String strIterador in VarsAmb.Keys){ Console.WriteLine("{0} = {1}", strIterador, VarsAmb[strIterador].ToString()); } } } Nota, es necesario tener una precaucin extra al decidir el tipo de variable de iteracin, porque un tipo equivocado no puede ser detectado por el compilador, pero si detectado en tiempo de ejecucin y causar una excepcin. Sentencia while La Sentencia while se utiliza cuando no se conoce previamente cuantas veces ha de repetirse un bloque de cdigo, por lo que puede ejecutarse 0 o ms veces. Este bloque se repetira mientras la condicin evalue una expresin booleana verdadera, no ser posible evaluar otro tipo de expresin. while(condicional){} Ejemplo: using System; using System.IO; class SentenciaWhile{ public static void Main(){ if(!File.Exists("test.html")){ Console.WriteLine("El archivo test.html no existe"); return; } StreamReader SR = File.OpenText("test.html"); String strLinea = null; while(null != (strLinea = SR.ReadLine())){ Console.WriteLine(strLinea); } SR.Close(); } } Es posible utilizar la sentencia break para salir del ciclo o continue para saltar una iteracin. Sentencia do La diferencia entre la sentencia while y do es que do se evalua despus de su primer iteracin, por lo que al menos siempre se ejecuta una vez: do{ sentencias; }while(condicin); Es posible salir de un ciclo do a travs de la sentencia break y es posible saltar una iteracin utilizando la sentencia continue El siguiente ejemplo le la entrada de la consola toma el primer caracter leido, lo convierte en un Tipo double y suma su valor mientras la entrada sea 's' o hasta que la entrada sea 'n'. using System; class Consola{ public static void Main(){ Consola LeerDatos = new Consola(); LeerDatos.Run(); } public void Run(){ char chContinuar = 's'; string strDatos; double dSuma = 0; do{ Console.Write("Proporcione un nmero: "); strDatos = Console.ReadLine(); dSuma += Double.Parse(strDatos); Console.Write("Continuar s/n?"); strDatos = Console.ReadLine(); chContinuar = strDatos[0]; if(chContinuar == 'n') break; }while(chContinuar == 's'); Console.WriteLine("La suma de los nmeros es: " + dSuma); } } Sentencias de Salto
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
34/51
23/11/11
Sentencias de Salto
typeof El operador typeof regresa el tipo del objeto, el cual es una instancia de la clase System.Type Una instancia ya existente puede obtener el tipo de objeto con el mtodo de la instancia GetType(). is El operador is es utilizado para determinar cuando una referencia a un objeto puede ser converitda a un tipo especfico o interface. El operador as es muy similar al operador is, pero en vez de determinar cuando un objeto es un tipo especfico o interface, as tambin realiza la conversin explicita a ese tipo o interface y si no lo puede convertir el operador regresa null. Utilizar as es ms eficiente que utilizar is, porque as slo necesita checar el tipo del objeto una vez e is checa el tipo cuando el operador es utilizado y lo checa otra vez cuando la conversin se realiza. Utilizando is if(UnObjeto is UnTipo){ UnTipo ut = (UnTipo) UnObjeto; } Utilizando as UnTipo ut = UnObjeto as UnTipo; if(ut != null){ sentencias; } Conversiones En C# las conversiones se dividen en conversiones explcitas y conversiones implcitas que son aquellas que podran siempre ocurrir: //conversiones implcitas sbyte a = 55; short b = a; int c = b; long d = c; //conversiones explcitas c = (int) d; b = (short) c; a = (sbyte) b; A continuacin se presenta la jerarqua de conversin en C## Manejo de Excepciones Las excepciones son el mtodo fundamental de manejo de condiciones de error. Ejemplo: using System; class DivisionCero{ public static void Main(){ int iA = 33; int iB = 0; try{
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
35/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
36/51
23/11/11
}
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
37/51
23/11/11
ArgumentOutOfRangeException Lanzada por un mtodo cuando un argumento no est en el rango permitido InteropException ComException SEHException Clase base para excepciones que son originadas u ocurren en ambientes fuera del CLR Excepcin que contiene informacin HRESULT COM Excepcin que encapsula informacin del manejo de excepciones destructurada Win32
Relanzamiento de Excepciones El siguiente cdigo muestra como es posible atrapar una excepcin, manejarla y se volverla a invocar: using System; class FactorialCheckedReThrow{ public static void Main(string[] aArgs){ if(aArgs.Length == 0){ Console.WriteLine("Debe proporcionar un argumento, Ejemplo: Factorial 5"); return; } long lFactorial = 1; long lCalcular = Int64.Parse(aArgs[0]); long lAux = 1; try{ checked{ //Habilitar chequeo de overflow for(lAux = 1; lAux <= lCalcular; lAux++){ lFactorial *= lAux; //Test Line Console.WriteLine("{0}! * {1}", lAux, lFactorial); } } }catch(OverflowException){ Console.WriteLine("El factorial {0}! causo una excepcin", lCalcular); throw; } Console.WriteLine("{0}! es {1}", lCalcular, lFactorial); } } Creacin de Clases Exception Es recomendable utilizar las clases predefinidas para excepciones, para ciertos escenarios es posible crear clases de excepciones apropiadas, por ejemplo cuando creamos una clase, tambin podemos crear excepciones para esta clase, esto es conveniente cuando se utiliza la clase y manejar posibles escenarios de error con las clases de excepciones creadas. using System;
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
38/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
39/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
40/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
41/51
23/11/11
} Compilar:
csc /r:informatique.com.mx.dll iAplic.cs Recuerde que sus clases deben tener el modificador de acceso public, de lo contrario el compilador notificara un error (error CS0122: is inaccessible due to its protection level), por lo que tendr que agregar el modificador de acceso y volver a compilar. Namespace y Ensambles Un objeto puede ser utilizado desde un archivo fuente C# slo si ese objeto puede ser localizado por el compilador C#, por default el compilador slo abre el ensamble conocido como mscorlib.dll, el cual contiene las funciones principales para el CLR. Para referenciar objetos localizados en otros ensambles, el nombre del archivo de ensamble debe ser pasado al compilador, esto es posible utilizando un switch al compilar: /r:nombreEnsamble Es as como se crea un correlacin entre el namespace de un objeto y el nombre del ensamble en el cual reside, por ejemplo los tipos de namespace en el System.Net residen en el ensamble System.Net.dll Compilacin Condicional La Compilacin Condicional permite excluir o incluir cdigo, en C# existen dos formas de hacer esto: Uso del Preprocesador Atributo conditional Uso del Preprocesador C# el compilador emula el preprocesador, ya que no hay un preprocesador por separado. El compilador de C# no soporta macros, en cambio soporta las siguientes directivas: Definicin de smbolos Exclusin de cdigo basado en smbolos Lanzamiento de errores y advertencias Definicin de smbolos La Definicin de smbolos es utilizada para excluir o incluir cdigo dependiendo si son o no son definidos ciertos smbolos. Una forma para definir un smbolo es utilizando la directiva #define en un archivo fuente C#, est definicin deber realizarse antes de cualquier otra sentencia: #define DEBUG #define RELEASE En este caso #define DEBUG, define un smbolo DEBUG y su mbito es el archivo donde es definido, al igual que el smbolo RELEASE. Otra forma utilizada para definir smbolos es usar el compilador y es de mbito global para todos los archivos: csc /define:DEBUG nombreArchivo.cs Si se requiere definir mltiples smbolos utilizando el compilador, es necesario separar cada smbolo con una coma (,) csc /define:DEBUG,RELEASE,DEMOVERSION nombreArchivo.cs Si el cdigo fuente incluye directivas de definicin de smbolos, es posible deshabilitarlas utilizando la directiva #undef cuyo mbito tambin corresponde al archivo donde es definida: #undef DEBUG Exclusin de cdigo basado en smbolos El principal propsito de los smbolos es la inclusin o exclusin condicional del cdigo, basado sobre si son o no son definidos los smbolos. El siguiente cdigo no define smbolos en el archivo fuente: . sentencia; . #if NOMBRE_SIMBOLO sentencia; #else sentencia; #endif . Pero es posible definir o no los smbolos al compilar la aplicacin: csc /define:NOMBRE_SIMBOLO NombreAplicacion.cs Las directivas del preprocesador emulado utilizadas para evaluar el smbolo son: #if, #else y #endif las cuales actuan como su contraparte, la sentencia condicional if C#, es posible utilizar &&, || y !: //#define SIMBOLO_A #define SIMBOLO_B #define SIMBOLO_C #if SIMBOLO_A #undef SIMBOLO_C #endif using System; class NombreClase{ public static void Main(){ #if SIMBOLO_A . #elif SIMBOLO_B && SIMBOLO_C . #else . #endif } } Lanzamiento de errores y advertencias Existe otro uso de las directivas del preprocesador para lanzar errores del compilador o advertencias dependiendo de ciertos smbolos, para ello se utilizan las directivas: #warning #error Por ejemplo #if SIMBOLO_ERROR
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
42/51
23/11/11
/// Descripcin : Clase que define lo que es y puede hacer una persona /// /// class Persona{ ///La propiedad iSueldo se emplea para obtener y asignar el valor del sueldo de una persona private int iSueldo; public int Sueldo{
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
43/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
44/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
45/51
23/11/11
depuracin inicia.
Es posible establecer diferentes tipos de breakpoint: File, interrumpe la ejecucin cuando una ubicacin especfica en el archivo fuente se alcanza Data, interrumpe la ejecucin cuando una variable cambia a un valor especifico Function, interrumpe la ejecucin en una ubicacin especfica dentro de una funcin especfica Address, interrumpe la ejecucin cuando una direccin de memoria especfica se alcanza Una vez que se interrumpe la ejecucin, es posible continuarla utilizando los comandos: Step Over Step Into Step Out Run to Cursor Es posible modificar valores de variables simplemente dando doble clic en la columna valor de aquella variable que se desea modificar, as como tambin es posible observar las variables, para ello es necesario dar clic en la columna nombre y escribir el nombre de las variables que se desean observar. Las excepciones son un punto excelente de comienzo para una sesin de depuracin, cuando una excepcin no es controlada apropiadamente por el cdigo se muestra la ventana de depuracin llamada JIT just in time. Seguridad Hoy en da el cdigo viene de distintas fuentes, no solo el que es instalado via un setup por el servidor, tambin puede ser instalado via una pgina web o correo electrnico. .NET plantea dos posibles soluciones para la seguridad: Seguridad de acceso al cdigo Seguridad basada en roles Seguridad de acceso al cdigo La Seguridad de acceso al cdigo controla el acceso protegiendo los recursos y operaciones. El cdigo es confiable en distintos grados, dependiendo su identidad y de donde viene. Funciones de la seguridad de acceso al cdigo: El administrador puede definir las polticas de seguridad asignando ciertos permisos para definir grupos de cdigo. El cdigo puede requerir que quien invoca (caller) debe tener permisos especificos La ejecucin de cdigo est restringido en tiempo de ejecucin, realizando chequeos para verificar que los permisos otorgados a quien invoca (caller) coincidan con el permiso requerido para la operacin. El cdigo puede requerir los permisos necesarios de ejecucin y los permisos que podran ser utilizados, es decir, verificar los permisos indispensables. Los permisos son definidos para representar ciertos derechos para acceder a distintos recursos del sistema. La seguridad de acceso al cdigo otorga permisos cuando un componente es cargado, este otorgamiento esta basado en el requerimiento del cdigo, definiendo operaciones permitidas por las polticas de seguridad. Existen dos puntos importantes de la seguridad de acceso al cdigo, donde el requerimiento mnimo para beneficiarse de la seguridad de acceso al cdigo es para generar un cdigo de tipo seguro. Verificar el tipo de seguridad del cdigo administrado, el runtime forza la restriccin de seguridad del cdigo administrado, para determinar cuando el cdigo es seguro. Es importante que el runtime sea capaz de checar los permisos de quien invoca de manera confiable, evadiendo hoyos de seguridad que son creados cuando cdigo menos confiable invoca cdigo altamente confiable, para ello el cdigo administrado debe ser verificado como tipo seguro. Cada acceso a tipos se realiza slo en un sentido permitido. El cdigo C# es de tipo no seguro, pero el IL y los metadatos son inspeccionados antes de dar el visto bueno del tipo de seguridad del cdigo. Permisos que son requeridos por el cdigo, el beneficio de activar el requerimiento de permisos es conocer cuando se tiene el permiso apropiado para realizar acciones y cuando no. Es posible prevenir al cdigo de el otorgamiento de permisos adicionales que no son necesarios. Los permisos mnimos garantizan que el cdigo se ejecute con los recursos justos cuando el cdigo requiere de muchos permisos sin que falle. La categoria de los permisos es: Required, permiso que el cdigo necesita para ejecutarse correctamente. Optional, permisos que no son obligatorios para la ejecucin correcta del cdigo, pero que podra ser bueno tenerlos. Refused, permiso que se necesita para que el cdigo nunca se otorgue, aunque la poltica de seguridad lo permita, se utiliza para restringir vulnerabilidades potenciales. Permisos Estndar Los Permisos Estndar son: EnvironmentPermission, clase que define permisos de acceso a variables de ambiente, donde son posibles dos tipos de acceso, de slo lectura y escritura al valor de una variable de ambiente. El tipo de acceso escritura incluye permisos para crear y eliminar variables de ambiente. FileDialogPermission, controla el acceso a archivos basado en el sistema de archivos de dilogo. El usuario debe autorizar el acceso al archivo via el cuadro de dilogo. FileIOPermission, es posible especificar tres tipos de acceso a archivos de entrada y salida: lectura, escritura y adicin, el acceso lectura incluye acceder a la informacin del archivo, el tipo escritura incluye eliminar y sobreescribir, el acceso adicin no permite leer otros bits. IsolatedStoragePermission, controla el acceso a almacenamientos aislados, este acceso permite utilizacin, tamao de almacenamiento, tiempo de expiracin y almacenamiento de datos. ReflectionPermission, controla la capacidad de leer el tipo de informacin de tipos miembro no pblicos y controla el uso de Reflection.Emit RegistryPermission, Control de lectura, creacin y escritura en el registry SecurityPermission, coleccin de permisos simples que son utilizados por el sistema de seguridad, es posible controlar la ejecucin de cdigo, sobreescritura de chequeos de seguridad, invocacin de cdigo no administrado, serializacin, etc. UIPermission, define el acceso a varios aspectos de la interfaz de usuario, incluyendo el uso de windows, acceso a eventos y uso del portapapeles. Permisos Identidad Los Permisos Identidad son: PubilsherIdentityPermission, la firma de componentes .NET provee resistencia de software publisher
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
46/51
23/11/11
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
47/51
23/11/11
}
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
48/51
23/11/11
}
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
49/51
23/11/11
}
Console.WriteLine("0:E", Scientific (exponential) 33345.8977); Fixed-point General Number Console.WriteLine("0:F", 33345.8977); Console.WriteLine("0:G", 33345.8977); Console.WriteLine("0:N", 33345.8977);
Formato Personalizado String El Formato Personalizado String, son utilizados para obtener ms control, sobre la conversacin que est disponible a travs del formato estndar de strings. Reemplazo de Cero o Digito Console.WriteLine("{0:000}",12); Salida: 012 Reemplazo de Espacio o Digito Console.WriteLine("{0:#####}",123); Salida: 123 Punto Decimal Console.WriteLine("{0:#####.000}",12345.2); Salida: 12345.200 Separador de Grupo Console.WriteLine("{0:##,###}",1123456789); Salida: 1,123,456,789 Separador de Grupo Console.WriteLine("{0:000,.##}",12394); Salida: 123.95 Porcentaje Console.WriteLine("{0:##.000%}",98144); Salida: 98.144% Notacin Exponencial Console.WriteLine("{0:###.000E-00}",3.1415533E+04); Salida: 314.155E-02 Separador de Seccin Console.WriteLine("{0:###.00;0;(###.00)}",-456.55); Salida: 457 Escape y Literales Console.WriteLine("{0:###\#}",255); Salida: 255# Parseo Numrico Los nmeros pueden ser parseados utilizando el mtodo Parse(), esto es posible ya que lo provee el tipo de dato. int iValue = Int32.Parse("123"); double dValue = Double.Parse("1.23"); Input/Output El lenguaje Comn en Tiempo de Ejecucin .NET provee funciones de entrada/salida en el namespace System.IO. La lectura y escritura la realiza la clase Stream, la cual describe como los bytes pueden ser escritos o leidos. Stream es una clase abstracta que en la prctica las clases derivan de Stream para ser utilizadas. Clases disponibles:
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
50/51
23/11/11
Clases disponibles:
FileStream, flujo en un archivo de disco MemoryStream, flujo que es almacenado en memoria NetworkStream, flujo en una conexin de red BufferedStream, implementa un buffer en la cima de otro stream. Lectura y Escritura de Archivos Existen dos formas de obtener flujos (streams) que conectan a un archivo, uno utilizando la clase FileStream, la cual provee un control total sobre el acceso de archivos, incluyendo modo de acceso, compartido y buffering. A continuacin se muestra un ejemplo donde, cada vez que el programa es ejecutado se sobreescribe el contenido del archivo en caso de que este exista, si no existe se crea: using System; using System.IO; class App{ public static void Main(){ FileStream f = new FileStream("nuevo.txt", FileMode.Create); StreamWriter s = new StreamWriter(f); for(int iNumberLine = 1; iNumberLine <= 10; iNumberLine++){ s.WriteLine("Linea " + iNumberLine); } s.Close(); f.Close(); } } Salida, Archivo Nuevo.txt cuyo contenido es: Linea 1 Linea 2 Linea 3 Linea 4 Linea 5 Linea 6 Linea 7 Linea 8 Linea 9 Linea 10 Serializacin La Serializacin es el proceso utilizado por el runtime para objetos persistentes en algn orden de almacenamiento o para transferirlos de un lugar a otro. La informacin de los metadatos en un objeto contiene informacin suficiente para que el runtime serialice los campos, pero es necesario indicar al runtime hacerlo correctamente a travs de dos atributos [Serializable] el cual es utilizado para marcar un objeto que es posible serializar y [NonSerialized] que es aplicado para un campo o propiedad para indicar que no debera ser serializado. Threading (Hilos) El namespace System.Threading contiene clases utilizadas para threading y sincronizacin. El tipo apropiado de sincronizacin y/o exclusin depende del diseo del programa, pero C# soporta exclusin simple utilizando la sentencia lock. lock utiliza la clase System.Threading.Monitor y provee funcionalidad similar a la invocacin de CriticalSection en Win32. Agradecimientos a Juan Garcia por enviar el tutorial original de informatique.com.mx
www.canalvisualbasic.net/manual-net/c-sharp/#docCommXML
51/51