Is there a way to block or assert on accidental recursion in c#

Question

I am working with a large and complex event driven body of code and there are piles of opportunity to accidentally create a recursive condition.

Sometimes the recursive condition is temporary and the application catches up with itself but even that usually creates unnecessary lag. Other times it creates a stackoverflow which is often very difficult to debug when it happens at a client site.

I would like to have a way to either blacklist or whitelist sections of code that are permitted to recurse. If the recursive condition happens during DEV then I want it to assert so that I can correct the code.

What I am considering is having the application examine its own stack to ensure that the method it just entered is not already on the stack.

Any pointers would be appreciated.

Note: This is for a Web Application but I have run into this challenge in multiple environments.

Answer 1

You can inspect stack like this:

[MethodImpl(MethodImplOptions.NoInlining)]
// optionally decorate with Conditional to only be used in Debug configuration
[Conditional("DEBUG")]
public static void FailIfCallerIsRecursive() {
    var trace = new StackTrace();
    // previous frame is the caller
    var caller = trace.GetFrame(1).GetMethod();
    // inspect the rest
    for (int i = 2; i < trace.FrameCount; i++) {
        // if found caller somewhere up the stack - throw
        if (trace.GetFrame(i).GetMethod() == caller)
            throw new Exception("Recursion detected");
    }            
}

Then just call it a the beginning:

void MyPotentiallyRecursiveMethod() {
    FailIfCallerIsRecursive()
}

But note that it's quite expensive. However since you are going to use that only in dev (debug) configuration - why not. You can also modify it a bit to throw only when certain level of recursion is detected (so caller appears X time up the stack).

Answer 2

You could call the RuntimeHelpers.EnsureSufficientExecutionStack method and then catch the InsufficientExecutionStackException that is thrown if the next method call would cause a (not catchable) StackOverflowException.

You could create an extension method for it:

public static T EnsureSafeRecursiveCall<T>(this Func<T> method)
{
    try
    {
        RuntimeHelpers.EnsureSufficientExecutionStack();
        return method();
    }
    catch (InsufficientExecutionStackException ex)
    {
        string msg = $"{method.Method.Name} would cause a {nameof(StackOverflowException)} on the next call";
        Debug.Fail(msg);
        // logging here is essential here because Debug.Fail works only with debug
        throw new StackOverflowException(msg, ex); // wrap in new exception to avoid that we get into this catch again and again(note we are in a recursive call)
    }
}

Now your original method remains almost unchanged:

public static IEnumerable<T> YourRecursiveMethod<T>(IEnumerable<T> seq)
{
    var method = new Func<IEnumerable<T>>(() => YourRecursiveMethod(seq));
    return method.EnsureSafeRecursiveCall();
}