可能是重复问题:
最佳实践: 在构造函数中初始化类字段还是在声明时初始化？
大多数情况下，我看到初始化变量的方式像这样：
public class Test
{
private int myIntToInitalize;
public Test()
{
myIntToInitalize = 10;
}
}
从我的角度来看，这是初始化变量的最常见方式。大多数书籍、博客以及.NET内部实现中的代码都等同于我的示例。
最近我看到有人直接进行初始化，而不是在构造函数中设置值。
public class Test
{
private int myIntToInitalize = 10;
}
就观点而言，初始化和声明变量或在构造函数中初始化变量并没有区别。
除了最佳实践和代码行长度之外，直接初始化变量的好处在哪里？是否存在微妙差异？
有一个在某些情况下可能具有重要意义的区别。
实例初始化器在执行基类构造函数之前执行。因此，如果基类构造函数调用了任何在派生类中被覆盖的虚拟方法，则该方法会看到这种差异。通常，这不应该是一个明显的区别，因为在构造函数中调用虚拟方法几乎总是不明智的做法。
就清晰度而言，如果您在声明时初始化变量，它可以非常清楚地表明该值不依赖于任何构造函数参数。另一方面，将所有初始化放在一起也有助于可读性，我认为。我会尝试确保，如果您有多个构造函数，它们都委托给一个“主”构造函数，该构造函数执行所有“真正”的初始化——这意味着您只需要将这些赋值放在一个地方。
演示差异的示例代码：
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();
}
}
当一个实例被构造时，任何在声明时初始化的变量都将在构造函数运行之前初始化。如果您在构造函数中没有访问这些变量或使用它们的值，则两种方法之间没有功能上的区别。
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()
{
}
}
}
Class 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
}
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指令，唯一的区别是：
在调用Class Test1的::ctor()之前初始化变量； 在调用Class Test2的::ctor()之后初始化变量。
注意：就性能而言，两个类的表现相同，因为它们具有相同数量和类型的IL指令，只是执行IL指令的顺序不同。
对于您的简单示例，这只是一个样式问题。
当涉及继承时，有微妙的差异。例如，字段初始化器的执行顺序是派生类字段初始化器、基类字段初始化器、基类构造函数、派生类构造函数。
以此示例为例：
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;
}
}
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)
{
}
}