CLR笔记：8.方法

1.实例构造器ctor(引用类型)
    创建引用类型的实例时的步骤：
        首先，为实例的数据字段分配内存；
        接着，初始化对象的系统开销字段(类型对象指针和同步块索引)；
        最后，调用类型的实例构造器设置对象的初始状态。

     ctor不能被继承，不能用virtual，new，override，sealed，abstract。

    如果类中没有显示定义任何ctor，则默认定义一个无参ctor，这个ctor不执行任何语句，只是调用基类的无参ctor；当然，如果类中有ctor，则不存在这个默认的无参ctor。
    如果类为abstract的，则默认的ctor是protected；否则这个默认ctor都是public的。
    如果类为static的，则不会生成默认的ctor。
    
    如果基类A中没有提供无参ctor，这里，我们只考虑A中只有一个有参ctor（如果连这个ctor也没有，那么A就是上面的那种情况了），这时，子类B必须显示调用基类的ctor，否则不能编译，如下所示：

    public class A
    {
        public A(int t)
        { 
        
        }
    }

    public class B : A
    {
        public B(int t)  : base(t)        //必须显示调用
        {

        }
    }

最终，都会调用到System.Object的公有无参ctor。

不需要实例构造器的时候：反序列化；Object.MemberwiseClone()方法。
内联方法，其实就是在默认无参ctor中赋值。

2.实例构造器ctor(值类型)
    1.C#中，struct不能包含显示的无参ctor——CLR允许struct有无参ctor
    2.struct一定要显示调用其有参ctor，这样在new新对象的时候，才会执行ctor中的语句
    3.CLR会保证所有实例字段(值类型和引用类型)都被初始化为0或者null (如果没有手动设置，就由CLR自动分配)。
    4.在struct中，不能使用内联直接给字段赋值(初始化只能在显示ctor中做)
    5.每个字段都要在ctor中初始化，不然编译器会报错

3.静态构造器cctor
cctor可以用于接口/引用类型/值类型，但是C#不支持接口。
cctor位于AppDomain中，在类第一次被访问时执行。
cctor不能超过一个(可以没有)，而且永远没有参数。
cctor是私有的，但不能显示声明为私有。
在值类型中定义cctor是没有意义的——没有机会执行cctor。
cctor的调用过程：
    编译时，JIT编译器将检查AppDomain是否执行了cctor(有记录的)，以决定是否生成调用代码；
    执行时，如果有多个线程，则需要一个互斥的线程同步锁，以确保只执行一次cctor。
避免在两个类的cctor中互相引用，CLR不能确保先执行哪一个cctor，可以编译，但是返回指不唯一。
如果cctor抛出异常，CLR会认为该类型不可用，与此类型相关的操作都会抛出System.TypeInitializationException异常。
cctor中只能访问静态字段，它的用途就是初始化这些静态字段。也可以使用内联初始化，与cctor效果一样。
cctor不应调用其基类的cctor，两者没有关系。
CLR不支持静态的Finalize()方法。

cctor的性能：
精确语义Precise：针对在cctor中初始化而言；
字段初始化前语义BeforeFieldInit：针对于内联初始化而言。
二者的区别在于是否会在MSIL中的cctor上附加一个BeforeFieldInit标记。
测试代码如下：

    class Program
    {
        static void Main()
        {
            const Int32 iterations = 1000 * 1000 * 1000;
            PrefTest1(iterations);
            PrefTest2(iterations);

            Console.ReadLine();
        }

        private static void PrefTest1(Int32 iterations)
        {
            Stopwatch sw = Stopwatch.StartNew();
            for (Int32 i = 0; i < iterations; i++)
            {
                BeforeFieldInit.s_x = 1;
            }
            Console.WriteLine("PrefTest1: {0} BeforeFieldInit", sw.Elapsed);

            sw = Stopwatch.StartNew();
            for (Int32 j = 0; j < iterations; j++)
            {
                Precise.s_x = 1;
            }
            Console.WriteLine("PrefTest1: {0} Precise", sw.Elapsed);
        }

        private static void PrefTest2(Int32 iterations)
        {
            Stopwatch sw = Stopwatch.StartNew();
            for (Int32 i = 0; i < iterations; i++)
            {
                BeforeFieldInit.s_x = 1;
            }
            Console.WriteLine("PrefTest2: {0} BeforeFieldInit", sw.Elapsed);

            sw = Stopwatch.StartNew();
            for (Int32 j = 0; j < iterations; j++)
            {
                Precise.s_x = 1;
            }
            Console.WriteLine("PrefTest2: {0} Precise", sw.Elapsed);
        }
    }

*Stopwatch类，提供一组方法和属性，可以准确地测量运行时间

4.操作符重载
CLR不知道操作符是什么；操作符是C#定义的，相应的生成编译器识别的语言。
操作符重载是public static的，有一元重载和二元操作两种方式。
要求重载方法的参数至少有一个参数与重载方法的类型一样。
运算符参数不能使用ref/out修饰符。

例子：对于运算符+，
    在定义时，会在编译器中生成op_Addition()方法，在方法定义表中，这个方法属于specialname组——说明它是一个特殊方法
    在调用时，编译器会在specialname组查找相应的op_Addition()方法，如果存在而且方法参数匹配，则执行；否则，编译错误。

对于操作符重载，建议同时定义一个友好的方法，如重载+，同时定义一个Add方法。

操作符语法详见http://www.cnblogs.com/Jax/archive/2007/09/13/891984.html

