C # captura uma exceção de estouro de pilha

Eu tenho uma chamada recursiva para um método que lança uma exceção de estouro de pilha. A primeira chamada é cercada por um bloco try catch, mas a exceção não é detectada.

A exceção de estouro de pilha se comporta de maneira especial? Posso capturar / manipular a exceção adequadamente?

Não tenho certeza se relevante, mas informações adicionais:

• a exceção não é lançada no tópico principal

• o objeto onde o código está lançando a exceção é carregado manualmente por Assembly.LoadFrom (...). CreateInstance (...)

A partir do 2.0, uma exceção StackOverflow só pode ser detectada nas seguintes circunstâncias.

1. O CLR está sendo executado em um ambiente hospedado ^* onde o host permite especificamente que as exceções StackOverflow sejam tratadas
2. A exceção stackoverflow é lançada pelo código do usuário e não devido a uma situação real de estouro de pilha ( Referência )

_{^* "ambiente hospedado" como em "meu código hospeda CLR e eu configuro as opções de CLR" e não "meu código é executado em hospedagem compartilhada"}

O jeito certo é consertar o estouro, mas ....

Você pode obter uma pilha maior: -

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

Você pode usar a propriedade System.Diagnostics.StackTrace FrameCount para contar os quadros usados ​​e lançar sua própria exceção quando um limite de quadro for atingido.

Ou você pode calcular o tamanho da pilha restante e lançar sua própria exceção quando cair abaixo de um limite: -

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

Basta pegar o queijo. ;)

Na página do MSDN em StackOverflowException s:

Em versões anteriores do .NET Framework, seu aplicativo podia capturar um objeto StackOverflowException (por exemplo, para se recuperar de recursão ilimitada). No entanto, essa prática é atualmente desencorajada porque um código adicional significativo é necessário para capturar de forma confiável uma exceção de estouro de pilha e continuar a execução do programa.

A partir do .NET Framework versão 2.0, um objeto StackOverflowException não pode ser detectado por um bloco try-catch e o processo correspondente é encerrado por padrão. Consequentemente, os usuários são aconselhados a escrever seu código para detectar e evitar um estouro de pilha. Por exemplo, se seu aplicativo depende da recursão, use um contador ou uma condição de estado para encerrar o loop recursivo. Observe que um aplicativo que hospeda o common language runtime (CLR) pode especificar que o CLR descarregue o domínio do aplicativo onde ocorre a exceção de estouro de pilha e deixe o processo correspondente continuar. Para obter mais informações, consulte ICLRPolicyManager Interface e Hosting the Common Language Runtime.

Como vários usuários já disseram, você não pode pegar a exceção. No entanto, se você está lutando para descobrir onde está acontecendo, você pode configurar o visual studio para quebrar quando for lançado.

Para fazer isso, você precisa abrir as Configurações de exceção no menu 'Depurar'. Em versões mais antigas do Visual Studio, isso está em 'Debug' - 'Exceptions'; nas versões mais recentes, está em 'Debug' - 'Windows' - 'Configurações de exceção'.

Depois de abrir as configurações, expanda 'Common Language Runtime Exceptions', expanda 'System', role para baixo e marque 'System.StackOverflowException'. Em seguida, você pode examinar a pilha de chamadas e procurar o padrão de repetição das chamadas. Isso deve dar uma ideia de onde procurar para consertar o código que está causando o estouro da pilha.

Conforme mencionado acima várias vezes, não é possível capturar uma StackOverflowException que foi gerada pelo sistema devido a um estado de processo corrompido. Mas há uma maneira de perceber a exceção como um evento:

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

A partir do .NET Framework versão 4, esse evento não é gerado para exceções que corrompem o estado do processo, como estouro de pilha ou violações de acesso, a menos que o manipulador de eventos seja crítico para a segurança e tenha o atributo HandleProcessCorruptedStateExceptionsAttribute.

No entanto, seu aplicativo será encerrado após sair da função de evento (uma solução MUITO suja, era reiniciar o aplicativo dentro deste evento haha, não fiz isso e nunca farei). Mas é bom o suficiente para registrar!

No .NET Framework versões 1.0 e 1.1, uma exceção não tratada que ocorre em um thread diferente do thread do aplicativo principal é capturada pelo tempo de execução e, portanto, não causa o encerramento do aplicativo. Portanto, é possível que o evento UnhandledException seja gerado sem que o aplicativo seja encerrado. A partir do .NET Framework versão 2.0, este backstop para exceções não tratadas em threads filho foi removido, porque o efeito cumulativo de tais falhas silenciosas incluía degradação de desempenho, dados corrompidos e travamentos, todos difíceis de depurar. Para obter mais informações, incluindo uma lista de casos em que o tempo de execução não termina, consulte Exceções em threads gerenciados.

Sim, no CLR 2.0, o estouro de pilha é considerado uma situação irrecuperável. Portanto, o tempo de execução ainda encerra o processo.

Para obter detalhes, consulte a documentação http://msdn.microsoft.com/en-us/library/system.stackoverflowexception.aspx

Você não pode. O CLR não vai deixar você. Um estouro de pilha é um erro fatal e não pode ser recuperado.

Você não pode, como a maioria das postagens está explicando, deixe-me adicionar outra área:

Em muitos sites você encontrará pessoas dizendo que a maneira de evitar isso é usar um AppDomain diferente, portanto, se isso acontecer, o domínio será descarregado. Isso é absolutamente errado (a menos que você hospede seu CLR), pois o comportamento padrão do CLR irá gerar um evento KillProcess, derrubando seu AppDomain padrão.

É impossível, e por um bom motivo (por exemplo, pense em todos aqueles catch (Exception) {} ao redor).

Se você deseja continuar a execução após o estouro da pilha, execute o código perigoso em um AppDomain diferente. As políticas CLR podem ser definidas para encerrar o AppDomain atual em estouro sem afetar o domínio original.