Why does setting a static method result in a stack overflow?

Question

I am wondering why, when in C#, if a use the set accessor to change a static class member, I get a Stack Overflow error.

I am not disputing this as a bug, I just want to know what exactly is going on in the internals of the machine.

EDIT :The question was a little unclear, sorry about that.

Answer 1

You shouldn't; I expect you have something like:

private static int foo;
public static int Foo {
    get {return foo;}
    set {Foo = value;} // spot the typo!!! (should be foo)
}

Essentially, the set is:

static void set_Foo(int value) {
    set_Foo(value);
}

so this is recursive, and will eventually consume up the stack (assuming no optimisations, etc).

It is impossible to diagnose more without a code sample.

Answer 2

Look at your call stack in the debugger (you do stop when exceptions are thrown, right?) This should give you a strong indication of what's going on.

Answer 3

You want to know what's going on in the internals to cause the stack overflow?

Your method calls another method that results in infinite recursion: A calls A, stack overflow. A calls B, then B calls A, stack overflow. And so on.

As Marc Gravell suggested, it's likely theres a bug in your property implementation.

Answer 4

I'm guessing you're doing something like this:

public class MyClass
{
    public int TheInt
    {
    get
    {
     return TheInt;
    }
    set
    {
     TheInt = value; // assignment = recursion!
    }
}

The problem is, in the set function for TheInt, you're assigning a value to TheInt which will result in a nested call to the set function. You get recursion, and then a stack overflow.

Answer 5

I think I see a different interpretation of the question. Where the question isn't why the overflow happens, but why accessors can cause overflows. In this case, the accessor is a function call just like any other, and so it does consume stack space.

If you're using public members with no accessors, MyClass.myint doesn't become a function call, and can't overflow the stack.