Mendapatkan semua pesan dari InnerException (s)?

Apakah ada cara untuk menulis kode "tangan pendek" gaya LINQ untuk berjalan ke semua tingkat InnerException (s) of Exception yang dilempar? Saya lebih suka menulisnya di tempat daripada memanggil fungsi ekstensi (seperti di bawah) atau mewarisi Exceptionkelas.

static class Extensions
{
    public static string GetaAllMessages(this Exception exp)
    {
        string message = string.Empty;
        Exception innerException = exp;

        do
        {
            message = message + (string.IsNullOrEmpty(innerException.Message) ? string.Empty : innerException.Message);
            innerException = innerException.InnerException;
        }
        while (innerException != null);

        return message;
    }
}; 

Sayangnya LINQ tidak menawarkan metode yang dapat memproses struktur hierarki, hanya koleksi.

Saya sebenarnya memiliki beberapa metode ekstensi yang dapat membantu melakukan ini. Saya tidak memiliki kode pasti di tangan tetapi mereka seperti ini:

// all error checking left out for brevity

// a.k.a., linked list style enumerator
public static IEnumerable<TSource> FromHierarchy<TSource>(
    this TSource source,
    Func<TSource, TSource> nextItem,
    Func<TSource, bool> canContinue)
{
    for (var current = source; canContinue(current); current = nextItem(current))
    {
        yield return current;
    }
}

public static IEnumerable<TSource> FromHierarchy<TSource>(
    this TSource source,
    Func<TSource, TSource> nextItem)
    where TSource : class
{
    return FromHierarchy(source, nextItem, s => s != null);
}

Kemudian dalam hal ini Anda dapat melakukan ini untuk menghitung melalui pengecualian:

public static string GetaAllMessages(this Exception exception)
{
    var messages = exception.FromHierarchy(ex => ex.InnerException)
        .Select(ex => ex.Message);
    return String.Join(Environment.NewLine, messages);
}

Maksudmu seperti ini?

public static class Extensions
{
    public static IEnumerable<Exception> GetInnerExceptions(this Exception ex)
    {
        if (ex == null)
        {
            throw new ArgumentNullException("ex");
        }

        var innerException = ex;
        do
        {
            yield return innerException;
            innerException = innerException.InnerException;
        }
        while (innerException != null);
    }
}

Dengan cara ini Anda bisa LINQ di seluruh hierarki pengecualian Anda, seperti ini:

exception.GetInnerExceptions().Where(e => e.Message == "Oops!");

Bagaimana dengan kode ini:

private static string GetExceptionMessages(this Exception e, string msgs = "")
{
  if (e == null) return string.Empty;
  if (msgs == "") msgs = e.Message;
  if (e.InnerException != null)
    msgs += "\r\nInnerException: " + GetExceptionMessages(e.InnerException);
  return msgs;
}

Pemakaian:

Console.WriteLine(e.GetExceptionMessages())

Contoh keluaran:

Tidak ada endpoint yang mendengarkan di http: //nnn.mmm.kkk.ppp: 8000 / routingservice / router yang dapat menerima pesan tersebut. Ini sering disebabkan oleh alamat yang salah atau tindakan SOAP. Lihat InnerException, jika ada, untuk detail selengkapnya.

InnerException: Tidak dapat terhubung ke server jarak jauh

InnerException: Tidak ada koneksi yang dapat dibuat karena mesin target secara aktif menolaknya 127.0.0.1:8000

Saya tahu ini jelas, tetapi mungkin tidak untuk semua.

exc.ToString();

Ini akan melalui semua pengecualian batin Anda dan mengembalikan semua pesan, tetapi bersama dengan jejak tumpukan dll.

Anda tidak memerlukan metode ekstensi atau panggilan rekursif:

try {
  // Code that throws exception
}
catch (Exception e)
{
  var messages = new List<string>();
  do
  {
    messages.Add(e.Message);
    e = e.InnerException;
  }
  while (e != null) ;
  var message = string.Join(" - ", messages);
}

LINQ umumnya digunakan untuk bekerja dengan kumpulan objek. Namun, bisa dibilang, dalam kasus Anda tidak ada kumpulan objek (kecuali grafik). Jadi meskipun beberapa kode LINQ dimungkinkan, IMHO akan agak berbelit-belit atau artifisial.

Di sisi lain, contoh Anda terlihat seperti contoh utama di mana metode penyuluhan sebenarnya masuk akal. Belum lagi masalah seperti penggunaan kembali, enkapsulasi, dll.

Saya akan tetap menggunakan metode ekstensi, meskipun saya mungkin telah menerapkannya seperti itu:

