<Effictive C# 2nd edition>读书笔记

Item 14:Minimize Duplicate Initialization Logic

Here is the order of operations for constructing the first instance of a type:
1. Static variable storage is set to 0.
2. Static variable initializers execute.
3. Static constructors for the base class execute.
4. The static constructor executes.
5. Instance variable storage is set to 0.
6. Instance variable initializers execute.
7. The appropriate base class instance constructor executes.
8. The instance constructor executes.

Subsequent instances of the same type start at step 5 because the class ini-tializers execute only once. Also, steps 6 and 7 are optimized so that con-structor initializers cause the compiler to remove duplicate instructions.

you are guaranteed 
that all memory your object uses has been set to 0 when an instance is created. This is true for both static members and instance members. 

Some general rules can be followed for initialization:

Your goal is to make sure that you initialize all the values the way you want and exe-cute that initialization code only once. Use initializers to initialize simple 
resources. Use constructors to initialize members that require more sophis-ticated logic. Also factor calls to other constructors, to minimize duplication

Item 15: Utilize using and try/finally for Resource Cleanup

The using state-ment ensures that Dispose() is called. You allocate an object inside a using statement, and the C# compiler generates a try/finally block around each object:.

The using statement works only if the compile-time type supports the IDisposable interface. You cannot use it with arbitrary objects

Item 17:Implement the Standard Dispose Pattern 

The implementation of your IDisposable.Dispose() method is responsi-ble for four tasks:
1. Freeing all unmanaged resources.
2. Freeing all managed resources (this includes unhooking events).
3. Setting a state flag to indicate that the object has been disposed. You 
need to check this state and throw ObjectDisposed exceptions in your 
public methods, if any get called after disposing of an object.
4. Suppressing finalization. You call GC.SuppressFinalize(this) to 
accomplish this task.

Item 18:Distinguish Between Value Types and Reference Types

Value types are not polymorphic. 
They are better suited to storing the data that your application manipu-lates. Reference types can be polymorphic and should be used to define 
the behavior of your application. Consider the expected responsibilities 
of your new type, and from those responsibilities, decide which type to 
create. Structs store data. Classes define behavior.

Why in C#, need value types and reference types explicityly

In C++, all parameters and return values were passed by value. Pass-ing by value is very efficient, but it suffers from one problem: partial copy-ing (sometimes called slicing the object). If you use a derived object where 
a base object is expected, only the base portion of the object gets copied. 
You have effectively lost all knowledge that a derived object was ever there. 
Even calls to virtual functions are sent to the base class version

The Java language responded by more or less removing value types from 
the language. All user-defined types are reference types. In the Java lan-guage, all parameters and return values are passed by reference. This strat-egy has the advantage of being consistent, but it’s a drain on performance. 
Let’s face it, some types are not polymorphic—they were not intended to 
be. Java programmers pay a heap allocation and an eventual garbage col-lection for every variable. They also pay an extra time cost to dereference 
every variable. All variables are references.

Item 38:

At compile time, dynamic variables have only those methods defined in Sys-tem.Object. However, the compiler adds code so that every member access is implemented as a dynamic call site. At runtime, code executes to exam-ine the object and determine if the requested method is available.

There are also performance costs with using dynamic and with building expressions at runtime. Just like any dynamic type system, your program has more work to do at runtime because the compiler did not perform any of its usual type checking. The compiler must generate instructions to perform all those checks at runtime. 

Item 45: Minimize Boxing and Unboxing

.NET Framework where methods have parameters typed as System.Object. Those APIs will still produce boxing and unbox-ing operations. It happens automatically. The compiler generates the box-ing and unboxing instructions whenever you use a value type where a reference type, such as System.Object, is expected. In addition, the boxing and unboxing operations occur when you use a value type through an interface pointer. You get no warnings—boxing just happens. Even a sim-ple statement such as this performs boxing:
Console.WriteLine("A few numbers:{0}, {1}, {2}", 25, 32, 50);

The box-ing and unboxing operations make copies where you might not expect.