Sdílet prostřednictvím

interface (Referenční dokumentace jazyka C#)

Rozhraní definuje kontrakt. Jakýkoliv class, recordnebo struct který implementuje tento kontrakt musí poskytnout implementaci členů definovaných v rozhraní.

Rozhraní může definovat výchozí implementaci člena. Může také definovat static členy, které poskytují jednu implementaci pro společné funkce.

Rozhraní může definovat nebo static abstract členy deklarovatstatic virtual, že implementovaný typ musí poskytnout deklarované členy. Metody obvykle deklarují, static virtual že implementace musí definovat sadu přetížených operátorů.

Referenční dokumentace jazyka C# dokumentuje naposledy vydané verze jazyka C#. Obsahuje také počáteční dokumentaci k funkcím ve verzi Public Preview pro nadcházející jazykovou verzi.

Dokumentace identifikuje všechny funkce, které byly poprvé představeny v posledních třech verzích jazyka nebo v aktuálních verzích Public Preview.

Návod

Informace o tom, kdy byla funkce poprvé představena v jazyce C#, najdete v článku o historii verzí jazyka C#.

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

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();
    }
}

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

Modifikátory přístupu

Rozhraní může být členem oboru názvů nebo třídy. Můžete deklarovat rozhraní nejvyšší úrovně, které je deklarováno v oboru názvů, ale není vnořené uvnitř jiného typu, jako public nebo internal. Výchozí hodnota je internal. Deklarace vnořeného rozhraní deklarované uvnitř jiného typu můžete deklarovat pomocí libovolného modifikátoru přístupu.

Členy rozhraní bez implementace (abstraktní členy) jsou implicitně public a nemohou mít žádný jiný modifikátor přístupu. Členy rozhraní s výchozí implementací jsou private ve výchozím nastavení, pokud nezadáte modifikátor přístupu, ale můžete deklarovat jakýkoli modifikátor přístupu (public, private, protected, nebo internal).

Členy rozhraní

Deklarace rozhraní může obsahovat následující členy:

Výchozí členové rozhraní

Deklarace členů obvykle neobsahují tělo. Člen rozhraní však může deklarovat tělo. Výchozí implementací jsou členské subjekty v rozhraní. Pomocí členů s těly může rozhraní poskytnout výchozí implementaci tříd a struktur, které neposkytují přepsání implementace.

Důležité

Pokud přidáte výchozí členy rozhraní, musí každý ref struct , který implementuje rozhraní, explicitně deklarovat člena.

Statické abstraktní a virtuální členy

Rozhraní může deklarovat static abstract a static virtual členy pro všechny typy členů s výjimkou polí. Deklarováním těchto členů může rozhraní vyžadovat, aby implementace typů definovala 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 deklarované static abstract v rozhraních nemají mechanismus dispečerského modulu runtime, který je podobný virtual metodám nebo abstract metodám deklarovaným 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. Kromě toho většina rozhraní, která deklarují nebo metody deklarujístatic virtual, že jeden z parametrů typu musí static abstract. Například INumber<T> rozhraní deklaruje, ž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, static jsou vyvolány členy deklarované na int . Alternativně platí, že pokud double je argument typu, static jsou vyvolány členy deklarované v double typu.

Důležité

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

Tuto funkci můžete vyzkoušet pomocí kurzu o statických abstraktních členech v rozhraních.

Dědičnost rozhraní

Rozhraní nemohou obsahovat stav instance. I když jsou teď statická pole povolená, pole instancí nejsou v rozhraních povolená. Automatické vlastnosti instance nejsou v rozhraních podporované, protože by implicitně deklarovaly skryté pole. Toto pravidlo má malý vliv na deklarace vlastností. V deklaraci rozhraní následující kód deklaruje automaticky implementovanou vlastnost jako v objektu 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í dědí z jiného rozhraní, typ implementovaný odvozené rozhraní musí implementovat všechny členy v základních rozhraních kromě těchto členů deklarovaných v odvozené rozhraní, jak je znázorněno v následujícím kódu:

public interface I1
{
    void M1();
}

public interface I2 : I1
{
    void M2();
}

public class C : I2
{
    // implements I1.M1
    public void M1() { }
    // implements I2.M2
    public void M2() { }
}

Pokud 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 není 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í naleznete v tématu explicitní implementace 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# a specifikace funkce pro statické abstraktní členy v rozhraních.

Viz také

  • Last updated on