AppDomain.FirstChanceException e eccezione di overflow dello stack

Question

Sto utilizzando l'evento FirstChanceException per registrare i dettagli di eventuali eccezioni generate.

static void Main(string[] args) 
{ 
    AppDomain.CurrentDomain.FirstChanceException += (sender, eventArgs) => 
    { 
     Console.WriteLine("Inside first chance exception."); 
    }; 

    throw new Exception("Exception thrown in main."); 
} 

Funziona come previsto. Ma se viene lanciata un'eccezione all'interno del gestore eventi, si verificherà un overflow dello stack poiché l'evento verrà generato in modo ricorsivo.

static void Main(string[] args) 
{ 
    AppDomain.CurrentDomain.FirstChanceException += (sender, eventArgs) => 
    { 
     throw new Exception("Stackoverflow"); 
    }; 

    throw new Exception("Exception thrown in main."); 
} 

Come si gestiscono le eccezioni che si verificano all'interno del gestore eventi?

Edit:

Ci sono alcune risposte suggeriscono che ho avvolgere il codice all'interno del gestore di eventi in un blocco try/catch, ma questo non funziona in quanto l'evento viene generato prima che l'eccezione può essere gestita.

static void Main(string[] args) 
{ 
    AppDomain.CurrentDomain.FirstChanceException += (sender, eventArgs) => 
    { 
     try 
     { 
      throw new Exception("Stackoverflow"); 
     } 
     catch 
     { 
     } 
    }; 

    throw new Exception("Exception thrown in main."); 
} 

Answer 1

In deroga generale è possibile gestire come tutti gli altri, ma per quanto riguarda, in particolare, ad eccezione StackOverflow e OutOfMemory, non possono essere gestiti in .NET Framework.

Guardate qui: How do I prevent and/or handle a StackOverflowException? (C#)

partire dalla versione .NET Framework 2.0, un oggetto StackOverflowException non può essere catturato da un blocco try-catch e il corrispondente processo è terminato per impostazione predefinita. Di conseguenza, gli utenti sono invitati a scrivere il codice per rilevare e impedire uno stack overflow. Ad esempio, se l'applicazione dipende dalla ricorsione, utilizzare un contatore o una condizione per terminare il ciclo ricorsivo.

Answer 2

Penso aggiungendo un altro try {} catch(){} blocco del gestore di eccezioni avrebbe aiutato

static void Main(string[] args) 
{ 
    AppDomain.CurrentDomain.FirstChanceException += (sender, eventArgs) => 
    { 
     try { 
      throw new Exception("Stackoverflow"); 
     } catch (Exception e) 
     { 
      // Do something very simple not throwing an exception... 
     } 
    }; 

    throw new Exception("Exception thrown in main."); 
} 

Answer 3

maniglia interna eccezioni manualmente per esempio

static void Main(string[] args) { 
    AppDomain.CurrentDomain.FirstChanceException += (sender, eventArgs) => 
    { 
     try{ 
     throw new Exception("Stackoverflow");} catch (Exception ex){/*manual handle*/} 
    }; 
     throw new Exception("Exception thrown in main."); 
} 

Answer 4

L'articolo di MSDN si è collegato fa alcune raccomandazioni:

È necessario gestire tutte le eccezioni che si verificano nel gestore di eventi per l'evento FirstChanceException. Altrimenti, FirstChanceException viene generato in modo ricorsivo. Ciò potrebbe comportare un sovraccarico dello stack e la chiusura dell'applicazione. Si consiglia di implementare gestori di eventi per questo evento come aree di esecuzione vincolate (CER), per evitare che le eccezioni relative all'infrastruttura, come l'esaurimento della memoria o dello stack, influiscano sulla macchina virtuale durante l'elaborazione della notifica di eccezione.

Così racchiudono la funzione all'interno di un blocco try/catch, e chiamare PrepareConstrainedRegion prima del blocco per evitare eccezioni OutOfMemory: http://msdn.microsoft.com/en-us/library/system.runtime.compilerservices.runtimehelpers.prepareconstrainedregions.aspx

Edit: Beh, avete ancora il problema ricorsione anche con l'try/blocco di cattura. Quindi ... Immagino che devi solo chiamare solo un codice sicuro che non creerà alcuna eccezione. Quel gestore di eventi sembra abbastanza pericoloso, consiglierei di usarlo solo per scopi di debug.

Answer 5

Prima utilizzare un metodo, invece di un delegato, quindi il nome del metodo sarà definito

Quindi utilizzare Environment.StackTrace per verificare se il metodo è già nella stacktrace

Ecco un pezzo di codice non testati:

static void Main(string[] args) 
{ 
    AppDomain.CurrentDomain.FirstChanceException += handleFirstChanceException; 
} 

private void handleFirstChanceException(object sender, EventArgs eventArgs) 
{ 
    if (Environment.StackTrace.Contains("handleFirstChanceException")) 
     return; 

    // handle 
} 

credo che quanto sopra non funziona, perché sarà sempre contiene il nome del metodo, ma si può contare, se apparire più di 1 volta. Inoltre, controlla che non sia in linea quando compili in modalità di rilascio, in questo caso sei in difficoltà

Answer 6

Anche se non è un buon modo, in VB .NET puoi impedire l'attivazione di eccezioni all'interno del gestore di eventi FirstChanceException usando " In errore Riprendi successiva "istruzione, proveniente da VB 6. (Non sono sicuro che C# abbia qualcosa di simile) Inoltre, dovresti impedire la ricorsione sul gestore di eventi come menzionato here. Di seguito è riportato il codice di esempio, sembra funzionare come previsto.

Sub Main(args As String()) 
    AddHandler AppDomain.CurrentDomain.FirstChanceException, AddressOf FirstChanceExceptionEventHandler 
    Throw New Exception("Exception thrown in main.") 
End Sub 

Private Sub FirstChanceExceptionEventHandler(ByVal source As Object, ByVal e As FirstChanceExceptionEventArgs) 
    On Error Resume Next 

    Dim frames As StackFrame() = New StackTrace(1).GetFrames() 
    Dim currentMethod As MethodBase = MethodBase.GetCurrentMethod() 
    If frames IsNot Nothing AndAlso frames.Any(Function(x) x.GetMethod() = currentMethod) Then 
     Return 
    Else 
     Throw New Exception("Stackoverflow") 
    End If 
End Sub 

Answer 7

Questo è il lavoro per me:

private volatile bool _insideFirstChanceExceptionHandler;  

// ... 

AppDomain.CurrentDomain.FirstChanceException += OnFirstChanceException; 

// ... 

private void OnFirstChanceException(object sender, FirstChanceExceptionEventArgs args) 
{ 
    if (_insideFirstChanceExceptionHandler) 
    { 
     // Prevent recursion if an exception is thrown inside this method 
     return; 
    } 

    _insideFirstChanceExceptionHandler = true; 
    try 
    { 
     // Code which may throw an exception 
    } 
    catch 
    { 
     // You have to catch all exceptions inside this method 
    } 
    finally 
    { 
     _insideFirstChanceExceptionHandler = false; 
    } 
}