.NET C#基礎（7）：介面 - 人如何和貓互動

来源:https://www.cnblogs.com/HiroMuraki/archive/2022/06/10/16361278.html
-Advertisement-
Play Games

0. 文章目的 面向有一定基礎的C#初學者，介紹C#中介面的意義、使用以及特點。 1. 閱讀基礎 瞭解C#基本語法（如定義一個類、繼承一個類） 理解OOP中的基本概念（如繼承，多態） 2. 什麼是介面 2.1 現實中的協定與介面 貓貓頭在整理電腦文件，需要一個小工具來分類文件，於是貓貓頭向群里求助： ...


0. 文章目的

  面向有一定基礎的C#初學者，介紹C#中介面的意義、使用以及特點。

 

1. 閱讀基礎

  瞭解C#基本語法（如定義一個類、繼承一個類）

  理解OOP中的基本概念（如繼承，多態）

 

2. 什麼是介面

2.1 現實中的協定與介面

  貓貓頭在整理電腦文件，需要一個小工具來分類文件，於是貓貓頭向群里求助：

  “有沒有小伙伴幫我用Objective-C做一個分類文件的小工具”

  群里沒有人回答，貓貓頭意識到可能是因為會Objective-C的人比較少，於是改問：

  “有沒有小伙伴幫我用Rust做一個分類文件的小工具”

  群里依然沒有人回答，貓貓頭意識到可能是會Rust的人比較少，但貓貓頭此時還意識到，自己只是需要獲一個可以分類文件的小工具，用什麼語言好像並不重要。於是，貓貓頭想了一下，改問：

  “有沒有小伙伴可以幫我做一個分類文件的小工具”

  很快，群里有人用Shell幫貓貓頭寫了一個小工具，貓貓頭用小工具很快完成了任務。

 

  上述例子中，貓貓頭在請求幫助時，給出了一個可以幫忙上的‘前提’，即可以提供一個可以分類文件的小工具，而通過這個前提，貓貓頭的朋友知道如何幫助貓貓頭。我們將這種用於指示兩個實體之間（比如貓貓頭和TA的朋友之間）如何交互的‘前提’稱之為‘協定’。

  協定的最大意義在於規範了不同物件間的交互方式，一個物件如果想要知道如何與另一個物件交互，只需要瞭解與該物件交互所需要遵守的協定，而不需要考慮該物件的具體情況。就像貓貓頭只需要一個能分類文件的小工具，而幫忙的朋友到底如何實現這個小工具其實並無所謂。

  而現實中所謂的介面就是一種協定，例如設備的USB充電介面，任何只要滿足USB規範的連接線都可以接入其充電介面併為其供電，而至於電從哪裡來設備本身並不關心。介面是使物件得以模塊化的重要概念，介面定義了一種‘只要滿足即可交互’的規範，這可以極大程度上降低物件之間的耦合。

  對於編程語言來說，介面的主要作用也是用於為各個模塊之間做出協定，通過協定，模塊之間知道如何進行交互，而不需要為各種模塊進行特別編碼，以此可以最大程度減小模塊間的耦合度。

2.2 繼承與抽象類

（1）基石：繼承與多態

  在具體討論介面是什麼之前，需要先知道介面最早的樣子是什麼。首先我們定義一個Animal類，定義一個名為MakeSound的虛方法：

class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("make some noise");
    }
}

  接下來從Animal派生出兩個類，並重寫其MakeSound方法：

class Cat
{
    public override void MakeSound()
    {
        Console.WriteLine("meow meow");
    }
}

class Dog
{
    public override void MakeSound()
    {
        Console.WriteLine("woof woof");
    }
}

  由於Cat與Dog繼承自Animal，因此像下麵這樣代碼是可以使用的：

void Pet(Animal animal)
{
    animal.MakeSound(); 
}

Cat cat = new Cat();
Pet(cat);

Dog dog = new Dog();
Pet(dog);

（會輸出meow meow與woof woof）

  Animal類中定義了MakeSound方法，因此其肯定有一個MakeSound方法可以調用，而Cat與Dog都是Animal的子類，因此兩者也肯定有一個MakeSound方法可以調用，所以上述代碼是安全的。當調用時，由於多態，上述代碼會輸出‘meow meow’與‘woof woof’。

（2）進一步抽象

  上面的代碼中，Animal對MakeSound方法的定義的唯一意義在於保證了其有一個名為MakeSound的方法可以調用，而上文的Pet方法里調用Animal對象的MakeSound方式時，因為多態，實際調用的是Cat與Dog中重寫MakeSound的方法。也就是說，Animal如何實現MakeSound方法並不重要，因此完全可以不提供Animal中MakeSound方法的實現：

class Animal
{
    public virtual void MakeSound()
    {
        // 方法實現並不重要
    }; 
}

  然後另一方面，很多時候我們希望調用的MakeSound方法能做一些有意義的事，這就需要繼承自Animal的類都重寫該方法，所以我們可能還希望可以在編碼時要求Animal的子類重寫其MakeSound方法。

  C#提供了實現上述需求的方法，在C#中，有一種特殊的類叫做抽象類（abstract class），這種類不允許實例化，並且允許定義一種被稱為抽象方法（abstarct method）的方法，抽象方法指的是在當前類中不提供實現，轉而由子類提供實現的方法。下麵是將Animal類轉化為抽象類的示例：

abstract class Animal
{
    public abstract void MakeSound(); // 抽象方法不需要也不能提供方法實現，實現由子類完成
}

  （在class關鍵字前添加abstract可將類定義為抽象類，為方法添加abstract修飾符可將方法定義為抽象方法）

  現在，繼承自Animal類的類型都必須重寫其抽象方法MakeSound了，重寫抽象方法和重寫一般的虛方法一致：

class Cat
{
    public override void MakeSound()
    {
        Console.WriteLine("meow meow");
    }
}

class Dog
{
    public override void MakeSound()
    {
        Console.WriteLine("woof woof");
    }
}

  使用上也沒有什麼區別：

void Pet(Animal animal)
{
    animal.MakeSound(); 
}

Cat cat = new Cat();
Pet(cat);

Dog dog = new Dog();
Pet(dog);

  不知道看到這裡你是否意識到了什麼：Animal類保證了其子類有一個MakeSound方法可以被調用，所以Pet方法可以假定所有Animal的子類都有一個MakeSound方法，因此可以安全調用。也就是說，Animal類向外保證了其子類必然有一個MakeSound方法可以調用，而繼承自Animal的Cat與Dog類都實現了Animal對外的保證。

（3）介面

  再進一步來看，其實Pet方法中只需要對象可以提供MakeSound方法即可，至於對象的類型是否與Animal之間存在‘IS-A’關係並不重要，也就是說，對Pet方法來說只要對象可以‘保證’有一個MakeSound方法可以調用即可。現在我們將這一保證抽象出來，並用一個語義更清晰的類名來指代這種保證：

abstract class CanMakeSound
{
    public abstract void MakeSound();
}

  再進一步，在語言層面上提供語法支持來將其與抽象類區分開（定義為一個‘保證’，而不是一個類），我們使用interface來表示這一保證：

interface CanMakeSound
{
    public abstract void MakeSound();
}

  由於這隻是一種保證，所有裡面的方法都只是一種協定（表示有某個方法可以調用），因此方法只需要方法簽名即可（返回類型+方法名+參數列表），另外，既然是‘對外保證’可以調用某一方法，那麼方法也應該是public的，所以可以預設所有的方法聲明都是public的抽象方法：

interface CanMakeSound
{
    void MakeSound();
}

  這樣，通過一步步對抽象類的提煉，我們提出了介面（interface）的這一概念，在簡化語法的同時，CanMakeSound提供的‘保證’也有了更明確的語義。

  這就是介面的本質：協定行為，指明‘可以做什麼’，即‘CAN-DO’。介面是一個概念，不同的語言對介面概念的實現方式不同，例如C#為介面提供了語言級的支持，而一些沒有為介面提供語言級支持的編程語言也可以通過上述的抽象類來模擬介面，例如C++，另一方面，C#中的介面其實也可以視為一種特殊的抽象類。

  不過在繼續之前，我們來看看如果C#沒有對介面的支持將會是什麼樣。在上述例子中我們一開始用抽象類來模擬介面，由於C#不支持多重繼承，因此無法同時實現多個抽象類，如果要表示實現多個‘介面’就不得不一層一層繼承下去，這會使編碼變得複雜以至於難以維護：

abstract class Walkable { ... }
abstract class Flyable { ... }

class WalkableCat : Walkable { }
class WalkableAndFlyableCat : Flyable { }
class SuperCat : WalkableAndFlyableCat { }

  上述代碼中SuperCat使用了兩個輔助類WalkableCat和WalkableAndFlyableCat才得以同時實現Walkable與Flyable，甚至概念上來說SuperCat只是WalkableAndFlyableCat的子類，而不是有‘可以做什麼’的保證，語義上也缺乏清晰度。因此，C#將介面視為一種專門的類型，並提供語言級的支持是很有必要的。

 

3. C#中的介面

3.1 定義介面

  要在C#中定義一個介面，需要使用interface關鍵字，併在介面中定義協定的方法，下麵是一個介面定義：

interface IFlyable
{
    void Fly();
}

（根據C#的編碼建議，介面命名應該以大寫字母I開頭）

  上述代碼中，介面IFlyable協定了實現該介面的的類型都會有一個Fly方法可以調用，你可以把它想象成下麵這樣的抽象類：

abstract class IFlyable
{
    public abstract void Fly();
}

  對比兩者，可以發現定義介面時除了將abstract class替換為了interface外，對方法也沒有用public與abstract修飾，這一原因在前文已經提及過：由於介面本身就是用於對外協定行為，因此介面協定的方法自然應該是可以被外部訪問的public，同時介面中的方法只是提供一種協定，因此無需提供實現。

  當然，一個介面中可以協定多個方法：

interface IFlyable
{
    void Prepare();
    void Fly();
}

  但是，介面中不能定義欄位：

interface IFlyable
{
    string Name; // 不允許定義欄位
}

  這是由於介面的作用是協定行為，而所謂的行為就是方法。但是，你可以在介面中定義屬性甚至事件：

interface IFlayable
{
    event Action Prepared;
    string Name { get; set; }
    string this[int index] { get; set; } // 索引器也是屬性（有參數性）
}

  這是由於屬性本質上是方法，事件本質上是對多播委托的方法封裝，因此上面介面定義的實際含義如下：

interface IFlayable
{
    // event Action Prepared;
    void add_PreparedHandler(Action action);    // 註冊委托
    void remove_PreparedHandler(Action action); // 取消註冊委托
    
    // string Name { get; set; }
    string get_Name();         // 獲取Name屬性
    void set_Name(string val); // 設置Name屬性
    
    // string this[int index] { get; set; }
    string get_Item(int index);           // 獲取Item屬性
    void set_Name(int index, string val); // 設置Item屬性
}

3.2 使用介面

3.2.1 實現介面

  介面定義後，就可以讓類型去實現了。要讓一個類型實現介面很簡單，只需要‘繼承’該介面，然後實現該介面中協定過的方法即可，例如下麵用SuperCat實現IFlyable介面：

interface IFlyable
{
    void Fly();
}

class Cat { }
class SuperCat : Cat, IFlayable
{
    public void Fly()
    {
        Console.WriteLine("Flying");
    }
}

  上述代碼中特地讓SuperCat繼承自Cat類，只是為了說明實現一個介面的語法和繼承一個類型的語法相似，並且介面的位置要位於基類之後，所以下麵這樣是不行的：

class SuperCat : IFlayable, Cat { } // 錯誤，基類要在介面位置之前

  實現介面的方法時只需要保證方法簽名相同（返回類型+方法名+參數列表），而方法本身可以添加async、unsafe等方法修飾符，因此下麵SuperCat中的Fly方法也可以實現IFlyable：

class SuperCat : Cat, IFlayable
{
    public unsafe async void Fly()
    {
        Console.WriteLine("Flying");
    }
}

  另外，與繼承類最大的不同在於，類型可以實現多個介面，只實現了各個介面協定的方法即可：

// SuperCat繼承自Cat
class SuperCat : Cat, IFlyable, IWalkable, ISoundMaker
{ 
	// 實現IFlyable
	// 實現IWalkable
	// 實現ISoundMaker
}

3.2.2 調用介面

  可以像使用抽象類引用一樣使用介面引用，如下麵使用IFlyable：

void Call(IFlyable flyable)
{
    flyable.Fly(); // IFlyable介面協定了實現該介面的方法都有一個Fly方法可以調用
}

SuperCat superCat = new SuperCat();
Call(superCat);

  簡而言之，將介面視為一個抽象類使用即可。

3.3 進階介面操作

3.3.1 介面“繼承”

  介面與介面之間也可以繼承，例如：

