Wie kann ich eine StackOverflowException verhindern und / oder behandeln?

HINWEIS Die Frage in die bounty von @WilliamJockusch und die ursprüngliche Frage sind unterschiedlich.

Diese Antwort ist über StackOverflow ist im Allgemeinen Fall von third-party-Bibliotheken und-was Sie kann/nicht kann. Wenn Sie auf der Suche über den speziellen Fall mit XslTransform finden Sie die akzeptierte Antwort.

Stack-overflows passieren, weil die Daten auf dem stack einen bestimmten Grenzwert überschreitet (in bytes). Die details, wie diese Erkennung funktioniert, finden Sie hier.

Frage ich mich, ob es einen Allgemeinen Weg, um track down StackOverflowExceptions. In anderen Worten, nehmen wir an ich habe eine unendliche Rekursion irgendwo in meinem code, aber ich habe keine Ahnung wo. Ich will es aufspüren, die von einigen bedeutet, dass ist einfacher als den code schrittweise alle über dem Platz, bis ich sehen, es geschieht. Ist mir egal, wie hackish es ist.

Als ich oben in den link, die Erkennung eines stack-überlauf von der statischen code-Analyse erforderlich wäre die Lösung das Halteproblem ist unentscheidbaren. Jetzt haben wir festgestellt, dass es gibt keine silberne Kugel, ich kann Ihnen zeigen, ein paar tricks, die ich denke, hilft, das problem zurückzuverfolgen.

Ich denke, diese Frage kann Verschieden interpretiert werden, und da bin ich ein wenig gelangweilt :-), werde ich brechen Sie in verschiedenen Variationen.

Erkennung eines stack-überlauf in einem test-Umgebung

Grundsätzlich das problem hier ist, dass Sie eine (begrenzte) test-Umgebung und entdecken wollen, einen stack-überlauf in einem (erweiterten) Produktionsumgebung.

Statt erkennen das SO an sich, ich wird dieses Problem durch die Ausnutzung der Tatsache, dass die stack-Tiefe eingestellt werden kann. Der debugger gibt Ihnen alle Informationen, die Sie benötigen. Die meisten Sprachen können Sie angeben, die stack-Größe oder die max Rekursionstiefe.

Im Grunde versuche ich zu erzwingen, indem Sie die stack-Tiefe so klein wie möglich. Wenn es nicht überläuft, kann ich immer machen, größer (=in diesem Fall: sicherer) für die Produktionsumgebung. Im moment bekommen Sie einen stack-überlauf, können Sie manuell entscheiden, ob es ein "Gültiger" oder nicht.

Um dies zu tun, übergeben Sie die stack-Größe (in unserem Fall: ein kleiner Wert), um einen Thread-parameter, und sehen, was passiert. Die Standard-stack-Größe .NET ist 1 MB ist, verwenden wir eine Art kleiner Wert:

class StackOverflowDetector
{
    static int Recur()
    {
        int variable = 1;
        return variable + Recur();
    }

    static void Start()
    {
        int depth = 1 + Recur();
    }

    static void Main(string[] args)
    {
        Thread t = new Thread(Start, 1);
        t.Start();
        t.Join();
        Console.WriteLine();
        Console.ReadLine();
    }
}

Hinweis: wir verwenden diesen code unten, wie gut.

Sobald es läuft, können Sie es auf einen größeren Wert, bis Sie ein, SO dass macht Sinn.

Erstellen von Ausnahmen vor, die Sie SO

Den StackOverflowException ist nicht abfangbar. Dies bedeutet, dass es nicht viel Sie tun können, wenn es passiert ist. So, wenn Sie glauben, etwas ist verpflichtet, die schief gehen in Ihrem code, können Sie Ihre eigenen Ausnahme in einigen Fällen. Das einzige, was Sie dazu brauchen, ist der aktuelle stack-Tiefe; es gibt keine Notwendigkeit für einen Schalter, die Sie verwenden können, die echte Werte aus .NET:

class StackOverflowDetector
{
    static void CheckStackDepth()
    {
        if (new StackTrace().FrameCount > 10) //some arbitrary limit
        {
            throw new StackOverflowException("Bad thread.");
        }
    }

