Trouver à l'intérieur de la plupart exception sans l'aide d'une boucle while?

Quand C# déclenche une exception, il peut avoir un intérieur d'exception. Ce que je veux faire est d'obtenir à l'intérieur de la plupart d'exception, ou en d'autres termes, la feuille d'exception qui n'a pas un intérieur d'exception. Je peux le faire dans une boucle while:

while (e.InnerException != null)
{
    e = e.InnerException;
}

Mais je me demandais si il y avait quelques one-liner que je pourrais utiliser pour ce faire à la place.

  • Je me suis levée d'une exception dans une de mes classes, mais ma classe est utilisé par une bibliothèque qui avale toutes les exceptions et jette sa propre. Le problème est, à l'exception de la bibliothèque est très générique et j'ai besoin de savoir qui d'exception, je l'ai jeté à savoir comment gérer le problème. Pour aggraver les choses, la bibliothèque va jeter son propre exception à plusieurs reprises imbriqués les uns dans les autres, à une profondeur arbitraire. Ainsi, par exemple, qu'il va jeter LibraryException -> LibraryException -> LibraryException -> MyException. Mon exception est toujours le dernier sur la chaîne, et ne dispose pas de son propre intérieur d'exception.
  • Oh, je comprends pourquoi vous pourriez étape vers le bas à l'intime, l'ayant fait moi-même (et ses variantes, comme la plus intime qui dérive d'un type particulier), mais je ne comprends pas ce qu'est la question avec ce que vous avez déjà.
  • Oh, je vois ce que tu veux dire. Je me demandais juste si il y avait une autre façon de l'écrire. Je suis tellement habitué à l'utilisation de LINQ à faire à peu près tout ce qu'il me semble bizarre quand je dois écrire une boucle. Je travaille principalement avec les données d'accès donc j'ai assez bien travailler avec ICollections pour presque tout ce que je fais.
  • n'est-ce pas LINQ juste de masquer le fait que le code est essentiellement en boucle? Il n'existe aucun véritable base de jeu commandes .NET?
  • Oui, LINQ de cours utilise des boucles sous les couvertures, mais je n'ai pas à écrire qu'une partie de moi-même. Je préfère écrire list.ForEach(Console.WriteLine) que foreach (var item in list) { Console.WriteLine(item); }.
  • Le plus de la réponse correcte est tapi dans le fond et (actuellement) seulement 2 votes -- Exception.GetBaseException(). Cela a été dans le cadre essentiellement pour toujours. Grâce à batCattle pour la santé mentale-case.
  • stackoverflow.com/a/1456603/1135871 peut également être utile.
  • Peut-être utile gist.github.com/benbrandt22/8676438
  • Double Possible de la Bonne façon de gérer InnerException arbres?

InformationsquelleAutor Daniel T. | 2010-10-06
  1. 121

    Oneliner 🙂

    while (e.InnerException != null) e = e.InnerException;

    Évidemment, vous ne pouvez pas faire plus simple.

    Comme dit dans cette réponse par Glenn McElhoe, c'est la seule façon fiable.

    InformationsquelleAutor Draco Ater
  2. 115

    Je crois Exception.GetBaseException() fait la même chose que ces solutions.

    Mise en garde: à Partir de diverses observations que nous avons compris qu'il n'est pas toujours littéralement faire la même chose, et dans certains cas, le récursive/itération solution à aller plus loin. Il est généralement les recoins les plus profonds de l'exception, qui est malheureusement incompatible, grâce à certains types d'Exceptions que de remplacer la valeur par défaut. Cependant si vous prenez certains types d'exceptions et de faire raisonnablement sûr qu'ils ne sont pas excentriques (comme AggregateException) alors je m'attends à ce qu'il obtient la légitime intime/première exception.

    • +1 Il n'y a rien comme savoir la BCL afin d'éviter des solutions alambiquées. Clairement, c'est le plus de la réponse correcte.
    • Pour une raison quelconque, GetBaseException() n'ai pas de retour de la première racine exception.
    • Glenn McElhoe a souligné que, en effet GetBaseException() ne permet pas toujours de faire ce que MSDN suggère que nous pouvons nous attendre en général (que "l'Exception qui est la cause d'un ou de plusieurs exceptions suivantes"). Dans AggregateException elle est limitée à la plus faible exception du même type, et peut-être y en a d'autres.
    • Ne fonctionne pas pour mon problème. J'ai un peu plus de niveaux plus bas que ce que cela donne.
    • J'ai utilisé ce ex.GetBaseException().GetBaseException().GetBaseException() pour se rendre à l'deeptest exception.
    • GetBaseException() ne fonctionne pas pour moi, parce que la première exception est un AggregateException.

    InformationsquelleAutor Josh Sutterfield
  3. 15

    Boucle dans InnerExceptions est la seule façon fiable.

    Si l'exception interceptée est un AggregateException, puis GetBaseException() renvoie uniquement les plus intimes AggregateException.

    http://msdn.microsoft.com/en-us/library/system.aggregateexception.getbaseexception.aspx

    • Bonne prise. Merci - qui explique les commentaires ci-dessus où la réponse n'a pas de travail pour certaines personnes. Il est clair que MSDN de la description générale de la "root cause d'un ou de plusieurs exceptions suivantes" n'est pas toujours ce que vous pourriez supposer, puisque les classes dérivées peuvent le remplacer. La vraie règle semble être que toutes les exceptions dans une chaîne d'exceptions "d'accord" sur GetBaseException() & retour le même objet, ce qui semble être le cas pour AggregateException.
    InformationsquelleAutor Glenn McElhoe
  4. 11

    Si vous ne savez pas à quelle profondeur l'intérieur des exceptions sont imbriquées, il n'y a pas moyen de contourner une boucle ou la récursivité.

    Bien sûr, vous pouvez définir une méthode d'extension qui fait abstraction de cette suite:

    public static class ExceptionExtensions
{
    public static Exception GetInnermostException(this Exception e)
    {
        if (e == null)
        {
            throw new ArgumentNullException("e");
        }

        while (e.InnerException != null)
        {
            e = e.InnerException;
        }

        return e;
    }
}
    InformationsquelleAutor dtb
  5. 10

    Je sais que c'est un vieux post, mais je suis surpris que personne n'a suggéré GetBaseException() qui est une méthode de l' Exception classe:

    catch (Exception x)
{
    var baseException = x.GetBaseException();
}

    Cela a été autour depuis .NET 1.1. La Documentation ici:
    http://msdn.microsoft.com/en-us/library/system.exception.getbaseexception(v=vs. 71).aspx

    • En effet il a été indiqué avant le 5 décembre 2012
    InformationsquelleAutor Matt
  6. 1

    Parfois, vous pourriez avoir de nombreuses exceptions internes (beaucoup de barbotage des exceptions).
    Dans ce cas, vous pourriez faire:

    List<Exception> es = new List<Exception>();
while(e.InnerException != null)
{
   es.add(e.InnerException);
   e = e.InnerException
}
    InformationsquelleAutor Ryan Ternier
  7. 1

    Pas tout à fait une ligne, mais à proximité:

            Func<Exception, Exception> last = null;
        last = e => e.InnerException == null ? e : last(e.InnerException);
    InformationsquelleAutor Steve Ellinger
  8. 1

    En fait est si simple, vous pouvez utiliser Exception.GetBaseException()

    Try
      //Your code
Catch ex As Exception
      MessageBox.Show(ex.GetBaseException().Message, My.Settings.MsgBoxTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
End Try
    • Merci pour votre solution! Peu de gens pensent à en VB 😀
    • Et il ya une raison pourquoi! 😛
    InformationsquelleAutor armadillo.mx
  9. 1

    Vous avez une boucle, et d'avoir à boucle, c'est plus propre pour déplacer la boucle dans une fonction séparée.

    J'ai créé une méthode d'extension pour traiter cette question. Elle retourne une liste de toutes les exceptions internes du type spécifié, pourchassant Exception.InnerException et AggregateException.InnerExceptions.

    Mon problème, pourchassant l'intérieur des exceptions a été plus compliqué que d'habitude, parce que les exceptions ont été lancés par les constructeurs des classes qui ont été invoqués par la réflexion. L'exception, nous ont été d'attraper eu un InnerException de type TargetInvocationException, et les exceptions dont nous avons réellement besoin de regarder ont été enfoui au plus profond dans l'arbre.

    public static class ExceptionExtensions
{
    public static IEnumerable<T> innerExceptions<T>(this Exception ex)
        where T : Exception
    {
        var rVal = new List<T>();

        Action<Exception> lambda = null;
        lambda = (x) =>
        {
            var xt = x as T;
            if (xt != null)
                rVal.Add(xt);

            if (x.InnerException != null)
                lambda(x.InnerException);

            var ax = x as AggregateException;
            if (ax != null)
            {
                foreach (var aix in ax.InnerExceptions)
                    lambda(aix);
            }
        };

        lambda(ex);

        return rVal;
    }
}

    L'utilisation est assez simple. Si, par exemple, vous voulez savoir si nous avons rencontré un 

    catch (Exception ex)
{
    var myExes = ex.innerExceptions<MyException>();
    if (myExes.Any(x => x.Message.StartsWith("Encountered my specific error")))
    {
        //...
    }
}
    • Ce Exception.GetBaseException() ?
    • bien trop compliqué à résoudre un problème simple
    InformationsquelleAutor Jeff Dege
  10. 1

    Vous pouvez utiliser la récursivité pour créer une méthode dans une classe utilitaire quelque part.

    public Exception GetFirstException(Exception ex)
{
    if(ex.InnerException == null) { return ex; } //end case
    else { return GetFirstException(ex.InnerException); } //recurse
}

    Utilisation:

    try
{
    //some code here
}
catch (Exception ex)
{
    Exception baseException = GetFirstException(ex);
}

    L'extension de la méthode proposée (bonne idée @dtb)

    public static Exception GetFirstException(this Exception ex)
{
    if(ex.InnerException == null) { return ex; } //end case
    else { return GetFirstException(ex.InnerException); } //recurse
}

    Utilisation:

    try
{
    //some code here
}
catch (Exception ex)
{
    Exception baseException = ex.GetFirstException();
}
    • Utile public static Exception GetOriginalException(this Exception ex) { if (ex.InnerException == null) return ex; return ex.InnerException.GetOriginalException(); }
    • Ne s'applique AggregateException.InnerExceptions ?
    InformationsquelleAutor Brad