interface IMachine
{
    void Launch();
}

interface IGameConsole : IMachine
{
    void PlayGame();
}

  上述代碼中IGameConsole介面“繼承”了IMachine介面，這意味著實現IGameConsole介面時除了要實現其協定的PlayGame方法外，也需要實現IMachine介面中協定的Launch方法：

class Xbox : IGameConsole
{
    public void Launch() { ... }   // IMachine協定的Launch方法
    public void PlayGame() { ... } // IGameConsole協定的PlayGame方法
}

  之所以要為“繼承”添加引號，是因為介面間的繼承行為從概念上來說應該稱為‘組合’，也就是說，IGameConsole並不是繼承了IMachine介面，而是對IMachine介面進行了組合。請記住這個概念，在後文中會提及原因。

3.3.2 顯式實現介面

  有時候多個介面協定的方法之間可能存在衝突，例如：

interface IGameConsole
{
    void Launch(); // 啟動游戲
}

interface IMachine
{
    void Launch(); // 啟動機器
}

class Xbox : IGameConsole, IMachine
{
    public void Launch() { ... } // 只能定義一個Launch
}

  上述代碼中的介面IGameConsole與IMachine都協定了一個Launch方法，然而兩個Launch方法所做的事並不一樣，因此需要分別對其進行實現。但顯然你只能定義一個Launch方法。要解決此類問題，就需要顯式實現介面。以上述情況為例，顯式實現介面的方法如下：

class Xbox : IGameConsole, IMachine
{
    void IGameConsole.Launch() { ... } // 實現IGameConsole的Launch
    void IMachine.Launch() { ... }     // 實現IMachine的Launch
}

  有兩個需要點需要關註：

  1. 顯式實現的方法沒有訪問修飾符
  2. 顯式實現的方法名為介面名.方法名

  由於顯式實現的方法沒有訪問修飾符，意味著其訪問許可權是預設的private，外部無法直接調用，但可以通過介面引用來調用相應的方法：

XBox xbox = new XBox();
// xbox.GetInformation(); // 不能直接調用

IGameConsole console = xbox;              // 使用IGameConsole引用
ConsoleInfo a = console.GetInformation(); // 調用Xbox中的IGameConsole.GetInformation

IMachine machine = xbox;                  // 使用IMachine引用
MachineInfo b = machine.GetInformation(); // 調用Xbox中的IMachine.GetInformation

  另外，對於類內部來說，也需要使用介面引用來調用：

class Xbox : IGameConsole, IMachine
{
    void IGameConsole.Launch() { ... } // 實現IGameConsole的Launch
    void IMachine.Launch() { ... }     // 實現IMachine的Launch
    
    void Test()
    {
        IGameConsole console = this;   // 使用介面引用調用IGameConsole的Launch方法
        console.Launch();
    }
}

  順便一提，由於要通過介面引用來調用方法，因此對值類型來說此時將會面臨裝箱問題。一般情況下，應該儘可能選擇預設的實現方式（即通過定義方法簽名相同的方法）而非顯式實現。

  現在回過頭來談論一下為什麼介面之間的“繼承”實際是‘組合’，還是對於下述列子：

interface IMachine
{
    void Launch(); // 這個Launch用來啟動機器
}

interface IGameConsole : IMachine
{
    void Launch(); // 這個Launc用來啟動游戲
}

class Xbox : IGameConsole
{
    void IGameConsole.Launch() { ... }
    void IMachine.Launch() { ... }
}

  你應該很快能理解上述代碼的意圖：IGameConsole組合了IMachine介面，Xbox實現IGameConsole介面，並顯式實現了兩個GetInformation方法。如果介面之間是繼承，那麼上述代碼從概念上說不通：IGameConsole繼承自IMachine，然後重寫了其同名的Launch方法，然而我們在實現介面的時候卻分別實現了IMachine和IGameConsole的Launch方法，那麼IGameConsole到底繼承了IMachine什麼？另一方面來講，協定的行為又如何用繼承關係描述？總不能說‘可以啟動游戲’繼承了‘可以開機’吧。因此，應當認識到介面之間的“繼承”實質是組合，即將協定進行組合。

3.3.3 介面方法的預設實現

  儘管介面協定的方法預設是抽象方法，但是你確實可以在介面中為協定的方法提供實現，這種方法被稱為預設介面方法：

