在C#中,除了可以在类的构造函数中初始化私有字段的值,还可以在私有字段定义的地方进行初始化(即默认赋值)。下面讨论默认赋值和在构造函数中赋值的区别,以便更好的在代码中使用这两种赋值。
主要内容:
- 对代码生成的影响
- 对代码执行的影响
1. 对代码生成的影响
首先构造两个Class,其中ClassA使用默认赋值的方式,ClassB使用构造函数赋值的方式。
代码如下:
public class ClassA { private Int32 a = 123; private String b = "abc"; private Object c = new object(); public ClassA() { } public ClassA(int aa) { a = aa; } } public class ClassB { private Int32 a; private String b; private Object c; public ClassB() { a = 123; b = "abc"; c = new object(); } public ClassB(int aa) { a = aa; } }
编译成dll后,再用ILSpy查看其IL代码,发现ClassA生成的代码比较多。即每个构造函数开始执行处,都会将字段的默认赋值生成IL代码插入其中。
ClassA IL代码如下
.class public auto ansi beforefieldinit ClassA extends object { // Fields .field private int32 a .field private string b .field private object c // Methods .method public hidebysig specialname rtspecialname instance void .ctor () cil managed { // Method begins at RVA 0x2073 // Code size 40 (0x28) .maxstack 8 IL_0000: ldarg.0 IL_0001: ldc.i4.s 123 IL_0003: stfld int32 class cnblog_bowen.ClassA::a IL_0008: ldarg.0 IL_0009: ldstr "abc" IL_000e: stfld string class cnblog_bowen.ClassA::b IL_0013: ldarg.0 IL_0014: newobj instance void object::.ctor() IL_0019: stfld object class cnblog_bowen.ClassA::c IL_001e: ldarg.0 IL_001f: call instance void object::.ctor() IL_0024: nop IL_0025: nop IL_0026: nop IL_0027: ret } // End of method ClassA..ctor .method public hidebysig specialname rtspecialname instance void .ctor ( int32 aa ) cil managed { // Method begins at RVA 0x209c // Code size 47 (0x2f) .maxstack 8 IL_0000: ldarg.0 IL_0001: ldc.i4.s 123 IL_0003: stfld int32 class cnblog_bowen.ClassA::a IL_0008: ldarg.0 IL_0009: ldstr "abc" IL_000e: stfld string class cnblog_bowen.ClassA::b IL_0013: ldarg.0 IL_0014: newobj instance void object::.ctor() IL_0019: stfld object class cnblog_bowen.ClassA::c IL_001e: ldarg.0 IL_001f: call instance void object::.ctor() IL_0024: nop IL_0025: nop IL_0026: ldarg.0 IL_0027: ldarg.1 IL_0028: stfld int32 class cnblog_bowen.ClassA::a IL_002d: nop IL_002e: ret } // End of method ClassA..ctor } // End of class cnblog_bowen.ClassA
ClassB IL代码如下
.class public auto ansi beforefieldinit ClassB extends object { // Fields .field private int32 a .field private string b .field private object c // Methods .method public hidebysig specialname rtspecialname instance void .ctor () cil managed { // Method begins at RVA 0x20cc // Code size 40 (0x28) .maxstack 8 IL_0000: ldarg.0 IL_0001: call instance void object::.ctor() IL_0006: nop IL_0007: nop IL_0008: ldarg.0 IL_0009: ldc.i4.s 123 IL_000b: stfld int32 class cnblog_bowen.ClassB::a IL_0010: ldarg.0 IL_0011: ldstr "abc" IL_0016: stfld string class cnblog_bowen.ClassB::b IL_001b: ldarg.0 IL_001c: newobj instance void object::.ctor() IL_0021: stfld object class cnblog_bowen.ClassB::c IL_0026: nop IL_0027: ret } // End of method ClassB..ctor .method public hidebysig specialname rtspecialname instance void .ctor ( int32 aa ) cil managed { // Method begins at RVA 0x20f5 // Code size 17 (0x11) .maxstack 8 IL_0000: ldarg.0 IL_0001: call instance void object::.ctor() IL_0006: nop IL_0007: nop IL_0008: ldarg.0 IL_0009: ldarg.1 IL_000a: stfld int32 class cnblog_bowen.ClassB::a IL_000f: nop IL_0010: ret } // End of method ClassB..ctor } // End of class cnblog_bowen.ClassB
由此看出,虽然默认赋值的方法比较直观和方便,但是从生成的代码来看,默认赋值的方法会导致代码膨胀,所以不应在以下场合使用:
1)字段比较多的Class
2)构造函数有多个重载版本
2. 对代码执行的影响
通过上面的IL代码,我们发现默认赋值除了会导致代码膨胀,赋值的时机也和在构造函数中对字段的赋值不一样。
我们知道,类的构造函数在执行之前,都会调用其基类的构造函数,由于所以类都默认继承System.Object,所以上面的ClassA和ClassB虽然没有指定基类,
但都继承于System.Object,所以都会调用System.Object的构造函数。
调用System.Object的构造函数的IL代码即为:call instance void object::.ctor()从上面的IL代码中,我们发现:
1)默认赋值方式是在调用System.Object的构造函数前给字段赋值的
2)构造函数中赋值方式是在调用System.Object的构造函数后给字段赋值的 这里的差别虽然很小,但是有时却会导致代码产生不同的结果,从而带来潜在的bug。
这两种赋值方式在什么情况下会导致执行结果不同呢?
根据其赋值时机的不同,我们可以推断在如下情况下,两种赋值方式的执行结果不同。
基类中调用虚方法并且如果子类覆盖(override)了此虚方法,那么此虚方法中的字段就有可能已经初始化或者未初始化。
第一种情况 (默认赋值的方式)
class Test { static void Main() { // 第一步:调用SubClass的构造函数 SubClass sub = new SubClass(); Console.ReadKey(true); } } public class BaseClass { // 第四步:调用基类构造函数,其中虚方法Print已经被子类覆盖 public BaseClass() { Print(); } public virtual void Print() { Console.WriteLine("Base class initilized!"); } } public class SubClass : BaseClass { // 第三步:对sub_a,sub_b,obj进行赋值,然后再调用基类构造函数 private Int32 sub_a = 123; private String sub_b = "abc"; private Object obj = new object(); // 第二步:由于是默认赋值的方式,所以先将sub_a,sub_b,obj赋值后再调用基类构造函数 public SubClass() { } // 第五步:调用被覆盖的Print方法,由于obj已被赋值,所以进入else分支去执行 public override void Print() { if (null == obj) Console.WriteLine("Sub class is uninitilize!"); else { Console.WriteLine("a= " + sub_a); Console.WriteLine("b= " + sub_b); Console.WriteLine("Sub class was initilized!"); } } }
执行结果如下,执行过程可以参见上面代码中的注释
![image image](https://images.cnblogs.com/cnblogs_com/wang_yb/201106/201106171643599305.png)
第二种情况(构造函数中对字段赋值的方式)
class Test { static void Main() { // 第一步:调用SubClass的构造函数 SubClass sub = new SubClass(); Console.ReadKey(true); } } public class BaseClass { // 第三步:调用基类构造函数,其中虚方法Print已经被子类覆盖 public BaseClass() { Print(); } public virtual void Print() { Console.WriteLine("Base class initilized!"); } } public class SubClass : BaseClass { private Int32 sub_a; private String sub_b; private Object obj; // 第二步:由于是在构造函数对字段辅助的方式,所以先默认调用基类构造函数 public SubClass() { // 第五步:基类构造函数执行完后,进入下面的赋值 sub_a = 123; sub_b = "abc"; obj = new object(); } // 第四步:调用被覆盖的Print方法,由于obj还未被赋值,所以进入if分支去执行 public override void Print() { if (null == obj) Console.WriteLine("Sub class is uninitilize!"); else { Console.WriteLine("a= " + sub_a); Console.WriteLine("b= " + sub_b); Console.WriteLine("Sub class was initilized!"); } } }
执行结果如下,执行过程可以参见上面代码中的注释
![image image](https://images.cnblogs.com/cnblogs_com/wang_yb/201106/201106171644063030.png)
小小的赋值,也会导致意外的bug。所以我们在使用时默认赋值时一定要对其赋值的时机做到心中有数。