Kurzusok
/
C#
C#
/
Tanterv
/
Interfészek
In

Interfészek ebben a kurzusban: C#

2 feladat

A(z) Interfészek fogalomról

A interfaces a legfőbb eszköz arra, hogy egy osztály használatát leválasszuk annak megvalósításáról. Ez a leválasztás rugalmasságot biztosít a megvalósítás karbantartásához, és segít megteremteni a típusbiztos, generikus működést.

Az interfész szintaxisa hasonlít az osztály vagy a struct szintaxisához, azzal a különbséggel, hogy a metódusok és a tulajdonságok csak szignatúraként jelennek meg, törzs nélkül.

public interface ILanguage
{
    string Speak();
}

public interface IItalianLanguage : ILanguage
{
    string Speak();
    string SpeakItalian();
}

public interface IScriptConverter
{
    string Version { get; set; }
    string ConvertCyrillicToLatin(string cyrillic);
}

A megvalósító osztálynak vagy structnak minden műveletet meg kell valósítania, amelyet az interfész meghatároz.

Az interfészek jellemzően a következők valamelyikét teszik:

  • lehetővé teszik, hogy a használó kód több különböző osztályt egységesen, generikusan kezeljen. Ilyenkor az interfészek ugyanazt a szerepet töltik be, mint egy bázisosztály
  • egy adott célra a funkcionalitás egy részét teszik elérhetővé (például IComparable<T>), vagy
  • egy osztály nyilvános API-ját teszik elérhetővé, hogy több megvalósítás is létezhessen egymás mellett. Ilyen például a test double
public class ItalianTraveller : IItalianLanguage
{
    public string Speak()
    {
        return "Ciao mondo";
    }

    public string SpeakItalian()
    {
        return Speak();
    }
}

public class ItalianTravellerV2 : IItalianLanguage
{
    public string Speak()
    {
        return "migliorata - Ciao mondo";
    }

    public string SpeakItalian()
    {
        return Speak();
    }
}

public class FrenchTraveller : ILanguage
{
    public string Speak()
    {
        return "Ça va?";
    }
}

public class RussianTraveller : ILanguage, IScriptConverter
{
    public string Version { get; set; } = "1.0";

    public string Speak()
    {
        return "Привет мир";
    }

    public string ConvertCyrillicToLatin(string cyrillic)
    {
        throw new NotImplementedException();
    }
}

public class DocumentTranslator : IScriptConverter
{
    public string Version { get; set; } = "1.0";

    public string Translate(string russian)
    {
        throw new NotImplementedException();
    }

    public string ConvertCyrillicToLatin(string cyrillic)
    {
        throw new NotImplementedException();
    }
}

A fenti interfészeket és osztályokat használó kód a következőkre képes:

  • minden beszélőt ugyanúgy kezelni, függetlenül a nyelvtől.
  • lehetővé tenni, hogy egy írásváltást kezelő alrendszer anélkül működjön, hogy törődne azzal, milyen konkrét típusokkal van dolga.
  • nem tudni az olasz beszélő változásairól, ami kényelmes, ha az osztály kódját és a felhasználó kódját különböző csapatok tartják karban

Az interfészeket széles körben használják a tesztelés támogatására, mert megkönnyítik a mockingot.

A cikk részletesen bemutatja, milyen típusú tagok kerülhetnek egy interfészbe.

Az interfészek örökölhetnek más interfészekből.

Az interfész tagjai alapértelmezés szerint nyilvánosak.

Az interfészek tartalmazhatnak egymásba ágyazott típusokat, például const literálokat, enums, delegates, classes és structs típusokat. Ilyenkor az interfészek ugyanúgy névtérként működnek, ahogy az osztályok és a structok is, a viselkedés és a szintaxis pedig azonos.

A C# tervezésénél fogva nem támogatja a többszörös öröklődést, de az interfészeken keresztül lehetővé teszi annak egy fajtáját.

Sőt, az interfészmechanizmus alapját az adja, hogy a polimorfizmus interfészeken keresztül is megvalósítható.

Explicit interfészmegvalósítás

Előfordulhat, hogy két különböző interfészben ugyanazok a metódusnevek és szignatúrák szerepelnek. Hogy ezeknek a metódusoknak külön megvalósítást adhassunk, a C# biztosítja az interfészek explicit megvalósítását. Ne feledd, hogy egy interfész adott megvalósításának használatához az objektumra hivatkozó kifejezést át kell alakítanod arra az interfészre. Ezt értékadással, castolással vagy paraméterként való átadással érheted el.

public interface IFoo
{
    void X();
}

public interface IBar
{
    void X();
}

public class Census : IFoo, IBar
{
    void IFoo.X()
    {
        Console.Write("This is from Foo");
    }

    void IBar.X()
    {
        Console.Write("This is from Bar");
    }
}

public class User
{
    public void Use()
    {
        IFoo foo = new Census();
        IBar bar = new Census();
        foo.X();
        // => "This is from Foo"
        bar.X();
        // => "This is from Bar"
    }
}

Számos felhasználási eset létezik:

  • Domainek ütközése (ahogy a fenti példa mutatja), amikor a metódusok szignatúrája azonos.
  • Azonos nevű, de eltérő visszatérési típusú metódusok: ha saját gyűjteményosztályokat írsz, előfordulhat, hogy a régi IEnumerable.GetEnumerator() metódushoz külön explicit interfészre van szükség a IEnumerable<T>.GetEnuerator() mellett. Lehet, hogy sosem használod ezt az interfészt, de a fordító ragaszkodhat hozzá.
  • Olyan metódusok, amelyek neve nem ütközik az interfészek között, de szeretnénk, hogy a megvalósító osztály valamilyen kapcsolódó célra használja ezt a nevet: az IFormattable rendelkezik egy ToString() metódussal, amely egy formátumtípus paramétert és egy IFormatProvider típusú paramétert is fogad. A Base Class Library (BCL) FormattableString osztálya azért valósítja meg ezt az interfészt, hogy olyan rutinok is használhassák, amelyek IFormattable értéket várnak, ugyanakkor a ToString(IFormatProvider) fő változatánál kifejezőbb, ha elhagyjuk a formátumtípus paramétert, mivel a megvalósítás nem használja, és csak összezavarná az API használóit.

Alapértelmezett megvalósítás

A C# 8-as verziója egy régóta húzódó API-problémát orvosol. Ha metódusokat adsz egy interfészhez, hogy új megvalósítások számára bővítsd a funkcionalitást, akkor az interfész összes létező megvalósítását módosítanod kell, hogy megfeleljenek az API-szerződésnek, még akkor is, ha nincs megvalósításspecifikus viselkedésük. A C# ma már lehetővé teszi, hogy az interfész részeként egy alapértelmezett metódust adjunk meg (a Java-fejlesztők számára ez ismerős lesz). Korábban egy ilyen változás esetén az interfész 2. verziója létezett az eredeti mellett.

Ez a cikk kiváló bevezető az interfészekbe, és az alapértelmezett megvalósításra, valamint más támogató újításokra összpontosít, például a static, private és virtual tagokra.

Szerkesztés GitHubon A hivatkozás új ablakban vagy lapon nyílik meg

Tanuld meg a(z) Interfészek fogalmat

A gyakorlás zárolva

Oldj fel még 1 feladatot, hogy gyakorolhasd a(z) Interfészek fogalmat