interface IGameConsole
{
    void Launch()
    {
        Console.WriteLine("Launched");
    }
}

class Xbox : IGameConsole
{
    // 此時不需要為IGameConsole協定的Launch方法提供實現
}


Xbox xbox = new Xbox();
        
// 由於Launch方法在Xbox中沒有聲明為public，因此需要通過介面引用來調用
IGameConsole console = xbox;
console.Launch();

（輸出：Launched）

  實現介面時可以不實現介面中提供了預設實現的方法，但是由於方法沒有在實現該介面的類型中定義為public，因此此時該方法對外部來說無法訪問，此時則同樣需要通過介面引用來調用相應方法。另外，不必擔心兩個介面的預設實現出現衝突，如下：

interface IGameConsole
{
    void Launch()
    {
        Console.WriteLine("GameConsole Launched");
    }
}

interface IMachine
{
    void Launch()
    {
        Console.WriteLine("Machine Launched");
    }
}

class Xbox : IGameConsole, IMachine
{

}

  這是因為如果XBox沒有實現IGameConsole與IMachine的Launch方法，那麼外部要使用這兩個介面協定的方法就只能通過介面引用，那麼這時候顯然可以明確要調用的方法：

Xbox xbox = new Xbox();

IGameConsole console = xbox;
console.Launch(); // IGameConsole預設實現的Launch

IMachine machine = xbox;
machine.Launch(); // IMachine預設實現的Launch

  此外，如果對介面組合時出現方法衝突，編譯器會給出警告，此時可以使用new關鍵字來抑制警告：

interface IMachine
{
    void Launch()
    {
        Console.WriteLine("Machine Launched");
    }
}

interface IGameConsole : IMachine
{
    new void Launch() // new的含義是：本類型中與基類中相似簽名的成員沒有關係
    {
        Console.WriteLine("GameConsole Launched");
    }
}

（同樣此時只能通過介面引用來調用介面方法，因此也不會出現衝突）

  最後，如果類型中實現了介面的預設方法（無論是預設實現還是顯式實現），那麼就會覆蓋預設實現：

interface IGameConsole
{
    void Launch()
    {
        Console.WriteLine("Launched");
    }
}

class Xbox : IGameConsole
{
    public void Launch() // 實現IGameConsole的Launch方法
    {
        Console.WriteLine("Xbox Launched");
    }
}

Xbox xbox = new Xbox();

IGameConsole console = xbox;
console.Launch(); // 此時調用的是Xbox中定義的Launch

（上述代碼輸出‘Xbox Launched’）  

  然而，不推薦使用介面預設實現，因為介面本身應該只提供協定功能，一般情況下如果需要有預設實現更應該考慮使用基類而不是介面，或者定義一個實現了該介面的類，併在這個類中提供實現：

interface IGameConsole { ... }

class GameConsoleBase : IGameConsole { ... }

  通常真正需要預設實現的場合是需要更新某個介面，但又不希望影響之前已經使用了該介面的代碼。

3.3.4 為介面添加靜態方法

  你可以在介面中定義靜態方法：

interface IFoo 
{
    static void Hello() 
    {
        Console.WriteLine("Hello");
    }
}

  其使用和使用一般類的靜態方法沒有區別：

IFoo.Hello();

  靜態方法不屬於介面的協定，因此實現介面時不需要實現介面中的靜態方法，你可以把介面中的靜態方法理解為一個由該介面管理的方法。不過，C#目前有一項預覽功能，可以像協定普通方法一樣協定靜態方法，這在後文會提到。

3.3.5 指定介面成員的訪問修飾符

  介面成員預設的訪問修飾符為public，但你可以指定為其他修飾符：

interface IFoo 
{
    private void PrivateMethod()      // private訪問限制，必須提供預設實現
    {
        Console.WriteLine("Require defualt Implement");
    }
    
    protected void ProtectedMethod(); // protected訪問限制，可在組合了該介面的介面中使用
    
    internal void InternalMethod();   // internal訪問限制，同一程式集範圍內可用
    
    public void PublicMethod();       // pubilc訪問限制，預設的訪問限制
    
    // ... 還有一些很少用的組合訪問修飾符，這裡就不提了
}

  而當訪問限製為private時，由於這個方法只能用在介面內部訪問，無法在介面外為其提供實現，所以必須為其提供預設實現，通常private訪問級別是用於實現預設介面方法的輔助方法。另外再特別說明一下訪問限製為protected時的情況。當介面中協定的方法的訪問限製為protected時，如果要實現該方法，則必須顯式實現，否則不會被視為該方法的實現：

class Foo : IFoo
{
    void IFoo.ProtectedMethod() { ... }      // 顯式實現IFoo中的ProtectedMethod
    
    protected void ProtectedMethod() { ... } // 只是定義了一個ProtectedMethod方法而已，與介面無關
}

  另外，由於你只是‘實現’了該介面而不是‘繼承’了該介面，所以你也無法調用其方法：

class Foo : IFoo 
{
    void IFoo.ProtectedMethod() { ... }

    void Test()
    {
        IFoo foo = this;
        foo.ProtectedMethod(); // Foo和介面IFoo之間不是繼承關係，無法調用
    }
}

  這類方法只能在組合該介面的介面中調用：

interface IFoo 
{
    protected void ProtectedMethod();
}

interface Foo2 : IFoo 
{
    void DoSomething() 
    {
        ProtectedMethod(); // 可以訪問IFoo中的ProtectedMethod方法
    }
}

  你可能覺得這種既不能被外部訪問也不能被內部訪問的方法沒什麼用，不過下麵是一個使用例子：

查看代碼 
interface ISpeaker
{
    protected void Say(); // protected訪問許可權，只能在介面內以及組合了該介面的介面內使用
}

interface IRepeater : ISpeaker // IRepeater組合了ISpeaker
{
    void Repeat() // Repeat的預設實現，調用三次ISpeaker協定的Say方法
    {
        Say();
        Say();
        Say();
    }
}

class HelloRepeater : IRepeater
{
    void ISpeaker.Say() // 顯式實現了ISpeaker中協定訪問等級為protected的Say方法
    {
        Console.WriteLine("Hello!");
    }
}

class WorldRepeater : IRepeater
{
    void ISpeaker.Say() // 顯式實現了ISpeaker中協定訪問等級為protected的Say方法
    {
        Console.WriteLine("World!");
    }
}



void CallRepeater(IRepeater speaker)
{
    speaker.Repeat();
}

CallRepeater(new HelloRepeater());
CallRepeater(new WorldRepeater());

（輸出三次Hello!與三次World!）   

  儘管如此，通常來說訪問級別為protected的介面方法確實沒什麼明顯的作用，但在一些特殊的情況下可能對於封裝和修改現有系統有幫助。

3.4 特殊介面

3.4.1 泛型介面

  可以聲明一個泛型介面：

interface IDataObject<T>
{
    T GetData();
}

  上面定義了一個泛型介面IDataObject<>，泛型介面並不神秘，就如可以像理解抽象類一樣去理解介面，同樣可以用理解泛型類的方式去理解泛型介面，由於泛型不是本文重點故不多做闡述。不過，為了提高泛型介面的實用性，泛型介面還支持將類型參數聲明為協變數或逆變數，關於協變與逆變在另一篇文章里有所闡述，這裡也不再贅述。

3.4.2 協定靜態成員的介面

  前文提到過介面允許協定靜態成員，但截至目前這是C#的一項預覽功能，需要在項目的csproj配置文件中向PropertyGroup添加EnablePreviewFeatures以啟用語言的預覽功能：

<EnablePreviewFeatures>True</EnablePreviewFeatures>

  一個協定了靜態方法的介面如下（註意由於介面中本身可以定義靜態方法，所以需要添加abstract關鍵字來指示其為抽象方法）：

interface IGameConsole
{
    static abstract void PrintInfo();
}

  以及一個實現該介面協定的靜態方法的類：

class Xbox : IGameConsole
{
    public static void PrintInfo()
    {
        Console.WriteLine("A famous game console");
    }
}

  咋一看好像協定靜態方法的意義不大，因為調用靜態方法需要直接使用類型名，無法通過介面引用來調用。但是，考慮以下代碼：

interface IAddable<T> where T : IAddable<T>
{
    static abstract T operator +(T left, T right);
}


