Exception (Clase)

Artículo
08/13/2007

Representa los errores que se producen durante la ejecución de una aplicación.

Espacio de nombres: System
Ensamblado: mscorlib (en mscorlib.dll)

Sintaxis

'Declaración
<SerializableAttribute> _
<ComVisibleAttribute(True)> _
<ClassInterfaceAttribute(ClassInterfaceType.None)> _
Public Class Exception
    Implements ISerializable, _Exception
'Uso
Dim instance As Exception

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
[ClassInterfaceAttribute(ClassInterfaceType.None)] 
public class Exception : ISerializable, _Exception

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
[ClassInterfaceAttribute(ClassInterfaceType::None)] 
public ref class Exception : ISerializable, _Exception

/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
/** @attribute ClassInterfaceAttribute(ClassInterfaceType.None) */ 
public class Exception implements ISerializable, _Exception

SerializableAttribute 
ComVisibleAttribute(true) 
ClassInterfaceAttribute(ClassInterfaceType.None) 
public class Exception implements ISerializable, _Exception

Comentarios

Esta clase es la clase base de todas las excepciones. Cuando se produce un error, el sistema o la aplicación que se está ejecutando en ese momento informa del mismo produciendo una excepción que contiene información sobre el error. Una vez que se produce una excepción, la aplicación o el controlador de excepciones predeterminado controlan dicha excepción.

Common Language Runtime proporciona un modelo de control de excepciones basado en la representación de excepciones en forma de objetos, y en la separación del código de programa y del código de control de excepciones en bloques try y catch, respectivamente. Puede haber uno o varios bloques catch, cada uno de los cuales está diseñado para controlar un tipo de excepción en particular; o bien, uno de los bloques está diseñado para detectar una excepción más específica que otro de los bloques.

Si una aplicación controla las excepciones que se producen durante la ejecución de un bloque de código de la aplicación, el código debe incluirse dentro de una instrucción try. El código de la aplicación que está incluido dentro de una instrucción try es un bloque try. El código de la aplicación que controla las excepciones producidas por un bloque try se coloca dentro de una instrucción catch y se denomina bloque catch. Puede haber cero o más bloques catch asociados a un bloque try. Cada uno de los bloques catch incluye un filtro de tipos que determina los tipos de excepciones que controla.

Cuando se produce una excepción en un bloque try, el sistema busca los bloques catch asociados en el orden en el que aparecen en el código de la aplicación, hasta que encuentra un bloque catch que controla la excepción. Un bloque catch controla una excepción de tipo T si el filtro de tipos del bloque catch especifica T o cualquier tipo del que se derive T. El sistema detiene la búsqueda cuando encuentra el primer bloque catch que controla la excepción. Por este motivo, el bloque catch que controla un tipo debe especificarse en el código de la aplicación delante del bloque catch que controla sus tipos base, tal y como se muestra en el ejemplo que se incluye tras esta sección. El bloque catch que controla System.Exception se especifica en último lugar.

Si ninguno de los bloques catch asociados al bloque try actual controla la excepción y el bloque try actual está anidado dentro de otros bloques try en la llamada actual, se realiza una búsqueda de los bloques catch asociados al siguiente bloque try envolvente. Si no se encuentra ningún bloque catch para la excepción, el sistema busca los niveles de anidamiento anteriores de la llamada actual. Si en la llamada actual no se encuentra ningún bloque catch para la excepción, ésta asciende por la pila de llamadas y en el marco de pila anterior se busca un bloque catch que controle la excepción. La búsqueda en la pila de llamadas continúa hasta que se controla la excepción o hasta que no hay más marcos en la pila de llamadas. Si se alcanza la parte superior de la pila de llamadas sin haber encontrado un bloque catch que controle la excepción, el controlador de excepciones predeterminado controla la excepción y la aplicación termina.

Los tipos de excepción admiten las siguientes características:

Texto legible para el usuario donde se describe el error. Cuando se produce una excepción, el motor en tiempo de ejecución pone a disposición del usuario un mensaje de texto donde se informa de la naturaleza del error y se recomienda llevar a cabo una determinada acción para solucionar el problema. Este mensaje de texto se guarda en la propiedad Message del objeto de excepción. Durante la creación del objeto de excepción, puede pasarse una cadena de texto al constructor para que se describan los detalles de esa excepción en concreto. Si no se le proporciona al constructor ningún argumento de mensaje de error, se utiliza el mensaje de error predeterminado.
Estado de la pila de llamadas en el momento en que se produjo la excepción. La propiedad StackTrace incluye un seguimiento de pila que puede utilizarse para determinar la parte del código en la que se ha producido un error. El seguimiento de pila muestra todos los métodos a los que se ha llamado y los números de línea del archivo de código fuente donde se realizan las llamadas.

Existen dos categorías de excepciones en la clase base Exception:

Clases de excepción predefinidas de Common Language Runtime que se derivan de SystemException.
Clases de excepción de aplicaciones definidas por el usuario que se derivan de ApplicationException.

Exception incluye determinadas propiedades que ayudan a identificar la ubicación del código, el tipo, el archivo de ayuda y el motivo de la excepción: StackTrace, InnerException, Message, HelpLink, HResult, Source, TargetSite y Data.

