Effective C#之12:Prefer Variable Initializers to Assignment Statements

最新推荐文章于 2024-09-13 15:26:39 发布

MaybeHelios

最新推荐文章于 2024-09-13 15:26:39 发布

阅读量785

点赞数

分类专栏： Effective C# 文章标签： c# constructor variables initialization construction compiler

Effective C# 专栏收录该内容

54 篇文章 0 订阅

订阅专栏

rel="File-List" href="file:///C:%5CDOCUME%7E1%5CHelios%5CLOCALS%7E1%5CTemp%5Cmsohtmlclip1%5C01%5Cclip_filelist.xml"> rel="themeData" href="file:///C:%5CDOCUME%7E1%5CHelios%5CLOCALS%7E1%5CTemp%5Cmsohtmlclip1%5C01%5Cclip_themedata.thmx"> rel="colorSchemeMapping" href="file:///C:%5CDOCUME%7E1%5CHelios%5CLOCALS%7E1%5CTemp%5Cmsohtmlclip1%5C01%5Cclip_colorschememapping.xml">

Item 12: Prefer Variable Initializers to Assignment Statements

优先使用变量初始化器而不是赋值表达式

Classes often have more than one constructor. Over time, it's easy for the member variables and the constructors to get out of synch. The best way to make sure this doesn't happen is to initialize variables where you declare them instead of in the body of every constructor. You should utilize the initializer syntax for both static and instance variables.

类通常具有一个或者多个构造函数。随着时间的流失，成员变量和构造函数之间很容易变得不同步。确保这些不会发生的最好的方法是在声明变量的时候就初始化，而不是在每个构造函数中进行初始化。你应该在静态变量和实例变量上面利用初始化语法。

Constructing member variables when you declare that variable is natural in C#. Just assign a value:

在声明一个变量的时候，就构建成员变量，在C#里面是很自然的事情，仅仅就是赋一个值：

 
     public class MyClass
    {
        // declare the collection, and initialize it.
        private ArrayList coll = new ArrayList();
    }
 

Regardless of the number of constructors you eventually add to the MyClass type, _coll will be initialized properly. The compiler generates code at the beginning of each constructor to execute all the initializers you have defined for your instance member variables. When you add a new constructor, _coll gets initialized. Similarly, if you add a new member variable, you do not need to add initialization code to every constructor; initializing the variable where you define it is sufficient. Equally important, the initializers are added to the compiler-generated default constructor. The C# compiler creates a default constructor for your types whenever you don't explicitly define any constructors.

由于忽略了逐渐加入到MyClass类型中的构造函数的数目，cool被会很好的进行初始化。每个构造函数中一开始执行你定义的所有初始化，编译器就会为所有的实例成员变量生成了代码。当你加入一个新的构造函数时，cool已经被初始化了。同理，如果你加入一个新的成员变量，那么就没必要向每个构造函数里面加入初始化代码；在你定义变量的地方就进行初始化，足够了。同样重要的是，初始化器被加到了编译器生成的默认构造函数中。当你没有显式的定义任何构造函数的时候，C#编译器会为你的类型创建默认的构造函数。

Initializers are more than a convenient shortcut for statements in a constructor body. The statements generated by initializers are placed in object code before the body of your constructors. Initializers execute before the base class constructor for your type executes, and they are executed in the order the variables are declared in your class.

初始化器不仅仅是构造函数体里面表达式的一个便捷的快捷方式。在对象代码里面，初始化器生成的表达式，放置在构造函数体的前面。初始化器在基类构造函数执行前被执行，它们被执行的顺序就是在类里被声明的顺序。

Using initializers is the simplest way to avoid uninitialized variables in your types, but it's not perfect. In three cases, you should not use the initializer syntax. The first is when you are initializing the object to 0, or null. The default system initialization sets everything to 0 for you before any of your code executes. The system-generated 0 initialization is done at a very low level using the CPU instructions to set the entire block of memory to 0. Any extra 0 initialization on your part is superfluous. The C# compiler dutifully adds the extra instructions to set memory to 0 again. It's not wrong. it's just inefficient. In fact, when value types are involved, it's very inefficient.

