identification Type d'exception dans un gestionnaire

Question

J'ai créé la classe d'exception personnalisée

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

Dans ma demande, je veux savoir est exception throw est mon exception personnalisée ou non.

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

Answer 1

MISE À JOUR: en supposant C# 6, les chances sont que votre cas peut être exprimé sous la forme d'un filtre d'exception. Telle est l'approche idéale du point de vue de la performance en supposant que votre exigence peut être exprimée en termes de celui-ci, par exemple:

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

---

En supposant C# < 6, le plus efficace est d'attraper un type Exception spécifique et ne manipulation basé sur cela. Tout fourre-tout traitement peut être fait séparément

try 
{ 
} 
catch (Web2PDFException ex) 
{ 
} 

ou

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

ou (si vous avez besoin d'écrire un gestionnaire général - qui est généralement une mauvaise idée, mais si vous êtes sûr qu'il est préférable pour vous, vous êtes sûr):

if(err is Web2PDFException) 
{ 
} 

ou (dans certains cas, si vous avez besoin de faire des choses de la hiérarchie de type plus complexe qui ne peut pas être exprimé avec is)

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

ou de passer à VB.NET ou F # et utiliser is ou Type.IsAssignableFrom dans les filtres d'exception

Answer 2

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

Answer 3

Vous devez toujours prendre des exceptions aussi concrètes que possible, vous devez donc utiliser

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

Vous devriez bien sûr utiliser quelque chose comme ceci si vous insistez:

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

Answer 4

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

mais il y a probablement une meilleure façon de faire ce que vous voulez.

Answer 5

vous pouvez ajouter des informations supplémentaires à votre exception dans votre classe et puis quand vous attrapez l'exception que vous pouvez contrôler vos informations sur mesure pour identifier votre exception

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

et vous pouvez obtenir votre valeur

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

comme ça pour plus d'informations: http://msdn.microsoft.com/en-us/library/system.exception.data.aspx

Answer 6

Dans les situations où je don Je ne sais pas exactement quel type d'exception pourrait provenir d'une méthode, un petit truc que j'aime faire est de récupérer le nom de la classe de l'exception et de l'ajouter au journal des erreurs afin qu'il y ait plus d'informations.

try 
{ 
    <code> 

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

Je ne garantis pour traiter toujours des types d'exceptions individuellement, mais le supplément d'information peut être utile, surtout lorsqu'ils traitent avec le code de gens qui aiment capturer fourre-tout types génériques.

Answer 7

Autre possibilité:

var exception = err as Web2PDFException; 

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

Answer 8

lieu de codage et recompilation dur, pourquoi ne pas simplement appeler la méthode GetType hors de l'exception réelle en utilisant le débogueur de Visual Studio?

Pour ce faire, lors du débogage on peut appeler des méthodes en utilisant le Immediate Window du débogueur. Par exemple, je devais savoir ce que l'exception et juste la propriété Name extrait de GetType en tant que telle, sans avoir à recompiler: