C # rileva un'eccezione di overflow dello stack

Ho una chiamata ricorsiva a un metodo che genera un'eccezione di overflow dello stack. La prima chiamata è circondata da un blocco try catch ma l'eccezione non viene rilevata.

L'eccezione di overflow dello stack si comporta in modo speciale? Posso rilevare / gestire correttamente l'eccezione?

Non sono sicuro se pertinente, ma informazioni aggiuntive:

• l'eccezione non viene generata nel thread principale

• l'oggetto in cui il codice genera l'eccezione viene caricato manualmente da Assembly.LoadFrom (...). CreateInstance (...)

A partire dalla 2.0, un'eccezione StackOverflow può essere rilevata solo nelle seguenti circostanze.

1. Il CLR viene eseguito in un ambiente ospitato ^{* in} cui l'host consente specificamente di gestire le eccezioni StackOverflow
2. L'eccezione stackoverflow viene generata dal codice utente e non a causa di una situazione di overflow dello stack effettiva ( riferimento )

_{^* "ambiente ospitato" come in "il mio codice ospita CLR e configuro le opzioni di CLR" e non "il mio codice viene eseguito su hosting condiviso"}

Il modo giusto è riparare l'overflow, ma ...

Puoi darti uno stack più grande: -

using System.Threading;
Thread T = new Thread(threadDelegate, stackSizeInBytes);
T.Start();

Puoi utilizzare la proprietà System.Diagnostics.StackTrace FrameCount per contare i frame che hai utilizzato e generare la tua eccezione quando viene raggiunto un limite di frame.

Oppure puoi calcolare la dimensione dello stack rimanente e lanciare la tua eccezione quando scende al di sotto di una soglia: -

class Program
{
    static int n;
    static int topOfStack;
    const int stackSize = 1000000; // Default?

    // The func is 76 bytes, but we need space to unwind the exception.
    const int spaceRequired = 18*1024; 

    unsafe static void Main(string[] args)
    {
        int var;
        topOfStack = (int)&var;

        n=0;
        recurse();
    }

    unsafe static void recurse()
    {
        int remaining;
        remaining = stackSize - (topOfStack - (int)&remaining);
        if (remaining < spaceRequired)
            throw new Exception("Cheese");
        n++;
        recurse();
    }
}

Prendi il formaggio. ;)

Dalla pagina MSDN su StackOverflowException s:

Nelle versioni precedenti di .NET Framework, l'applicazione poteva rilevare un oggetto StackOverflowException (ad esempio, per ripristinare da ricorsione illimitata). Tuttavia, tale pratica è attualmente sconsigliata perché è necessario un codice aggiuntivo significativo per rilevare in modo affidabile un'eccezione di overflow dello stack e continuare l'esecuzione del programma.

A partire da .NET Framework versione 2.0, un oggetto StackOverflowException non può essere intercettato da un blocco try-catch e il processo corrispondente viene terminato per impostazione predefinita. Di conseguenza, si consiglia agli utenti di scrivere il proprio codice per rilevare e prevenire un overflow dello stack. Ad esempio, se l'applicazione dipende dalla ricorsione, utilizzare un contatore o una condizione di stato per terminare il ciclo ricorsivo. Si noti che un'applicazione che ospita il Common Language Runtime (CLR) può specificare che CLR scarica il dominio dell'applicazione in cui si verifica l'eccezione di overflow dello stack e lascia che il processo corrispondente continui. Per ulteriori informazioni, vedere Interfaccia ICLRPolicyManager e Hosting di Common Language Runtime.

Come hanno già detto diversi utenti, non puoi catturare l'eccezione. Tuttavia, se hai difficoltà a scoprire dove sta accadendo, potresti voler configurare Visual Studio in modo che si interrompa quando viene lanciato.

Per farlo, devi aprire le Impostazioni delle eccezioni dal menu "Debug". Nelle versioni precedenti di Visual Studio, si trova in "Debug" - "Eccezioni"; nelle versioni più recenti, si trova su "Debug" - "Windows" - "Impostazioni eccezioni".

Una volta aperte le impostazioni, espandere "Eccezioni Common Language Runtime", espandere "Sistema", scorrere verso il basso e selezionare "System.StackOverflowException". Quindi puoi guardare lo stack di chiamate e cercare lo schema ripetitivo delle chiamate. Questo dovrebbe darti un'idea di dove cercare per correggere il codice che causa l'overflow dello stack.

Come accennato in precedenza più volte, non è possibile catturare un'eccezione StackOverflowException che è stata generata dal sistema a causa dello stato del processo danneggiato. Ma c'è un modo per notare l'eccezione come un evento:

http://msdn.microsoft.com/en-us/library/system.appdomain.unhandledexception.aspx

A partire dalla versione 4 di .NET Framework, questo evento non viene generato per le eccezioni che danneggiano lo stato del processo, come overflow dello stack o violazioni di accesso, a meno che il gestore eventi non sia critico per la sicurezza e abbia l'attributo HandleProcessCorructedStateExceptionsAttribute.

Tuttavia la tua applicazione terminerà dopo essere uscito dalla funzione evento (una soluzione MOLTO sporca, era riavviare l'app all'interno di questo evento haha, non l'ho fatto e non lo farà mai). Ma è abbastanza buono per la registrazione!

Nelle versioni di .NET Framework 1.0 e 1.1, un'eccezione non gestita che si verifica in un thread diverso dal thread dell'applicazione principale viene rilevata dal runtime e pertanto non causa la chiusura dell'applicazione. Pertanto, è possibile che l'evento UnhandledException venga generato senza che l'applicazione venga terminata. A partire da .NET Framework versione 2.0, questo backstop per le eccezioni non gestite nei thread figlio è stato rimosso, poiché l'effetto cumulativo di tali errori silenziosi includeva degrado delle prestazioni, dati danneggiati e blocchi, tutti difficili da eseguire il debug. Per ulteriori informazioni, incluso un elenco di casi in cui il runtime non viene terminato, vedere Eccezioni nei thread gestiti.

Sì da CLR 2.0 lo stack overflow è considerato una situazione non recuperabile. Quindi il runtime interrompe ancora il processo.

Per i dettagli, consultare la documentazione http://msdn.microsoft.com/en-us/library/system.stackoverflowexception.aspx

Non puoi. Il CLR non te lo permetterà. Un overflow dello stack è un errore irreversibile e non può essere ripristinato.

Non puoi come spiegano la maggior parte dei post, lasciami aggiungere un'altra area:

Su molti siti web troverai persone che dicono che il modo per evitarlo è usare un AppDomain diverso, quindi se ciò accade il dominio verrà scaricato. Questo è assolutamente sbagliato (a meno che tu non ospiti il ​​tuo CLR) poiché il comportamento predefinito del CLR genererà un evento KillProcess, abbattendo il tuo AppDomain predefinito.

È impossibile, e per una buona ragione (per esempio, pensa a tutte quelle catture (Eccezione) {} in giro).

Se vuoi continuare l'esecuzione dopo l'overflow dello stack, esegui codice pericoloso in un AppDomain diverso. I criteri CLR possono essere impostati per terminare l'AppDomain corrente in caso di overflow senza influire sul dominio originale.