Interfejsy — wspólna umowa bez wspólnego przodka

Czego się dziś nauczysz

Jedna baza to za mało

Szkolny inwentarz drukuje etykiety z kodem. Etykietę dostaje komputer z pracowni, książka z biblioteki i legitymacja ucznia. Wszystkie trzy rzeczy trzeba wypisać jedną pętlą.

Z lekcji 45 znasz jedno narzędzie do „wspólnego typu” — klasę bazową. Spróbujmy:

class MaEtykiete
{
    public virtual string Etykieta() { return "???"; }
}

class Komputer : Urzadzenie, MaEtykiete    // BLAD CS1721
{
}

Nawet gdyby dziedziczenie po dwóch klasach było dozwolone, pomysł byłby zły. Spójrz na te trzy rzeczy:

Nie ma wspólnego przodka, bo te rzeczy nie mają ze sobą nic wspólnego poza jedną umiejętnością. Książka nie jest urządzeniem, uczeń tym bardziej. Wspólna klasa bazowa dla nich wszystkich musiałaby się nazywać „Rzecz” i nie zawierałaby ani jednego sensownego pola.

Umowa bez wykonania

Interfejs to spis umiejętności bez ani jednej linii wykonania. Deklaruje się go słowem interface:

interface IEtykieta
{
    string TekstEtykiety();        // tylko nazwa, typ wyniku i parametry
    string Kod { get; }            // wlasciwosc tylko do odczytu
}

Trzy rzeczy w tym zapisie różnią się od klasy:

• Nie ma ciał metod — po nawiasach stoi średnik. Interfejs mówi „co”, nigdy „jak”.
• Nie ma modyfikatorów public ani abstract. Wszystkie składowe interfejsu są publiczne i abstrakcyjne z definicji, więc się tego nie pisze.
• Nie ma pól ani konstruktora. Interfejs nie przechowuje danych, więc nie ma czego ustawiać.

Klasa implementuje interfejs — zapis jest taki sam jak dziedziczenie, po dwukropku:

class Ksiazka : IEtykieta
{
    public string Tytul { get; }
    public string Autor { get; }
    public string Kod { get; }              // z interfejsu

    public Ksiazka(string tytul, string autor, string kod)
    {
        Tytul = tytul;
        Autor = autor;
        Kod = kod;
    }

    public string TekstEtykiety()          // z interfejsu
    {
        return $"{Kod}  {Autor}: {Tytul}";
    }
}

Kompilator pilnuje kompletności tak samo jak przy klasie abstrakcyjnej:

class Ksiazka : IEtykieta        // BLAD CS0535
{
    public string Tytul { get; }
    // nie ma ani TekstEtykiety(), ani Kod
}

CS0535 — „Ksiazka nie implementuje elementu członkowskiego interfejsu IEtykieta.TekstEtykiety()”. Umowa albo jest dotrzymana w całości, albo program się nie buduje.

Interfejs jako typ zmiennej

Tak jak klasa abstrakcyjna, interfejs nie da się utworzyć przez new, ale świetnie nadaje się na typ zmiennej, parametru i tablicy:

IEtykieta e = new Ksiazka("Pan Tadeusz", "Mickiewicz", "KS-102");
Console.WriteLine(e.TekstEtykiety());

// IEtykieta x = new IEtykieta();       // BLAD CS0144 - interfejsu nie da sie utworzyc

static void Wydrukuj(IEtykieta co)      // dziala dla KAZDEJ klasy z ta umowa
{
    Console.WriteLine($"[ {co.TekstEtykiety()} ]");
}

Metoda Wydrukuj nie wie i nie chce wiedzieć, czy dostała książkę, komputer czy legitymację. Wie tylko jedno: to coś potrafi podać tekst etykiety. Na tym polega cała siła interfejsów.

Jedna baza, dowolnie wiele umów

Tu jest różnica, dla której interfejsy istnieją: klasa może mieć jedną bazę i dowolnie wiele interfejsów.

interface IEtykieta
{
    string TekstEtykiety();
    string Kod { get; }
}

interface ISerwisowane
{
    int DniDoSerwisu { get; }
    void Serwisuj();
}

