带着问题读CLR via C#（七）方法

Q1: 类中的实例构造函数可否被继承？

A1: 实例构造函数永远不能被继承。

 

Q2: 抽象类可否包含有参实例构造函数，如果可以，何时会被调用？

A2: 可以。抽象类有参构造函数通过其子实体类的构造函数调用，且若该抽象类没有提供无参构造函数，其子实体类必须显式调用一个它的有参构造函数，否则编译器会报错。代码如下：

    abstract class AbstractClass
    {
        public int Id { get; set; }
        public AbstractClass(int id)
        {
            Id = id;
        }
    }

    class ErrorSon : AbstractClass
    {
        public string Name { get; set; }

        // This line will throw an exception when compile the code: 'Test.AbstractClass' does not contain a constructor that takes 0 arguments    
        public ErrorSon(string name)
        {
            Name = name;
        }
    }

    class CorrectSon : AbstractClass
    {
        public string Name { get; set; }

        // Call the constructor of the abstract class explicitly
        public CorrectSon(int id, string name)
            : base(id)
        {
            Name = name;
        }
    }

 

Q3: 值类型可否定义构造函数？

A3: CLR允许值类型定义构造函数，但C#编译器不允许值类型定义无参构造函数，执行值类型构造函数的唯一可能是显式去调用。CLR不会为值类型生成默认的无参构造函数，值类型的任何构造函数都必须初始化值类型所有字段。代码如下：

struct Point
{
    public int X;
    public int Y;
    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
}

class Test
{
    public Point point { get; set; }
    public Test()
    {
        point = new Point(5, 5);
    }
}

 

Q4: 静态构造函数有什么特点？

A4: 1）只在第一次用到该类时执行一次；2）只能定义一次且不能包含参数；3）只能访问类型的静态字段；4）不能包含访问修饰符，默认private.

 

Q5: 多个线程同时访问一个类，静态构造函数如何确保不被多次执行？

A5: 在调用静态构造函数时，调用线程会获取一个互斥线程同步锁，这样如果多个线程想要同时调用一个类型的静态构造函数，只有一个线程可以获得锁，其它线程会被阻塞掉。第一个线程执行了静态构造函数之后，等待的线程会被唤醒，发现该静态构造函数已经被执行，就不会再次执行。

 

Q6: 如何重载操作符？

A6: CLR规范要求操作符重载方法必须是public static, C#语言规范要求操作符重载至少有一个参数的类型与当前定义这个方法的类型相同。代码如下：

class Point
{
    public int X { get; set; }
    public int Y { get; set; }

    public static Point operator +(Point p1, Point p2)
    {
        return new Point() { X = p1.X + p2.X, Y = p1.Y + p2.Y };
    }
}

static void Main(string[] args)
{
    Point p1 = new Point();
    p1.X = 5;
    p1.Y = 5;
    Point p2 = new Point();
    p2.X = 10;
    p2.Y = 20;

    Point p3 = p1 + p2;
    Console.WriteLine(p3.X);
    Console.WriteLine(p3.Y);
    Console.Read();
}

运行结果：

 

Q7: 什么是转换操作符方法？如何重载？

A7: 转换操作符是将对象从一个类型转换到另一个类型的方法。CLR规范要求转换操作符重载方法必须是public static, C#语言规范要求参数类型和返回类型二者必有其一与定义转换方法的类型相同。代码如下：

    class Rational
    { 
        // 由int32构建Rational对象
        public Rational(Int32 num)
        {
            //...
        }
        
        // 由Single构建Rational对象
        public Rational(Single num)
        { 
            //...
        }

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

        // 由一个Rational转换为Single
        public Single ToSingle()
        {
            //...
        }        

        // 有一个Int32隐式构建并返回一个Rational对象
        // implicit关键字：告诉编译器为了生成代码来调用此方法，不需要在源代码中进行显示转换
        public static implicit operator Rational(Int32 num)
        {
            return new Rational(num);
        }

        // 由一个Single隐式构建并返回一个Rational对象
        public static implicit operator Rational(Single num)
        {
            return new Rational(num);
        }

        // 由一个Rational显式返回一个Int32
        // explicit关键字：告诉编译器生成代码来调用此方法，必须要在源代码中进行显式转换
        public static explicit operator Int32(Rational r)
        {
            return r.ToInt32();
        }

        // 由一个Rational显式返回一个Single
        public static explicit operator Single(Rational r)
        {
            return r.ToSingle();
        }
    }

 

