【C# Programming】继承、接口

一、继承

1、派生

继承在相似而又不同的概念之间建立了类层次概念。更一般的类称为基类，更具体的类称为派生类。派生类继承了基类的所有性质。

定义派生类要在类标识符后面添加一个冒号，接着添加基类名。

public class PdaItem
{
    public string Name { get; set; }
    public DateTime LastUpdated { get; set; }
}

// Define the Contact class as inheriting the PdaItem class
public class Contact : PdaItem
{
    public string Address { get; set; }
    public string Phone { get; set; }
}

除非明确指定了基类，否则所有类都默认从object 派生。

2、基类和派生类的转型

由于派生建立了“属于”关系，所以总可以将派生类的值赋给基类型的变量。这称为隐式类型转换。从基类型转换到派生类型，要求执行显式转型。方法是在原始引用名称前，将要转换成的目标类型放到圆括号中。

public static void Main()
{
    // Derived types can be implicitly converted to base types
    Contact contact = new Contact();
    PdaItem item = contact;//隐式类型转换

    // Base types must be cast explicitly to derived types 显示类型转换/强制类型转换
    contact = (Contact)item; 
    // ...
}

3、自定义转换

类型之间的转换并不限于单一继承链中的类型，不同类型相互之间也能进行转换，关键是两个类型之间提供转型操作符。 C# 允许显式或隐式转型操作符。例如：

class GPSCoordinates
{
    public static implicit operator UTMCoordinates(GPSCoordinates coordinates)
    { 
        // ...
        return null;//return the new UTMCoordinates object
    }
}
class UTMCoordinates { /*… */}

如果需要显式转换，可将implict 换成 explict。

4、private 访问修饰符

派生类继承了除构造器和析构器之外的所有基类成员，到那时私有成员只能在声明它们的那个类型中才能访问，派生类不能访问基类的私有成员。

public class PdaItem
{
    private string _Name;
    // ...
}

public class Contact : PdaItem
{
    // ...
}
public class Program
{
    public static void ChapterMain()
    {
        Contact contact = new Contact();
        // ERROR:  ‘PdaItem. _Name’ is inaccessible due to its protection level

        //contact._Name = "Inigo Montoya";  //uncomment this line and it will not compile
    }
}

5、protected 访问修饰符

基类中受保护的成员只能由基类以及派生链中的其他类访问。

public class Program
{
    public static void Main()
    {
        Contact contact = new Contact();
        contact.Name = "Inigo Montoya";
        // ERROR:  ‘PdaItem.ObjectKey’ is inaccessible due to its protection level
        //contact.ObjectKey = Guid.NewGuid(); //uncomment this line and it will not compile
     }
}
public class PdaItem   {  protected Guid ObjectKey { get; set; } }
public class Contact : PdaItem
{
    void Save()
    {
        // Instantiate a FileStream using <ObjectKey>.dat for the filename.
        FileStream stream = System.IO.File.OpenWrite(ObjectKey + ".dat");
    }
    void Load(PdaItem pdaItem)
    {
        // ERROR:  ‘pdaItem.ObjectKey’ is inaccessible due to its protection level
        //pdaItem.ObjectKey =...;
        Contact contact = pdaItem as Contact;
        if(contact != null)
            contact.ObjectKey = new Guid();//...; 
    }
    public string Name { get; set; }
}

6、单继承

继承链中的类理论是无限的。但是C#是单继承语言，意味着一个类不能从两个类中直接派生。
在极少数需要多继承类结构时，一般的解决方法是使用聚合(aggregation)即一个类包含另一个类的实例。

7、密封类

密封类要求使用sealed 修饰符，这样做的结果时不能从它们派生其他类。

public sealed class CommandLineParser
{
    // ...
}
// ERROR:  Sealed classes cannot be derived from
public sealed class DerivedCommandLineParser
    //: CommandLineParser //uncomment this line and it will not compile
{
    // ...
}

