Tipo de excepción en un manejador

Question

He creado la clase de excepción personalizada

public class Web2PDFException : Exception 
{ 
    public Web2PDFException(string message, 
     Exception innerException) 
     : base(message, innerException) 
    { 
    } 
} 

En mi solicitud me quiero averiguar es excepción tiro es mi excepción personalizada o no.

try 
{ 
} 
catch (Exception err) 
{ 
//Find exception type here 
} 

Answer 1

ACTUALIZADO: suponiendo C# 6, lo más probable es que su caso se puede expresar como un filtro de excepción. Este es el enfoque ideal desde una perspectiva de rendimiento suponiendo que el requisito se puede expresar en términos de la misma, por ejemplo:

try 
{ 
} 
catch (Web2PDFException ex) when (ex.Code == 52) 
{ 
} 

---

Suponiendo C# < 6, el más eficiente es coger un tipo específico Exception y no la manipulación basado en eso. Cualquier cajón de sastre de manipulación se puede hacer por separado

try 
{ 
} 
catch (Web2PDFException ex) 
{ 
} 

o

try 
{ 
} 
catch (Web2PDFException ex) 
{ 
} 
catch (Exception ex) 
{ 
} 

o (si es necesario escribir un manejador en general - que es generalmente una mala idea, pero si está seguro de que es mejor para usted, usted puede estar seguro):

if(err is Web2PDFException) 
{ 
} 

o (en algunos casos si es necesario hacer algunas cosas más compleja jerarquía de tipos que no puede ser expresado con is)

if(err.GetType().IsAssignableFrom(typeof(Web2PDFException))) 
{ 
} 

o cambiar a VB.NET o C# y utilizar is o Type.IsAssignableFrom en Filtros de excepción

Answer 2

try 
{ 
    // Some code 
} 
catch (Web2PDFException ex) 
{ 
    // It's your special exception 
} 
catch (Exception ex) 
{ 
    // Any other exception here 
} 

Answer 3

Siempre debe capturar las excepciones lo más concreto posible, por lo que debe utilizar

try 
{ 
    //code 
} 
catch (Web2PDFException ex) 
{ 
    //Handle the exception here 
} 

Por supuesto, debería utilizar algo como esto si insiste:

try 
{ 
} 
catch (Exception err) 
{ 
    if (err is Web2PDFException) 
    { 
     //Code 
    } 
} 

Answer 4

try 
{ 
} 
catch (Exception err) 
{ 
    if (err is Web2PDFException) 
     DoWhatever(); 
} 

pero es probable que haya una forma mejor de hacer lo que sea que desee.

Answer 5

puede añadir alguna información adicional a su excepción en su clase y luego cuando se captura la excepción puede controlar su información personalizada para identificar su excepción

this.Data["mykey"]="keyvalue"; //you can add any type of data if you want 

y entonces se puede obtener el valor de su

string mystr = (string) err.Data["mykey"]; 

así para más información: http://msdn.microsoft.com/en-us/library/system.exception.data.aspx

Answer 6

Cuando se trata de situaciones en las que Don No sé exactamente qué tipo de excepción podría surgir de un método, un pequeño "truco" que me gustaría hacer es recuperar el nombre de clase de la Excepción y agregarlo al registro de errores para que haya más información.

try 
{ 
    <code> 

} catch (Exception caughtEx) 
{ 
    throw new Exception("Unknown Exception Thrown: " 
         + "\n Type: " + caughtEx.GetType().Name 
         + "\n Message: " + caughtEx.Message); 
} 

Yo respondo de manipulación es obligatorio tipos de excepciones de forma individual, pero el toque adicional de información puede ser útil, especialmente cuando se trata de código de las personas que aman a capturar de captura-todos los tipos genéricos.

Answer 7

alternativa:

var exception = err as Web2PDFException; 

if (excecption != null) 
{ 
    Web2PDFException wex = exception; 
    .... 
} 

Answer 8

en lugar de codificar duro y volver a compilar, ¿por qué no llamar al método GetType fuera de la excepción real utilizando Visual Studio depurador de?

Para hacer eso, mientras se depura uno puede llamar a métodos usando el Immediate Window del depurador. Por ejemplo lo que necesitaba saber cuál era la excepción y acaba de extraer la propiedad Name de GetType como tal sin tener que recompilar: