第十章 定义类成员

10.1成员定义
    1.类成员包括字段、方法和属性。所有的成员都有自己的访问级别
    public----成员可以由任何代码访问。
    private---成员只能由类中代码访问。
    internal--成员只能由定义它的项目（程序集）内部的代码访问。
    protected--成员只能由类或派生类中的代码访问。
    protected internal---只能由项目（程序集）中派生类的代码访问。
    字段、方法和属性都可以使用关键字static来声明，这表示它们是类的静态成员，而不是对象实例的成员。
   
    2.定义字段
    公共字段以PascalCasing形式来命名，私有字段通常使用camelCasing来命名。
    字段可以使用关键字readonly，表示这个字段只能在执行构造函数的过程中赋值，或由初始化赋值语句赋值。
    class MyClass
    {
        public readonly int MyInt = 17;
    }
   
    字段可以使用关键字static声明为静态,静态字段可以通过它们的类来访问，而不是通过这个类的对象实例来访问。
    字段可以使用关键字const来创建一个常量。

    3.定义方法
    公共方法用PascalCasing形式来命名
    virtual---------方法可以重写。
    abstract--------方法必须在非抽象的派生类中重写（只用于抽象类中）。
    override--------方法重写了一个基类方法（如果方法被重写，必须使用该关键字）。
    extern----------方法定义放在其他地方。
    如果使用了override，也可以使用sealed指定在派生类中不能对这个方法作进一步的修改，即这个方法不能由派生类重写。

    4.定义属性
    属性拥有两个类似于函数的块，一个块拥有获取属性的值，另一个块用于设置属性的值。这两个块称为访问器，分别用get和set关键字定义。
    可以忽略其中的一个块来创建只读或制鞋属性。还可以在访问器上包含可访问修饰符。
    .NET Framework中的公共属性与字段和方法一样，以PascalCasing方法来命名。
    private int myInt;
    public int MyIntProp
    {
        get
        {
            return myInt;
        }
        set
        {
            myInt = value;
        }
    }
    如果set块赋予了无效的值有4中选择：
    1）什么都不做
    2）给字段赋默认值
    3）继续执行，但记录下该事件
    4）抛出一个异常
    一般情况下，后两个选择比较好，这取决于如何使用类，以及给类的用户授予多少控制权。
    set
     {
        if (value >= 0 && value <= 10)
           intVal = value;
        else
           throw (new ArgumentOutOfRangeException("Val", value,
              "Val must be assigned a value between 0 and 10."));
     }
    属性可以使用virtual,override,abstract关键字，但这几个关键字不能用于字段。
    private int myInt;
    public int MyIntProp
    {
        get
        {
            return myInt;
        }
        protected set
        {
            myInt = value;
        }
    }
    访问器可以使用什么可访问修饰符，取决于属性的可访问性，访问器的可访问性不能高于它所属的属性。

10.2 类成员的其他议题
    1.隐藏基类方法
    无论继承的成员是否为虚拟，都可以隐藏这些执行代码
    public class MyBaseClass
    {
        public virtual void DoSomething()
        {
            Console.WriteLine("Base imp");
        }
    }
    public class MyDerivedClass :MyBaseClass
    {
        public override void DoSomething()
        {
            Console.WriteLine("Derived imp");
        }
    }
    MyDerivedClass myObj = new MyDerivedClass();
    MyBaseClass myBaseObj;
    myBaseObj = myObj;
    myBaseObj.DoSomething();
    //Derived imp
    重写方法是替换基类中的执行代码

    public class MyDerivedClass :MyBaseClass
    {
         new public  void DoSomething()
        {
            Console.WriteLine("Derived imp");
        }
    }
    //Base imp
    new关键字隐藏了基类的执行代码，但仍可以通过基类访问它。
   
    2.调用重写或隐藏的基类方法
    无论是重写成员还是隐藏成员，都可以在派生类的内部访问基类成员
    1)要对派生类的用户隐藏继承的公共成员，但仍能在类中访问其功能
    2)要给继承的虚拟成员添加执行代码，而不是简单地用重写的新执行代码替换它
    可以使用base关键字，它表示包含在派生类中的基类的执行代码
    public class MyDerivedClass :MyBaseClass
    {
        public override void DoSomething()
        {
            base.DoSomething();
        }
    }
   
    this关键字
    可以用在类成员内部，且该关键字也引用对象实例。由this引用的对象实例是当前的对象实例
    最常用的功能是把当前对象实例的引用传递给一个方法.
    public void doSomething()
    {
        MyTargetClass myObj = new MyTargetClass（）；
        myObj.DoSomethingWith(this);
    }
   
    3.嵌套的类型定义
    可以在类中定义类，就可以在定义中使用各种访问修饰符，而不仅仅是public,internal，也可以使用new关键字隐藏继承于基类的类型定义。
    如果实例化，必须限定名称。
    功能主要用于定义于其包含类来说是私有的类，这样命名空间中的其他代码就不能访问。
    public class MyClass
    {
        public class myNestedClass
        {
            public int nestedClassField;
        }
    }
    MyClass.myNestedClass myObj = new MyClass.myNestedClass();
   
10.3 接口的实现
    1.接口成员的定义
     1)不允许使用访问修饰符(public、private、protected、internal),所有的接口成员都是公共的
     2)接口成员不能包含代码体
     3)接口不能定义字段成员
     4)接口成员不能用关键字static、virtual、abstract、sealed来定义
     5)类型定义成员是禁止的
    隐藏继承了基接口的成员，可以用关键字new
    interface IMyBaseInterface
    {
        void DoSomething ();
    }
    interface IMyDerivedInterface :IMyBaseInterface
    {
        new void DoSomething ();
    }

    2.在类中实现接口
    实现接口的类必须包含该接口所有成员的执行代码，且必须匹配指定的签名，并且必须是公共的。
    public interface IMyInterface
    {
        void DoSomething ();
        void DoSomethingElse ();
    }
   
    public class MyClass :IMyInterface
    {
        publicvoid DoSomething ()
        {}
        public void DoSomethingElse ()
        {}
    }
   
    可以使用关键字virtual或abstract来执行接口成员，但不能使用static或const。
    接口成员还可以在基类上实现。
    public interface IMyInterface
    {
        void DoSomething ();
        void DoSomethingElse ();
    }
    public class MyBaseClass
    {
        public void DoSomething ();
        {}
    }
    public class MyDerivedClass :MyBaseClass,IMyInterface
    {
        public void DoSomethingElse ()
        {}
    }
   
    显示执行接口成员
    接口成员由类显示地执行，该成员就只能通过接口来访问，不能通过类来访问。
    public interface IMyInterface
    {
        void DoSomething ();
        void DoSomethingElse ();
    }
    public class MyClass :IMyInterface
    {
        void IMyInterface.DoSomething ()
        {}
        public void DoSomethingElse ()
        {}
    }
   
    用非公共的可访问性添加属性访问器
    如果在定义属性的接口中只包含set，可以给类中的属性添加get，反之亦然。
    但是，只有所添加的访问器的可访问修饰符比接口中定义的访问器的可访问修饰符更严格，才能做。
    public interface IMyInterface
    {
        int MyIntProperty
        {
            get;
        }
    }
    public class MyBaseClass :IMyInterface
    {
        protected int myInt;
        public int MyIntProperty
        {
            get
            {
                return myInt;
            }
            protected set
            {
                myInt = value;
            }
        }
    }
   
10.4 部分类定义
    使用类定义(partial class definition)，使用部分类定义，使类的定义横跨多个文件。
    只需在每个包含部分类定义的文件中对类使用partial关键字即可。