12

可能重复：
最佳实践：在构造函数或声明中初始化类字段？

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

public class Test
{
    private int myIntToInitalize;

    public Test()
    {
        myIntToInitalize = 10;
    }
}

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

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

public class Test
{
    private int myIntToInitalize = 10;
}

从这个角度来看，初始化和声明变量或在构造函数中初始化变量没有区别。

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

4

6 回答 6

24

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

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

就清晰而言，如果您在声明点初始化变量，则很清楚该值不依赖于任何构造函数参数。另一方面，将所有初始化放在一起也有助于可读性，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();
    }
}
于 2012-12-29T16:49:46.507 回答
5

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

静态常量和最终常量是另一回事。我在线初始化那些。

于 2012-12-29T16:40:26.250 回答
4

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

于 2012-12-29T16:41:14.443 回答
3

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

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

于 2012-12-29T17:08:39.140 回答
2

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

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

拿这个样本：

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;
     }
 }

它打印：

  • 派生初始化器
  • 基础初始化器
  • 碱基
  • 派生的ctor
于 2012-12-29T16:51:08.180 回答
0 
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，但在 Test2 类上，当您调用需要 1 个参数的构造函数时，则不会。

于 2012-12-29T16:54:30.187 回答