Wie fängt man Ausnahmen ab, die in verschiedenen Threads in C# ausgelöst werden?

In verschiedenen Threads ausgelöste Ausnahmen abfangen

Bei der Multithread-Programmierung kann es schwierig sein, Ausnahmen zu behandeln, die in anderen Threads als dem auftreten Hauptthread. Dieses Problem tritt auf, wenn eine Methode (Methode1) einen neuen Thread erzeugt und dieser Thread eine andere Methode (Methode2) ausführt, die eine Ausnahme auslöst. Die Frage ist, wie diese Ausnahme in Methode 1 erfasst werden kann.

Lösung für .NET 4 und höher

Für .NET 4 und spätere Versionen: Task Die Klasse bietet eine praktische Lösung. Es ermöglicht Ihnen, Ausnahmen mithilfe der .Exceptions-Eigenschaft des Aufgabenobjekts abzurufen. Hier sind zwei Ansätze:

• Behandeln von Ausnahmen im Aufgabenthread:

  class Program
  {
      static void Main(string[] args)
      {
          Task<int> task = new Task<int>(Test);
          task.ContinueWith(ExceptionHandler, TaskContinuationOptions.OnlyOnFaulted);
          task.Start();
          Console.ReadLine();
      }
  
      static int Test()
      {
          throw new Exception();
      }
  
      static void ExceptionHandler(Task<int> task)
      {
          var exception = task.Exception;
          Console.WriteLine(exception);
      }
  }</int></int></int>

• Behandeln von Ausnahmen in Anrufer Thread:

  class Program
  {
      static void Main(string[] args)
      {
          Task<int> task = new Task<int>(Test);
          task.Start();
  
          try
          {
              task.Wait();
          }
          catch (AggregateException ex)
          {
              Console.WriteLine(ex);
          }
  
          Console.ReadLine();
      }
  
      static int Test()
      {
          throw new Exception();
      }
  }</int></int>

In beiden Fällen erhalten Sie eine AggregateException und die tatsächlichen Ausnahmen sind über ex.InnerExceptions zugänglich.

Lösung für .NET 3.5

Für .NET 3.5 können Sie Folgendes verwenden Ansätze:

• Behandeln von Ausnahmen im untergeordneten Thread:

  class Program
  {
      static void Main(string[] args)
      {
          Exception exception = null;
          Thread thread = new Thread(() => SafeExecute(() => Test(0, 0), Handler));
          thread.Start();
  
          Console.ReadLine();
      }
  
      private static void Handler(Exception exception)
      {
          Console.WriteLine(exception);
      }
  
      private static void SafeExecute(Action test, Action<exception> handler)
      {
          try
          {
              test.Invoke();
          }
          catch (Exception ex)
          {
              Handler(ex);
          }
      }
  
      static void Test(int a, int b)
      {
          throw new Exception();
      }
  }</exception>

• Behandeln von Ausnahmen im Anrufer-Thread:

  class Program
  {
      static void Main(string[] args)
      {
          Exception exception = null;
          Thread thread = new Thread(() => SafeExecute(() => Test(0, 0), out exception));
  
          thread.Start();
  
          thread.Join();
  
          Console.WriteLine(exception);
  
          Console.ReadLine();
      }
  
      private static void SafeExecute(Action test, out Exception exception)
      {
          exception = null;
  
          try
          {
              test.Invoke();
          }
          catch (Exception ex)
          {
              exception = ex;
          }
      }
  
      static void Test(int a, int b)
      {
          throw new Exception();
      }
  }

Diese Optionen Bieten Sie Flexibilität bei der Behandlung von Ausnahmen in Multithread-Szenarien und stellen Sie so ein robustes Fehlermanagement in Ihren Anwendungen sicher.

Das obige ist der detaillierte Inhalt vonWie fängt man Ausnahmen ab, die in verschiedenen Threads in C# ausgelöst werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!