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


    }

}

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指令的执行顺序不同

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
Base ctor
派生的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上。

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

6 个答案: