interface (Referenční dokumentace jazyka C#)

Rozhraní definuje kontrakt. Všechny class nebo struct implementované kontrakty musí poskytovat implementaci členů definovaných v rozhraní. Rozhraní může definovat výchozí implementaci pro členy. Může také definovat static členy, aby poskytovala jednu implementaci pro společné funkce. Počínaje C# 11 může rozhraní definovat nebo static virtual členové deklarovatstatic abstract, že implementovaný typ musí poskytovat deklarované členy. Metody obvykle deklarují, static virtual že implementace musí definovat sadu přetížených operátorů.

V následujícím příkladu musí třída ImplementationClass implementovat metodu s názvem SampleMethod, která nemá žádné parametry a vrací void.

Další informace a příklady najdete v tématu Rozhraní.

Ukázkové rozhraní

interface ISampleInterface
{
    void SampleMethod();
}

class ImplementationClass : ISampleInterface
{
    // Explicit interface member implementation:
    void ISampleInterface.SampleMethod()
    {
        // Method implementation.
    }

    static void Main()
    {
        // Declare an interface instance.
        ISampleInterface obj = new ImplementationClass();

        // Call the member.
        obj.SampleMethod();
    }
}

Rozhraní může být členem oboru názvů nebo třídy. Deklarace rozhraní může obsahovat deklarace (podpisy bez jakékoli implementace) následujících členů:

Výchozí členové rozhraní

Tyto předchozí deklarace členů obvykle neobsahují tělo. Člen rozhraní může deklarovat tělo. Členské orgány v rozhraní představují výchozí implementaci. Členové s orgány umožňují rozhraní poskytovat "výchozí" implementaci pro třídy a struktury, které neposkytují přepsání implementace. Rozhraní může zahrnovat:

Statické abstraktní a virtuální členy

Počínaje jazykem C# 11 může rozhraní deklarovat static abstract a static virtual členové pro všechny typy členů kromě polí. Rozhraní mohou deklarovat, že implementace typů musí definovat operátory nebo jiné statické členy. Tato funkce umožňuje obecným algoritmům určit chování podobné číslům. Příklady můžete zobrazit v číselných typech v modulu runtime .NET, například System.Numerics.INumber<TSelf>. Tato rozhraní definují běžné matematické operátory implementované mnoha číselnými typy. Kompilátor musí vyřešit volání a static virtualstatic abstract metody v době kompilace. Metody static virtual a static abstract metody deklarované v rozhraních nemají mechanismus dispečerského modulu runtime analogický s virtual metodami nebo abstract metody deklarované ve třídách. Místo toho kompilátor používá informace o typu dostupné v době kompilace. static virtual Proto jsou metody téměř výhradně deklarovány v obecných rozhraních. Většina rozhraní, která deklarují nebo static abstract deklarujístatic virtual, že jeden z parametrů typu musí implementovat deklarované rozhraní. Například rozhraní deklaruje, INumber<T> že T musí implementovat INumber<T>. Kompilátor používá argument typu k překladu volání metod a operátorů deklarovaných v deklaraci rozhraní. Například int typ implementuje INumber<int>. Když parametr T typu označuje argument inttypu , členové static deklarovaní na int jsou vyvolány. Případně, pokud double je argument typu, členové static deklarovaní pro typ double jsou vyvolány.

Důležité

Odeslání metody pro static abstract a static virtual metody deklarované v rozhraních se vyřeší pomocí typu času kompilace výrazu. Pokud je typ modulu runtime výrazu odvozen z jiného typu času kompilace, budou volána statické metody základního typu (čas kompilace).

Tuto funkci můžete vyzkoušet tak, že v rozhraních pracujete s kurzem o statických abstraktních členech.

Dědičnost rozhraní

Rozhraní nemusí obsahovat stav instance. I když jsou statická pole povolená, pole instancí nejsou v rozhraních povolená. Automatické vlastnosti instance nejsou podporovány v rozhraních, protože by implicitně deklarovaly skryté pole. Toto pravidlo má jemný vliv na deklarace vlastností. V deklaraci rozhraní následující kód deklaruje automaticky implementovanou vlastnost jako v nebo classstruct. Místo toho deklaruje vlastnost, která nemá výchozí implementaci, ale musí být implementována v jakémkoli typu, který implementuje rozhraní:

public interface INamed
{
  public string Name {get; set;}
}

Rozhraní může dědit z jednoho nebo více základních rozhraní. Když rozhraní přepíše metodu implementovanou v základním rozhraní, musí použít explicitní syntaxi implementace rozhraní .

Jestliže seznam základních typů obsahuje základní třídu a rozhraní, musí se základní třída nacházet v seznamu jako první.

Třída, která implementuje rozhraní, může explicitně implementovat členy rozhraní. Explicitně implementovaný člen nemůže být přístupný prostřednictvím instance třídy, ale pouze prostřednictvím instance rozhraní. Kromě toho je možné k výchozím členům rozhraní přistupovat pouze prostřednictvím instance rozhraní.

Další informace o explicitní implementaci rozhraní najdete v tématu Implementace explicitního rozhraní.

Příklad implementace rozhraní

Následující příklad ukazuje implementaci rozhraní. V tomto příkladu obsahuje rozhraní deklaraci vlastnosti a třída obsahuje implementaci. Jakákoli instance třídy, která implementuje rozhraní IPoint, má celočíselné vlastnosti x a y.

interface IPoint
{
    // Property signatures:
    int X { get; set; }

    int Y { get; set; }

    double Distance { get; }
}

class Point : IPoint
{
    // Constructor:
    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }

    // Property implementation:
    public int X { get; set; }

    public int Y { get; set; }

    // Property implementation
    public double Distance =>
       Math.Sqrt(X * X + Y * Y);
}

class MainClass
{
    static void PrintPoint(IPoint p)
    {
        Console.WriteLine("x={0}, y={1}", p.X, p.Y);
    }

    static void Main()
    {
        IPoint p = new Point(2, 3);
        Console.Write("My Point: ");
        PrintPoint(p);
    }
}
// Output: My Point: x=2, y=3

specifikace jazyka C#

Další informace najdete v části Rozhraníspecifikace jazyka C#, specifikace funkce pro C# 8 – Výchozí členy rozhraní a specifikace funkce pro C# 11 – statické abstraktní členy v rozhraních.

Viz také