Should instance fields be initialized in the constructor body or in the class body?

In all of my professional and educational experience, I have always followed the paradigm of not immediately defining values within a class until the object is created. I did this because I saw others doing it. I still, to this day, do not understand why this is the case.

In case you don't understand what I'm referencing, here is an example of how most people (myself included) may create an object class. This will be C#, since that is what I was working with that drove me to this question:

public class Thing {
    private List<int> stuff;

    public Thing() {
        stuff = new List<int>();
    }
}

What I'm wondering as to why it is not ever done is this:

public class Thing {
    private List<int> stuff = new List<int>();

    public Thing() {
    }
}

As far as I understand, each instance of Thing would still have an independent instance of stuff, as the value is not static. I don't have an exceptional understanding of compilers, as I never took the course in undergrad, so the answer may be that. So why can't (or shouldn't I) use the latter form of code? Industry standards aside.

Both alternatives are valid (they compile).

If I were to venture a guess as to why you often see the first option, it may have to do with constructor parameters. Imagine this variation of a class:

public class Thingy
{
     private List<int> stuff;
     private Gizmo gizmo;

     public Thingy(Gizmo gizmo)
     {
         stuff = new List<int>();
         this.gizmo = gizmo;
     }
}

If you'd gone with the second option, you could initialize stuff directly, but you can only assign gizmo from the constructor. This would spread the initialisation code, so that you, as a code reader, have to look in more than one place to understand how the class is initialised.

Using the first option shown here, you centralise all class initialisation code in one place, making it easier for the next programmer to understand how the class gets initialised.

This becomes even more pronounced with constructor chaining:

public class Thingy
{
     private List<int> stuff;
     private Gizmo gizmo;

     public Thingy(Gizmo gizmo) : this(gizmo, new List<int>())
     {
     }

     public Thingy(Gizmo gizmo, List<int> stuff)
     {
         this.stuff = stuff;
         this.gizmo = gizmo;
     }
}

Even with multiple constructors, there's only one place where the object is initialised.

In the special case where there are no constructor parameters (as in the OP), both alternatives solve that problem. I suppose many people (me included) prefer to keep things consistent, so they go for the first option for that reason.

This will furthermore also help if you at a later date decide to add a constructor parameter. If you've already used the first option, you don't have to move the class' initialisation code.