变量的初始化：直接还是在构造函数中？

大多数时候，我看到了像这样初始化变量的方法

public class Test
{
    private int myIntToInitalize;

    public Test()
    {
        myIntToInitalize = 10;
    }
}

从我的角度来看，这是初始化变量的最常用方法。书籍，博客以及.NET的内部实现中的大多数代码都与我的示例相同。

最近我看到人们直接进行初始化，所以没有在构造函数中设置值。

public class Test
{
    private int myIntToInitalize = 10;
}

从观点来看，初始化和声明变量或初始化构造函数中的变量没有区别。

除了最佳实践和代码行的长度之外，直接初始化变量的好处在哪里并且存在细微差别？

---

我们可以说我们在发布和版本下编译以下代码。优化构建

namespace ConsoleApplication4
{

    public class Test1
    {
        private int myIntToInitalize;

        public Test1()
        {
            myIntToInitalize = 10;
        }
    }

    public class Test2
    {
        private int myIntToInitalize = 10;
    }


    static class Program
    {

        private static void Main()
        {
        }


    }

}

IL Test Class for Class Test1

.class public auto ansi beforefieldinit Test1
    extends [mscorlib]System.Object
{
    .method public hidebysig specialname rtspecialname instance void .ctor() cil managed
    {
        .maxstack 8
        L_0000: ldarg.0 
        L_0001: call instance void [mscorlib]System.Object::.ctor()
        L_0006: ldarg.0 
        L_0007: ldc.i4.s 10
        L_0009: stfld int32 ConsoleApplication4.Test1::myIntToInitalize
        L_000e: ret 
    }


    .field private int32 myIntToInitalize

}

Class Test2的IL指令

.class public auto ansi beforefieldinit Test2
    extends [mscorlib]System.Object
{
    .method public hidebysig specialname rtspecialname instance void .ctor() cil managed
    {
        .maxstack 8
        L_0000: ldarg.0 
        L_0001: ldc.i4.s 10
        L_0003: stfld int32 ConsoleApplication4.Test2::myIntToInitalize
        L_0008: ldarg.0 
        L_0009: call instance void [mscorlib]System.Object::.ctor()
        L_000e: ret 
    }


    .field private int32 myIntToInitalize

}

非常明显，两个类都有相同数量的IL指令，唯一的差别是，

在类Test1中调用:: ctor（）之前初始化

变量; 和 在类Test2中调用:: ctor（）之后初始化变量;

注意：性能方面，Class会执行相同的操作，因为它们具有相同的数字和＆amp; IL指令的类型，只是IL指令的执行顺序不同

---

在某些情况下，存在一个潜在的显着差异。

在执行基类构造函数之前，执行实例初始值设定项。因此，如果基类构造函数调用在派生类中重写的任何虚方法，则该方法将看到差异。 通常这不应该是一个明显的区别，但是 - 因为在构造函数中调用虚方法几乎总是一个坏主意。

就清晰度而言，如果在声明点初始化变量，则很明显值的值不依赖于任何构造函数参数。另一方面，将所有初始化保持在一起也有助于提高可读性，IMO。我会尝试以确保在任何可能的情况下，如果你有多个构造函数，它们都会委托给一个“主”构造函数来完成所有“真正的”初始化 - 这意味着你只会将这些分配放入一个地方。

演示差异的示例代码：

using System;

class Base
{
    public Base()
    {
        Console.WriteLine(ToString());
    }
}

class Derived : Base
{
    private int x = 5;
    private int y;

    public Derived()
    {
        y = 5;
    }

    public override string ToString()
    {
        return string.Format("x={0}, y={1}", x, y);
    }
}

class Test
{
    static void Main()
    {
        // Prints x=5, y=0
        new Derived();
    }
}