Can you cancel the stackoverflow exception in the following code? [closed]

Question

The following code will produce a run-time error, stackoverflow exception.

class Foo
{
    //static Foo foo = new Foo(); // you are not allowed using this approach
    //static readonly Foo foo = new Foo(); // you are not allowed using this approach
    Foo foo = new Foo();
}
class Program
{
    static void Main(string[] args)
    {
        new Foo();
    }
}

The objective is to cancel the exception without

• removing, modifying or commenting out the existing code,
• using the approaches mentioned (and their variants in access modifiers, public, private, etc) as the given comments,
• using try-catch-finally or its variants,
• using attributes,
• using compilation condition,

You are only allowed to add your own code inside the Foo class. How do you cancel the exception at run-time?

Answer 1

Here, another try:

class Foo
{
    //static Foo foo = new Foo(); // you are not allowed using this approach
    //static readonly Foo foo = new Foo(); // you are not allowed using this approach
    Foo foo = new Foo();
    MWAHAHAHA, THIS LINE GIVES A COMPILE ERROR! NO STACKOVERFLOW EXCEPTION ANYMORE! LOL
}
class Program
{
    static void Main(string[] args)
    {
        new Foo();
    }
}

Answer 2

How about this?

class Foo
{
    //static Foo foo = new Foo(); // you are not allowed using this approach
    //static readonly Foo foo = new Foo(); // you are not allowed using this approach
    String str = @"
    Foo foo = new Foo();
    ";
}
class Program
{
    static void Main(string[] args)
    {
        new Foo();
    }
}

Answer 3

class Foo
{
    public class Bar
    {
        Foo foo = new Foo();
    }
}
class Program
{
    static void Main(string[] args)
    {
        new Foo();
    }
}

I don't have a C# compiler at hand, but I suspect this might work. The idea is to put the definition in a nested class, such that foo would only be assigned if an instance of Bar is created. Now, the problem is that (I believe) the nested class needs to be public. I don't know if this is a rule violation, i.e. that the rule applies to any use of an access modifier, or only if applied to foo. (Could someone who can compile C# please try this with and without the public?)

Answer 4

Never wrote C# before, does this work ?

class Foo
{
    Foo fooExit = exitMe();
    //static Foo foo = new Foo(); // you are not allowed using this approach
    //static readonly Foo foo = new Foo(); // you are not allowed using this approach
    Foo foo = new Foo();

    static Foo exitMe()
    {
        System.Environment.Exit(0);
        return null;
    }
}
class Program
{
    static void Main(string[] args)
    {
        new Foo();
    }
}

Answer 5

class Foo
{
    Foo(bool recursion = false)
    {
        if (recursion)
            Foo foo = new Foo();
    }
}
class Program
{
    static void Main(string[] args)
    {
        new Foo();
    }
}

Answer 6

To simplify Florent's code:

class Foo
{
    Foo foo = new Foo();

    static Foo() {
        System.Environment.Exit(1);
    }

}

Answer 7

class Foo
{
    while (true);
    Foo foo = new Foo();
}
class Program
{
    static void Main(string[] args)
    {
        new Foo();
    }
}

Its not a bug, it's a feature!

In case that doesn't work

class Foo
    if(false)
        Foo foo = new Foo();
}

class Program
{

    static void Main(string[] args)
    {
        new Foo();
    }
}

Answer 8

The Answer is:

class Foo
{
    //static Foo foo = new Foo(); // you are not allowed using this approach
    //static readonly Foo foo = new Foo(); // you are not allowed using this approach

    public void Method()
    {
    Foo foo = new Foo();
    }
}
class Program
{
    static void Main(string[] args)
    {
        new Foo();
        Console.ReadLine();
    }
}

Answer 9

Note: The rules changed since I posted this.

That is it:

class Foo
{
    //static Foo foo = new Foo(); // you are not allowed using this approach
    //static readonly Foo foo = new Foo(); // you are not allowed using this approach
    Foo foo = null; // Removing code != modifying.
}
class Program
{
    static void Main(string[] args)
    {
        new Foo();
    }
}

Answer 10

class Foo
{
    //static Foo foo = new Foo(); // you are not allowed using this approach
    //static readonly Foo foo = new Foo(); // you are not allowed using this approach
    Foo foo = true?null: new Foo();
}
class Program
{
    static void Main(string[] args)
    {
        new Foo();
    }
}