public static string GetAllMessages(this Exception ex)
{
   if (ex == null)
     throw new ArgumentNullException("ex");

   StringBuilder sb = new StringBuilder();

   while (ex != null)
   {
      if (!string.IsNullOrEmpty(ex.Message))
      {
         if (sb.Length > 0)
           sb.Append(" ");

         sb.Append(ex.Message);
      }

      ex = ex.InnerException;
   }

   return sb.ToString();
}

Tapi itu sebagian besar masalah selera.

Saya tidak berpikir demikian, pengecualian bukanlah IEnumerable sehingga Anda tidak dapat melakukan kueri LINQ terhadapnya sendiri.

Metode ekstensi untuk mengembalikan pengecualian dalam akan bekerja seperti ini

public static class ExceptionExtensions
{
    public static IEnumerable<Exception> InnerExceptions(this Exception exception)
    {
        Exception ex = exception;

        while (ex != null)
        {
            yield return ex;
            ex = ex.InnerException;
        }
    }
}

Anda kemudian dapat menambahkan semua pesan menggunakan query linq seperti ini:

var allMessageText = string.Concat(exception.InnerExceptions().Select(e => e.Message + ","));

Untuk menambahkan ke orang lain, Anda mungkin ingin mengizinkan pengguna memutuskan cara memisahkan pesan:

    public static string GetAllMessages(this Exception ex, string separator = "\r\nInnerException: ")
    {
        if (ex.InnerException == null)
            return ex.Message;

        return ex.Message + separator + GetAllMessages(ex.InnerException, separator);
    }

    public static string GetExceptionMessage(Exception ex)
    {
        if (ex.InnerException == null)
        {
            return string.Concat(ex.Message, System.Environment.NewLine, ex.StackTrace);
        }
        else
        {
            // Retira a última mensagem da pilha que já foi retornada na recursividade anterior
            // (senão a última exceção - que não tem InnerException - vai cair no último else, retornando a mesma mensagem já retornada na passagem anterior)
            if (ex.InnerException.InnerException == null)
                return ex.InnerException.Message;
            else
                return string.Concat(string.Concat(ex.InnerException.Message, System.Environment.NewLine, ex.StackTrace), System.Environment.NewLine, GetExceptionMessage(ex.InnerException));
        }
    }

Saya hanya akan meninggalkan versi paling ringkas di sini:

public static class ExceptionExtensions
{
    public static string GetMessageWithInner(this Exception ex) =>
        string.Join($";{ Environment.NewLine }caused by: ",
            GetInnerExceptions(ex).Select(e => $"'{ e.Message }'"));

    public static IEnumerable<Exception> GetInnerExceptions(this Exception ex)
    {
        while (ex != null)
        {
            yield return ex;
            ex = ex.InnerException;
        }
    }
}

public static class ExceptionExtensions
{
    public static IEnumerable<Exception> GetAllExceptions(this Exception ex)
    {
        Exception currentEx = ex;
        yield return currentEx;
        while (currentEx.InnerException != null)
        {
            currentEx = currentEx.InnerException;
            yield return currentEx;
        }
    }

    public static IEnumerable<string> GetAllExceptionAsString(this Exception ex)
    {            
        Exception currentEx = ex;
        yield return currentEx.ToString();
        while (currentEx.InnerException != null)
        {
            currentEx = currentEx.InnerException;
            yield return currentEx.ToString();
        }            
    }

    public static IEnumerable<string> GetAllExceptionMessages(this Exception ex)
    {
        Exception currentEx = ex;
        yield return currentEx.Message;
        while (currentEx.InnerException != null)
        {
            currentEx = currentEx.InnerException;
            yield return currentEx.Message;
        }
    }
}

Sebagian besar solusi yang disajikan di sini memiliki kesalahan implementasi berikut:

• menangani nullpengecualian
• menangani pengecualian bagian dalam dari AggregateException
• tentukan kedalaman maksimum untuk pengecualian dalam berulang (yaitu dengan ketergantungan melingkar)

Implementasi yang lebih baik adalah di sini:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

public static string AggregateMessages(this Exception ex) =>
    ex.GetInnerExceptions()
        .Aggregate(
            new StringBuilder(),
            (sb, e) => sb.AppendLine(e.Message),
            sb => sb.ToString());

public static IEnumerable<Exception> GetInnerExceptions(this Exception ex, int maxDepth = 5)
{
    if (ex == null || maxDepth <= 0)
    {
        yield break;
    }

    yield return ex;

    if (ex is AggregateException ax)
    {
        foreach(var i in ax.InnerExceptions.SelectMany(ie => GetInnerExceptions(ie, maxDepth - 1)))
            yield return i;
    }

    foreach (var i in GetInnerExceptions(ex.InnerException, maxDepth - 1))
        yield return i;
}

Contoh penggunaan:

try
{
    // ...
}
catch(Exception e)
{
    Log.Error(e, e.AggregateMessages());
}