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

Question

可能重复：
Best Practice: Initialize class fields in constructor or at declaration?

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

public class Test
{
    private int myIntToInitalize;

    public Test()
    {
        myIntToInitalize = 10;
    }
}

在我看来，这是初始化变量的最通用方式。书籍、博客以及 .NET 的内部实现中的大部分代码都与我的示例等效。

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

public class Test
{
    private int myIntToInitalize = 10;
}

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

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

Answer 1

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

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

为了清楚起见，如果你在声明的时候初始化变量，就很清楚值不依赖于任何构造函数参数。另一方面，将所有初始化放在一起也有助于可读性，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();
    }
}

Answer 2

我不知道有任何细微差别。我通常喜欢将所有初始化都放在构造函数中，因为我认为它使代码更具可读性。但这更多是一种风格选择和个人喜好。我还没有听说过以一种或另一种方式证明它的技术原因。我怀疑这会对性能产生任何影响。

静态常量和最终常量是另一回事。我将那些内联初始化。

Answer 3

在构造实例时，任何在声明时初始化的变量都将在构造函数运行之前被初始化。如果您没有访问这些变量或在构造函数本身中使用它们的值，那么这两种方法之间没有功能差异。

Answer 4

假设我们在发布和优化构建下编译以下代码

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()
        {
        }


    }

}

类 Test1 的 IL 指令

.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

}

类 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() 后被初始化；

注意：两个类的性能表现相同，因为它们具有相同数量和类型的 IL 指令，只是 IL 指令的执行顺序不同

Answer 5

对于您的简单示例，这只是样式问题。

涉及继承时存在细微差别。对于实例字段初始化器，执行顺序是派生类字段初始化器、基类字段初始化器、基类构造器、派生类构造器。

拿这个样本：

public class Program
{
    public static void Main(string[] args)
    {
        new Derived();
    }
 }

 public class Base 
 {
     private int x = BaseInitializer();

     public Base()
     {
          Console.WriteLine("Base ctor");
     }

     private static int BaseInitializer()
     {
         Console.WriteLine("BaseInitializer");
         return 0;
     }
 }

 public class Derived : Base
 {
     private int x = DerivedInitializer();

     public Derived() : base()
     {
         Console.WriteLine("Derived ctor");
     }

     private static int DerivedInitializer()
     {
         Console.WriteLine("DerivedInitializer");
         return 0;
     }
 }

打印出来：

• DerivedInitializer
• BaseInitializer
• 基础构造函数
• 派生的ctor

Answer 6

public class Test
{
    private int myIntToInitalize = 10;
    public Test()
    {

    }

    public Test(string x)
    {
    }
}

public class Test2
{
    private int myIntToInitalize;
    public Test2()
    {
        this.myIntToInitalize = 10;
    }

    public Test2(string x)
    {
    }
}

在类 Test1 上，每个对象实例都将 myIntToInitalize 设置为 10， 但是当你调用需要 1 个参数的构造函数时，不在类 Test2 上。