What is the difference between instantiation in constructor or in field definition?

What is the difference between this:

public class Foo {
    private B开发者_如何学Car bar;
    public Foo() { bar = new Bar(); }
}

and this:

public class Foo {
    private Bar bar = new Bar();
    public Foo() { }
}

The difference is that in the second case field initialization happens before this/base constructor while in the first case initialization happens inside the constructor.

The CLR does not support initializing fields like this. To make it work, the C# compiler rewrites your constructor. The IL looks like this:

  IL_0000:  ldarg.0
  IL_0001:  newobj     instance void ConsoleApplication1.Bar::.ctor()
  IL_0006:  stfld      class ConsoleApplication1.Bar ConsoleApplication1.Foo::bar
  IL_000b:  ldarg.0
  IL_000c:  call       instance void [mscorlib]System.Object::.ctor()
  IL_0011:  ret

Note that the Bar constructor is called before the Foo base constructor. Which is the difference with your other snippet, there the Foo base constructor is called afterward. This will rarely make a difference, unless the field is inherited and the base class constructor does something with it.

Or if field initializers depend on each other, they are initialized in strict textual order. You can control the order by doing it explicitly in the constructor.

Stating the obvious a bit, but with the second approach there's no need for a constructor.

There is no difference, because a compiler places all field definitions before constructor's code. So in IL-code both variants look equally.

To add to Darin Dimitrov's answer, initialising the fields in line is a good idea if you have several constructor overloads, and you don't want to call other overloaded constructors for some reason.