8、virtual 修饰符

C#支持重写(override)实例方法和属性，但不支持重写字段或者任何静态成员，为了重写，在基类中必须将允许重写的每个成员标记为virtual。

public class PdaItem
{
    public virtual string Name { get; set; }
}
public class Contact : PdaItem
{
    public override string Name
    {
        get {
            return $"{ FirstName } { LastName }";
        }
        set {
            string[] names = value.Split(' ‘);
            FirstName = names[0];
            LastName = names[1];
        }
    }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

C# 应用于派生类的override 关键字是必须的，C# 不允许隐式重写。为了重写，基类和派生类成员签名必须一致。

9、new 修饰符

如果重写方法没有使用override 关键字，则编译器会报告警告消息，一种方法是添加override关键字，另一种方法是使用new 修饰符。

warning CS0108: 'Program.DerivedClass.DisplayName()' hides inherited member 'Program.BaseClass.DisplayName()'. Use the new keyword if hiding was intended.

warning CS0114: 'Program.SuperSubDerivedClass.DisplayName()' hides inherited member 'Program.SubDerivedClass.DisplayName()'. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword.

new 修饰符在基类面前隐藏了派生类重新声明的成员，这时是搜索继承链，找到使用new 修饰符的那个成员前的成员，然后调用该成员，例如：

public class Program{
    public class BaseClass{
        public void DisplayName() => Console.WriteLine("BaseClass");
    }
    public class DerivedClass : BaseClass{
        // Compiler WARNING: DisplayName() hides inherited  member. Use the new keyword if hiding was intended.
        public virtual void DisplayName() => Console.WriteLine("DerivedClass");
    }
    public class SubDerivedClass : DerivedClass{
        public override void DisplayName() =>Console.WriteLine("SubDerivedClass");
    }
    public class SuperSubDerivedClass : SubDerivedClass{
        public new void DisplayName()  => Console.WriteLine("SuperSubDerivedClass");
    }
    public static void Main()
    {
        SuperSubDerivedClass superSubDerivedClass = new SuperSubDerivedClass();
        SubDerivedClass subDerivedClass = superSubDerivedClass;
        DerivedClass derivedClass = superSubDerivedClass;
        BaseClass baseClass = superSubDerivedClass;
        superSubDerivedClass.DisplayName();
        subDerivedClass.DisplayName();
        derivedClass.DisplayName();
        baseClass.DisplayName();
    }
}

10、sealed 修饰符

虚成员也可以密封，这样做会禁止子类重写继承链中高层基类的虚成员，例如：

class A
{
    public virtual void Method()
    {
    }
}
class B : A
{
     public override sealed void Method()
     {
     }
}
class C : B
{
     // ERROR:  Cannot override sealed members
     //public override void Method()
     //{
     //}
}

11、base 成员

重写成员时，可以使用base关键字调用该成员的基类版本。 base 表示当前类的基类。

public class Address
{
    public string StreetAddress;
    public string City;
    public string State;
    public string Zip;
    public override string ToString()
    {
        return $"{ StreetAddress + NewLine }"
            + $"{ City }, { State }  { Zip }";
    }
}
public class InternationalAddress : Address {
    public string Country;
    public override string ToString() => base.ToString() +NewLine + Country;
}

12、构造器

当构造派生类的对象时，基类的构造函数首先被调用。如果基类没有默认构造函数，则需要在派生类的构造函数中显示调用基类的构造函数，例如：

public class PdaItem
{
    public PdaItem(string name)
    {
        Name = name;
    }
    public string Name { get; set; }
}
public class Contact : PdaItem
{
    public Contact(string name) :
        base(name)
    {
        Name = name;
    }
    public new string Name { get; set; }
    // ...
}

13、抽象类

抽象类是仅供派生的类，无法实例化抽象类，只能实例化从它派生的类。不抽象，可以实例化的类称为具体类。

抽象类代表抽象的实体。一个类要从抽象类成功派生，必须为抽象类中的抽象方法提供具体实现. C#要求为类定义添加abstract 修饰符。

public abstract class PdaItem
{
    public PdaItem(string name)
    {
        Name = name;
    }
    public virtual string Name { get; set; }
}
public class Program
{
    public static void Main()
    {
        PdaItem item;
        // ERROR:  Cannot create an instance of the abstract class
        //item = new PdaItem("Inigo Montoya"); //uncomment this line and it will not compile
    }
}

14、抽象成员

不可实例化只是抽象类的一个较次要的特征，其主要特征是包含抽象成员。抽象成员是没有实现的方法或属性。其作用是强制所有派生类实现。

public abstract class PdaItem{
    public PdaItem(string name)
    {
        Name = name;
    }
    public virtual string Name { get; set; }
    public abstract string GetSummary();
}

public class Contact : PdaItem{
    public Contact(string name) : base(name) {}
    public override string Name
    {
        get{                
            return $"{ FirstName } { LastName }";
        }
        set{
            string[] names = value.Split(' ‘);
            FirstName = names[0];
            LastName = names[1];
        }
    }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Address { get; set; }
    public override string GetSummary() =>$"FirstName: { FirstName + NewLine }"
        + $"LastName: { LastName + NewLine }" + $"Address: { Address + NewLine }";
}

public class Appointment : PdaItem
{
    public Appointment(string name) :
        base(name)
    {
        Name = name;
    }

    public DateTime StartDateTime { get; set; }
    public DateTime EndDateTime { get; set; }
    public string Location { get; set; }

    // ...
    public override string GetSummary()
    {
        return $"Subject: { Name + NewLine }"
            + $"Start: { StartDateTime + NewLine }"
            + $"End: { EndDateTime + NewLine }"
            + $"Location: { Location }";
    }
}

相同签名的成员在不同类中的不同实现，称为多态性（polymorphism).抽象成员是实现多态的一个手段

public class Program{
    public static void Main()
    {
        PdaItem[] pda = new PdaItem[3];
        Contact contact = new Contact("Sherlock Holmes");
        contact.Address = "221B Baker Street, London, England";
        pda[0] = contact;
        Appointment appointment = new Appointment("Soccer tournament");
        appointment.StartDateTime = new DateTime(2008, 7, 18);
        appointment.EndDateTime = new DateTime(2008, 7, 19);
        appointment.Location = "Estádio da Machava";
        pda[1] = appointment;
        contact = new Contact("Anne Frank");
        contact.Address = "Apt 56B, Whitehaven Mansions, Sandhurst Sq, London";
        pda[2] = contact;
        List(pda);
    }
    public static void List(PdaItem[] items)
    {
        // Implemented using polymorphism. The derived type knows the specifics of implementing GetSummary().
        foreach(PdaItem item in items)
        {
            Console.WriteLine("________");
            Console.WriteLine(item.GetSummary());
        }
    }
}

15、System.Object

任何对象，不管是自定义类型，还是系统内建类型，都最终从Sytem.Object派生。因此，都定义了如下方法：

16、使用 is 操作符验证基础类型

C# 允许在继承链中向下转型。C#提供了is 操作符判断基础类型。它允许验证一个数据项是否是属于特定类型

public class AnObject
{
    public static void Save(object data)
    {
        if(data is string)
        {
            data = Encrypt((string)data);
        }
        // ...
    }

    private static object Encrypt(string data)
    {
        return null;
    }
}

17、使用 as 操作符进行转换

as 操作符尝试将对象转换为特定类型，如果对象不能转换,as 操作符返回null. 因而转型失败不会引发异常

class Program
{
    static object Print(IDocument document)
    {
        if(document != null)
        {
            // Print document...
        }
        return null;
    }
    static void  Main()
    {
        object data = new object();
        // ...
        Print(data as Document);
    }
}
internal class Document : IDocument
{
}
internal interface IDocument
{
}

二、接口

1、概述

和抽象类不同，接口能将实现细节和提供的服务完全隔离开。接口的关键特点是既不包含实现，也不包含数据。
按照惯例，接口名采用Pascal大小写风格，以大写字母I 作为前缀
- interface Ixxxx { //... }
接口声明的成员描述了在实现该接口的类型中必须能够访问的成员

interface IFileCompression
{
    void Compress(string targetFileName, string[] fileList);
    void Uncompress(
        string compressedFileName, string expandDirectoryName);
}

如果接口要求派生类包含特定数据，会声明属性而不是字段

interface IListable {
    string[] ColumnValues // Return the value of each column in the row.
    {
        get;
    }
}
public abstract class PdaItem{
    public PdaItem(string name) {
        Name = name;
    }
    public virtual string Name { get; set; }
}
class Contact : PdaItem, Ilistable{
    public Contact(string firstName, string lastName, string address, string phone)
	    : base(null)
    {
        FirstName = firstName; 
        LastName = lastName; 
        Address = address;
        Phone = phone;
    }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Address { get; set; }
    public string Phone { get; set; }
    public string[] ColumnValues {
        get {
            return new string[] { FirstName, LastName, Phone, Address };
        }
    }
    public static string[] Headers {
        get { return new string[] {"First Name", "Last Name ", "Phone ", "Address" };
    }
}

2、接口实现

声明类以实现接口，类似于从基类派生：要实现的接口和基类名称以逗号分隔，基类在前，接口顺序任意。类可以实现多个接口，但只能从一个基类直接派生。例如：

public class Contact : PdaItem, IListable, IComparable
{
    public Contact(string name) : base(name) {}
    #region IComparable Members
    public int CompareTo(object obj)
    {
        int result;
        Contact contact = obj as Contact;、
        if(obj == null) 
            result = 1; // This instance is greater than obj. 
        else if(obj.GetType() != typeof(Contact)) 
            throw new ArgumentException($"The parameter is not a of type { nameof(Contact) }", nameof(obj));
        else if(Contact.ReferenceEquals(this, obj))
            result = 0;
        else {
                result = LastName.CompareTo(contact.LastName);
                if(result == 0)
                    result = FirstName.CompareTo(contact.FirstName);
            }
            return result;
        }
        #endregion
        string[] IListable.ColumnValues{
        get {
            return new string[]  {FirstName, LastName, Phone, Address};
        }
    }
    protected string LastName { get; set; }
    protected string FirstName { get; set; }
    protected string Phone { get; set; }
    protected string Address { get; set; }
}

一旦某个类声明自己要实现的接口，接口所有成员都必须实现，抽象类允许提供接口成员的抽象实现。
接口的另一特征是永远不能实例化。不能用new 创建接口，所以接口没有构造器或者析构器。只有实例化实现接口的类型，才能使用接口实例。接口不能包含静态成员
在类型中实现接口成员时有两种方式：显式和隐式

3、显示成员实现

显式声明的接口成员需要在成员名前附加接口前缀，例如：

public class Contact : PdaItem, IListable, IComparable {
    //….
    string[] IListable.ColumnValues{
        get {
            return new string[]  {FirstName, LastName, Phone, Address};
        }
    }
}

显式实现的接口只能通过接口本身调用，因此需要将对象转型为接口。显式实现的接口成员直接和接口关联，因此不允许使用virtual, override, 或者public 来修饰他们。例如：

public class Program
{
    public static void Main()
    {
         string[] values;
         Contact contact1, contact2 = null;
         // ERROR:  Unable to call ColumnValues() directly on a contact.
         // values = contact1.ColumnValues;
         // First cast to IListable.
         values = ((IListable)contact2).ColumnValues;
         // ...
    }
}

4、隐式成员实现

隐式实现只要求成员是公共的且签名与接口成员的签名相符。接口成员实现不需要override 关键字或者其他任何表明该成员与接口关联的指示符。

由于成员是像其他类成员那样声明的，所以可以像调用其它类成员那样直接调用隐式实现的成员。 result = contact1.CompareTo(contact2);

隐式实现上，显式实现不允许的许多修饰符是必须或者可选的。例如：隐式实现必须式public.而且还可选择virtual.具体取决于派生类是否可以重写。去掉virtual 导致成员密封。

5、显式接口实现与隐式接口实现的比较

选择显示实现还是隐式实现的基本原则：

如果成员是类的辅助成员，则必要设计成类的直接可见成员
假设接口成员的用途在实现类中不明确，就可以考虑显式成员
显式接口成员不会在类型的声明空间添加具名元素。所以，假如类型有一个潜在的与之相冲突的成员。那么另一个是显式的接口成员，就可以与之同名

6、接口继承

一个接口可以从另一个接口派生，派生的接口将继承“基接口”的所有成员。例如：

interface IReadableSettingsProvider
{
    string GetSetting(string name, string defaultValue);
}
interface ISettingsProvider : IReadableSettingsProvider
{
    void SetSetting(string name, string value);
}
class FileSettingsProvider : ISettingsProvider{
    public void SetSetting(string name, string value)  { /*.. */ }
    public string GetSetting(string name, string defaultValue)
    {
        return name + defaultValue; // just returning this for the example
    }
}

假如显式实现GetSetting，必须通过IReadableSettingsProvider
即使类实现的接口是从基接口派生的，这个类任然可以可以声明自己要实现这两个接口。例如：

interface IReadableSettingsProvider
{
    string GetSetting(string name, string defaultValue);
}
interface ISettingsProvider : IReadableSettingsProvider
{
    void SetSetting(string name, string value);
}
class FileSettingsProvider : ISettingsProvider， IReadableSettingsProvider{
    public void SetSetting(string name, string value)  { /*.. */ }
    public string GetSetting(string name, string defaultValue)
    {
        return name + defaultValue; // just returning this for the example
    }
}

7、多接口继承

接口也能从多个接口继承，而且语法与类的继承和实现语法一致。

interface IReadableSettingsProvider
{
    string GetSetting(string name, string defaultValue);
}
interface IWriteableSettingsProvider
{
    void SetSetting(string name, string value);
}
interface ISettingsProvider : IReadableSettingsProvider,
    IWriteableSettingsProvider
{
}

8、接口上的扩展方法

扩展方法的一个重要特点是除了能作用于类，还能作用于接口，语法和作用于类一致。方法的第一个参数是要扩展的接口，该参数必须附加this 修饰符。

class Program
{
    public static void Main()
    {
        Contact[] contacts = new Contact[6];
        contacts[0] = new Contact("Dick", "Traci", "123 Main St., Spokane, WA 99037", "123-123-1234");
        contacts.List(Contact.Headers); // Classes are implicitly converted totheir supported interfaces.
        Console.WriteLine();
        //…..
    }
}
static class Listable
{
    public static void List( this IListable[] items, string[] headers)
    {
        //....
    }
}

9、通过接口实现多继承

虽然类职能从一个基类派生。但是可以实现任意数量的接口

interface IPerson {
    string FirstName {get; set;   }
    string LastName{get;  set; }
}
public class Person : IPerson {
    public string FirstName { get; set; }
    public string LastName { get; set; }
}
public class Contact : PdaItem, IPerson {
public Contact(string name)
    : base(name) {}
    private Person Person
    {
        get { return _Person; }
        set { _Person = value; }
    }
    private Person _Person;
    public string FirstName
    {
        get { return _Person.FirstName; }
        set { _Person.FirstName = value; }
    }        
    public string LastName {
        get { return _Person.LastName; }
        set { _Person.LastName = value; }
    }
}