Q8: 什么是扩展方法，扩展方法如何创建，创建过程中应注意什么？

A8: 通过扩展方法，开发人员可以向已定义的数据类型添加自定义功能，而不用创建新的派生类型。 通过使用这些扩展方法，可以编写一个能够像调用现有类型的实例方法那样进行调用的方法。扩展方法必须在非泛型静态类中声明，对类名没有要求，第一个参数必须用this关键字标记要扩展的类型名。定义扩展方法的静态了必须文件作用域，即不能为嵌套在另一个类中类。多个静态类可以定义相同的扩展方法，此时不能用实例来调用扩展方法，需要用静态方法调用方式显式调用某一个静态方法。代码如下：

    class Program
    {
        static void Main(string[] args)
        {
            string s = "http://www.googl.com";

            // 以实例方式调用扩展方法
            Uri uri = s.ConvertToUri();

            // 因为StringExtension类和StringExtension2类同时定义了AllAreCapital方法，
            // 所以不能用实例来调用，需要以调用静态方法的语法显式调用
            bool allAreCaplital = StringExtension.AllAreCapital(s);
        }
    }

    public static class StringExtension
    { 
        // 扩张方法将string转换为uri
        public static Uri ConvertToUri(this String s)
        {
            // ...
        }

        // 扩展方法确定字符串是否所有字母为大写
        public static bool AllAreCapital(this String s)
        {
            // ...                                
        }
    }

    public static class StringExtension2
    {
        // 扩展方法确定字符串是否所有字母为大写
        public static bool AllAreCapital(this String s)
        {
            // ...                                
        }
    }

扩展方法调用实际是对静态方法的调用，所以CLR不会生成代码对调用方法的表达式的值进行null检测，如以下代码是可以成功执行的：

    class Program
    {
        static void Main(string[] args)
        {
            string str = null;
            str.Print();
            Console.Read();
        }
    }

    public static class StringExtension
    {
        public static void Print(this string str)
        {
            Console.WriteLine("Executed!");
        }
    }

若一个扩展方法的名称和一个实例方法相同，则该扩展方法永远不会被执行。

为了能够快速检测到扩展方法，在C#中，一旦用了this关键字标记某个静态方法的第一个参数，编译器就会在内部向该方法应用一个ExtensionAttribute特性，这个特性会在最终生成的文件的元数据中持久性地储存下来，任何静态方法只要包含了至少一个扩展方法，它的元数据中也会应用这个特性，任何程序集只要包含了至少一个定义了静态方法的静态类，它的元数据中也会应用这个特性。

 

Q9: 什么是分部方法，分部方法如何创建，它的作用是什么？

A9: 分部类或结构可以包含分部方法。 类的一个部分包含方法的签名。 可以在同一部分或另一个部分中定义可选实现。 如果未提供该实现，则会在编译时移除方法以及对方法的所有调用。代码如下：

// Definition in file1.cs
partial void onNameChanged();

// Implementation in file2.cs
partial void onNameChanged()
{
  // method body
}

定义分部方法应注意：1）它只能在分部类或结构中声明；2）返回类型始终是void，任何参数不能使用out修饰符；3）可以使用ref参数，可以是泛型方法，可以是实例或静态方法，也可以使用标记为unsafe；4）声明和实现必须具有完全相同的签名；5）分部方法总被是为private，但是C#编译器禁止显式在方法名前加private关键字。