class Komputer : Urzadzenie, IEtykieta, ISerwisowane
{
    // ...
}

Kolejność po dwukropku jest ustalona: najpierw klasa bazowa, potem interfejsy. Odwrotnie daje CS1722. Same interfejsy można wymieniać w dowolnej kolejności.

Ta sama umowa w niepowiązanych klasach

Teraz trzy klasy z zupełnie różnych światów trafiają do jednej tablicy:

IEtykieta[] doWydruku =
{
    new Komputer("Dell OptiPlex", "KOM-014"),
    new Ksiazka("Pan Tadeusz", "Mickiewicz", "KS-102"),
    new Legitymacja("Kasia Nowak", "3TP", "LEG-88")
};

foreach (IEtykieta e in doWydruku)
{
    Console.WriteLine(e.TekstEtykiety());
}

Komputer dziedziczy po Urzadzenie, Ksiazka po niczym, Legitymacja po niczym. Nie mają wspólnego przodka poza object — a mimo to mieszczą się w jednej tablicy, bo mają wspólną umowę.

Sprawdzanie, czy klasa spełnia umowę

is i as z lekcji 46 działają także z interfejsami:

foreach (object rzecz in inwentarz)
{
    if (rzecz is IEtykieta e)
    {
        Console.WriteLine(e.TekstEtykiety());
    }

    if (rzecz is ISerwisowane s && s.DniDoSerwisu < 30)
    {
        Console.WriteLine($"  UWAGA: serwis za {s.DniDoSerwisu} dni");
    }
}

Jeden obiekt może pasować do kilku sprawdzeń naraz — komputer wejdzie do obu if, a książka tylko do pierwszego.

Sześć różnic i jedna decyzja

Interfejs i klasa abstrakcyjna z lekcji 47 wyglądają podobnie: obie zapowiadają składowe bez ciała i obu nie da się utworzyć. Różnic jest jednak sześć i wszystkie są istotne.

Jak wybrać

Umowy, które ktoś już napisał

Interfejsów nie pisze się głównie samemu — częściej implementuje się gotowe z biblioteki. Cztery spotkasz najszybciej.

IComparable<T> — „umiem się porównać”

Klasa, która ma jedną metodę CompareTo, zaczyna działać z Array.Sort z lekcji 24:

class Uczen : IComparable<Uczen>
{
    public string Nazwisko { get; }
    public int Punkty { get; }

    public Uczen(string nazwisko, int punkty)
    {
        Nazwisko = nazwisko;
        Punkty = punkty;
    }

    public int CompareTo(Uczen? inny)
    {
        if (inny == null)
        {
            return 1;
        }
        return inny.Punkty - Punkty;      // malejaco po punktach
    }

    public override string ToString()
    {
        return $"{Nazwisko} {Punkty} pkt";
    }
}

Uczen[] wyniki =
{
    new Uczen("Nowak", 34),
    new Uczen("Lis", 51),
    new Uczen("Wrona", 42)
};

Array.Sort(wyniki);                   // dziala, bo Uczen umie sie porownac

foreach (Uczen u in wyniki)
{
    Console.WriteLine(u);
}

Lis 51 pkt
Wrona 42 pkt
Nowak 34 pkt

Array.Sort został napisany wiele lat przed Twoją klasą i nic o niej nie wie. Potrafi ją posortować, bo wymaga tylko jednej umowy: IComparable<T>. Do tego wracamy w lekcji 51.

IEnumerable<T> — „można mnie przejść pętlą foreach”

To umowa, którą spełniają tablice, List<T> i wszystkie kolekcje z lekcji 31–33. Właśnie dlatego foreach działa z każdą z nich, choć w środku są zupełnie różne.

IDisposable — „mam co zwolnić”

Znasz ją z lekcji 36 i 40: klasa z metodą Dispose() daje się użyć w bloku using, który wywoła zwolnienie także wtedy, gdy poleci wyjątek.

IFormattable, IEquatable<T> i pozostałe

Nie trzeba ich pamiętać. Trzeba pamiętać schemat: gdy jakaś gotowa metoda w .NET „nie chce” Twojej klasy, poszukaj w dokumentacji, jakiego interfejsu wymaga jej parametr. Prawie zawsze wystarczy dopisać jedną metodę.