Cuando existe una relación causal entre dos o más excepciones, la propiedad InnerException incluye esta información. La excepción externa se produce en respuesta a esta excepción interna. El código que controla la excepción externa puede utilizar la información de la excepción interna anterior para controlar el error de forma más adecuada. Se puede almacenar información adicional acerca de la excepción en la propiedad Data.

La cadena de mensaje de error que se pasa al constructor durante la creación del objeto de excepción debe localizarse y puede suministrarse desde un archivo de recursos mediante ResourceManager. Para obtener más información sobre los recursos localizados, vea la información general sobre el espacio de nombres System.Resources y Empaquetar e implementar recursos.

Para proporcionar al usuario abundante información sobre el motivo de la excepción, la propiedad HelpLink puede incluir una dirección URL (o URN) de un archivo de ayuda.

Exception utiliza HRESULT COR_E_EXCEPTION, que tiene el valor 0x80131500.

Para obtener una lista con los valores de propiedad iniciales de una instancia de Exception, vea los constructores Exception.

Consideraciones de rendimiento

Cuando se produce o se controla una excepción, se utiliza una cantidad significativa de recursos del sistema y en tiempo de ejecución. Hay que producir excepciones sólo para controlar condiciones verdaderamente extraordinarias, no para controlar eventos previsibles o el control del flujo. Por ejemplo, la aplicación puede producir razonablemente una excepción si un argumento de método no es válido porque se espera que se llame al método con parámetros válidos. Un argumento de método no válido significa que se ha producido algo extraordinario. A la inversa, no hay que producir una excepción si la entrada de usuario no es válida porque se puede esperar que los usuarios a veces introduzcan datos no válidos. En dicho caso, hay que proporcionar un mecanismo de reintento de modo que los usuarios puedan introducir una entrada válida.

Haga que se inicien excepciones sólo para las condiciones extraordinarias, y que se detecten en un controlador de excepciones de propósito general que se aplique a la mayor parte de la aplicación, no en uno que se aplique a una excepción determinada. El motivo de este enfoque es que la mayoría de los errores se pueden controlar mediante la validación y el código de control de errores próximo al error; no es necesario que se produzca ni se detecte ninguna excepción. El controlador de excepciones de propósito general detecta excepciones verdaderamente inesperadas que se hayan producido en cualquier parte de la aplicación.

Además, no hay que producir una excepción cuando sea suficiente un código de devolución; tampoco hay que convertir un código de devolución en una excepción, ni detectar rutinariamente una excepción; debe pasarse por alto y seguir el procesamiento.

Ejemplo

En el siguiente ejemplo de código se muestra un bloque catch que está definido para controlar los errores de ArithmeticException. Este bloque catch detecta también los errores de DivideByZeroException porque DivideByZeroException se deriva de ArithmeticException y no hay ningún bloque catch definido explícitamente para detectar los errores de DivideByZeroException.

Imports System

Class ExceptionTestClass
   
   Public Shared Sub Main()
      Dim x As Integer = 0
      Try
         Dim y As Integer = 100 / x
      Catch e As ArithmeticException
         Console.WriteLine("ArithmeticException Handler: {0}", e.ToString())
      Catch e As Exception
         Console.WriteLine("Generic Exception Handler: {0}", e.ToString())
      End Try
   End Sub 'Main
End Class 'ExceptionTestClass

using System;

class ExceptionTestClass 
{
public static void Main() 
{
   int x = 0;
      try 
      {
         int y = 100/x;
      }
         catch (ArithmeticException e) 
         {
         Console.WriteLine("ArithmeticException Handler: {0}", e.ToString());
         }
            catch (Exception e) 
            {
            Console.WriteLine("Generic Exception Handler: {0}", e.ToString());
            }
      } 
}

using namespace System;
int main()
{
   int x = 0;
   try
   {
      int y = 100 / x;
   }
   catch ( ArithmeticException^ e ) 
   {
      Console::WriteLine( "ArithmeticException Handler: {0}", e );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Generic Exception Handler: {0}", e );
   }

}

import System.*;

class ExceptionTestClass
{
    public static void main(String[] args)
    {
        int x = 0;
        try {
            int y = 100 / x;
        }
        catch (ArithmeticException e) {
            Console.WriteLine("ArithmeticException Handler: {0}", e.ToString());
        }
        catch (System.Exception e) {
            Console.WriteLine("Generic Exception Handler: {0}", e.ToString());
        }
    } //main
} //ExceptionTestClass

El código de C# genera el siguiente resultado:

ArithmeticException Handler: System.DivideByZeroException: Attempted to divide by zero. at ExceptionTestClass.Main()

El código de Visual Basic genera el siguiente resultado:

ArithmeticException Handler: System.OverflowException: Exception of type System.OverflowException was thrown. at ExceptionTestClass.Main()

Jerarquía de herencia

System.Object
System.Exception
Clases derivadas

Seguridad para subprocesos

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Plataformas

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium, Windows Mobile para Pocket PC, Windows Mobile para Smartphone, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter Edition

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

Información de versión

.NET Framework

Compatible con: 2.0, 1.1, 1.0

.NET Compact Framework

Compatible con: 2.0, 1.0

Vea también

Referencia

Exception (Miembros)
System (Espacio de nombres)
SystemException
ApplicationException (Clase)

Otros recursos

Controlar y generar excepciones
Empaquetar e implementar recursos

Compartir a través de