Wie kann ich Ausnahmen abfangen, die von einem separaten Thread in .NET ausgelöst werden?

In verschiedenen Threads ausgelöste Ausnahmen abfangen: Ein umfassender Leitfaden

Dieser Artikel befasst sich mit dem häufigen Problem der Erfassung von Ausnahmen, die in separaten Threads vom Aufruf ausgelöst werden Verfahren. Das Problem tritt auf, wenn eine Methode (Methode1) einen neuen Thread erzeugt und während der Ausführung in diesem Thread (Methode2) eine Ausnahme auftritt. Die Herausforderung besteht darin, diese Ausnahmeinformationen zurück an Methode 1 zu übertragen.

Lösung

In .NET 4 und späteren Versionen ist die Task Klasse bietet eine elegante Lösung. Mit dieser Klasse können Sie:

1. Separate Ausnahmebehandlung in Aufgaben-Threads

Bei diesem Ansatz können Sie die Ausnahme im Aufgaben-Thread verarbeiten, wie im folgenden Codeausschnitt dargestellt:

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>

2. Behandeln Sie Ausnahmen im Thread des Aufrufers

Alternativ können Sie die Ausnahme im Thread des Aufrufers mit diesem Code verarbeiten:

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>

Beachten Sie, dass die erhaltenen Ausnahmen vom Typ AggregateException sind, mit die tatsächlichen Ausnahmen, die in der ex.InnerExceptions-Eigenschaft gespeichert sind.

.NET 3.5 Lösung

In .NET 3.5 gibt es zwei Ansätze:

1. Ausnahmebehandlung 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>

2. Ausnahmebehandlung im Thread des Anrufers

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

Das obige ist der detaillierte Inhalt vonWie kann ich Ausnahmen abfangen, die von einem separaten Thread in .NET ausgelöst werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!