class Math<T> where T : IAddable<T>
{
    public static T Add(T left, T right)
    {
        return left + right;
    }
}

  由於運算符重載的本質是定義一個靜態方法，因此協定靜態方法意味著可以對類型允許使用的運算符進行協定，意味著可以在泛型中假定泛型類型可以進行+-*/等運算，這對於泛型約束來說非常有用，要知道在相當的一段時間里C#是沒有辦法假定泛型類型可以使用運算符的。需要說明的是你可能註意到上述代碼中泛型介面IAddable<>的 類型參數T的泛型約束是where T : IAddable<T>，看起來有點彆扭，這是因為運算符重載要求其參數類型至少有一個是當前類型，因此需要T是IAddable<T>類型（即自己）。

 

4. 介面雜談

4.1 介面在繼承鏈中的傳遞

  首先定義一個介面，基類以及其子類：

interface IGameConsole
{
    public void Launch();
}

class Xbox : IGameConsole
{
    public void Launch()
    {
        Console.WriteLine("Xbox Launched!");
    }
}

class XboxOne : Xbox { }

  既然基類實現了介面，那麼其子類必然也滿足介面的實現，因此下麵的代碼可以按預期運行：

IGameConsole console = new XboxOne(); // IGameConsole可以引用XboxOne
console.Launch(); // 輸出Xbox Launched!

  子類自然可以重新實現父類中實現過的介面協定，但是要分情況：

（1）父類中的方法不是虛方法，需要重新實現介面：

class XboxOne : Xbox, IGameConsole // 聲明重新實現IGameConsole
{
    public new void Launch()
    {
        Console.WriteLine("Xbox One Launched!");
    }
}

  （方法中的new修飾符不是必須的，但是加上會讓語義更清晰）

  這樣在使用介面引用時才能調用到正確的方法：

IGameConsole console = new XboxOne();
console.Launch(); // 輸出Xbox One Launched!

  而下麵的實現無法正確重新實現：

class XboxOne : Xbox
{
    public void Launch()
    {
        Console.WriteLine("Xbox One Launched!");
    }
}

  畢竟Xbox的Launch方法只是一個普通非虛方法，只是它可以實現IGameConsole介面的協定而已。

（2）父類中的方法為虛方法，直接重寫該虛方法即可：

class XboxOne : Xbox
{
    public override void Launch() // 如果基類的Launch方法被修飾為虛方法，則直接重寫即可
    {
        Console.WriteLine("Xbox One Launched!");
    }
}

  當然，嚴格來說這是多態的功勞（雖然介面本身的實現也依賴多態就是了）。

4.2 多重實現

  可以同時對介面進行預設實現和顯式實現：

interface IGameConsole
{
    void Launch();
}

class Xbox : IGameConsole
{
    public void Launch()       // 預設實現
    {
        Console.WriteLine("Xbox Launched!");
    }

    void IGameConsole.Launch() // 顯式實現
    {
        Console.WriteLine("A Game Console Launched");
    }
}

   不過從實際上來說，同時定義預設實現和顯式實現後，真正實現介面的是顯式實現，而預設實現此時就只是普通的方法而已。原因是因為使用介面無外乎通過下麵兩方式：

Xbox xbox = new Xbox();

xbox.Launch();    // 輸出Xbox Launched!

IGameConsole console = xbox;
console.Launch(); // 輸出A Game Console Launched

  第一是直接通過對象使用，但其實這和介面無關，這本身就只是一個普通的方法調用。

  第二是通過介面引用調用，這時候介面引用將調用顯式實現，因此顯式實現才是真正的實現。

  這是合理的，因為顯式實現的語義更明確。

5. 使用建議

5.1 基類 or 介面？

  使用基類有時也可以做到介面能做的事，而另一方面在面向介面編程成為一種流行時可能讓人在更應該使用基類的地方使用介面。關於選擇基類還是介面，主要有如下幾點可以考慮：

（1）IS-A還是CAN-DO。在OOP中繼承主要是描述類型間的IS-A關係，例如Cat繼承自Animal，因為Cat是一種（IS-A）Animal，而介面主要用於表示‘CAN-DO’，即表示類型‘可以做什麼’。

（2）是否需要儲存狀態或定義複雜行為。基類可以定義欄位，提供更豐富的方法實現，而介面不能定義欄位並且方法通常都是抽象方法（不推薦使用預設實現）。

（3）行為是否比類型重要。例如某一位置只需要使用類型FileUtil的某個方法來獲取文本數據，那麼此時重要的是獲取文本數據，至於數據是不是FileUtil提供的其實並不重要，此時若將獲取數據這一行為抽象為介面可以獲得提供更好的泛用性。

