Comment attraper l'original (intérieure) exception en C#?

J'ai hate d'avoir à vous dire cela, mais vous ne pouvez pas attraper un intérieur d'exception.

Ce que vous pouvez faire est de inspecter un.

Je vous suggère de prendre votre haut niveau d'exception (je crois que c'était LockerException) et d'inspecter le InnerException des biens de cette exception. Vérifier le type, et si ce n'est pas un SqlException, vérifier la InnerException de cette exception. À pied chaque une jusqu'à trouver un SqlException type, puis d'obtenir les données dont vous avez besoin.

Cela dit, je suis d'accord avec dasblinkenlight que vous devriez envisager, si possible, un lourd refactoriser de votre cadre d'exception.

Vérifier le code d'erreur d'un enveloppé exception n'est pas une bonne pratique, parce que ça fait mal d'encapsulation plutôt sévèrement. Imaginez à un certain point, la réécriture de la logique à lire à partir d'un non-SQL source, par exemple, un service web. Il serait de jeter quelque chose autre que SQLException sous la même condition, et à l'extérieur de code n'aurait aucun moyen de le détecter.

Vous devez ajouter le code pour le bloc d'attraper SQLException pour vérifier e.Number = 247 à droite, puis et là, et de le jeter BusinessRuleException avec une propriété qui le différencie de BusinessRuleException jeté en réponse à la non-SQLException et SQLException avec e.Number != 247 de manière significative. Par exemple, si le nombre magique 247 signifie que vous avez rencontré un duplicata (une pure spéculation de ma part en ce moment), vous pourriez faire quelque chose comme ceci:

catch (SQLException e) {
    var toThrow = new BusinessRuleException(e);
    if (e.Number == 247) {
        toThrow.DuplicateDetected = true;
    }
    throw toThrow;
}

Lorsque vous attrapez BusinessRuleException plus tard, vous pouvez vérifier sa DuplicateDetected de la propriété, et d'agir en conséquence.

EDIT 1 (en réponse à l'observation que le DB-lecture de code ne peut pas vérifier pour SQLException)

Vous pouvez également modifier votre BusinessRuleException pour vérifier SQLException dans son constructeur, comme ceci:

public BusinessRuleException(Exception inner)
:   base(inner) {
    SetDuplicateDetectedFlag(inner);
}

public BusinessRuleException(string message, Exception inner)
:   base(message, inner) {
    SetDuplicateDetectedFlag(inner);
}

private void SetDuplicateDetectedFlag(Exception inner) {
    var innerSql = inner as SqlException;
    DuplicateDetected = innerSql != null && innerSql.Number == 247;
}

C'est moins souhaitable, parce qu'il rompt l'encapsulation, mais au moins il le fait en un seul endroit. Si vous avez besoin d'examiner d'autres types d'exceptions (par exemple, parce que vous avez ajouté un service web source), vous pouvez l'ajouter à la SetDuplicateDetectedFlag méthode, et tout fonctionne de nouveau.

Bonne question et les bonnes réponses!

Je veux juste compléter les réponses déjà donné avec quelques réflexions:

D'une part je suis d'accord avec dasblinkenlight et les autres utilisateurs. Si vous attrapez une exception à renvoyer une exception de type différent avec l'original de l'exception définie comme l'intérieur d'exception, alors vous devez faire cela pour aucune autre raison que de maintenir la méthode du contrat. (L'accès à SQL server est un détail d'implémentation que l'appelant n'est pas/ne doit pas/ne peut pas en être conscient, il ne peut donc pas prévoir qu'un SqlException (ou DbException d'ailleurs) sera lancé.)

L'application de cette technique a cependant des implications que l'on doit être conscient de:

• Vous cacher la cause de l'erreur. Dans votre exemple, vous êtes à la déclaration de l'appelant qu'une règle d'entreprise n'était pas valide(?), violé(?) etc., alors qu'en fait, il y a un problème d'accès à la DB (ce qui serait tout à fait clair si le DbException ont été autorisés à bulles haut de la pile des appels plus loin).
• Vous cacher l'endroit où l'erreur s'est produite à l'origine. Le StackTrace propriété de l'exception interceptée sera point à un catch-bloc loin de l'emplacement de l'erreur à l'origine s'est produite. Cela peut faciliter le débogage notoirement difficile, sauf si vous prenez
  le plus grand soin pour vous connecter la pile des traces de toutes les exceptions internes ainsi. (Ceci est particulièrement vrai une fois que le logiciel a été déployé en production et vous n'avez aucun moyen de joindre un
  débogueur...)

Étant donné que .NET ne vous permettent pas de modifier le Message de l'Exception pour inclure des informations supplémentaires, quel est le mécanisme prévu pour attraper origine des exceptions?

Il est vrai que .NET ne vous permettent pas de modifier le Message de l'Exception. Il constitue un autre mécanisme toutefois de fournir des informations supplémentaires à une Exception via le Exception.Data dictionnaire. Donc, si tout ce que vous voulez faire est d'ajouter des données supplémentaires d'une exception, il n'y a aucune raison pour envelopper l'exception d'origine et de lancer une nouvelle. Au lieu de faire juste:

public void DoStuff(String filename)
{
    try {
       //Some file I/O here...
    }
    catch (IOException ex) {

      //Add filename to the IOException
      ex.Data.Add("Filename", filename);

      //Send the exception along its way
      throw;
    }
}