Inwentarz szkolny

Inwentarz szkolny: dwa interfejsy, jedna klasa abstrakcyjna i cztery klasy, które łączą się w różne kombinacje. Zwróć uwagę, że tablica jest typu object[] — nie ma typu, który obejmowałby wszystkie te rzeczy.

// Program.cs - pelny plik
object[] inwentarz =
{
    new Komputer("Dell OptiPlex", "KOM-014", 12),
    new Komputer("HP ProDesk", "KOM-015", 95),
    new Ksiazka("Pan Tadeusz", "Mickiewicz", "KS-102"),
    new Legitymacja("Kasia Nowak", "3TP", "LEG-88"),
    new LicznikWejsc()
};

Console.WriteLine("=== etykiety do wydruku ===");
foreach (object rzecz in inwentarz)
{
    if (rzecz is IEtykieta e)
    {
        Console.WriteLine(e.TekstEtykiety());
    }
}

Console.WriteLine();
Console.WriteLine("=== plan serwisu ===");
foreach (object rzecz in inwentarz)
{
    if (rzecz is ISerwisowane s)
    {
        if (s.DniDoSerwisu < 30)
        {
            Console.Write("PILNE: ");
        }
        s.Serwisuj();
    }
}

Console.WriteLine();
Console.WriteLine("=== jedna metoda dla wszystkiego, co ma etykiete ===");
Wydrukuj(new Ksiazka("Lalka", "Prus", "KS-201"));
Wydrukuj(new Legitymacja("Marek Lis", "2TP", "LEG-91"));

Console.WriteLine();
Console.WriteLine("=== co spelnia ktora umowe ===");
foreach (object rzecz in inwentarz)
{
    string nazwa = rzecz.GetType().Name;
    string etyk = rzecz is IEtykieta ? "IEtykieta" : "-";
    string serw = rzecz is ISerwisowane ? "ISerwisowane" : "-";
    Console.WriteLine($"{nazwa,-14} {etyk,-11} {serw}");
}

static void Wydrukuj(IEtykieta co)
{
    Console.WriteLine($"+-- {co.Kod} " + new string('-', 20));
    Console.WriteLine($"|   {co.TekstEtykiety()}");
    Console.WriteLine("+" + new string('-', 27));
}


interface IEtykieta
{
    string Kod { get; }
    string TekstEtykiety();
}

interface ISerwisowane
{
    int DniDoSerwisu { get; }
    void Serwisuj();
}

abstract class Urzadzenie
{
    public string Nazwa { get; }

    protected Urzadzenie(string nazwa)
    {
        Nazwa = nazwa;
    }

    public abstract string Opis();
}

class Komputer : Urzadzenie, IEtykieta, ISerwisowane
{
    public string Kod { get; }
    public int DniDoSerwisu { get; }

    public Komputer(string nazwa, string kod, int dniDoSerwisu) : base(nazwa)
    {
        Kod = kod;
        DniDoSerwisu = dniDoSerwisu;
    }

    public override string Opis()
    {
        return $"komputer {Nazwa}";
    }

    public string TekstEtykiety()
    {
        return $"{Kod}  {Nazwa}  (pracownia)";
    }

    public void Serwisuj()
    {
        Console.WriteLine($"{Kod}: przeglad za {DniDoSerwisu} dni");
    }
}

class LicznikWejsc : Urzadzenie, ISerwisowane
{
    public int DniDoSerwisu => 200;

    public LicznikWejsc() : base("licznik wejsc") { }

    public override string Opis()
    {
        return "licznik wejsc przy drzwiach";
    }

    public void Serwisuj()
    {
        Console.WriteLine($"licznik: przeglad za {DniDoSerwisu} dni");
    }
}

class Ksiazka : IEtykieta
{
    public string Tytul { get; }
    public string Autor { get; }
    public string Kod { get; }

    public Ksiazka(string tytul, string autor, string kod)
    {
        Tytul = tytul;
        Autor = autor;
        Kod = kod;
    }

    public string TekstEtykiety()
    {
        return $"{Kod}  {Autor}: {Tytul}";
    }
}