    static int Recur()
    {
        CheckStackDepth();
        int variable = 1;
        return variable + Recur();
    }

    static void Main(string[] args)
    {
        try
        {
            int depth = 1 + Recur();
        }
        catch (ThreadAbortException e)
        {
            Console.WriteLine("We've been a {0}", e.ExceptionState);
        }
        Console.WriteLine();
        Console.ReadLine();
    }
}

Beachten Sie, dass dieser Ansatz funktioniert auch, wenn Sie Umgang mit den third-party-Komponenten, die mit einem callback-Mechanismus. Das einzige, was erforderlich ist, dass Sie abfangen können einige fordert in dem stack-trace.

Erkennung in einem separaten thread

Du explizit vorgeschlagen, so hier geht.

Können Sie versuchen, erkennen Sie dies in einem eigenen thread.. aber wahrscheinlich wird es nicht tun Sie etwas gutes. Ein stack-überlauf passieren kann schnell, noch bevor man sich ein Kontext-switch. Dies bedeutet, dass dieser Mechanismus nicht zuverlässig bei allen... würde ich nicht empfehlen, tatsächlich. Es war lustig zu bauen, aber, so ist hier der code 🙂

class StackOverflowDetector
{
    static int Recur()
    {
        Thread.Sleep(1); //simulate that we're actually doing something :-)
        int variable = 1;
        return variable + Recur();
    }

    static void Start()
    {
        try
        {
            int depth = 1 + Recur();
        }
        catch (ThreadAbortException e)
        {
            Console.WriteLine("We've been a {0}", e.ExceptionState);
        }
    }

    static void Main(string[] args)
    {
        //Prepare the execution thread
        Thread t = new Thread(Start);
        t.Priority = ThreadPriority.Lowest;

        //Create the watch thread
        Thread watcher = new Thread(Watcher);
        watcher.Priority = ThreadPriority.Highest;
        watcher.Start(t);

        //Start the execution thread
        t.Start();
        t.Join();

        watcher.Abort();
        Console.WriteLine();
        Console.ReadLine();
    }

    private static void Watcher(object o)
    {
        Thread towatch = (Thread)o;

        while (true)
        {
            if (towatch.ThreadState == System.Threading.ThreadState.Running)
            {
                towatch.Suspend();
                var frames = new System.Diagnostics.StackTrace(towatch, false);
                if (frames.FrameCount > 20)
                {
                    towatch.Resume();
                    towatch.Abort("Bad bad thread!");
                }
                else
                {
                    towatch.Resume();
                }
            }
        }
    }
}

Führen Sie diese in den debugger und Spaß haben, was passiert.

Über die Merkmale von einem stack-überlauf

Andere interpretation deiner Frage ist: "Wo sind die Teile des Codes, die möglicherweise zu einem stack-überlauf Ausnahme?". Offensichtlich wird die Antwort HIERFÜR ist: alle Codes mit Rekursion. Für jedes Stück code, können Sie eine manuelle Analyse.

Ist es auch möglich zu ermitteln, diese mithilfe von statische code-Analyse. Was Sie tun müssen, ist zu dekompilieren, alle Methoden und herauszufinden, ob Sie enthalten eine unendliche Rekursion. Hier ist etwas code, der dies für Sie übernimmt:

//A simple decompiler that extracts all method tokens (that is: call, callvirt, newobj in IL)
internal class Decompiler
{
    private Decompiler() { }

    static Decompiler()
    {
        singleByteOpcodes = new OpCode[0x100];
        multiByteOpcodes = new OpCode[0x100];
        FieldInfo[] infoArray1 = typeof(OpCodes).GetFields();
        for (int num1 = 0; num1 < infoArray1.Length; num1++)
        {
            FieldInfo info1 = infoArray1[num1];
            if (info1.FieldType == typeof(OpCode))
            {
                OpCode code1 = (OpCode)info1.GetValue(null);
                ushort num2 = (ushort)code1.Value;
                if (num2 < 0x100)
                {
                    singleByteOpcodes[(int)num2] = code1;
                }
                else
                {
                    if ((num2 & 0xff00) != 0xfe00)
                    {
                        throw new Exception("Invalid opcode: " + num2.ToString());
                    }
                    multiByteOpcodes[num2 & 0xff] = code1;
                }
            }
        }
    }