5.转换操作符方法
System.Decimal是一个很好的学习操作符重载/转换的Sample
为一个Rational定义转换符构造器和方法：
操作符转换也是public static的

    public sealed class Rational
    {
        public Rational(Int32 num)
        {
            //由Int32构建一个Rational
        }

        public Rational(Single num)
        {
            //由Single构建一个Rational
        }

        public Int32 ToInt32()
        { 
            //将Rational转换为Int32
        }

        public Single ToSingle()
        {
            //将Rational转换为Single
        }

        //将Int32隐式转为Rational，回调Rational(Int32)构造器
        public static implicit operator Rational(Int32 num)
        {
            return new Rational(num);
        }

        //将Single隐式转为Rational，回调Rational(Single)构造器
        public static implicit operator Rational(Single num)
        {
            return new Rational(num);
        }

        //将Rational显式转为Int32，回调ToInt32()
        public static explicit operator Int32(Rational r)
        {
            return r.ToInt32();
        }

        //将Rational显式转为Single，回调ToSingle()
        public static explicit operator Single(Rational r)
        {
            return r.ToSingle();
        }
    }

由上面代码可以看出，implicit/explicit是对两个构造器和两个ToXXX()方法的包装。
相应的IL代码：

        public static Rational op_Implicit(Int32 num)
        public static Rational op_Implicit(Single num)
        public static Int32 op_Explicit(Rational r)
        public static Single op_Explicit(Rational r)

第3个和第四个方法仅仅是返回类型不同，这样的语法只有在IL中允许。可以看到，操作符转换实际上是在利用IL的这一特性。

6.通过引用向方法传递参数
    默认CLR的方法参数都是按值传递的。无论引用还是值类型参数，都是传递一个copy的副本——这样意味着方法可以修改对象，而不对方法外的对象有影响，仅在方法内部有影响。
    CLR允许按照引用方式传递参数：out，ref，在声明和调用时都要加上ref/out关键字
        二者在CLR中等效，在C#中有区别：
            不能将未初始化的参数作为ref传递到方法

        //正确使用ref
        static void Main()
        {
            int x = 2;

            GetRef(ref x);
        }

        private static void GetRef(ref int x)
        { 
            x ++;
        }

        //错误使用ref
        static void Main()
        {
            int x;  //未初始化，即使方法中赋值也不行

            GetRef(ref x);
        }

        private static void GetRef(ref int x)
        { 
            x = 10;
        }

            在out方法中必须给out参数初始化赋值，这时，无论调用前是否给out参数初始化赋值，out方法中都要赋值，否则会编译错误。示例如下：

        //正确使用out
        static void Main()
        {
            //以下两句话都是对的
            int x;
            int x = 10;

            GetOut(out x);
        }

        private static void GetOut(out int x)
        { 
            x = 10;     //一定要初始化，即使调用前已经初始化了
        }

        //错误使用out
        static void Main()
        {
            int x = 10;

            GetOut(out x);
        }

        private static void GetOut(out int x)
        { 
            x ++;     //一定要初始化，即使调用前已经初始化了
        }

方法可以基于ref/out可以重载，ref/out也算是方法签名的一部分。但是重载不能仅限于ref和out的差别，如下：
可以有

    public sealed class Point
    {
        static void Add(Point p);
        static void Add(ref Point p);
    }

不能有

    public sealed class Point
    {
        static void Add(Point p);
        static void Add(ref Point p);
        static void Add(out Point p);
    }

用ref实现交换两个引用类型的方法：标准写法，使用泛型

        public static void Swap<T>(ref T a, ref T b)
        {
            T t = b;
            b = a;
            a = t;
        }

        public static void SomeMethod()
        {
            String s1 = "Jax.Bao";
            String s2 = "Fish.Xu";

            Swap(ref s1, ref s2);
        }

out/ref在值类型上使用和引用类型上使用行为相同。仅差在值类型实例分配到的是内存，引用类型分配到的是指针。

以后的FileStream可以写成以下模式：

        static void Main()
        {
            FileStream fs = null;

            ProcessFiles(ref fs);

            for (; fs != null; ProcessFiles(ref fs))
            { 
                fs.Read(.);            
            }
        }


        private static void ProcessFiles(ref FileStream fs)
        {
            if (fs != null)
            {
                fs.Close();
            }

            if (noMoreFileToProcess)
            {
                fs = null;
            }
            else
            { 
                fs = new FileStream(.);
            }
        }

7.向方法传递可变数量的参数 params关键字
只有最后一个参数可以是params的，而且必须是一个一维数组，可以传递null或0个元素的数组，甚至是不传值(忽略此参数，会默认生成0长的数组作为方法参数)。
调用的时候，不用创建数组对象，直接在方法中传入任意数量的参数。

        static void Main()
        {
            Console.WriteLine(TestParams());

            Console.WriteLine(TestParams("1", "2"));
        }

        public static int TestParams(params string[] p1)
        {
            return p1.Length;
        }

8.声明方法的参数类型
原则1：方法参数尽可能指定为最弱的类型
    选用IEnumberable<T>，而不是IList<T>或ICollection<T>
原则2：方法返回类型尽可能指定为最强的类型
    返回FileStream，而不是Stream
原则3：如果希望在不影响调用代码的情况下，能对方法内部实现进行修改，这时候返回类型要使用最弱类型中的最强的一个。
    使用IList<T> ，而不是List<T>

9.CLR不支持常量方法和常量参数