Comment passer d'exception explicitement pour le thread principal en c#

Je suis familier avec le fait que l'exception levée dans un thread, normalement, ne pouvait pas être pris dans un autre thread.
Comment puis-je transférer l'erreur cependant pour le thread principal?

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
    //...
  }
}

OriginalL'auteur user829174 | 2012-01-08

c#multithreading

Si vous êtes en utilisant .NET 4 il ya de meilleures façons de le faire avec Tasks, mais si vous avez besoin d'utiliser Threads...

Si votre exemple est une application de console, votre Principale méthode de sortie, peut-être avant Go commence à s'exécuter. Donc votre "fil conducteur" peut ne pas exister lorsque l'exception est levée. Pour arrêter cela, vous avez besoin d'une synchronisation.

Quelque chose comme cela devrait le faire:

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

Si c'est une INTERFACE d'application, les choses sont un peu plus facile. Vous aurez besoin de passer une référence à votre thread d'INTERFACE utilisateur dans le Go méthode afin qu'il sache où envoyer l'exception. La meilleure façon de le faire est de passer le SynchronizationContext de le thread d'INTERFACE utilisateur.

Quelque chose de ce genre:

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

OriginalL'auteur Nicholas Butler

7

Si C# 4.0 est disponible pour vous, alors vous pouvez utiliser un Task au lieu d'un Thread. Les exceptions non traitées dans le Task sont automatiquement propagées à l'joindre le fil. Voir ici: http://msdn.microsoft.com/en-us/library/dd997415.aspx pour les exemples et les exceptions à cette règle.

C# 4.0 n'est pas disponible

OriginalL'auteur Tudor
2

Vous pouvez vous abonner à général les exceptions non gérées au niveau application.

OriginalL'auteur Tormod

C'est vraiment un vieux thread mais j'ai une approche originale à cette question, je vais donc mettre ma solution ici.

Le principal objectif dans mon cas, le thread principal est interrompu par exception à ce moment que l'enfant fil s'est l'exception, au lieu de la surveillance ou de l'attente, comme proposé dans d'autres réponses.
Comme il a été dit dans d'autres threads, on peut pas le faire avec la manière traditionnelle, mais nous pouvons envoyer interruption de l'autre thread, le thread principal.

L'envoi d'interrompre le thread principal génère ThreadInterruptedException sur le thread principal. Afin de l'attraper dans le thread principal et la vérification de tous les drapeau levé par l'autre thread va faire les détails de l'exception transfert.

Voici un exemple minimal (vous pouvez le rompre pour les classes et de faire mieux la conception plus tard)

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

OriginalL'auteur Rami Yampolsky

0

Je suppose que votre soi-disant "fil conducteur" doit interroger ou attendre pour les exceptions. Cela peut être fait avec une file d'attente et un sémaphore.
```
catch( Exception ex )
{
   lock( queueLock )
   {
      queue.Enqueue( ex )
      semaphore.Release();
   }

}
```
Dans votre thread principal vous pouvez interroger ou d'attendre le sémaphore.

OriginalL'auteur Thomas Maierhofer

Vous devez vous connecter pour publier un commentaire.