使用初始化器是避免在你的类型里面出现未初始化变量的最简单方法，但是不够完美。有3种情况，不应该使用初始化语法。第一个，当你将对象初始化为0或者null的时候。在任何代码被执行之前，默认的系统初始化将一切设置为0。系统生成的0初始化是在一个很低的级别被完成的，使用CPU指令结构将整块的内存设置为0。你做得任何额外的0初始化都是多余的。C#编译器很负责的加入额外的指令，再次将内存设置为0。这没错但是低效。事实上，如果涉及到值类型，是相当低效的。

 
 MyValType myVal1;  // initialized to 0
MyValType myVal2 = new MyValType(); // also 0

Both statements initialize the variable to all 0s. The first does so by setting the memory containing MyVal1 to 0. The second uses the IL instruction initobj, which causes both a box and an unbox operation on the _MyVal2 variable. This takes quite a bit of extra time (see Item 17).

两条语句都将变量设置成全0。第一个，将含有myVal1的内存设置为0；第二个，使用了IL指令 init obj，这在myVal2上会同时引发装箱和拆箱，会花费相当多额外时间(见Item 17)。

The second inefficiency comes when you create multiple initializations for the same object. You should use the initializer syntax only for variables that receive the same initialization in all constructors. This version of MyClass has a path that creates two different ArrayList objects as part of its construction:

当你为同一个对象创建多个初始化时，会碰到第二个低效的做法。你应该仅仅为这种变量使用初始化器语法：从所有的构造函数上接收同样的初始化过程。这个版本的MyClass有一个路径，在构造函数的一部分创建了2个不同的ArrayList对象。

 
     public class MyClass
    {
        // declare the collection, and initialize it.
        private ArrayList coll = new ArrayList();
        MyClass()
        {
        }
        MyClass(Int32 size)
        {
            coll = new ArrayList(size);
        }
    }
 

When you create a new MyClass, specifying the size of the collection, you create two array lists. One is immediately garbage. The variable initializer executes before every constructor. The constructor body creates the second array list. The compiler creates this version of MyClass, which you would never code by hand. (For the proper way to handle this situation, see Item 14.)

当你创建一个新的MyClass时，指定集合的大小，就创建了2个数组列表。一个很快成为了垃圾。变量初始化器在每个构造函数前被执行，构造函数体创建了第二个数组列表。编译器为你创建了MyClass的这个版本，你可能从没有手工编写过(如何恰当的处理这种情况，请看Item 14)。

 
     public class MyClass
    {
        // declare the collection, and initialize it.
        private ArrayList coll;
        MyClass()
        {
            coll = new ArrayList();
        }
        MyClass(int size)
        {
            coll = new ArrayList();
            coll = new ArrayList(size);
        }
    }
 

The final reason to move initialization into the body of a constructor is to facilitate exception handling. You cannot wrap the initializers in a Try block. Any exceptions that might be generated during the construction of your member variables get propagated outside of your object. You cannot attempt any recovery inside your class. You should move that initialization code into the body of your constructors so that you implement the proper recovery code to create your type and gracefully handle the exception (see Item 45).

将初始化移到构造函数体内部的最后一个原因是，便于处理异常。你不能将初始化器放到Try代码块里面。在你的成员变量给生成的期间，在对象外部可能发生任何异常。在类的内部你不能尝试任何修复。你应该将初始化代码移到构造函数内部，那样的话就可以实现合适的修复代码来创建你的类型，并且比较优雅的处理异常(见Item 45)。

Variable initializers are the simplest way to ensure that the member variables in your type are initialized regardless of which constructor is called. The initializers are executed before each constructor you make for your type. Using this syntax means that you cannot forget to add the proper initialization when you add new constructors for a future release. Use initializers when all constructors create the member variable the same way; it's simpler to read and easier to maintain.

在忽略哪个构造函数被调用的情况下，为了保证类型内部的成员变量都能被初始化，使用变量初始化器是最简单的方法。初始化器在每个构造函数之前被执行。使用该语法意味着，当你为了以后的发布版本添加新的构造函数的时候，不会忘记添加合适的初始化。在所有的构造函数使用同样的方式创建成员变量的时候，使用初始化器，更加易读，更加容易维护。