Come monitorare un thread di vitale importanza

Question

Ho un thread di lavoro che è di vitale importanza per la mia applicazione.
Viene creato con new Thread(method).Start(); Non ci faccio parte, mi aspetto che venga eseguito finché il mio programma è in esecuzione.
Tuttavia, può succedere che si verifichi un'eccezione su questo thread; e come conseguenza il thread sarà (a parte qualche ultimo logging) shutdown. Un recupero non è possibile per questo errore critico. Poiché il thread è di vitale importanza per l'app, deve anche essere chiuso.

Ora la mia domanda è: Come posso monitorare lo stato del mio thread?

Volete

• sondaggio proprietà IsAlive?
• rilancia l'eccezione rilevata e funziona con AppDomain.CurrentDomain.UnhandledException?
• implementare uno event che segnalerà la fine del mio thread in background?
• utilizzare un BackgroundWorker, che implementa RunWorkerCompleted? (Ma un BackgroundWorker è davvero la scelta giusta per i thread di lunga durata?)
• qualcosa di completamente diverso?

EDIT:
In questo momento, ho risolto il problema chiamando Application.Exit() ->incidente presto e spesso. Questo è un'opzione, troppo :)

Answer 1

Perché non avvolgere le routine di thread principale in questo modo:

void ThreadStart() 
{ 
     try 
     { 
      ThreadImplementation();   
     } 
     catch (Exception e) 
     { 
      mainForm.BeginInvoke(OnBackgroundThreadException, e); 
     } 
} 

Questo farà in modo che si ottiene un messaggio sul thread principale dell'applicazione ogni volta che il filo fa un anomalo spegnimento. Non hai bisogno di sondare nulla. Un BackgroundWorker è in genere utile quando è necessario tornare al thread dell'interfaccia utente in modo asincrono. (I.E. aggiornamenti di progresso).

Answer 2

Alla fine del gestore di eccezioni del tuo thread, invocare un metodo di callback sul thread principale e riavviare il lavoratore:

public delegate void AbnormalExitDelegate(object errorArgs); 

class Boss 
{ 
    Worker worker; 
    void Start() 
    { 
     worker = new Worker(); 
     worker.AbnormalExitCallback = new AbnormalExitDelegate(AbnormalExit); 
     Thread workerThread = new Thread(worker.DoWork); 
     workerThread.Start(); 
    } 
    public void AbnormalExit(object errorArgs) 
    { 
     Start(); 
    } 
} 
class Worker 
{ 
    public AbnormalExitDelegate AbnormalExitCallback; 
    public void DoWork() 
    { 
     try 
     { 
      // do work here 
     } 
     catch (Exception ex) 
     { 
      // pass stuff back, like the exception 
      AbnormalExitCallback(ex); 
     } 
    } 
}