    private static OpCode[] singleByteOpcodes;
    private static OpCode[] multiByteOpcodes;

    public static MethodBase[] Decompile(MethodBase mi, byte[] ildata)
    {
        HashSet<MethodBase> result = new HashSet<MethodBase>();

        Module module = mi.Module;

        int position = 0;
        while (position < ildata.Length)
        {
            OpCode code = OpCodes.Nop;

            ushort b = ildata[position++];
            if (b != 0xfe)
            {
                code = singleByteOpcodes[b];
            }
            else
            {
                b = ildata[position++];
                code = multiByteOpcodes[b];
                b |= (ushort)(0xfe00);
            }

            switch (code.OperandType)
            {
                case OperandType.InlineNone:
                    break;
                case OperandType.ShortInlineBrTarget:
                case OperandType.ShortInlineI:
                case OperandType.ShortInlineVar:
                    position += 1;
                    break;
                case OperandType.InlineVar:
                    position += 2;
                    break;
                case OperandType.InlineBrTarget:
                case OperandType.InlineField:
                case OperandType.InlineI:
                case OperandType.InlineSig:
                case OperandType.InlineString:
                case OperandType.InlineTok:
                case OperandType.InlineType:
                case OperandType.ShortInlineR:
                    position += 4;
                    break;
                case OperandType.InlineR:
                case OperandType.InlineI8:
                    position += 8;
                    break;
                case OperandType.InlineSwitch:
                    int count = BitConverter.ToInt32(ildata, position);
                    position += count * 4 + 4;
                    break;

                case OperandType.InlineMethod:
                    int methodId = BitConverter.ToInt32(ildata, position);
                    position += 4;
                    try
                    {
                        if (mi is ConstructorInfo)
                        {
                            result.Add((MethodBase)module.ResolveMember(methodId, mi.DeclaringType.GetGenericArguments(), Type.EmptyTypes));
                        }
                        else
                        {
                            result.Add((MethodBase)module.ResolveMember(methodId, mi.DeclaringType.GetGenericArguments(), mi.GetGenericArguments()));
                        }
                    }
                    catch { } 
                    break;


                default:
                    throw new Exception("Unknown instruction operand; cannot continue. Operand type: " + code.OperandType);
            }
        }
        return result.ToArray();
    }
}

class StackOverflowDetector
{
    //This method will be found:
    static int Recur()
    {
        CheckStackDepth();
        int variable = 1;
        return variable + Recur();
    }

    static void Main(string[] args)
    {
        RecursionDetector();
        Console.WriteLine();
        Console.ReadLine();
    }

    static void RecursionDetector()
    {
        //First decompile all methods in the assembly:
        Dictionary<MethodBase, MethodBase[]> calling = new Dictionary<MethodBase, MethodBase[]>();
        var assembly = typeof(StackOverflowDetector).Assembly;

        foreach (var type in assembly.GetTypes())
        {
            foreach (var member in type.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance).OfType<MethodBase>())
            {
                var body = member.GetMethodBody();
                if (body!=null)
                {
                    var bytes = body.GetILAsByteArray();
                    if (bytes != null)
                    {
                        //Store all the calls of this method:
                        var calls = Decompiler.Decompile(member, bytes);
                        calling[member] = calls;
                    }
                }
            }
        }

        //Check every method:
        foreach (var method in calling.Keys)
        {
            //If method A -> ... -> method A, we have a possible infinite recursion
            CheckRecursion(method, calling, new HashSet<MethodBase>());
        }
    }

Nun, die Tatsache, dass eine Methode Zyklus enthält eine Rekursion, ist keineswegs eine Garantie, dass ein stack-überlauf wird passieren - es ist nur die wahrscheinlichste Voraussetzung für einen stack-überlauf Ausnahme. Kurz gesagt bedeutet dies, dass dieser code bestimmt die code-Stücken, wo ein stack-überlauf kann auftreten, der sollte verengen die meisten code erheblich.

Noch andere Ansätze

Es gibt einige andere Ansätze, die Sie versuchen können, dass ich noch nicht hier beschrieben.

