Wie gehen Ausnahme explizit zu den wichtigsten Threads in c#

Ich bin vertraut mit der Tatsache, dass die Ausnahme in einem thread normalerweise gar nicht sein gefangen in einem anderen thread.
Wie kann ich die Fehler allerdings, den Faden?

public static void Main()
{
   new Thread (Go).Start();
}

static void Go()
{
  try
  {
    //...
    throw null;    //The NullReferenceException will get caught below
    //...
  }
  catch (Exception ex)
  {
    //Typically log the exception, and/or signal another thread
    //that we've come unstuck
    //...
  }
}
InformationsquelleAutor user829174 | 2012-01-08
  1. 6

    Wenn Sie .NET 4 gibt es bessere Möglichkeiten, dies zu tun mit Tasks, aber vorausgesetzt, Sie verwenden müssen Threads...

    Wenn Ihr Beispiel ist eine Konsolenanwendung, dann Ihre Main-Methode verlassen, möglicherweise vor Go beginnt mit der Ausführung. So Ihr "Haupt-thread" kann nicht existieren, wenn die exception geworfen wird. Um dies zu stoppen, müssen Sie einige Synchronisation.

    Etwas soll dies gerne tun:

    static Exception _ThreadException = null;

public static void Main()
{
    var t = new Thread ( Go );
    t.Start();

    //this blocks this thread until the worker thread completes
    t.Join();

    //now see if there was an exception
    if ( _ThreadException != null ) HandleException( _ThreadException );
}

static void HandleException( Exception ex )
{
    //this will be run on the main thread
}

static void Go()
{
    try
    {
        //...
        throw null;    //The NullReferenceException will get caught below
        //...
    }
    catch (Exception ex) 
    {
        _ThreadException = ex;
    }
}

    Ist dies ein UI-app, die Dinge ein bisschen einfacher. Sie wird sich übergeben zu müssen, einen Hinweis auf Ihre UI-thread in der Go - Methode, damit es weiß, wo zu senden die Ausnahme. Der beste Weg, dies zu tun ist die übergabe der SynchronizationContext von der UI-thread.

    Etwas wie dies funktionieren würde:

    public static void Main()
{
    var ui = SynchronizationContext.Current;
    new Thread ( () => Go( ui ) ).Start();
}

static void HandleException( Exception ex )
{
    //this will be run on the UI thread
}

static void Go( SynchronizationContext ui )
{
    try
    {
        //...
        throw null;    //The NullReferenceException will get caught below
        //...
    }
    catch (Exception ex) 
    {
        ui.Send( state => HandleException( ex ), null );
    }
}
    InformationsquelleAutor Nicholas Butler
  2. 7

    Wenn C# 4.0 ist verfügbar, um Sie, dann können Sie einen Task statt einer Thread. Nicht abgefangene Ausnahmen in der Task werden automatisch übertragen, den Beitritt thread. Siehe hier: http://msdn.microsoft.com/en-us/library/dd997415.aspx für Beispiele und Ausnahmen von dieser Regel.

    • C# 4.0 ist nicht verfügbar
    InformationsquelleAutor Tudor
  3. 2

    Abonnieren Sie die Allgemeinen unbehandelte Ausnahmen an die app-Ebene.

    InformationsquelleAutor Tormod
  4. 2

    Dies ist ein wirklich Alter thread, aber ich habe einen originellen Ansatz, um dieses Problem so werde ich meine Lösung hier.

    Das Hauptziel in meinem Fall war, dass der main-thread wird unterbrochen durch eine Ausnahme im moment, dass das Kind thread bekam die Ausnahme, statt zu überwachen oder zu warten, wie vorgeschlagen, andere Antworten.
    Wie schon gesagt worden ist in anderen threads, wir können nicht mit konventionellen Weg, aber wir können senden interrupt aus, der andere thread den Haupt-thread.

    Sendet interrupt an den Haupt-thread erzeugt ThreadInterruptedException auf dem Haupt-thread. So fangen Sie es in den Haupt-thread und prüfen die fahne gehoben durch den anderen thread tun wird die Ausnahme details übertragen als gut.

    Ist hier ein minimal-Beispiel (Sie können es brechen, um Klassen und besser machen design später)

    static void Main(string[] args)
    {


        //initialize the second thread ***************************
        Exception exFromThread = null;

        Thread thread = new Thread((mainThread) =>
        {
            Thread.Sleep(1000);
            exFromThread = new Exception("Exception from other thread");
            ((Thread)mainThread).Interrupt(); //makes the main thread get exception
        });

        thread.Start(Thread.CurrentThread);
        //********************************************************

        try
        {
            //This loop represents your main thread logic
            for (int i = 0; true; i++)
            {
                Thread.Sleep(500);
                Console.WriteLine("main thread logic: " + i);
            }
        }
        catch (ThreadInterruptedException ex)
        {
            Console.WriteLine("Thread have been interrupted");
            Console.WriteLine(exFromThread.Message);
        }

        Console.WriteLine("Press any key..");

        Console.ReadLine();
    }
    InformationsquelleAutor Rami Yampolsky
  5. 0

    Ich davon aus, dass deine so genannten "Haupt-thread" sollte Umfrage, oder warten Sie für Ausnahmen. Diese kann getan werden, mit einer Warteschlange und einer semaphore. 

    catch( Exception ex )
{
   lock( queueLock )
   {
      queue.Enqueue( ex )
      semaphore.Release();
   }

}

    In der main-thread kann man Umfrage oder warten, bis die semaphore.

    InformationsquelleAutor Thomas Maierhofer
Schreibe einen Kommentar