Pourquoi exception non gérée dans un thread d'arrière-plan ne marche pas planter le domaine de l'application?

Je suis complètement perplexe. J'étais tellement persuadé que .NET ferme l'ensemble du domaine d'application s'il est uncaught exception dans un sujet que je n'ai jamais testé cette.

Cependant, je viens d'essayer le code suivant et il ne s'agit pas... quelqu'un Pourrait-il expliquer pourquoi?

(Essayé .NET 4 et 3.5)

static void Main(string[] args)
{
    Console.WriteLine("Main thread {0}", Thread.CurrentThread.ManagedThreadId);

    Action a = new Action(() =>
    {
        Console.WriteLine("Background thread {0}", Thread.CurrentThread.ManagedThreadId);

        throw new ApplicationException("test exception");
    });

    a.BeginInvoke(null, null);

    Console.ReadLine();
}

OriginalL'auteur Boppity Bop | 2011-06-24

  1. 9

    Ce qui se passe parce que les BeginInvoke utilise ThreadPool en interne et lors de la ThreadPool tout unhadled exceptions seront silence l'échec. Toutefois, si vous utilisez a.EndInvoke puis le unhadled exception sera jeter à la EndInvoke méthode.

    Remarque: comme João Angelo a déclaré que l'utilisation ThreadPool méthodes directement "comme ThreadPool.QueueUserWorkItems et UnsafeQueueUserWorkItem" lève des exceptions à la 2.0 et au-dessus.

    -1: Votre réponse suggère également que l'appel ThreadPool.QueueUserWorkItem avec une méthode qui renvoie une exception entraînera l'exception d'être mangé par le cadre, qui n'est pas vrai dans la version 2.0 et après.
    Angelo: Le pool de threads en général ne va pas lancer des exceptions, par exemple le nouveau C# 4.0 Tâche ne sera pas lancer des exceptions, mais à l'ivresse.Attendre méthode comme la méthode EndInvoke.
    Vous avez ABSOLUMENT raison. Je suis juste stupide!
    encore une fois, ce qui est une caractéristique de la Task Parallel Library et pas du Pool de Threads. Essayez d'utiliser le pool de threads directement et l'exception ne sera pas réduite au silence.
    oui vous avez raison, thx.

    OriginalL'auteur

  2. 6

    De Exceptions dans la gestion des Threads sur MSDN:

    Dans le .NET Framework version 2.0, le
    common language runtime permet à la plupart des
    les exceptions non gérées dans des threads
    procéder de façon naturelle. Dans la plupart des cas, ce
    signifie que l'exception non gérée
    les causes de l'application de terminer.

    C'est un changement significatif de la
    .NET Framework version 1.0 et 1.1,
    qui fournissent un filet de sécurité pour de nombreux
    les exceptions non gérées — par exemple,
    les exceptions non gérées dans le pool de thread
    les threads. Voir Changement par rapport à la
    Les Versions plus loin dans cette rubrique.

    Temporaire de compatibilité de la mesure,
    les administrateurs peuvent placer une
    indicateur de compatibilité dans le
    la section de l'application
    fichier de configuration. Cela provoque la
    common language runtime pour revenir à
    le comportement des versions 1.0 et 1.1.

    <legacyUnhandledExceptionPolicy enabled="1"/>
    Jon merci pour l'effort, mais vous n'avez pas lu la question ... La question est exactement POURQUOI il n'A PAS échoué. Cheers
    J'ai compris la question, je vais vous dire ce que le guide officiel est sur elle, et de vous donner quelques raisons possibles (framework version, paramètre de configuration), et de quelques autres de lecture pour comprendre ce qui se passe 🙂
    Est snappish critique la façon dont vous toujours de répondre à des étrangers qui tentent de vous aider gratuitement? Comment cela fonctionne pour vous?

    OriginalL'auteur

  3. 3

    Normalement avec asynchrone délégués si le délégué de la méthode lève une exception, le thread est terminé et l'exception est renvoyée de nouveau dans le code appelant seulement lorsque vous appelez EndInvoke.

    C'est pourquoi lors de l'utilisation asynchrone délégué ( BeginInvoke ), vous devez toujours appeler EndInvoke. Aussi, ce ne doit pas être confondu avec Control.BeginInvoke qui peut être appelé dans un incendie, et de l'oublier.

    Plus tôt, j'ai dit normalement, car il ya une possibilité pour vous d'affirmer que l'exception doit être ignoré si le délégué de la méthode renvoie void. Pour ce faire, vous devez marquer la méthode avec le OneWay attribut.

    Si vous exécutez l'exemple suivant, vous obtenez seulement une exception lors de l'appel de willNotIgnoreThrow.EndInvoke.

    static void Throws()
{
    Console.WriteLine("Thread: {0}", Thread.CurrentThread.ManagedThreadId);

    throw new ApplicationException("Test 1");
}

[OneWay]
static void ThrowsButIsIgnored()
{
    Console.WriteLine("Thread: {0}", Thread.CurrentThread.ManagedThreadId);

    throw new ApplicationException("Test 2");
}

static void Main(string[] args)
{
    Console.WriteLine("Main: {0}", Thread.CurrentThread.ManagedThreadId);

    var willIgnoreThrow = new Action(ThrowsButIsIgnored);
    var result1 = willIgnoreThrow.BeginInvoke(null, null);

    Console.ReadLine();
    willIgnoreThrow.EndInvoke(result1);

    Console.WriteLine("============================");

    var willNotIgnoreThrow = new Action(Throws);
    var result2 = willNotIgnoreThrow.BeginInvoke(null, null);

    Console.ReadLine();
    willNotIgnoreThrow.EndInvoke(result2);
}
    Anonyme Downvoter, le soin d'expliquer pourquoi pensez-vous ne pas répondre à l'OP question?
    Du mieux que je peux travailler Bobb est en train de juger toutes les questions que +1 ou -1, et à défaut de comprendre ce qu'est un downvote est pour
    rien à voir avec moi. ce n'est pas de mauvaise réponse.

    OriginalL'auteur

  4. 0

    parce exception jeter sur le fils y demeure, sauf si elle est réutilisée pour le thread principal.

    C'est ce que backgroundWorker fait pour vous, si vous avez exception dans le BackgroundWorker du fil, il obtient la levée de nouveau sur le thread principal.

    a.BeginInvoke(null, null);

    cela fait appel asynchrone, ce qui crée un autre thread pour exécuter cette

    vous mélangez un "thread d'arrière-plan" et classe BackgroundWorker.
    pas vraiment, BackgroundWorker crée le thread d'arrière-plan. La seule différence entre le mode normal fil et le dos thread est que le thread ne marche pas accueillir jusqu'à votre calendrier à partir de la clôture en baisse, alors que vous avez à attendre pour la normale de fil pour terminer son travail.

    OriginalL'auteur