1. Umgang mit der stack-überlauf durch hosting der CLR-Prozess und handling. Beachten Sie, dass Sie noch nicht 'fangen'.
2. Ändern alle IL-code, den Bau einer anderen DLL, hinzufügen, prüft der Rekursion. Ja, das ist durchaus möglich (ich habe es umgesetzt in die Vergangenheit : -), es ist nur schwierig und erfordert eine Menge code, um es richtig zu machen.
3. Verwenden .NET-profiling-API zu erfassen, werden alle Methodenaufrufe verwenden, um herauszufinden, stack-overflows. Zum Beispiel, Sie können implementieren, die prüft, dass, wenn Sie treffen die gleiche Methode X-mal in Ihrem Aufruf Baum, Sie geben ein signal. Es ist ein Projekt,hier, die Ihnen einen Vorsprung.

InformationsquelleAutor der Antwort atlaste

Wenn Sie die Anwendung hängt davon ab, 3d-party-code (in Xsl-Skripten), dann müssen Sie zunächst entscheiden wollen Sie verteidigen von Fehlern in Ihnen oder nicht.
Wenn Sie wirklich wollen, zu verteidigen, dann denke ich, sollten Sie Ihrer Logik, die anfällig für äußere Fehler in separate AppDomains.
Fang StackOverflowException ist nicht gut.

Überprüfen Sie auch diese Frage.

InformationsquelleAutor der Antwort Shrike

Mit .NET 4.0 können Sie die HandleProcessCorruptedStateExceptions Attribut aus dem System.- Laufzeit.ExceptionServices, um die Methode mit try/catch-block. Dies funktionierte wirklich! Vielleicht nicht empfohlen, aber funktioniert.

using System;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.ExceptionServices;

namespace ExceptionCatching
{
    public class Test
    {
        public void StackOverflow()
        {
            StackOverflow();
        }

        public void CustomException()
        {
            throw new Exception();
        }

        public unsafe void AccessViolation()
        {
            byte b = *(byte*)(8762765876);
        }
    }

    class Program
    {
        [HandleProcessCorruptedStateExceptions]
        static void Main(string[] args)
        {
            Test test = new Test();
            try {
                //test.StackOverflow();
                test.AccessViolation();
                //test.CustomException();
            }
            catch
            {
                Console.WriteLine("Caught.");
            }

            Console.WriteLine("End of program");

        }

    }      
}

InformationsquelleAutor der Antwort jdehaan

Durch die Blicke von ihm, abgesehen vom starten von einem anderen Prozess, es scheint nicht zu irgendeiner Weise der Handhabung einer StackOverflowException. Bevor jemand fragt, ich habe versucht, mit AppDomain, aber das hat nicht funktioniert:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;

namespace StackOverflowExceptionAppDomainTest
{
    class Program
    {
        static void recrusiveAlgorithm()
        {
            recrusiveAlgorithm();
        }
        static void Main(string[] args)
        {
            if(args.Length>0&&args[0]=="--child")
            {
                recrusiveAlgorithm();
            }
            else
            {
                var domain = AppDomain.CreateDomain("Child domain to test StackOverflowException in.");
                domain.ExecuteAssembly(Assembly.GetEntryAssembly().CodeBase, new[] { "--child" });
                domain.UnhandledException += (object sender, UnhandledExceptionEventArgs e) =>
                {
                    Console.WriteLine("Detected unhandled exception: " + e.ExceptionObject.ToString());
                };
                while (true)
                {
                    Console.WriteLine("*");
                    Thread.Sleep(1000);
                }
            }
        }
    }
}

Wenn Sie am Ende mit dem trennen-process-Lösung, jedoch würde ich empfehlen, mit Process.Exited und Process.StandardOutput und verarbeiten die Fehler selber, um Ihren Benutzern eine bessere Erfahrung.

InformationsquelleAutor der Antwort Nicholas Mertin

Sind, Lesen Sie bitte diese Eigenschaft alle paar Anrufe Environment.StackTrace , und wenn der stacktrace exceded einen bestimmten Schwellenwert, den Sie voreingestellt haben, können Sie wieder die Funktion.

Sollten Sie auch versuchen, zu ersetzen einige der rekursiven Funktionen mit Schlaufen.

InformationsquelleAutor der Antwort sharp12345