Question

I have been trying to figure out if there are any differences between these constructors. Assuming there is a Foo() constructor that takes no arguments, are all these constructors going to have the same result?

Example 1

public Foo()
    : this()
{
     blah;
     blah;
     blah;
}

Example 2

public Foo()
{
     this();
     blah;
     blah;
     blah;
}

Example 3

public Foo()
{
     this = new Foo();
     blah;
     blah;
     blah;
}

Answer 1

• Example 1 is valid (assuming there is a parameterless constructor), and calls the parameterless constructor as part of initialization. See my article on constructor chaining for more details. EDIT: Note that since the OP’s edit, it’s infinitely recursive.
• Example 2 is never valid
• Example 3 is only valid when Foo is a struct, and doesn’t do anything useful.

I would steer clear of assigning to this in structs. As you can see from the other answers, the very possibility of it is fairly rarely known (I only know because of some weird situation where it turned up in the spec). Where you’ve got it, it doesn’t do any good – and in other places it’s likely to be mutating the struct, which is not a good idea. Structs should always be immutable 🙂

EDIT: Just to make people go “meep!” a little – assigning to this isn’t quite the same as just chaining to another constructor, as you can do it in methods too:

using System;

public struct Foo
{
    // Readonly, so must be immutable, right?
    public readonly string x;

    public Foo(string x)
    {
        this.x = x;
    }

    public void EvilEvilEvil()
    {
        this = new Foo();
    }
}

public class Test
{
    static void Main()
    {
        Foo foo = new Foo("Test");
        Console.WriteLine(foo.x); // Prints "Test"
        foo.EvilEvilEvil();
        Console.WriteLine(foo.x); // Prints nothing
    }
}