5.2 對介面的一些使用建議

（1）介面名以I開頭，並且儘可能以‘CAN-DO’風格命名，或者合適時使用名詞亦可。下麵是良好的介面名例子：

interface IEnumerable { ... }   // 表示可遍歷
interface IList { ... }         // 表示可以進行類似列表的操作
interface IFlyable { ... }      // 表示能飛
interface IDataProvider { ... } // 表示能提供數據

（2）介面一旦定義後應該儘可能避免修改，因為介面是協定，類型之間基於介面的協定而做出假設進行交互，隨意更改會使程式的維護變得複雜。

（3）介面的協定應該儘可能少，能滿足其介面名描述的行為即可。多個簡單的介面組合勝過一個所謂的“萬能”介面。

（4）介面應該提供詳細的註釋，以闡述該介面的協定。


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 乾貨合集│最好用的 python 庫都在這
    一、分詞 - jieba 優秀的中文分詞庫，依靠中文詞庫，利用詞庫確定漢子之間關聯的概率，形成分詞結果 import jieba word = '偉大的中華人民共和國' jieba.cut(word) jieba.lcut(word) 二、詞雲庫 - wordcloud 對數據中出現頻率較高的 關鍵 ...
  • EasyExcel-合併單元格
    pom版本 <dependency> <groupId>com.alibaba</groupId> <artifactId>easyexcel</artifactId> <version>2.2.7</version> </dependency> 1.自定義合併單元格 在某些業務場景中可能會有合併單 ...
  • Java日誌體系一本通
    主要內容 1·學習java日誌體系及日誌工具的演進 2·瞭解日誌採集、處理、分析等各階段的常用中間件 3·學會搭建完整的elk日誌平臺 4·學習日誌打點，切麵，日誌文件等輸出手段 5·項目實戰，完成一訪問日誌鏈路的跟蹤 1、Java日誌體系 1.1 體系概述 1.1.1 日誌介面 JCL：Apach ...
  • SpringCloud微服務實戰——搭建企業級開發框架（四十一）：擴展JustAuth+SpringSecurity+Vue實現多租戶系統微信掃碼、釘釘掃碼等第三方登錄
    前面我們詳細介紹了SSO、OAuth2的定義和實現原理，也舉例說明瞭如何在微服務框架中使用spring-security-oauth2實現單點登錄授權伺服器和單點登錄客戶端。目前很多平臺都提供了單點登錄授權伺服器功能，比如我們經常用到的QQ登錄、微信登錄、新浪微博登錄、支付寶登錄等等。 如果我們自己 ...
  • 【Java面試】什麼是可重入，什麼是可重入鎖? 它用來解決什麼問題?
    一個工作了3年的粉絲，去一個互聯網公司面試，結果被面試官懟了。 面試官說：”這麼簡單的問題你都不知道？ 沒法聊了，回去等通知吧“。 這個問題是： ”什麼是可重入鎖，以及它的作用是什麼？“ 對於這個問題，來看看普通人和高手的回答吧 普通人： 嗯。。。。。。。。。。。。。。。。。。 高手： 好的。 可重 ...
  • Java連接MySQL
    JDBC概述 JDBC（Java Data Base Connectivity,java資料庫連接）是一種用於執行SQL語句的Java API，可以為多種關係資料庫提供統一訪問，它由一組用Java語言編寫的類和介面組成。是Java訪問資料庫的標準規範。 JDBC提供了一種基準,據此可以構建更高級的工 ...
  • 手把手教你使用 Spring Boot 3 開發上線一個前後端分離的生產級系統（十） - ShardingSphere-JDBC 集成與配置
    手把手教你使用 Spring Boot 3 開發上線一個前後端分離的生產級系統（一） - 介紹 手把手教你使用 Spring Boot 3 開發上線一個前後端分離的生產級系統（二） - 資料庫設計 手把手教你使用 Spring Boot 3 開發上線一個前後端分離的生產級系統（三） - 項目初始化 ...
  • 1w+ 字總結 Java 常用類，整理太全了，建議收藏..
    來源：cnblogs.com/lwtyyds/p/15678152.html 常用類概述 內部類 Object類 包裝類 數學類 時間類 字元串 String Builder和StringBuffer DecimalFormat 內部類 「概念」 ：在一個類內部再定義一個完整的類。 一般情況下類與類 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類