ইনারএক্সসেপশন (গুলি) থেকে সমস্ত বার্তা পাচ্ছেন?

Question 1

ব্যাতিক্রমের ইনারেক্সেপশন (গুলি) এর সমস্ত স্তরে হাঁটার জন্য একটি লিনকিউ স্টাইল "শর্ট হ্যান্ড" কোড লেখার কোনও উপায় আছে কি? আমি এটি কোনও এক্সটেনশন ফাংশন (নীচের হিসাবে) কল করার পরিবর্তে বা Exceptionশ্রেণীর উত্তরাধিকার সূত্রে লিখতে পছন্দ করব ।

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;
    }
};

Question 2

দুর্ভাগ্যক্রমে লিনকুই এমন পদ্ধতিগুলি সরবরাহ করে না যা শ্রেণিবদ্ধ কাঠামো প্রক্রিয়া করতে পারে, কেবল সংগ্রহগুলি।

আমার কাছে আসলে কিছু এক্সটেনশন পদ্ধতি রয়েছে যা এটি করতে সহায়তা করতে পারে। আমার হাতে সঠিক কোড নেই তবে এগুলি এরকম কিছু:

// 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);
}

তারপরে এই ক্ষেত্রে ব্যতিক্রমগুলি গণনার জন্য আপনি এটি করতে পারেন:

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

Question 3

তুমি এরকম কিছু বোঝাতে চাও?

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);
    }
}

আপনি আপনার সম্পূর্ণ ব্যতিক্রম শ্রেণিবিন্যাসের উপরে এইভাবে লিনকিউ করতে পারেন:

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

Question 4

এই কোড সম্পর্কে:

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;
}

ব্যবহার:

Console.WriteLine(e.GetExceptionMessages())

আউটপুট উদাহরণ:

এই বার্তাটি গ্রহণ করতে পারে এমন কোনও HTTP: //nnn.mmm.kkk.ppp: 8000 / রাউটিংসার্ভিস / রাউটারে কোনও শেষ পয়েন্ট শোনেনি। এটি প্রায়শই কোনও ভুল ঠিকানা বা এসওএপি ক্রিয়া দ্বারা ঘটে থাকে। আরও তথ্যের জন্য অন্তর্ভুক্তিটি উপস্থিত থাকলে দেখুন।

অভ্যন্তরীণ ধারণা: দূরবর্তী সার্ভারে সংযোগ করতে অক্ষম

অভ্যন্তরীণ ধারণা: কোনও সংযোগ তৈরি করা যায়নি কারণ টার্গেট মেশিন সক্রিয়ভাবে এটি অস্বীকার করেছে 127.0.0.1:8000

Question 5

আমি জানি এটি সুস্পষ্ট, তবে সম্ভবত সবার জন্য নয়।

exc.ToString();

এটি আপনার সমস্ত অভ্যন্তরীণ ব্যতিক্রমগুলির মধ্য দিয়ে যাবে এবং সমস্ত বার্তা ফেরত পাঠাবে, তবে স্ট্যাক ট্রেস ইত্যাদির সাথে with

Question 6

আপনার এক্সটেনশন পদ্ধতি বা পুনরাবৃত্তি কলগুলির প্রয়োজন নেই:

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);
}

Question 7

লিনকিউ সাধারণত বস্তুর সংগ্রহের সাথে কাজ করতে ব্যবহৃত হয়। তবে, যুক্তিযুক্তভাবে, আপনার ক্ষেত্রে অবজেক্টগুলির কোনও সংগ্রহ নেই (তবে একটি গ্রাফ)। সুতরাং কিছু লিনকিউ কোড সম্ভব হলেও, আইএমএইচও এটি বরং সংশ্লেষিত বা কৃত্রিম হবে।

অন্যদিকে, আপনার উদাহরণটি মূল উদাহরণের মতো দেখায় যেখানে এক্সটেনশন পদ্ধতিগুলি আসলে যুক্তিসঙ্গত। পুনরায় ব্যবহার, এনক্যাপসুলেশন ইত্যাদির মতো বিষয়ে কথা বলতে হবে না

আমি কোনও এক্সটেনশন পদ্ধতিতে থাকব, যদিও আমি এটি সেভাবে প্রয়োগ করেছিলাম:

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();
}

তবে এটি মূলত স্বাদের একটি বিষয়।

Question 8

আমার মনে হয় না, ব্যতিক্রম কোনও আইএনওমারেবল নয় তাই আপনি নিজেরাই এর বিরুদ্ধে একটি লিনক কোয়েরি করতে পারবেন না।

অভ্যন্তরীণ ব্যতিক্রমগুলি ফিরিয়ে আনতে একটি এক্সটেনশন পদ্ধতি এটির মতো কাজ করবে

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

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

তারপরে আপনি এই জাতীয় লিঙ্ক কোয়েরি ব্যবহার করে সমস্ত বার্তা যুক্ত করতে পারেন:

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

Question 9

অন্যকে যুক্ত করতে আপনি ব্যবহারকারীকে কীভাবে বার্তাগুলি পৃথক করবেন সে বিষয়ে সিদ্ধান্ত নিতে দিতে পারেন:

    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);
    }

Question 10

    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));
        }
    }

Question 11

আমি এখানে সর্বাধিক সংক্ষিপ্ত সংস্করণটি ছেড়ে যাচ্ছি:

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;
        }
    }
}

Question 12

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;
        }
    }
}

Question 13

এখানে পূর্বনির্ধারিত বেশিরভাগ সমাধানে নিম্নলিখিত প্রয়োগের ত্রুটি রয়েছে:

nullব্যতিক্রমগুলি পরিচালনা করুন
এর অভ্যন্তরীণ ব্যতিক্রমগুলি পরিচালনা করুন AggregateException
অভ্যন্তরীণ ব্যতিক্রমগুলি পুনরাবৃত্তি করার জন্য সর্বাধিক গভীরতা নির্ধারণ করুন (যেমন: বিজ্ঞপ্তি নির্ভরতা)

একটি ভাল বাস্তবায়ন এটি এখানে:

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;
}

ব্যবহারের উদাহরণ:

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