C# 中的方法

  C# 提供的构造函数、操作符、转换操作符、属性等都应用了方法。
 
类的实例构造函数instance constructor:
  类的实例构造函数在方法定义源数据表(method definition metadata table)中称为 .ctor。创建类的实例对象时，会先调用其基类签名相同的构造函数，最后才执行类的构造函数。
          public ReferenceType() {.......}

值类型的实例构造函数：

     internal   struct  ValueTypes
     ... {
        private String m_s;
        private Int32 m_i;
        private Decimal m_d;

        public ValueTypes(String s, Int32 i)...{ // 定义值类型的有参构造函数
            m_s=s;
            m_i = i;
            m_d = 0;
        }
    }

值类型不能显式定义无参构造函数, 无参构造函数由CLR 定义，可以调用它。
          ValueTypes vt = new ValueTypes(); // 调用ValueTypes() 以将值类型中所有字段赋予其类型等价于0的值。
值类型可以定义有参构造函数，但必须在有参构造函数中对类型中所有字段进行初始化。
   public ValueTypes(String s, Int32 i)...{ // 定义值类型的有参构造函数
            m_s=s;
            m_i = i;
            m_d = 0;
       }  

静态构造函数static construct(也称类型构造函数type constructor、类型初始化器type initializer)：
  静态构造函数用于初始化类型中的静态字段。如果类型中定义了静态字段，可以在类型中显式定义一个静态构造函数，或不定义（这种情况会由编译器生成一个静态构造函数，并给生成类的类型定义表条目，附加BeforeFieldInit 元数据标记标记 “.class public auto ansi sealed beforefieldinit”）。
   可以在类型中显式定义静态构造函数，静态构造函数被标记为static ，静态构造函数通常是私有的，CLR 会自动地将静态构造函数标记为私有的。类型中只允许定义一个静态构造函数，且不能显式调用静态构造函数，实际中由CLR 负责调用静态构造函数。静态构造函数在方法定义元数据表中总被称为.cctor。

         static  ValueTypes()  ... {
            Single m_f = 4.5f; 
        }

操作符重载：
C#允许类型重载操作符（+、-、*、/、%、&、|、>、<、 !=）以操作类型自己的实例。

     internal   sealed   class  Complex
     ... {
        public Complex(Int32 i, String s) ...{
            this.m_i = i;
            this.m_s = s;
        }

        // 为Complex 类重载+、-操作符
        public static Complex operator+(Complex c1, Complex c2)...{
            return new Complex(c1.m_i + c2.m_i, c1.m_s + c2.m_s);
        }
        public static Complex operator-(Complex c1, Complex c2)...{
            return new Complex(c1.m_i - c2.m_i, c1.m_s + c2.m_s);
        }
        // 为Complex 类重载!=、==操作符
        public static Boolean operator==(Complex c1, Complex c2)...{
            return ((c1.m_i == c2.m_i)&&(c1.m_s == c2.m_s));
        }
        public static Boolean operator!=(Complex c1, Complex c2)...{
            return (c1.m_i != c2.m_i) && (c1.m_s != c2.m_s);
        }

        public override string ToString() ...{
            return this.m_i.ToString() + " " + this.m_s;
        }

        private Int32 m_i;
        private String m_s;
    }

转换操作符方法：
  有时需要将对象从一种类型转换到另一个不同的类型。当源类型和目标类型都是编译器的基元类型时，编译器知道如何生成转换对象所需的代码；如果源类型和目标类型不是基元类型或只有一个是基元类型，这时我们要创建转换操作符方法，以告诉编译器如何进行转换。

     public   sealed   class  Rational
     ... {
        // 由一个Int32 类型构造一个Rational 类型
        public Rational(Int32 num) ...{
            this.m_i = num;
        }
        public Rational(Single num) ...{
            this.m_s = num;
        }

        // 将一个Rational 类型转换为一个Int32 类型
        public Int32 ToInt32() ...{
            return this.m_i;
        }
        public Single ToSingle() ...{
            return this.m_s;
        }

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

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

        private Int32 m_i;
        private Single m_s;
    }

在关键字implicit 或关键字emplicit 之后，可以指定关键字operator 向编译器表明该方法是一个转换操作符方法。在关键字operator 后面，还需要指定对象要强制转换成什么类型。在圆括号中，需指定要进行强制转换的对象的类型。

属性perporty：
  属性分为有参属性（索引器indexer）和无参属性（perporty）。
  面向对象设计和面向对象编程的一个主要特点就是数据密封，属性是用来对类型中的私有字段进行密封的。它一般包含一个get 和一个set 访问器。类可以包含静态属性--密封一个静态字段、虚拟属性、实例属性。

     public   class  SomeType
     ... {
        public SomeType() ...{
            years = new Int32[3];
            objects = new Object[3];
        }
        public virtual String LastName ...{ // 虚拟属性
            get ...{ return lastName; }
            set ...{ lastName = value; }
        }
        public String FirstName ...{
            get ...{ return firstName; }
            set ...{ firstName = value; }
        }
        public static Single Age ...{ // 静态属性
            get ...{ return Age; }
            set ...{ age = value; }
        }

        // 类型可以提供多个索引器，只要它们的签名不同即可
        public Int32 this[Int32 year] ...{ // 索引器
            get ...{ return years[year]; }
            set ...{ years[year] = value; }
        }

        private String lastName;
        private String firstName;
        private static Single age; // 静态字段
        private Int32[] years;
        private Object[] objects;
    }