变量初始化:直接初始化或在构造函数中初始化

在某些情况下有一个潜在的显著差异。

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

就清晰度而言，如果您在声明时初始化变量，那么很明显，值不依赖于任何构造函数参数。另一方面，将所有初始化放在一起也有助于可读性，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();
    }
}

我没有意识到任何细微的差异。我通常喜欢将所有初始化都放在构造函数中，因为我认为这会使代码更可读。但这更多的是一种风格选择和个人偏好。我还没有听说过任何技术上的理由来证明这一点。我怀疑这是否会对性能产生影响。

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

当构造实例时，在声明时初始化的任何变量都将在运行构造函数之前初始化。如果您没有访问这些变量或在构造函数中使用它们的值，那么这两个方法之间就没有函数上的区别。

假设我们在发布&优化构建

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

    }
}

测试1级的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
}

测试2级的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((之前初始化变量；和变量是在调用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)
    {
    }
}