Francisco Cortijo Bon classes.xml program.xml exceptions Las excepciones ofrecen varias ventajas respecto a otros métodos de notificación de error, como los códigos devueltos (órdenes return) ya que ningún error pasa desapercibido (las excepciones no pueden ser ignoradas) y no tienen por qué tratarse en el punto en que se producen. Los valores no válidos no se siguen propagando por el sistema. No es necesario comprobar los códigos devueltos. Es muy sencillo agregar código de control de excepciones para aumentar la confiabilidad del programa. Una excepción es cualquier situación de error o comportamiento inesperado que encuentra un programa en ejecución. Las excepciones se pueden producir a causa de un error en el código o en código al que se llama (como una biblioteca compartida), que no estén disponibles recursos del sistema operativo, condiciones inesperadas que encuentra Common Language Runtime (por ejemplo, código que no se puede comprobar), etc. La aplicación se puede recuperar de algunas de estas condiciones, pero de otras no. Las excepciones pueden generarse en un proceso o hebra de nuestra aplicación (con la sentencia throw) o pueden provenir del entorno de ejecución de la plataforma .NET. En .NET Framework, una excepción es un objeto derivado de la clase Exception. El mecanismo de control de excepciones en C# es muy parecido al de C++ y Java: la excepción se inicia en un área del código en que se produce un problema. La excepción asciende por la pila hasta que la aplicación la controla o el programa se detiene. El proceso es el siguiente: La sentencia throw lanza una excepción (una instancia de una clase derivada de System.Exception, que contiene información sobre la excepción: Message, StackTrace, HelpLink, InnerException...). El bloque try delimita código que podría generar una excepción. El bloque catch indica cómo se manejan las excepciones. Se puede relanzar la excepción capturada o crear una nueva si fuese necesario. Se pueden especificar distintos bloques catch para capturar distintos tipos de excepciones. En ese caso, es recomendable poner primero los más específicos (para asegurarnos de que capturamos la excepción concreta). El bloque finally incluye código que siempre se ejecutará (se produzca o no una excepción). Ejemplo 1 El siguiente ejemplo pone de manifiesto el flujo de ejecución que sigue un programa que lanza y procesa una excepción. try { Console.WriteLine("try"); throw new Exception("Mi excepcion"); } catch { Console.WriteLine("catch"); } finally { Console.WriteLine("finally"); } La ejecución de este programa produce el siguiente resultado: try catch finally Ejemplo 2 Se puede profundizar en el tratamiento de la excepción, por ejemplo, comprobando alguna propiedad del objeto Exception generado. La clase Exception es la clase base de la que derivan las excepciones. La mayoría de los objetos de excepción son instancias de alguna clase derivada de Exception, pero se puede iniciar cualquier objeto derivado de la clase Object como excepción. En casi todos los casos, es recomendable iniciar y detectar sólo objetos Exception. La clase Exception tiene varias propiedades que facilitan la comprensión de una excepción. Entre éstas destacamos la propiedad Message. Esta propiedad proporciona información sobre la causa de una excepción. Veamos cómo se utiliza: try { Console.WriteLine("try"); throw new Exception("Mi excepcion"); } catch (Exception e) { Console.WriteLine("catch"); Console.WriteLine("Excepción detectada: " + e.Message); } catch { Console.WriteLine("catch"); } finally { Console.WriteLine("finally"); } La ejecución de este programa produce el siguiente resultado: try catch Excepción detectada: Mi excepcion finally La mayoría de las clases derivadas de la clase Exception no implementan miembros adicionales ni proporcionan más funcionalidad, simplemente heredan de Exception. Por ello, la información más importante sobre una excepción se encuentra en la jerarquía de excepciones, el nombre de la excepción y la información que contiene la excepción. Ejemplo 3 El siguiente ejemplo muestra cómo el uso de execpciones puede controlar un número importante de situaciones de error. static void Main(string[] args) { int numerador = 10; Console.WriteLine ("Numerador es = {0}", numerador); Console.Write ("Denominador = "); string strDen = Console.ReadLine(); int denominador, cociente; try { Console.WriteLine("--> try"); denominador = Convert.ToInt16(strDen); cociente = numerador / denominador; Console.WriteLine ("Cociente = {0}", cociente); } catch (ArithmeticException e) { Console.WriteLine("--> catch"); Console.WriteLine("Excep. aritmética"); Console.WriteLine("ArithmeticException Handler: {0}", e.ToString()); } catch (ArgumentNullException e) { Console.WriteLine("--> catch"); Console.WriteLine("Excep. de argumento nulo"); Console.WriteLine("ArgumentNullException Handler: {0}", e.ToString()); } catch (Exception e) { Console.WriteLine("--> catch"); Console.WriteLine("generic Handler: {0}", e.ToString()); } finally { Console.WriteLine("--> finally"); } Console.ReadLine(); } } Cuando todo funciona sin problemas: image/out_Excep2.gif Cuando se intenta dividir por cero: image/out_Excep3_smll.gif Cuando se produce desbordamiento: image/out_Excep4_smll.gif Cuando se produce otro problema (cadena vacía, por ejemplo): image/out_Excep5_smll.gif Ejemplo 4 Hemos visto que pueden conocerse los detalles de la excepción que se haya producido. Podemos conocer más detalles usando la propiedad StackTrace. Esta propiedad contiene un seguimiento de pila que se puede utilizar para determinar dónde se ha producido un error. El seguimiento de pila contiene el nombre del archivo de código fuente y el número de la línea del programa si está disponible la información de depuración. try"); denominador = Convert.ToInt16(strDen); cociente = numerador / denominador; Console.WriteLine ("Cociente = {0}", cociente); } catch (Exception e) { Console.WriteLine("--> catch"); Console.WriteLine("Generic Handler: {0}", e.ToString()); Console.WriteLine(); StackTrace st = new StackTrace(e, true); Console.WriteLine("Traza de la pila:"); for (int i = 0; i < st.FrameCount; i++) { StackFrame sf = st.GetFrame(i); Console.WriteLine(" Pila de llamadas, Método: {0}", sf.GetMethod() ); Console.WriteLine(" Pila de llamadas, Línea : {0}", sf.GetFileLineNumber()); } Console.WriteLine(); } finally { Console.WriteLine("--> finally"); } Console.ReadLine(); } } ]]> image/out_Excep6_smll.gif image/out_Excep7_smll.gif reflection La capacidad de reflexión de la plataforma .NET (similar a la de la plataforma Java) nos permite explorar información sobre los tipos de los objetos en tiempo de ejecución. La instrucción GetType() obtiene el objeto Type de la instancia actual sobre el que se aplica. El valor devuelto es representa el tipo exacto, en tiempo de ejecución, de la instancia actual. image/reflection.gif public class Test { private int n; public Test (int n) { this.n = n; } } // Acceso a información acerca de una clase public static void Main(string[] args) { Type tipoClase = typeof(Test); Console.WriteLine("El nombre del tipo de tipoClase es: {0}", tipoClase.Name); Test t = new Test(0); Type tipoVariable = t.GetType(); Console.WriteLine("El tipo de la variable t es: {0}", tipoVariable.Name); } El programa anterior muestra como resultado: El nombre del tipo de tipoClase es: Test El tipo de la variable t es: Test Otro ejemplo del uso de Type y GetType(): image/reflectionType.gif La reflexión puede emplearse para examinar los métodos, propiedades, ... de una clase: image/MemberInfo.gif 0) { Console.WriteLine (" Parámetros: " ); foreach (ParameterInfo p in ParInf) Console.WriteLine(" " + p.ParameterType + " " + p.Name); } } Console.ReadLine (); } } ]]> image/reflectionMethods.gif atribs Un atributo es información que se puede añadir a los metadatos de un módulo de código. Los atributos nos permiten "decorar" un elemento de nuestro código con información adicional. C# es un lenguaje imperativo, pero, como todos los lenguajes de esta categoría, contiene algunos elementos declarativos. Por ejemplo, la accesibilidad de un método de una clase se especifica mediante su declaración como public, protected, private o internal. C# generaliza esta capacidad permitiendo a los programadores inventar nuevas formas de información declarativa, anexarlas a distintas entidades del programa y recuperarlas en tiempo de ejecución. Los programas especifican esta información declarativa adicional mediante la definición y el uso de atributos. Esta información puede ser referente tanto al propio módulo o el ensamblado al que peretenezca, como a los tipos de datos definidos en él, sus miembros, los parámetros de sus métodos, los bloques set y get de sus propiedades e indexadores o los bloques add y remove de sus eventos. Se pueden emplear en ensamblados, módulos, tipos, miembros, valores de retorno y parámetros. Si bien el programador puede definir cuantos atributos considere necesarios, algunos atributos ya están predefinidos en la plataforma .NET. Atributo Descripción Browsable Propiedades y eventos que deben mostrarse en el inspector de objetos. Serializable Clases y estructuras que pueden "serializarse" (esto es, volcarse en algún dispositivo de salida, p.ej. disco), como en Java. Obsolete El compilador se quejará si alguien los utiliza (deprecated en Java). ProgId COM Prog ID Transaction Características transaccionales de una clase. Observar como al marcar como obsoleta la clase A se genera un error al compilar el módulo ya que se emplea en la línea comentada. ... [Obsolete("Clase A desfasada. Usar B en su lugar")] class A { public void F() {} } class B { public void F() {} } class SimpleAtrPredefApp { static void Main(string[] args) { A a = new A(); // Avisos a.F(); ... } } image/obsolete.gif Declarar un atributo en C# es simple: se utiliza la forma de una declaración de clase que hereda de System.Attribute y que se ha marcado con el atributo AttributeUsage, como se indica a continuación: El atributo AttributeUsage especifica los elementos del lenguaje a los que se puede aplicar el atributo. Las clases de atributos son clases públicas derivadas de System.Attribute que disponen al menos de un constructor público. Las clases de atributos tienen dos tipos de parámetros: Parámetros posicionales, que se deben especificar cada vez que se utiliza el atributo. Los parámetros posicionales se especifican como argumentos de constructor para la clase de atributo. En el ejemplo anterior, url es un parámetro posicional. Parámetros con nombre, los cuales son opcionales. Si se especifican al usar el atributo, debe utilizarse el nombre del parámetro. Los parámetros con nombre se definen mediante un campo o una propiedad no estáticos. En el ejemplo anterior, Topic es un parámetro con nombre. Los parámetros de un atributo sólo pueden ser valores constantes de los siguientes tipos: Tipos simples (bool, byte, char, short, int, long, float y double) string System.Type enumeraciones object (El argumento para un parámetro de atributo del tipo object debe ser un valor constante de uno de los tipos anteriores.) Matrices unidimensionales de cualquiera de los tipos anteriores Parámetros para el atributo AttributeUsage El atributo AttributeUsage proporciona el mecanismo subyacente mediante el cual los atributos se declaran. AttributeUsage tiene un parámetro posicional: AllowOn, que especifica los elementos de programa a los que se puede asignar el atributo (clase, método, propiedad, parámetro, etc.). Los valores aceptados para este parámetro se pueden encontrar en la enumeración System.Attributes.AttributeTargets de .NET Framework. El valor predeterminado para este parámetro es el de todos los elementos del programa (AttributeElements.All). AttributeUsage tiene un parámetro con nombre: AllowMultiple, valor booleano que indica si se pueden especificar varios atributos para un elemento de programa. El valor predeterminado para este parámetro es False. A continuación, se muestra un breve ejemplo de uso del atributo declarado en la sección anterior: En este ejemplo, el atributo HelpAttribute está asociado con las clases Clase1 y Clase2. Nota: Por convención, todos los nombres de atributo finalizan con la palabra "Attribute" para distinguirlos de otros elementos de .NET Framework. No obstante, no tiene que especificar el sufijo de atributo cuando utiliza atributos en el código (véase el ejemplo). Los atributos de un tipo o de un miembro de un tipo pueden ser examinados en tiempo de ejecución (reflexión), heredan de la clase System.Attribute y sus argumentos se comprueban en tiempo de compilación. Los principales métodos de reflexión para consultar atributos se encuentran en la clase System.Reflection.MemberInfo. El método clave es GetCustomAttributes, que devuelve un vector de objetos que son equivalentes, en tiempo de ejecución, alos atributos del código fuente. Ejemplo 1 El siguiente ejemplo muestra la manera básica de utilizar la reflexión para obtener acceso a los atributos: image/out_Atr1.gif Ejemplo 2 Este ejemplo amplía el anterior añadiendo muchas más posibilidades. image/attr-reflect.gif