Les meilleures pratiques pour la capture et le re-lancement .NET exceptions

Le moyen de conserver la trace de la pile est grâce à l'utilisation de la throw; Ceci est valable aussi bien

try {
  //something that bombs here
} catch (Exception ex)
{
    throw;
}

throw ex; c'est un peu comme lancer une exception de ce point, de sorte que la trace de la pile ne voulaient pas aller à l'endroit où vous délivrer les throw ex; déclaration.

Mike est également correct, en supposant que l'exception vous permet de passer d'une exception (ce qui est recommandé).

Karl Seguin a un grande écriture sur la gestion des exceptions dans son bases de la programmation e-book ainsi, ce qui est une excellente lecture.

Edit: lien de Travail pour Bases de la Programmation pdf. Il suffit de chercher le texte "exception".

En fait, il y a certaines situations qui le throw déclaration ne permet pas de conserver la StackTrace de l'information. Par exemple, dans le code ci-dessous:

try
{
  int i = 0;
  int j = 12 / i; //Line 47
  int k = j + 1;
}
catch
{
  //do something
  //...
  throw; //Line 54
}

La StackTrace indique que la ligne 54 soulevé l'exception, bien qu'il ait été soulevée à la ligne 47.

Unhandled Exception: System.DivideByZeroException: Attempted to divide by zero.
   at Program.WithThrowIncomplete() in Program.cs:line 54
   at Program.Main(String[] args) in Program.cs:line 106

Dans des situations comme celle décrite ci-dessus, il existe deux options pour preseve l'original StackTrace:

L'appel de l'Exception.InternalPreserveStackTrace

Que c'est une méthode privée, il doit être invoquée par l'aide de la réflexion:

private static void PreserveStackTrace(Exception exception)
{
  MethodInfo preserveStackTrace = typeof(Exception).GetMethod("InternalPreserveStackTrace",
    BindingFlags.Instance | BindingFlags.NonPublic);
  preserveStackTrace.Invoke(exception, null);
}

Je possède un désavantage de s'appuyer sur une méthode privée à préserver la StackTrace de l'information. Il peut être modifié dans les prochaines versions de .NET Framework. L'exemple de code ci-dessus et la solution proposée ci-dessous a été extrait à partir Fabrice MARGUERIE blog.

Appel D'Exception.SetObjectData

La technique ci-dessous a été suggéré par Anton Tykhyy comme réponse à En C#, comment puis-je renvoyer InnerException sans perdre la trace de la pile question.

static void PreserveStackTrace (Exception e) 
{ 
  var ctx = new StreamingContext  (StreamingContextStates.CrossAppDomain) ; 
  var mgr = new ObjectManager     (null, ctx) ; 
  var si  = new SerializationInfo (e.GetType (), new FormatterConverter ()) ; 

  e.GetObjectData    (si, ctx)  ; 
  mgr.RegisterObject (e, 1, si) ; //prepare for SetObjectData 
  mgr.DoFixups       ()         ; //ObjectManager calls SetObjectData 

  //voila, e is unmodified save for _remoteStackTraceString 
} 

Bien, il a l'avantage de compter dans les méthodes publiques seulement il dépend aussi de l'exception suivante constructeur (dont certaines exceptions développé par le 3e parties ne parviennent pas à mettre en œuvre):

protected Exception(
    SerializationInfo info,
    StreamingContext context
)

Dans ma situation, j'ai dû choisir la première approche, car les exceptions soulevées par une 3ème partie de la bibliothèque je l'aide a été de ne pas mettre en œuvre ce constructeur.

La règle de base est d'éviter d'Attraper et de Lancer la base Exception objet. Cela vous oblige à être un peu plus intelligent à propos des exceptions; en d'autres mots, il doit être explicitement prise pour SqlException de sorte que votre code de gestion de ne pas faire quelque chose de mal avec une NullReferenceException.

Dans le monde réel, cependant, la capture de et de journalisation la base d'exception, c'est aussi une bonne pratique, mais n'oubliez pas de marcher le tout pour obtenir tout InnerExceptions qu'il pourrait avoir.

Quelques personnes réellement manqué un point très important - "jeter" et de "jeter de l'ex" peut faire la même chose, mais ils ne vous donnent pas un élément crucial de la imformation qui est la ligne où l'exception s'est produite.

Considérons le code suivant:

static void Main(string[] args)
{
    try
    {
        TestMe();
    }
    catch (Exception ex)
    {
        string ss = ex.ToString();
    }
}

static void TestMe()
{
    try
    {
        //here's some code that will generate an exception - line #17
    }
    catch (Exception ex)
    {
        //throw new ApplicationException(ex.ToString());
        throw ex; //line# 22
    }
}

Lorsque vous faites un "jeter" ou "jeter ex", vous obtenez la trace de la pile, mais la ligne# va #22 de sorte que vous ne pouvez pas comprendre quelle ligne exactement jetait l'exception (sauf si vous avez seulement 1 ou quelques lignes de code dans le bloc try). Pour obtenir les attendus de la ligne #17 dans votre exception, vous aurez à lancer une nouvelle exception à l'exception d'origine trace de la pile.

Vous pouvez également utiliser:

try
{
//Dangerous code
}
finally
{
//clean up, or do nothing
}

Et toutes les exceptions levées vont remonter vers le niveau suivant que les gère.

Pour info je viens de tester cette et la trace de la pile rapporté par 'jeter;' n'est pas entièrement correcte de la pile. Exemple:

    private void foo()
    {
        try
        {
            bar(3);
            bar(2);
            bar(1);
            bar(0);
        }
        catch(DivideByZeroException)
        {
            //log message and rethrow...
            throw;
        }
    }

    private void bar(int b)
    {
        int a = 1;
        int c = a/b;  //Generate divide by zero exception.
    }

La trace de la pile des points à l'origine de l'exception correctement (rapporté le numéro de ligne), mais le numéro de la ligne signalée pour les foo() est la ligne de la jeter, la déclaration, par conséquent, vous ne peut pas vous dire d'où des appels à bar() a provoqué l'exception.