Megosztás:

interface (C# referencia)

Az interfész egy szerződést határoz meg. Bármely class, recordvagy struct a szerződést megvalósítónak biztosítania kell a felületen meghatározott tagok megvalósítását.

Az illesztő meghatározhat egy alapértelmezett implementációt egy tag számára. Tagokat is definiálhat static , hogy egyetlen implementációt biztosítsanak a közös funkciókhoz.

Az interfészek definiálhatják static abstract vagy static virtual a tagok deklarálhatják, hogy egy implementálási típusnak meg kell adnia a deklarált tagokat. A metódusok általában azt deklarálják, static virtual hogy egy implementációnak túlterhelt operátorokat kell meghatároznia.

A C# nyelv referenciadokumentuma a C# nyelv legújabb kiadású verzióját ismerteti. Emellett a közelgő nyelvi kiadás nyilvános előzetes verziójú funkcióinak kezdeti dokumentációját is tartalmazza.

A dokumentáció azonosítja azokat a funkciókat, amelyeket először a nyelv utolsó három verziójában vagy az aktuális nyilvános előzetes verziókban vezetnek be.

Jótanács

Ha meg szeretné tudni, hogy mikor jelent meg először egy funkció a C#-ban, tekintse meg a C# nyelvi verzióelőzményeiről szóló cikket.

Az alábbi példában az osztálynak ImplementationClass olyan metódust SampleMethod kell implementálnia, amely nem tartalmaz paramétereket, és visszaadja azokat 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();
    }
}

További információkért és példákért lásd : Interfészek.

Hozzáférési módosítók

Egy felület tagja lehet egy névtérnek vagy egy osztálynak. Deklarálhat egy legfelső szintű felületet, amely egy névtérben deklarálva van, de egy másik típusba nem ágyazva.publicinternal Az alapértelmezett érték internal. Bármilyen hozzáférési módosító használatával deklarálhat beágyazott felületi deklarációkat, amelyeket más típuson belül deklarálnak.

A implementációval nem rendelkező felülettagok (absztrakt tagok) implicit módon public vannak, és nem rendelkezhetnek más hozzáférés-módosítóval. Az alapértelmezett implementációval rendelkező felülettagok alapértelmezés szerint akkor jelennek private meg, ha nem ad meg hozzáférési módosítót, de bármilyen hozzáférési módosító (public, , privatevagy protectedinternal) deklarálható.

Interfésztagok

A felületi deklarációk a következő tagokat tartalmazhatják:

Alapértelmezett illesztőtagok

A tagdeklarációk általában nem tartalmaznak törzset. Az illesztőtagok azonban deklarálhatnak egy törzset. Az interfész tagszervezetei az alapértelmezett implementációk. A tagok testületekkel való használatával a felület alapértelmezett implementációt biztosíthat az osztályokhoz és az olyan szerkezetekhez, amelyek nem biztosítanak felülíró megvalósítást.

Fontos

Ha alapértelmezett illesztőtagokat ad hozzá, az interfészt megvalósító összes ref struct felhasználónak explicit módon deklarálnia kell ezt a tagot.

Statikus absztrakt és virtuális tagok

A felületek a mezők kivételével minden tagtípushoz deklarálhatók static abstract és static virtual tagok lehetnek. A tagok deklarálásával az interfész megkövetelheti, hogy a implementálási típusok operátorokat vagy más statikus tagokat határozzanak meg. Ez a funkció lehetővé teszi, hogy az általános algoritmusok számszerű viselkedést adjanak meg. A .NET-futtatókörnyezetben a numerikus típusok példái láthatók, például System.Numerics.INumber<TSelf>. Ezek az interfészek számos numerikus típus által implementált gyakori matematikai operátorokat határoznak meg. A fordítónak fordításkor meg kell oldania a static virtual hívásokat és static abstract a metódusokat. Az static virtual illesztőkben deklarált metódusok és static abstract metódusok nem rendelkeznek az osztályokban deklarált vagy virtual azokhoz hasonló futtatókörnyezeti küldési abstract mechanizmussal. Ehelyett a fordító a fordításkor elérhető típusinformációkat használja. Ezért a static virtual módszerek szinte kizárólag általános felületeken vannak deklarálva. Ezenkívül a legtöbb deklarált interfésznek vagy static virtual metódusnak azt kell deklarálniastatic abstract, hogy az egyik típusparaméternek implementálnia kell a deklarált interfészt. Az interfész például azt deklarálja, INumber<T> hogy T implementálnia INumber<T>kell. A fordító a típusargumentum használatával oldja fel a felületi deklarációban deklarált metódusok és operátorok hívásait. A típus például implementálja a int következőt INumber<int>: . Amikor a típusparaméter T a típusargumentumot intjelöli, a rendszer meghívja a static deklarált int tagokat. Másik lehetőségként, ha double a típus argumentumot adja meg, a rendszer meghívja a staticdouble típuson deklarált tagokat.

Fontos

Az interfészekben deklarált metódusok és metódusok kézbesítése static abstractstatic virtual egy kifejezés fordítási idejének típusával oldható fel. Ha egy kifejezés futásidejű típusa más fordítási idő típusból származik, a rendszer meghívja az alap (fordítási idő) típus statikus metódusait.

Ezt a funkciót úgy is kipróbálhatja, ha a felületi statikus absztrakt tagokról szóló oktatóanyagot használja.

Interfész öröklése

A csatolók nem tartalmazhatnak példányállapotot. Bár a statikus mezők most már engedélyezettek, a példánymezők nem engedélyezettek a felületeken. A példány automatikus tulajdonságai nem támogatottak az interfészekben, mivel implicit módon deklarálnának egy rejtett mezőt. Ez a szabály enyhe hatással van a tulajdonságdeklarációkra. A felületi deklarációkban a következő kód nem deklarál automatikusan implementált tulajdonságot, ahogyan az egy class vagy struct. Ehelyett egy olyan tulajdonságot deklarál, amely nem rendelkezik alapértelmezett implementációval, de az interfészt megvalósító bármilyen típusban implementálni kell:

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

Egy interfész egy vagy több alapillesztőtől örökölhet. Ha egy interfész egy másik interfésztől öröklődik, a származtatott interfészt implementáló típusnak az alapfelületeken lévő összes tagot a származtatott felületen deklarált tagokon kívül kell implementálnia, ahogyan az a következő kódban is látható:

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

Ha egy felület felülír egy alapillesztőben implementált metódust, az explicit felület implementálási szintaxisát kell használnia.

Ha egy alaptípuslista alaposztályt és interfészeket tartalmaz, az alaposztálynak a listában kell elsőnek lennie.

Az interfészt megvalósító osztály explicit módon implementálhatja az adott felület tagjait. Egy explicit módon implementált tag nem érhető el osztálypéldányon keresztül, csak a felület egy példányán keresztül. Emellett az alapértelmezett illesztőtagok csak a felület egy példányán keresztül érhetők el.

További információ az explicit felület implementálásáról: Explicit Interface Implementáció.

Példa felület implementálására

Az alábbi példa a felület implementálását mutatja be. Ebben a példában a felület tartalmazza a tulajdonságdeklarációt, az osztály pedig a megvalósítást. A megvalósító IPoint osztály minden példánya egész számtulajdonságokkal x és 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

C# nyelvspecifikáció

További információkért tekintse meg a C#-nyelv specifikációjánakInterfészek szakaszát, valamint a statikus absztrakt tagok felületi jellemzőkre vonatkozó specifikációját.

Lásd még

  • Last updated on