Tydzień temu na łamach portalu CentrumXP.pl zostało wprowadzone nowe pojęcie, które odgrywa w świecie programistów ogromną rolę.. Interfejsy – bo o nich jest tutaj mowa – są kontraktem jaki zostaje utworzony pomiędzy klasą a użytkownikiem. Jest to kontrakt, który musi zostać w pełni wypełniony po stronie klasy. Oznacza to, że musi ona zaimplementować wszystkie metody czy właściwości dziedziczonego interfejsu.
Potrafimy już definiować interfejsy i je implementować. Nauczyliśmy się również używać naraz kilku interfejsów, a także je rozszerzać. Dzisiaj będziemy kontynuować temat interfejsów i poznamy kilka nowych zagadnień z nimi związanych. Między innymi opowiemy sobie o słowach kluczowych is oraz as, o sposobach przesłaniania interfejsów czy o mechanizmie jawnej implementacji interfejsu.
Jak już wiemy, możliwe jest rozszerzanie już istniejącego interfejsu poprzez dodanie do niego jakiejś nowej metody lub właściwości. Łatwo można się domyśleć, że interfejsy można łączyć ze sobą: tworzymy nowy interfejs i łączymy go z już istniejącym oraz w razie potrzeby dodajemy nowe metody czy też inne elementy nowego interfejsu. Na początek prześledźmy poniższy przykład:
interface IMojInterfejs
{
int Dodawanie();
int Wynik
{
get;
set;
}
}
interface IMnozenie
{
int
Mnozenie();
}
interface IOperacje : IMnozenie
{
int Dzielenie();
int
KwadratSumy();
}
public class MojaKlasa : IMojInterfejs,
IOperacje
{
int a, b;
//przechowuje wartosc
wlasciwosci
private int _wynik = 0;
//konstruktor klasy
MojaKlasa
public
MojaKlasa(int a, int
b)
{
this.a = a;
this.b = b;
}
//implementacja metody
Dodawanie() z interfejsu IMojInterfejs
public
int Dodawanie()
{
return a + b;
}
//implementacja
wlasciwosci z interfejsu IMojInterfejs
public int Wynik
{
get { return _wynik;
}
set { _wynik = value;
}
}
//implementacja metod
z interfejsu IOperacje
public int Dzielenie()
{
return a /
b;
}
//implementacja metody
z interfejsu IKwadrat, obslugiwany przez interfejs IOperacje
public
int KwadratSumy()
{
return (a + b) * (a + b);
}
public
int Mnozenie()
{
return a * b;
}
}
public class Glowna
{
static
void Main()
{
MojaKlasa mk
= new MojaKlasa(36,
6);
//rzutowanie mk na
rozne interfejsy
IMojInterfejs imMk = mk as
IMojInterfejs;
if (imMk != null)
{
imMk.Wynik =
imMk.Dodawanie();
System.Console.WriteLine("Suma liczb: 36 i 6 wynosi: {0}",
imMk.Wynik);
}
IMnozenie
imnMk = mk as IMnozenie;
if (imnMk !=
null)
{
mk.Wynik = imnMk.Mnozenie();
System.Console.WriteLine("Mnożenie liczb: 36 i 6 wynosi: {0}",
mk.Wynik);
}
IOperacje io
= mk as IOperacje;
if (io != null)
{
System.Console.WriteLine("Dzielenie liczby: 36 przez liczbę: 6 wynosi:
{0}", io.Dzielenie());
System.Console.WriteLine("Kwadrat sumy liczb: 36 i 6 wynosi: {0}",
io.KwadratSumy());
}
}
}
W powyższym przykładzie łączymy ze sobą 2 interfejsy: IOpercje obsługuje istniejący już interfejs IMnozenie. W ten sposób interfejs IOperacje łączy w jednym ciele metody swoje z metodą interfejsu IMnozenie.
Nasz programik potrzebuje jeszcze parę słów komentarza, bowiem zastosowaliśmy w nim nowe dla nas słowo. A mianowicie chodzi o: as. W poniższym fragmencie kodu utworzyliśmy obiekt klasy MojaKlasa:
MojaKlasa mk = new MojaKlasa(36, 6);
IMojInterfejs imMk = mk as
IMojInterfejs;
if (imMk != null)
{
imMk.Wynik =
imMk.Dodawanie();
System.Console.WriteLine("Suma
liczb: 36 i 6 wynosi: {0}", imMk.Wynik);
}
a następnie używamy go jako egzemplarza interfejsu IMojInterfejs. Innymi słowy, jeśli nie jesteśmy pewni, czy nasza klasa (w tym przypadku MojaKlasa) obsługuje dany interfejs (czyli IMojInterfejs) to możemy zrzutować obiekt tej klasy używając operatora as i w ten sposób sprawdzić, czy wynikiem takiego rzutowania jest null (co oznacza, że po prostu nasza klasa nie obsługuje danego interfejsu) czy też jakaś wartość (co oznacza, że nasza klasa obsługuje żądany interfejs).
Kiedy obiekt klasy, która obsługuje dany interfejs zostanie prawidłowo zrzutowany na ten interfejs, wówczas obiekt ten może wywoływać wszystkie metody, właściwości i inne zdarzenia zrzutowanego interfejsu.
Zanim przejdziemy dalej, należy prawidłowo zdefiniować pojęcie „egzemplarza interfejsu”. W żargonie programistycznym bardzo często tak się mówi, jednak nie jest to prawidłowe. Precyzyjniej powinno się określać to pojęcie jako referencja na obiekt, który implementuje dany interfejs.
W wyniku uruchomienia powyższego przykładu otrzymaliśmy następujące wyniki:
Spróbujmy teraz napisać dobrze już nam znany przykład w trochę inny sposób:
interface IMojInterfejs
{
int Dodawanie();
int Wynik
{
get;
set;
}
}
interface IMnozenie
{
int Mnozenie();
}
interface IOperacje : IMnozenie
{
int Dzielenie();
int
KwadratSumy();
}
public class MojaKlasa : IMojInterfejs,
IOperacje
{
int
a, b;
private
int _wynik = 0;
public
MojaKlasa(int a, int
b)
{
this.a = a;
this.b = b;
}
public
int Dodawanie()
{
return a + b;
}
public
int Wynik
{
get { return _wynik;
}
set { _wynik = value;
}
}
public
int Dzielenie()
{
return a / b;
}
public
int KwadratSumy()
{
return (a + b) * (a + b);
}
public
int Mnozenie()
{
return a * b;
}
}
public class Glowna
{
static
void Main()
{
MojaKlasa mk = new MojaKlasa(45, 8);
if (mk is IMojInterfejs)
{
IMojInterfejs imMk = (IMojInterfejs)mk;
imMk.Wynik = imMk.Dodawanie();
System.Console.WriteLine("Suma liczb: 45 i 8 wynosi: {0}",
imMk.Wynik);
}
if (mk is IMnozenie)
{
IMnozenie
imnMk = (IMnozenie)mk;
mk.Wynik = imnMk.Mnozenie();
System.Console.WriteLine("Wynik mnożenia liczb: 45 i 8 wynosi: {0}",
mk.Wynik);
}
if (mk is IOperacje)
{
IOperacje
io = (IOperacje)mk;
System.Console.WriteLine("Dzielenie liczby: 45 przez liczbę: 8 wynosi:
{0}", io.Dzielenie());
System.Console.WriteLine("Kwadrat sumy liczb: 45 i 8 wynosi: {0}",
io.KwadratSumy());
}
}
}
Powyższy przykład ma taką samą logikę biznesową jak poprzedni, ale różni się jedną zasadniczą rzeczą. A mianowicie zastosowaliśmy w nim nowy operator, jakim jest słówko is. W poniższym fragmencie kodu zdefiniowaliśmy sobie obiekt mk typu MojaKlasa:
MojaKlasa mk = new MojaKlasa(45, 8);
if (mk is IMojInterfejs)
{
IMojInterfejs
imMk = (IMojInterfejs)mk;
imMk.Wynik = imMk.Dodawanie();
System.Console.WriteLine("Suma liczb: 45 i 8 wynosi: {0}",
imMk.Wynik);
}
a następnie sprawdzamy, czy obiekt ten obsługuje interfejs IMojInterfejs. W tym celu używamy właśnie operatora is. Operator ten zwraca wartość true, gdy obiekt mk można zrzutować na dany sprawdzany typ (czyli interfejs ImojInterfejs). W przeciwnym przypadku operator is zwraca false. W powyższym fragmencie kodu obiekt mk zwraca true, a więc możemy go bez żadnych przeszkód zrzutować na interfejs IMojInterfejs, a następnie na referencji wskazującej obiekt implementujący ten interfejs wywoływać odpowiednie metody oraz właściwości.
Na koniec krótkie podsumowanie: operator is sprawdza czy można rzutować wyrażenie na dany typ, natomiast operator as łączy w sobie funkcję właśnie operatora is, a także cast. W pierwszej kolejności as sprawdza, czy dane rzutowanie jest dozwolone (czyli czy operator is zwraca true), a gdy ten warunek jest spełniony, to wykonuje rzutowanie.
Używanie operatora as eliminuje potrzebę obsługi wyjątków (o wyjątkach napiszemy sobie wkrótce na łamach portalu CentrumXP), jednocześnie zwiększa wydajność naszego programu związanego z podwójnym sprawdzaniem wydajności bezpieczeństwa rzutowania. Dlatego też optymalnym rozwiązaniem jest rzutowanie interfejsów za pomocą słowa kluczowego as.
Drugim punktem niniejszego artykułu jest przesłanianie implementacji interfejsu. W klasie, która obsługuje dany interfejs, metody tego interfejsu możemy oznaczyć jako wirtualne. W klasach pochodnych możemy więc przesłaniać implementację tych metod, dzięki czemu możliwe jest używanie klas w sposób polimorficzny. Poniższy przykład prezentuje ten mechanizm:
interface IMojInterfejs
{
int
Wynik
{
get;
set;
}
}
interface IOperacje
{
int Dodawanie();
int
Odejmowanie();
}
public class KlasaPierwsza : IMojInterfejs,
IOperacje
{
int a, b;
public
KlasaPierwsza(int a, int
b)
{
this.a = a;
this.b = b;
}
private
int _wynik = 0;
public
int Wynik
{
get { return _wynik;
}
set { _wynik = value;
}
}
public
int Dodawanie()
{
return a + b;
}
public
virtual int
Odejmowanie()
{
return a - b;
}
}
public class KlasaDruga : KlasaPierwsza
{
int x, y;
public
KlasaDruga(int a, int
b) : base(a, b)
{
this.x = a;
this.y = b;
}
public
override int
Odejmowanie()
{
return (2 * x) - (2 * y);
}
}
class Glowna
{
static void Main()
{
KlasaPierwsza
kp = new KlasaPierwsza(13,
7);
IMojInterfejs im = kp as
IMojInterfejs;
IOperacje io
= kp as IOperacje;
if (im != null
&& io != null)
{
im.Wynik = io.Dodawanie();
System.Console.WriteLine("Suma dwóch liczb wynosi: {0}", im.Wynik
+ ".");
im.Wynik = io.Odejmowanie();
System.Console.WriteLine("Różnica dwóch liczb wynosi: {0}",
im.Wynik + ".");
}
KlasaDruga
kd = new KlasaDruga(10,
4);
IOperacje
iod = kd as IOperacje;
if (iod != null)
System.Console.WriteLine("Różnica dwóch liczb wynosi: {0}",
iod.Odejmowanie() + ".");
}
}
KlasaPierwsza obsługuje dwa interfejsy: IMojInterfejs oraz IOperacje. Klasa ta implementuje wszystkie metody oraz właściwości tych interfejsów, przy czym metoda Odejmowanie() jest zainicjowana w niej jako metoda wirtualna. KlasaDruga, która dziedziczy po klasie KlasaPierwsza nie musi przesłaniać tej metody, ale jest to dozwolone i właśnie taka sytuacja ma miejsce w naszym programiku. W klasie głównej widzimy polimorficzne wykorzystanie metody Odejmowanie(). Najpierw wywoływana jest ona za pomocą referencji na egzemplarz klasy KlasaPierwsza wskazującej na interfejs IOperacje, a poźniej wywoływana jest za pomocą referencji na obiekt kd (typu KlasaDruga) wskazującej na interfejs IOperacje (tutaj wywoływana jest właśnie przesłonięta wersja metody Odejmowanie()).
Po skompilowaniu i uruchomieniu powyższego przykładu otrzymamy następujące wyniki:
Na koniec chcielibyśmy napisać parę słów o jawnej implementacji interfejsów.
Często się zdarza, że klasa obsługuje np. 2 interfejsy, które maja w swoim ciele zdefiniowane 2 metody o tej samej sygnaturze i zwracanym typie. W takiej sytuacji jasne jest, że w danej klasie nie będziemy mogli zaimplementować tych metod, mimo że będą mięć różną logikę. Aby rozwiązać ten problem, musimy użyć mechanizmu jawnej implementacji interfejsów. Poniższy przykład to pokazuje:
interface IMojInterfejs
{
int Dodawanie();
int Wynik
{
get;
set;
}
}
interface IOperacje
{
int Odejmowanie();
int Dodawanie();
}
public class MojaKlasa : IMojInterfejs,
IOperacje
{
int a, b;
public
MojaKlasa(int a, int
b)
{
this.a = a;
this.b = b;
}
private
int _wynik = 0;
public
int Wynik
{
get { return _wynik;
}
set { _wynik
= value; }
}
public int Dodawanie()
{
return a + b;
}
public int Odejmowanie()
{
return a -
b;
}
int IOperacje.Dodawanie()
{
return (2 *
a) + (2 * b);
}
}
class Glowna
{
static
void Main()
{
MojaKlasa mk
= new MojaKlasa(18,
14);
mk.Wynik = mk.Dodawanie();
System.Console.WriteLine("Implemetacja metody IMojInterfejs.Dodawanie. Wynik
wynosi: {0}", mk.Wynik +".");
mk.Wynik = mk.Odejmowanie();
System.Console.WriteLine("Implementacje metody IOperacje.Odejmowanie. Wynik
wynosi: {0}", mk.Wynik +".");
IOperacje io
= mk as IOperacje;
if (io != null)
System.Console.WriteLine("Implementacja metody IOperacje.Dodawanie. Wynik
wynosi: {0}", io.Dodawanie());
}
}
W powyższym przykładzie zarówno IMojInterfejs jak i IOperacje mają w swym ciele zdefiniowaną metodę Dodawanie(), o tej samej sygnaturze i zwracanym typie. Aby można było obie zainicjować prawidłowo w klasie MojaKlasa, należy jedną z nich jawnie zaimplementować. Taka jawna implementacja tejże metody zdefiniowanej w interfejsie IOperacje odbywa się w następującym fragmencie kodu:
int IOperacje.Dodawanie()
{
return (2 *
a) + (2 * b);
}
Dostęp w klasie głównej do tej metody nie jest możliwy poprzez obiekt klasy MojaKlasa. Jedynym sposobem dostania się do tej metody jest zrzutowanie obiektu obsługującej go klasy:
IOperacje io = mk as IOperacje;
if (io != null)
System.Console.WriteLine("Implementacja metody IOperacje.Dodawanie. Wynik
wynosi: {0}", io.Dodawanie());
Należy pamiętać również o tym, że przed jawnie
zaimplementowaną metodą nie może znajdować się żaden modyfikator dostępu.
Metoda taka jest po prostu niejawnie publiczna. Metoda ta nie może też zawierać
takich modyfikatorów jak: abstract, virtual, override oraz new.
Po uruchomieniu powyższygo przykładu otrzymamy
następujące wyniki:
W niniejszym artykule wprowadziliśmy sobie nowe
pojęcia takie jak: operatory is oraz as, a także przesłanianie
interfejsów oraz mechanizm jawnej ich implementacji. Po tej styczności z
interfejsami, każdy z nas powienien wiedzieć do czego one służą i jak stosować.
Na pewno temat interfejsów nie został w pełni wyczerpany, ale najważniejsze
rzeczy zostały o nich powiedziane.
Za tydzień natomiast opowiemy sobie o interfejsach
kolekcji i skupimy się przede wszystkim na słownikach, jakie są dostępne w
języku C# 2.0.