class Legitymacja : IEtykieta
{
    public string Uczen { get; }
    public string Klasa { get; }
    public string Kod { get; }

    public Legitymacja(string uczen, string klasa, string kod)
    {
        Uczen = uczen;
        Klasa = klasa;
        Kod = kod;
    }

    public string TekstEtykiety()
    {
        return $"{Kod}  {Uczen} / {Klasa}";
    }
}

=== etykiety do wydruku ===
KOM-014  Dell OptiPlex  (pracownia)
KOM-015  HP ProDesk  (pracownia)
KS-102  Mickiewicz: Pan Tadeusz
LEG-88  Kasia Nowak / 3TP

=== plan serwisu ===
PILNE: KOM-014: przeglad za 12 dni
KOM-015: przeglad za 95 dni
licznik: przeglad za 200 dni

=== jedna metoda dla wszystkiego, co ma etykiete ===
+-- KS-201 --------------------
|   KS-201  Prus: Lalka
+---------------------------
+-- LEG-91 --------------------
|   LEG-91  Marek Lis / 2TP
+---------------------------

=== co spelnia ktora umowe ===
Komputer       IEtykieta   ISerwisowane
Komputer       IEtykieta   ISerwisowane
Ksiazka        IEtykieta   -
Legitymacja    IEtykieta   -
LicznikWejsc   -           ISerwisowane

Co dzieje się po kolei

• Komputer ma klasę bazową i dwa interfejsy — dokładnie to, czego nie dałoby się zrobić samym dziedziczeniem.
• Ksiazka i Legitymacja nie dziedziczą po niczym, a mimo to trafiają do tej samej pętli co komputer, bo spełniają tę samą umowę.
• LicznikWejsc jest urządzeniem i wymaga serwisu, ale nie ma etykiety — dlatego nie pojawia się w pierwszej pętli. Interfejsy dobiera się osobno dla każdej klasy.
• Pierwsza i druga pętla przechodzą tę samą tablicę, ale wybierają z niej różne podzbiory. Filtrem jest interfejs, nie klasa.
• Wydrukuj ma parametr typu IEtykieta. Nie zna klasy Ksiazka ani Legitymacja — używa tylko Kod i TekstEtykiety(), bo tyle gwarantuje umowa.
• Ostatnia pętla pokazuje pełny obraz: każda klasa spełnia inny zestaw umów, a is odpowiada na pytanie „czy potrafi”, nie „czym jest”.
• DniDoSerwisu w klasie Komputer jest zwykłą właściwością z konstruktora, a w LicznikWejsc właściwością wyliczaną. Interfejs nie narzuca sposobu — tylko to, że wartość ma być dostępna do odczytu.

Zestawienie elementów

Zanim utkniesz

Zadania

Co trzeba zapamiętać

• Interfejs to umowa: spis umiejętności bez ani jednej linii wykonania.
• Klasa ma jedną klasę bazową, ale dowolnie wiele interfejsów — to główna różnica.
• Po dwukropku najpierw klasa bazowa, potem interfejsy (inaczej CS1722).
• Składowe interfejsu są publiczne i abstrakcyjne z definicji, więc modyfikatorów się nie pisze.
• W klasie implementującej używasz public, nie override.
• Brak choćby jednej składowej to błąd CS0535 — umowa albo jest spełniona w całości, albo program się nie buduje.
• Interfejsu nie da się utworzyć przez new, ale jest doskonałym typem zmiennej i parametru.
• Interfejs odpowiada na pytanie „co to potrafi”, klasa abstrakcyjna na „czym to jest”.
• Interfejs nie ma pól ani konstruktora — gdy klasy mają wspólne dane, potrzebna jest klasa bazowa.
• Klasa abstrakcyjna i interfejs często występują razem: umowa na zewnątrz, wspólny kod w bazie.
• Nazwy interfejsów zaczynają się od I — to konwencja całej biblioteki .NET.
• Gotowe metody .NET współpracują z Twoimi klasami dzięki interfejsom: IComparable<T>, IEnumerable<T>, IDisposable.

Dokumentacja: Microsoft Learn — temat tej lekcji.