IDZ DO

PRZYKADOWY ROZDZIA
SPIS TRECI

KATALOG KSIEK
KATALOG ONLINE
ZAMW DRUKOWANY KATALOG

C# i ASP.NET. Szybki start

Autor: Jose Mojica
Tumaczenie: Wojciech Moch (rozdz. 1 - 6),
Radosaw Meryk (rozdz. 7 - 13)
ISBN: 83-7361-389-7
Tytu oryginau: C# Web Development with ASP.NET:
Visual QuickStart Guide
Format: B5, stron: 456
Przykady na ftp: 1127 kB

TWJ KOSZYK
DODAJ DO KOSZYKA

CENNIK I INFORMACJE
ZAMW INFORMACJE
O NOWOCIACH
ZAMW CENNIK

CZYTELNIA
FRAGMENTY KSIEK ONLINE

C# to cakiem nowy jzyk programowania zaprojektowany przez firm Microsoft.

Wyglda on jak mieszanka C++ i Javy, jest jednak tak prosty jak Visual Basic.
Z jego pomoc mona tworzy aplikacje WWW i programy wyposaone w graficzny
interfejs uytkownika. Jzyk ten zwizany jest z platform .NET, umoliwiajc
tworzenie zaawansowanych aplikacji biznesowych dziaajcych w rodowisku
sieciowym, w tym take z technologi budowania dynamicznych serwisw
internetowych ASP.NET. Programy dziaajce na platformie .NET mona pisa
w wielu jzykach programowania, ale wiele wskazuje na to, e wanie C# stanie si
najpopularniejszym z nich.
Ksika C# i ASP.NET. Szybki start jest doskonaym podrcznikiem dla
pocztkujcych programistw. Jak kada pozycja z serii Szybki start, skada si
z kilkudziesiciu rozdziaw, z ktrych kady przedstawia kolejne kroki, ktre naley
wykona, by osign zamierzony cel. Dodatkow zalet stanowi liczne ilustracje.
Opisano midzy innymi:
Instalacj niezbdnego oprogramowania
Skadniki jzyka C#
Instrukcje warunkowe i ptle
Prac z cigami znakw
Programowanie obiektowe w C#
Korzystanie z tablic i kolekcji
Delegaty, zdarzenie, obsug bdw
Tworzenie dynamicznych serwisw WWW w jzyku C#

Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl

Programista chccy tworzy zaawansowane aplikacje internetowe ma wybr pomidzy

dwoma platformami: Java 2 EE Suna i .NET Microsoftu. Jeli wybierze t drug, dziki
ksice C# i ASP.NET. Szybki start szybko bdzie mg tworzy funkcjonalne
aplikacje WWW w nowym, ekscytujcym jzyku C#.

Spis treci

Spis treci
Wstp

11

Zaczynamy
23
Jak zdoby C# ...........................................................................................24
Instalowanie IIS.........................................................................................26
Tworzenie projektu aplikacji sieciowej w Visual Studio .NET ................28
Uruchamianie projektw sieciowych za pomoc Visual Studio .NET........ 31
Pisanie prostej strony ASP .NET ..............................................................33
Wyszukiwanie bdw w aplikacjach ASP .NET .....................................35
Rczne uruchamianie kompilatora ............................................................38
Kompilowanie i uruchamianie programw C# bez pomocy VS.NET ........ 39
Wyszukiwanie bdw w programach bez pomocy VS.NET ...................41

Rozdzia 2.

Skadniki jzyka C#
43
Praca z elementami jzyka ........................................................................44
Pisanie kodu C#.........................................................................................48
Deklarowanie zmiennych ..........................................................................50
Definiowanie staych.................................................................................53
Grupowanie staych w typy wyliczeniowe................................................54
Deklarowanie funkcji ................................................................................56
Deklarowanie funkcji z parametrami ........................................................58
Zwracanie wartoci funkcji .......................................................................62
Definiowanie klas......................................................................................64
Dodawanie klas do przykadowej aplikacji...............................................67
Tworzenie i stosowanie obiektw .............................................................68
Tworzenie obiektw w przykadowej aplikacji.........................................70
Wczanie definicji klas ze rde zewntrznych......................................71
Grupowanie klas w przestrzeniach nazw ..................................................74
Dodawanie pl do klas ..............................................................................78
Inicjalizowanie pl w momencie ich deklarowania ...................................79
Dodawanie waciwoci do klas................................................................80
5

Spis treci

Rozdzia 1.

Spis treci

Spis treci

Dodawanie metod do klasy .......................................................................86

Dodawanie skadowych do klas przykadowego programu ......................89
Uruchamianie przykadowej aplikacji.......................................................90
Dodawanie komentarzy.............................................................................95
Kierunki parametrw w typach referencyjnych ........................................97
Rozdzia 3.

Wyraenia warunkowe i ptle

99
Praca z ptlami i warunkami ...................................................................100
Porwnywanie typw numerycznych .....................................................104
Porwnywanie typw referencyjnych .....................................................105
czenie porwna .................................................................................109
Instrukcje warunkowe .............................................................................110
Sprawdzanie wielu warunkw za pomoc instrukcji switch ...................112
Operator warunku....................................................................................114
Dodawanie instrukcji warunkowych do przykadowego programu ........115
Stosowanie ptli while ............................................................................122
Stosowanie ptli do .................................................................................123
Stosowanie ptli for.................................................................................124
Zakoczenie i kontynuacja ptli..............................................................126
Dodawanie ptli do przykadowego programu........................................129

Rozdzia 4.

Cigi znakw
133
Przygotowanie komputera do pracy z cigami znakw ..........................135
Praca z cigami znakw ..........................................................................137
Inicjalizowanie cigw znakw ..............................................................140
Porwnywanie cigw znakw ...............................................................142
czenie cigw znakw.........................................................................145
Okrelanie dugoci cigu znakw ..........................................................147
Porwnywanie i czenie cigw znakw w przykadowej aplikacji........ 148
Tworzenie cigw z pojedynczych znakw ............................................151
Znaki specjalne........................................................................................154
Stosowanie cigw literaw...................................................................156
Dostp do poszczeglnych znakw cigu ...............................................158
Wyszukiwanie podcigw wewntrz cigw znakw ............................159
Pobieranie wycinka cigu........................................................................160
Dzielenie cigu znakw...........................................................................161
Skadanie cigw.....................................................................................163

Spis treci

Zamiana liter na mae lub wielkie ...........................................................164

Formatowanie cigw znakw................................................................165
Uruchomienie przykadowej aplikacji.....................................................166
Zamiana obiektw na cigi znakw ........................................................171
Tworzenie cigw znakw za pomoc klasy StringBuilder .....................172
Rozdzia 5.

Dziedziczenie klas

173

Rozdzia 6.

Skadowe specjalne

203

Dodawanie wielu funkcji o takich samych nazwach,

czyli przecianie funkcji........................................................................204
Definiowane funkcji o zmiennej liczbie parametrw .................................207
Dodawanie konstruktorw ......................................................................209
Wywoywanie konstruktora klasy bazowej.............................................210
Dodawanie finalizerw ...........................................................................212
Tworzenie bibliotek kodu za pomoc skadowych statycznych..............213
Zmiana znaczenia operatora (przecianie operatorw) .........................216
Definiowanie rwnowanoci klas przez przecienie
operatora rwnoci ..................................................................................220
Definiowanie rwnowanoci klas przez pokrycie funkcji Equals .........222
Praca ze skadowymi specjalnymi...........................................................224
Rozdzia 7.

Typy

229

Dziaania z typami...................................................................................230
Uzyskiwanie typu klasy ..........................................................................234
Sprawdzanie zgodnoci typw ................................................................236
7

Spis treci

Praca z dziedziczeniem klas ....................................................................174

Dziedziczenie z innej klasy .....................................................................177
Udostpnianie skadowych klas i ograniczanie dostpu do nich.............180
Rozbudowa przykadowej aplikacji ........................................................183
Ukrywanie metod klasy bazowej ............................................................188
Pokrywanie funkcji w klasie wywiedzionej ............................................190
Dodawanie standardowego klawisza do przykadowej aplikacji ............194
Stosowanie nowego klawisza na formularzu WorkOrder .......................197
Dodawanie funkcji, ktre musz zosta pokryte.....................................200
Wymg dziedziczenia .............................................................................201
Blokowanie dziedziczenia.......................................................................202

Spis treci

Konwersja jednego typu na inny .............................................................237

Rozwinicie przykadowej aplikacji .......................................................240
Definiowanie regu konwersji (przecianie operatora konwersji) ........... 246

Spis treci

Rozdzia 8.

Interfejsy

249

Dziaania z interfejsami...........................................................................251
Definiowanie interfejsw ........................................................................255
Niejawna implementacja skadowych interfejsu .....................................257
Jawna implementacja skadowych interfejsu ..........................................260
Usprawnianie przykadowej aplikacji .....................................................261
Wykorzystanie obiektw poprzez interfejsy ...........................................268
Rozpoznawanie interfejsu .......................................................................269
Wykorzystanie interfejsw do polimorfizmu..........................................271
Interfejs bdcy pochodn innego interfejsu...........................................272
Refaktoryzacja.........................................................................................274
Ponowna implementacja interfejsw w klasie pochodnej.......................275
Koczymy przykadow aplikacj ..........................................................277
Rozdzia 9.

Tablice i kolekcje

279

Dziaania z tablicami i kolekcjami ..........................................................281

Tworzenie tablic wartoci .......................................................................285
Tworzenie tablic typw referencyjnych ..................................................287
Poruszanie si po tablicy .........................................................................291
Inicjowanie elementw tablicy w miejscu ..............................................294
Tworzenie tablic wielowymiarowych .....................................................296
Usprawnianie przykadowej aplikacji .....................................................298
Odnajdywanie elementw tablicy
za pomoc wyszukiwania liniowego.......................................................... 301
Sortowanie tablic.....................................................................................304
Odnajdywanie elementw tablicy
za pomoc wyszukiwania binarnego.......................................................... 307
Klasy dziaajce jak tablice (definiowanie indeksatorw) ......................309
Wprowadzenie indeksatorw do przykadowej aplikacji........................312
Kopiowanie tablic ...................................................................................313
Tworzenie list dynamicznych..................................................................314
Tworzenie kolejek ...................................................................................316
8

Spis treci

Tworzenie stosw....................................................................................317
Tworzenie tabel mieszajcych.................................................................318
Przegldanie elementw tabel mieszajcych...........................................320
Koczymy przykadow aplikacj ..........................................................321
Testowanie kontrolki CodeGridWeb.......................................................323
Rozdzia 10. Delegaty i zdarzenia

325

Rozdzia 11. Obsuga bdw

353

Wykonywanie dziaa z wyjtkami ........................................................354

Przechwytywanie wyjtkw....................................................................360
Przechwytywanie wybranych wyjtkw .................................................363
Uzyskiwanie informacji o wyjtku..........................................................366
Dziaania z acuchami wyjtkw...........................................................368
Deklarowanie wasnych wyjtkw..........................................................372
Definiowanie komunikatw o bdach....................................................374
Zgaszanie wyjtku..................................................................................375
Przechwytywanie i ponowne zgaszanie wyjtkw ................................376
Tworzenie acucha wyjtkw................................................................377
Wprowadzanie kodu,
ktry wykonuje si przed zakoczeniem dziaania funkcji.....................378
Zastosowanie sowa kluczowego using...................................................380
Wprowadzanie zabezpiecze formularzy do przykadowej aplikacji........ 382
Obsuga nieobsuonych bdw w aplikacjach WWW .........................385
9

Spis treci

Dziaania z delegatami i zdarzeniami......................................................327

Deklarowanie delegatw .........................................................................330
Tworzenie i wywoywanie delegatw .....................................................331
czenie delegatw .................................................................................333
Odczanie delegatw .............................................................................334
Deklarowanie i wyzwalanie zdarze .......................................................336
Deklarowanie zdarze przyjaznych dla WWW ......................................338
Subskrypcja zdarze................................................................................340
Asynchroniczne wyzwalanie delegatw .................................................342
Oczekiwanie na zakoczenie dziaania delegatw asynchronicznych ...... 346
Pobieranie wynikw dziaania delegatw asynchronicznych .................348
Koczymy przykadow aplikacj ..........................................................350

Spis treci

Spis treci

Rozdzia 12. Odbicia i atrybuty

389
Dziaania z odbiciami i atrybutami .........................................................390
Identyfikacja kompilata...........................................................................394
Dziaania z wywietlanymi nazwami ......................................................395
Dziaania z cigami znakw opisu cieek .............................................398
Dynamiczne adowanie programu na podstawie nazwy wywietlanej...... 399
Dynamiczne adowanie programu na podstawie cieki dostpu ...........400
Tworzenie egzemplarza klasy w kompilacie...........................................401
Uzyskiwanie listy klas w kompilacie ......................................................403
Wyszczeglnienie skadowych klasy ......................................................404
Dynamiczne ustawianie lub pobieranie pl.............................................406
Dynamiczne wywoywanie metody ........................................................409
Koczymy zadanie pierwsze w przykadowej aplikacji..........................411
Stosowanie atrybutw kodu ....................................................................413
Definiowanie atrybutw ..........................................................................414
Wyszukiwanie atrybutw w kodzie ........................................................417
Koczymy zadanie drugie w przykadowej aplikacji..............................420
Rozdzia 13. Projekty WWW w jzyku C#
423
Tworzenie projektu DLL za pomoc Visual Studio .NET ......................424
Odwoywanie si do kodu DLL i jego wykonywanie .............................428
Udostpnianie bibliotek DLL do globalnego wykorzystania ..................429
Tworzenie serwisw WWW ...................................................................432
Wykorzystywanie serwisw WWW .......................................................436
Skorowidz

10

439

Interfejsy

Interfejsy
Interfejsy

W wiecie, w ktrym yjemy, obowizuj zasady

interfejsw. Implementacjami podobnych
interfejsw s, na przykad, 
. Wielu z nas
oddycha i je (jeli kto si z tym nie zgadza,
prosz natychmiast przesta czyta t ksik).
Kady egzemplarz klasy 
 moe w inny
sposb oddycha lub je, ale, niezalenie od tego,
takie firmy, jak np. McDonald bd mogy odnosi
sukcesy tylko wtedy, gdy zostanie wykonana
metoda 
 naleca do interfejsu  .

249

Interfejsy

Interfejsy to typy pozwalajce na definiowanie

wielu klas speniajcych podobne funkcje.
Wyobramy sobie klas
. W klasie

s takie metody, jak: 
,   ,

   itp. Uytkownik jest
zadowolony z klasy
, poniewa umoliwia
mu ona dojazdy do pracy i z powrotem. W pewnym
momencie jego koledzy zaczli jednak artowa
z klasy
, dlatego postanowi zastpi j
klas . Przed zastpieniem klasy

klas  uytkownik chce mie jednak
pewno, e klasa ta spenia co najmniej takie
same funkcje, co klasa Escort. Musi wic
oferowa metody 
,   ,

  . Wszystkie te dziaania mog
by wykonywane inaczej ni w klasie
,
ale wane jest, aby istniay co najmniej takie
same metody. Ich zestaw nazywa si interfejsem.
Interfejs moe np. nosi nazw  
.
Wszystkie samochody, aby mogy by tak
nazywane, bd musiay zawiera implementacj
interfejsu  
(przynajmniej z naszego
punktu widzenia).

Rozdzia 8.

Interfejsy

W terminologii jzyka C# interfejsy s typami.

W stosunku do definicji interfejsw w jzyku C++
rni si tym, e nie s to wyspecjalizowane
klasy. S to natomiast oddzielne typy. Zgodnie
z podstawow definicj, interfejs jest zbiorem
definicji funkcji (tylko definicji, bez kodu
implementacji). Funkcje te same w sobie nie
wykonuj adnych dziaa. Przypominaj
interfejs   bez konkretnego egzemplarza
czowieka to tylko pojcie, a nie rzeczywista
implementacja. Aby mona byo skorzysta
z interfejsu, naley go zaimplementowa
w obrbie klasy. Kiedy klasa implementuje
interfejs, ogasza wszem i wobec, e obsuguje
wszystkie zdefiniowane w nim metody. Jeeli
sprzedawca uywanych samochodw twierdzi,
e jego towar jest implementacj interfejsu
 
, to tak samo, jakby mwi, e zawiera
co najmniej metody: 
,   ,

  . Jeeli ktra z metod
interfejsu nie zostanie zaimplementowana,
kompilator jzyka C# zgosi bd.
Zastosowanie interfejsw pozwala programistom
pisa kod wykorzystujcy funkcje i nie martwi
si ich implementacj. Dziki temu mona
rozpocz od jakiej implementacji, a potem
cakowicie j zastpi bez koniecznoci
przepisywania kodu. Sprawdza si to w przypadku
interfejsu  
. Kierowcy nie ucz si
prowadzenia konkretnego samochodu ucz si
prowadzi dowolny samochd, poniewa wszystkie
samochody realizuj ten sam, podstawowy interfejs.
Posumy si, jako przykadem rzeczywistego
zastosowania interfejsw, technologi ADO .NET,
ktra pozwala na realizacj poczenia z baz
danych. Firma Microsoft, mona w to wierzy
lub nie, nie ma zamiaru wymusza uycia tylko
jednej bazy danych. Zamiast zmusza do uycia
tego samego zestawu klas, zdefiniowaa interfejs
funkcji umoliwiajcych zrealizowanie poczenia
z baz danych. Producenci baz danych maj wic
moliwo napisania klas bdcych implementacj
tego interfejsu. Idea kodowania z wykorzystaniem
interfejsw polega na tym, e mona zmieni
wykorzystywany pakiet bazy danych bez
koniecznoci przepisywania aplikacji.

250

Interfejsy

Dziaania z interfejsami
Jako przykadow aplikacj w tym rozdziale
napiszemy modu ASP .NET. Nie bdzie
to aplikacja bardzo rozbudowana, ale za to bdzie
j mona wykorzysta w rzeczywistych
aplikacjach (w tym rozdziale nie bdzie aplikacji
dotyczcej supermenw).

Celem moduu, ktry utworzymy, bdzie

dostarczenie wszystkim stronom informacji
o rozmiarach obszaru klienta w przegldarce.
Obszar klienta w przegldarce to miejsce,
w ktrym jest wywietlana strona WWW
(wewntrz okna przegldarki, bez paskw menu
i stanu). Interesujce, e rodowisko .NET nie
przekazuje tych wymiarw za porednictwem
adnej z waciwoci. Mona jednak uzyska
te wielkoci za pomoc skryptw dziaajcych
po stronie serwera (VBScript lub JavaScript
dziaajce na komputerze-kliencie, a nie na
serwerze tak, jak strony ASP). Mona zapyta,
dlaczego interesuj nas te wymiary? Ot s
nam potrzebne, poniewa czasami chcemy
zastosowa grafik o mniejszych wymiarach,
jeli wymiary okna s mniejsze lub wikszych
wymiarach, jeli wymiary okna s wiksze.

251

Dziaania z interfejsami

A zatem, czym jest modu ASP .NET?

Modu jest klas, ktra moe przechwytywa
dania dowolnych stron w aplikacji. Moduy
wykorzystuje si do wykonywania takich
dziaa, jak np. testy zabezpiecze. Mog one
przechwyci kade danie i albo je zatrzyma,
albo kontynuowa lub te zmodyfikowa
w pewien sposb. Moduy mog take
wykonywa dziaania po obsudze dania
przez odpowiedni stron. Programistom
dowiadczonym w programowaniu aplikacji
WWW z pewnoci pomoe wyjanienie,
e moduy s odpowiednikiem filtrw IIS
w rodowisku .NET.

Dziaania z interfejsami

Rozdzia 8.
Rozwizanie problemu jest nastpujce. Kiedy
klient zada strony po raz pierwszy, modu
zatrzyma danie i zwrci stron z odpowiednim
skryptem dziaajcym po stronie klienta.
Zadaniem skryptu bdzie okrelenie wymiarw
obszaru klienta. Skrypt zapisze wymiary
w ukrytym polu, a nastpnie zada natychmiast
tej samej strony, ktrej klient da poprzednio.
Wysanie skryptu dziaajcego po stronie klienta
i zwrcenie pierwotnie danej strony powinno
nastpi na tyle szybko, aby uytkownik niczego
nie zauway. Za drugim razem, gdy modu
otrzyma danie tej samej strony (teraz zada
jej skrypt dziaajcy po stronie klienta),
modu odnajdzie ukryte pola zawierajce
wymiary, utworzy niewielki obiekt sucy
do przechowywania potrzebnych informacji
i przekae je do danej strony. Strona pobierze
obiekt z informacjami i zwrci wynik do klienta,
ktry wykorzysta informacje o rozmiarze obszaru
klienta. W naszym przypadku na stronie wymiary
wywietlone zostan w polach tekstowych.

Aby napisa modu:

1. Uruchom Visual Studio .NET (Start/

Programy/Microsoft Visual Studio .NET).

2. Wybierz polecenie File/New/Project.

Na ekranie pojawi si okno dialogowe

New Project.
3. W panelu Project Types po lewej stronie

okna New Project kliknij folder Visual C#

projects.
4. Zaznacz ikon ASP .NET Web Application

i zmie nazw aplikacji na interfacesproject

(rysunek 8.1).
5. Program Visual Studio utworzy nowy projekt

i otworzy formularz WebForm1.aspx.

6. Zmie nazw formularza na dimensions.aspx.

W tym celu wybierz polecenie View/Solution

Explorer z grnego paska menu.

252

Rysunek 8.1. Do utworzenia moduu potrzebny jest

tylko projekt biblioteki, a nie cay projekt WWW
ASP .NET. Jednak utworzenie projektu WWW
ASP .NET pozwala na napisanie i przetestowanie
moduu w jednym projekcie

Interfejsy
7. Kliknij prawym klawiszem myszy formularz

dimensions.aspx i wybierz polecenie

Properties. W tabelce waciwoci,
pokazanej poniej na rysunku 8.2, zmie
waciwo FileName z WebForm1.aspx
na dimensions.aspx.
8. Zmodyfikuj formularz dimension.aspx

Rysunek 8.2. Zmiana nazwy pliku nie powinna

sprawia teraz adnych problemw

Rysunek 8.3. Bardzo prosty formularz, ktry atwo

utworzy od nowa. Zawiera dwie etykiety, dwa pola
tekstowe oraz jedno cze

253

Dziaania z interfejsami

w taki sposb, aby wyglda tak, jak formularz

pokazany na rysunku 8.3. Oczywicie,
w rczne wykonanie tego zadanie trzeba
woy wiele pracy. Zamiast tego moesz
wprowadzi kod HTML bezporednio
w edytorze. Na rysunku 8.4, na nastpnej
stronie, zaprezentowano kod HTML niezbdny
do utworzenia formularza. Aby bezporednio
wprowadzi kod HTML, kliknij przycisk
HTML w oknie edytora. Alternatywnie
moesz pobra plik szkieletu dla tego projektu
(patrz Wskazwki na nastpnej stronie).

Rozdzia 8.
Wskazwki

To, co do tej pory zrobilimy w przykadowej

aplikacji, nie ma nic wsplnego z moduem

uytkownika. Formularz projektowany
w tym podrozdziale zostanie uyty
do przetestowania moduu. Kod moduu
zostanie dodany natychmiast po tym, jak
dowiemy si czego na temat implementacji
interfejsw.

Podobnie jak w przypadku innych projektw

w tej ksice, utworzenie projektu nie

jest konieczne do poznania poj
zaprezentowanych w niniejszym rozdziale.

Dziaania z interfejsami

Szkielety wszystkich projektw mona

pobra z witryny WWW Wydawnictwa

Peachpit pod adresem http://www.peachpit.
com/vqs/csharp.

254

Rysunek 8.4. Kod HTML pokazany na tym rysunku

mona wykorzysta jako wzorzec. Dziki formularzowi
moliwe jest uzyskanie informacji o wymiarach
i pozycji wszystkich elementw sterujcych

 
 

 



  ! 
"
 

 ! #$ % &

'()*&

'+&

 &$ %
, &

,'+&

-)./0."("01"12 2 *- &

!  $ %  
 
   &



  
-  34"1+56%7%8*$(6
9:8
0."("016 8(06;<
 
   &
 
 

,6  &



  '
-  34"1+56%798*$(6
9=8
0."("016 8(06<7
 
   &
 

,6  &


 
-  34"1+56%7;8*$(6
>?8
0."("016 8(06;@
 
   &

,6&

6 '
-  34"1+56%7?8*$(6
>?8
0."("016 8(06@>
 
   &

,6&




A. !
-  34"1+56%7:8*$(6
>=8
0."("016 8(06%%7
 
  
1B  

 &
 

,6- 
A&

,! &

,-&

,'()*&

Interfejsy
Tabela 8.1. Skadowe interfejsu (skadowe, ktre
mona wprowadzi do definicji interfejsu)

Definiowanie interfejsw

Nazwa

Przykad

Metoda

 
)EF8

Waciwo


C8D

Waciwo tylko
do odczytu


C8D

Indeks


H


IC86D

Interfejsy definiuje si za pomoc sowa

kluczowego . Dla interfejsw mona
definiowa metody, waciwoci, delegaty,
zdarzenia itp. Kady z elementw wewntrz
interfejsu musi by jednak tylko deklaracj
elementu i nie moe zawiera implementacji.

Zdarzenie



'
 
0
 A8

Rysunek 8.5. Skadowe interfejsu to tylko definicje,

ktre nie zawieraj kodu. W definicjach nie stosuje
si take modyfikatorw dostpu wszystkie
metody interfejsu s publiczne

1. Wpisz sowo kluczowe  lub ,

w zalenoci od zasigu, jaki ma mie

interfejs.
2. Wprowad sowo kluczowe ,

a po nim spacj.
3. Wpisz nazw interfejsu.
4. Otwrz nawias klamrowy .
5. Wprowad definicje skadowych (tabela 8.1).
6. Zamknij nawias klamrowy ! (rysunek 8.5).

255

Definiowanie interfejsw

 

"'

C
 
1C8D,,waciwo tylko
,, do odczytu
E

F8,,metoda
G EF8,,metoda
D

Aby zdefiniowa interfejs:

Rozdzia 8.
Wskazwki

Wszystkie metody interfejsu z definicji s

publiczne w definicji metody nie mona

wprowadzi modyfikatorw dostpu
(dotyczy to take modyfikatora ).

Danych typu interfejsu mona uy

w definicjach parametrw lub zmiennych

(rysunek 8.6). W przypadku interfejsw
nie mona jednak tworzy nowych
egzemplarzy na przykad nie mona
napisa "#.

W interfejsach mona przecia metody

(rysunek 8.7).

Definiowanie interfejsw

Jeeli jaki programista uyje interfejsu,

najlepiej nie zmienia jego definicji.

W przeciwnym razie istnieje ryzyko,
e napisany program przestanie dziaa.
W takiej sytuacji najlepiej zdefiniowa nowy
interfejs. Wicej informacji na ten temat
znajdzie si w dalszej czci tego rozdziau,
w podrozdziale Tworzenie interfejsw
pochodnych od innych interfejsw.

256

Rysunek 8.6. Po zdefiniowaniu interfejsu mona

go wykorzysta jako typ danych w deklaracjach
zmiennych lub parametrw
 + -J

C
(AEF
C

 
8

 
8
D
 2(+

 E
 
F
C
 
4&EF8
D
D

Rysunek 8.7. Przecianie metod to moliwo

istnienia kilku metod o tej samej nazwie.
Pamitaj, e mona to zrobi tylko pod warunkiem,
e zmieni si liczb parametrw lub zmodyfikuje
typ jednego z nich
 
 !"'

C
 
1C8D
,,waciwo tylko do odczytu
!
E

F8,,metoda
!
E 
!(-K

F8
,,przecianie
D

Interfejsy
Rysunek 8.8. Implementacja interfejsu przypomina
dziedziczenie. W przypadku metody niejawnej
wystarczy zaimplementowa skadowe interfejsu
jako metody publiczne
 
 !"'

C
 
1C8D
. E  F8
D

 $ %
 
&
C
! E 
 78


 8
 LLF
C
'


'
 
8

J
 E  M F8
D
D
D

Interfejsy s implementowane przez klasy.

Zaimplementowanie interfejsu oznacza
wprowadzenie kodu dla wszystkich
zdefiniowanych w nim metod. Kompilator
wymusza wprowadzenie kodu dla wszystkich
metod bez wyjtku. Wynika to std,
e programista wykorzystujcy interfejs
spodziewa si, e klasa implementujca
interfejs bdzie zawiera definicje wszystkich
zawartych w nim metod. Istniej dwa
mechanizmy implementowania interfejsw
w klasie: mechanizm niejawny i jawny.
Najpierw zaprezentujemy mechanizm niejawny.

Aby zaimplementowa interfejs

w sposb niejawny:
1. Po nazwie klasy, ktra bdzie implementowa

interfejs, wpisz dwukropek, a po nim nazw

interfejsu, ktry bdzie implementowany.
2. Wprowad skadowe odpowiadajce

wszystkim skadowym interfejsu.

3. Oznacz metody implementacyjne jako

publiczne.
4. Wpisz kod skadowych interfejsu

(rysunek 8.8).

257

Niejawna implementacja skadowych

   
6

C
 
" #

C

C
 
  8
D
D

Niejawna implementacja
skadowych interfejsu

Rozdzia 8.
Wskazwki

Ten mechanizm implementacji interfejsu

cechuje wada polegajca na tym, e kad

metod implementacyjn naley oznaczy
jako publiczn.

Aby zaimplementowa wicej ni jeden

interfejs, naley oddzieli poszczeglne

nazwy interfejsu przecinkiem (rysunek 8.9).

Rysunek 8.9. Klasa Person implementuje

zarwno interfejs IHuman, jak i IManager.
Zaimplementowanie interfejsu ustanawia relacj
jest. Innymi sowy, osoba (Person) jest
czowiekiem (Human) i menederem (Manager)
 
 !"'

C
 
1C8D
. E  F8
D

Niejawna implementacja skadowych

 
 !")

C
.-0
 -E 

K
"B
N F8
D
   
6
' (

"

C
 
" #

C

C
 
  8
D
D
 $ %
 
&
C
! E 
 78


 8
 LLF
C
'


'
 
8

J
 E  M F8
D
D
 $ !%
" 
'
 )


&
C
N E"B
N F
C
*A0 .  E
F8
D
D
D

258

Interfejsy
Rysunek 8.10. W powyszym kodzie zdefiniowano
klas Person, ktra implementuje interfejs IHuman.
Nastpnie, biorc pod uwag to, e nie wszystkie
osoby s menederami, zdefiniowano klas
opisujc menederw. Jednak, ze wzgldu na to,
e menederowie s ludmi (persons), klasa
ta dziedziczy wszystkie skadowe klasy Person
(zasada dziedziczenia). Na kocu znajduje si
implementacja interfejsu IManager

Jeeli klasa jest pochodn innej klasy

(nie interfejsu), najpierw naley wymieni

klas, ktra nie naley do interfejsu,
a nastpnie implementowane interfejsy.
Wszystkie te elementy trzeba oddzieli
przecinkami (rysunek 8.10).

 
 !"'

C
 
1C8D
. E  F8
D

Niejawna implementacja skadowych

 
 !")

C
.-0
 -E 

K
"B
N F8
D
   
6"'

C
  
1
C

C
 
  8
D
D
 . E  F
C
! E 
 78


 8
 LLF
C
'


'
 
8

J
 E  M F8
D
D
D
  )
 6*
' (

"

 $ !%

" 
'
 )


&
C
N E"B
N F
C
*A0 .  E
F8
D
D
D

259

Rozdzia 8.

Jawna implementacja skadowych

Jawna implementacja
skadowych interfejsu
Podczas implementowania interfejsu przez
wprowadzanie skadowych publicznych
powstaje problem polegajcy na tym, e czasami
dwa interfejsy zawieraj metod o takiej samej
nazwie i takich samych parametrach,
ale konieczne jest zaimplementowanie tych
metod na dwa rne sposoby. W przypadku
zastosowania metody niejawnej jedna metoda
publiczna bdzie stanowia implementacj
metod o takiej samej nazwie i tym samym
zbiorze parametrw dla wszystkich interfejsw.
Metoda jawna umoliwia poinformowanie
kompilatora o tym, ktr metod, ktrego
interfejsu mielimy zamiar zaimplementowa.

Aby jawnie zaimplementowa

interfejs:
1. Po nazwie klasy, ktra bdzie implementowa

interfejs, wpisz dwukropek, a po nim nazw

interfejsu, ktry bdzie implementowany.
2. Wpisz typ zwracanej wartoci dla skadowej

interfejsu.
3. Wpisz $ %&
%.

Mwic inaczej, wpisz nazw interfejsu,

po nim kropk, a po niej nazw metody
interfejsu.
4. Wprowad parametry skadowej interfejsu.
5. Wpisz kod skadowej interfejsu (rysunek 8.11).

Wskazwka

Wszystkie metody implementowane w ten

sposb s prywatne. Nie mona wprowadzi

modyfikatora dostpu na pocztku definicji.

260

Rysunek 8.11. W przypadku jawnego

implementowania interfejsu nie wprowadza si
modyfikatorw dostpu. Naley wpisa nazw
interfejsu, po nim kropk, a po niej nazw metody
 
 !"'

C
 
1C8D
. E  F8
D
   
6"'

C

" 
+#

C

C
 
  8
D
D
$ 
+%
 
&
C
! E 
 78


 8
 LLF
C
'


'
 
8

J
 E  M F8
D
D
D

Interfejsy

Usprawnianie
przykadowej aplikacji

Nie zamierzamy powica w tym rozdziale

wiele miejsca na tumaczenie, czym jest
zdarzenie. Na razie wystarczy, abymy wiedzieli,
e zdarzenie jest metod wywoywan w wyniku
dziaania. Implementacja zdarze pod wieloma
wzgldami przypomina implementacj
interfejsw. Rnica polega na tym, e interfejs
moe zawiera kilka metod, natomiast zdarzenie
zawiera tylko jedn metod. Przykadem
zdarzenia jest kliknicie przycisku. Klasa da
od zdarzenia  informacji od przycisku
formularza. Kiedy uytkownik kliknie przycisk,
serwer informuje klas, e miao miejsce
zdarzenie. Modu mona wykorzysta
np. do nasuchiwania wystpienia zdarzenia
*+,-. rodowisko ASP .NET wyzwala
to zdarzenie za kadym razem, gdy przegldarka
klienta zada strony.

261

Usprawnianie przykadowej aplikacji

Teraz, kiedy wiemy ju, w jaki sposb definiuje

si interfejsy oraz jak naley implementowa
interfejsy za pomoc klas, czas usprawni
przykadow aplikacj. Dokadniej rzecz ujmujc,
zdefiniujemy klas, ktra bdzie suy jako
modu uytkownika. Aby przeksztaci klas
w modu, naley zaimplementowa w niej
interfejs  &'&(
. Jego
zaimplementowanie nie jest trudne zawiera
tylko dwie metody:  i ). rodowisko
ASP .NET wywouje metod  w momencie,
gdy modu jest po raz pierwszy adowany
do pamici. Metoda ) wywoywana jest
w momencie usuwania moduu z pamici.
Jedyna trudno polega na wykorzystaniu
zdarzenia. Zdarzenia zostan opisane
w rozdziale 10. Delegaty i zdarzenia.

Rozdzia 8.

Aby zdefiniowa
klas moduu uytkownika:
1. Z paska menu wybierz polecenie Project/

Add class. Wpisz custommodule.cs jako

nazw klasy i wcinij Enter (rysunek 8.12).
2. W grnej czci kodu moduu, poniej
wiersza o treci +" , wpisz wiersz
+" &'.

Usprawnianie przykadowej aplikacji

3. W wierszu w postaci: "

 
 dodaj na kocu: (

tak, aby wiersz ten przyj posta: 
" 
."(
.
4. Teraz trzeba troch pooszukiwa.

W systemie Visual Studio .NET znajduje si

kreator pozwalajcy na atw implementacj
interfejsu. Z menu wybierz polecenie
View/Class View.

Rysunek 8.12. Wszystkie waciwoci funkcjonalne

moduu uytkownika zostan zaimplementowane
w klasie custommodule. Dziki wykorzystaniu okna
dialogowego pokazanego na rysunku uyjemy
kreatora do wygenerowania szkieletu klasy

5. W oknie Class View rozwi folder

interfacesproject/custommodule/Bases and
interfaces. Kliknij prawym klawiszem myszy
IHttpModule i z rozwijanego menu wybierz
Add/Implement Interface (rysunek 8.13).

Rysunek 8.13. Kreator implementacji interfejsu

wykorzystuje mechanizm niejawnej implementacji.
Dla kadej skadowej interfejsu definiowane s
elementy publiczne

262

Interfejsy
Rysunek 8.14. Interfejs IHttpModule spenia
dwie funkcje. Po pierwsze, informuje rodowisko
ASP .NET, e klasa jest moduem uytkownika.
Po drugie, rodowisko zyskuje moliwo
poinformowania klasy, kiedy modu jest adowany
po raz pierwszy (metoda Init) oraz kiedy nie jest ju
potrzebny (metoda Dispose)

6. Kreator spowoduje dodanie namiastek

metod  i ). Kod przyjmie posta

widoczn na rysunku 8.14.

7. Dodaj do klasy metod *+,-

(rysunek 8.15).


.-8

.-8


 ! #
C
,,,
 -&

,
" 
  (
 $
%++-
 &
.
/

D
D

 $ 0%&

.
/
,
"


.-8

.-8


 ! #
C
,,,
 -&
,,, Oglny opis moduu custommodule
,,,
, -&
   6"') 
C
  EF
C
,,
,, DO ZROBIENIA: Tutaj naley wprowadzi
,,logik konstruktora
,,
D
 
" 

!"') 
 
"
E.-' 

F
C
D
 +EF
C
D

 

D
D

$ 1"23%4 

'
!$-
"

"&
.
/

263

Usprawnianie przykadowej aplikacji

,,, Oglny opis moduu custommodule

,,,
, -&
   6"') 
C
  EF
C
,,
,, DO ZROBIENIA: Tutaj naley
,,wprowadzi logik konstruktora
,,
D

Rysunek 8.15. Metoda BeginRequest nie jest czci

interfejsu IHttpModule. Jest to zdarzenie zdefiniowane
dla klasy HttpApplication, informujce o tym,
e wystpuj dania do dowolnej ze stron w aplikacji

Rozdzia 8.
8. W metodzie  wprowad kod wicy
zdarzenie *+,- z metod klasy
*+,- (rysunek 8.16). Nie martw si,

jeeli na razie kod ten jest niejasny, jego

szczegowe wyjanienie znajdzie si
w rozdziale 10. Delegaty i zdarzenia.

Rysunek 8.16. Zwr uwag, e w celu powizania

zdarzenia klasy z metod do zdarzenia odwoujemy
si w taki sposb, jakby byo ono waciwoci
obiektu (obiekt.nazwazdarzenia), nastpnie
uywamy operatora += i przypisujemy mu nowy
obiekt (delegat). Metod przekazujemy jako
parametr konstruktora obiektu

.-8

.-8


 ! #
C
,,,
 -&

Usprawnianie przykadowej aplikacji

0O
-P 
,,,
, -&
   6"') 
C
  EF
C
,,
DO ZROBIENIA: Tutaj naley
,,wprowadzi logik konstruktora
,,
D
 
" 

!"') 
 
"
E.-' 

F
C
+1"23 56 
!$

%1"23&7
D
 +EF
C
D

 

G
JQE#
 K

  F
C
D
D
D

264

Interfejsy
Rysunek 8.17. Doce pikno literaw znakowych.
Zwr uwag, jak atwo korzystajc z literaw
znakowych mona umieci znaki koca wiersza
w cigu znakw. Po prostu formatujemy cig
znakw, tak jak chcemy, umieszczajc gdzie naley
znaki koca wiersza

utworzenia cigu znakw stanowicego

skrypt dziaajcy po stronie klienta i zapisz
go w obiekcie #. Pamitaj,
e obiekt # jest dostpny
na wszystkich stronach i dla kadego
klienta (rysunek 8.17).

Usprawnianie przykadowej aplikacji

 "
E.-' 


F
C

G
JQL
N

'
  EG
JQF8

"  6 89
:;
<

+++
:
 
"
"6$
;
 =0%&
0 
0 "

9. Wprowad kod w metodzie  w celu

 6 ++>

" 6
++>"
+
+0+?

6 @ 99799 @ " @
99799
+
+
! 
:A
;
: B
 699=099;
:
 
699
99 699*C99

 6 99.D/99;
:;: 69999

699099
 699ED99;:A;
:A
;
:A;
:A;97
+-
F9GG0$
C(B9H67
D

265

Rozdzia 8.
10. Teraz, w treci metody *+,- wpisz

Usprawnianie przykadowej aplikacji

kod pokazany na rysunku 8.18. Zadaniem

tego kodu jest sprawdzenie, czy s dostpne
informacje o wymiarach. Informacje
te powinny by dostpne za porednictwem
pola ukrytego. Jeeli pole tekstowe nie istnieje,
modu zablokuje danie strony i wyle
skrypt dziaajcy po stronie klienta. Skrypt
zarejestruje wymiary okna w ukrytym polu
i natychmiast zada strony ponownie. Modu
sprawdzi, czy pole tekstowe istnieje i, jeeli
istnieje, wprowadzi wymiary do obiektu 
(wicej informacji na ten temat znajdzie si
w ramce na nastpnej stronie).
Wskazwki

Kod zaprezentowany w tym podrozdziale

to kompletny kod potrzebny do utworzenia

moduu uytkownika. Jednak modu ten nie
bdzie dziaa dopty, dopki nie uzupenimy
przykadu kodem pokazanym w dalszej czci
tego rozdziau.

Kreator implementujcy interfejsy wprowadza
kod /+"  ""(


na pocztku bloku metod implementacyjnych

oraz /
+ na kocu tego bloku.
Te instrukcje nie dotycz bezporednio
kompilatora. Umoliwiaj one uzyskanie
rozwijanego kodu w edytorze. Jak mona
zauway, w edytorze pojawi si znak minus
z lewej strony deklaracji regionu (rysunek 8.19).
Kliknicie znaku minus w edytorze spowoduje
ukrycie kodu umieszczonego w obszarze
i zastpienie znaku minus plusem
(rysunek 8.20). Kliknicie znaku plus
spowoduje ponowne pojawienie si kodu.

Rysunek 8.18. Na tym rysunku znalaz si kod,

ktry wymaga wyjanienia. Szczegowe
informacje na jego temat mona znale w ramce
pt. Szczegy zdarzenia BeginRequest
G
JQE#
 K
 
 F
C
=
 " 6 %=
&
7

"  6
"+23+I
F909H7
 % 66  JJ  66
99&
.

"  6 %
"&"+>+
-
F9GG0$
C(B9H7

" )
 6 
"+I

%'
"+23+)
+-*
&7
"+2+
%)
&7
"+>23%&7
/
 
%+%9>9& 66 KL&
.

"FH   6 +%M7M&7
  6 +>$
+
CNE% FDH&7
 " 6
+>$
+CNE% FLH&7
"+>+F9GG>9H 6
7
"+>+F9GG>"9H 6
"7
/
D

Rysunek 8.19. Instrukcja #region powoduje

dodanie obszaru rozwijanego kodu. Kiedy edytor
wykryje dyrektyw #region, umieszcza znak minus
po lewej stronie okna kodu

Rysunek 8.20. Kliknicie znaku minus powoduje

rozwinicie kodu obszaru i wywietlenie opisu
za sowem #region, umoliwiajcego identyfikacj
kodu. Sowo kluczowe #region w kodzie nie ma adnego
znaczenia funkcjonalnego. Jest ono wykorzystywane
wycznie przez edytor, zatem, jeeli komu wydaje si
niepotrzebne, moe je usun

266

Interfejsy

Szczegy zdarzenia BeginRequest

W pierwszym wierszu metody *+,- znajduje si instrukcja konwersji obiektu 

(pierwszy parametr metody) na obiekt 0. 0 jest klas generowan przez kreator
podczas tworzenia projektu ASP .NET. Jest to pochodna klasy (#. Obiekt tej klasy
tworzy si za pierwszym razem, gdy dowolny klient skorzysta z dowolnej strony w aplikacji.
Z obiektu 0 mona uzyska dostp do innych obiektw np. , lub ,-.
W drugim wierszu kodu uyto obiektu 0 do uzyskania obiektu ,-. Jak pamitamy,
obiekt ,- umoliwia uzyskanie informacji na temat dania klienta. Jeeli skorzystamy
z waciwoci  , moemy uzyska dostp do ukrytego pola, ktre zostao utworzone
przez skrypt dziaajcy po stronie klienta. Nazwa tego ukrytego pola to 1) .

Do tej pory nie uywalimy obiektu  , ale przypomina on obiekty  oraz #.
Oglnie rzecz biorc, jest to jeszcze jeden sposb utrwalania informacji. Rnica midzy
tymi obiektami polega na czasie dostpnoci informacji. W obiekcie   informacje s
dostpne tylko na czas trwania dania klienta. W przypadku obiektu # informacje
s dostpne tak dugo, jak serwer WWW przetwarza aplikacj i maj do nich dostp wszystkie
klienty korzystajce z aplikacji. Informacje zapisane w obiekcie  s dostpne na czas
trwania programu, ale s one specyficzne dla kadego klienta. Obiekt   istnieje tylko
na czas dania. Jeeli zatem klient przechodzi z jednej strony na drug, informacje zostaj
utracone. W ramach tego samego dania modu moe jednak umieci informacje
w obiekcie   i strona bdzie miaa do nich dostp przez odwoanie +&1& .

267

Usprawnianie przykadowej aplikacji

W wierszu +&,-& 231) 34 nastpuje pobranie tekstu z ukrytego pola.

Jeeli pole nie istnieje, zwrcony wynik bdzie wartoci . W przeciwnym razie bd
to wsprzdne obszaru klienta. Skrypt dziaajcy po stronie klienta zapisuje wsprzdne
w postaci: szeroko;wysoko (np. 800;600). Jeeli wynik wynosi , do klienta wysyany
jest skrypt za pomoc funkcji ,&'. Potem nastpuje wywoanie funkcji
 ,-, ktrej dziaanie polega na zatrzymaniu dania strony. Jeeli wymiary s
dostpne, nastpuje rozbicie cigu znakw o formacie szeroko;wysoko na dwie liczby
i konwersja tych liczb na typ +. Wartoci te s nastpnie umieszczone w obiekcie  .

Rozdzia 8.

Wykorzystanie obiektw
poprzez interfejsy
Kiedy programista zdefiniuje interfejs
i zaimplementuje go jako konkretn klas,
moe uywa tej klasy poprzez interfejs.

Aby uywa klasy poprzez interfejs:

1. Zdefiniuj zmienn typu interfejsu.
Wpisz na przykad "5.
2. Ustaw zmienn typu interfejsu na warto

rwn klasie, ktra ten interfejs implementuje.

Wpisz na przykad 6""
78
(rysunek 8.21).

Wykorzystanie obiektw

Wskazwka

Nie mona tworzy egzemplarzy interfejsu.

Interfejs jest typem abstrakcyjnym,

co oznacza, e nie jest to klasa, ktrej
obiekty mona utworzy. Zamiast tego
tworzy si egzemplarze klasy
implementujcej interfejs.

Rysunek 8.21. Chocia typem zmiennej jest ICar,

nie mona napisa new ICar. Trzeba utworzy
egzemplarz klasy implementujcej interfejs.
Nie mona tworzy egzemplarzy interfejsu

 !"
C
 
J
EF8
 
.EF8
 
 -)EF8
D
  6"
C
  
J
EF
C
 
 RSAT-AK#AM 8
D
  
.EF
C
 
 RA T TSS
T T-U 8
D
  
 -)EF
C
 
 RV- KAO T-


 W 8
D
D
 + 
C
  
2( AEF
C
>



6  !
%&7
 
 8
L J
EF8
L  -)EF8
L .EF8
 
8
D
D

268

Interfejsy
Rysunek 8.22. Zmienna obj jest typu object.
Oznacza to, e moe wskazywa na obiekt Cat
lub na obiekt Dog. Powyszy kod testuje zawarto
zmiennej obj przez sprawdzenie, czy obiekt obj
obsuguje interfejs IDog

 !"
C
 
"
 0N
 EF8
D

 !"+
C
 
*
(0N
 EF8
D
  6"+
C
D

 0N

C
$
 E##F
C
!E4  0"F
C
"+E"+F#8
 
*
(0N
 EF8
D
D
D

Przed uyciem obiektu poprzez interfejs warto

sprawdzi, czy obiekt rzeczywicie obsuguje
interfejs. Oczywicie, jeeli mamy dostp
do definicji klasy, moemy na ni spojrze
i przekona si, czy klasa implementuje interfejs.
Czasami jednak mamy do czynienia z danymi
typu %, dla ktrych trzeba zweryfikowa,
czy obiekt, na ktry wskazuje zmienna, jest
zgodny z interfejsem, ktrego chcemy uy.
Istniej dwa sposoby sprawdzenia, czy obiekt
obsuguje interfejs.

Aby sprawdzi,
czy obiekt obsuguje interfejs:
1. Wpisz "7%""#+8, gdzie %

jest zmienn wskazujc na obiekt, ktry

chcesz sprawdzi, natomiast #+
jest nazw interfejsu, dla ktrego chcesz
przeprowadzi test (rysunek 8.22).
lub
Wpisz #+"5"6"%" #+,
gdzie #+ jest interfejsem, dla ktrego
chcesz przeprowadzi test, 5 jest dowoln
zmienn suc do przechowywania
odwoania do obiektu, a % jest obiektem,
ktry chcesz sprawdzi.

269

Rozpoznawanie interfejsu

 .6"
C
D

Rozpoznawanie interfejsu

Rozdzia 8.
2. Wpisz instrukcj "75968. Jeeli

po wykonaniu pierwszego kroku zmienna

5 jest rwna null, obiekt nie obsuguje
interfejsu. Jeli test zwrci warto rn
od null, obiekt obsuguje interfejs, a zmienna
5 wskazuje na odwoanie do interfejsu
(rysunek 8.23).
Wskazwki

Podczas korzystania z pierwszego

mechanizmu, po uzyskaniu informacji,

e obiekt obsuguje interfejs, aby uy
obiektu poprzez interfejs, naley zadeklarowa
zmienn typu interfejsu, po czym dokona
konwersji obiektu na interfejs.

Rozpoznawanie interfejsu

W przypadku drugiego mechanizmu

rozpoznawania interfejsu, zarwno konwersja

obiektu, jak i rozpoznanie nastpuje
w jednym kroku. Jeeli obiekt obsuguje
interfejs, zmienna 5 bdzie wskazywa
na obiekt, w przeciwnym razie zmienna 5
przyjmie warto null.

Istnieje trzeci mechanizm rozpoznawania,

czy obiekt obsuguje interfejs. Mona

sprbowa dokona konwersji obiektu
na interfejs. Jeeli obiekt nie obsuguje
interfejsu, konwersja spowoduje zgoszenie
wyjtku (bdu). Wyjtki zostan omwione
w rozdziale 11. Obsuga bdw.
Wykorzystywanie wyjtkw nie jest
zalecane jako sposb rozpoznawania
obsugi interfejsu przez obiekty, poniewa
wyjtki mog wpyn niekorzystnie
na wydajno dziaania programu.

270

Rysunek 8.23. Kiedy do sprawdzenia, czy obiekt

obsuguje interfejs, uyjemy polecenia as, uzyskamy
wynik null wtedy, gdy obiekt go nie obsuguje

 !"
C
 
"
 0N
 EF8
D

 !"+
C
 
*
(0N
 EF8
D
  6"+
C
D
 .6"
C
D
 0N

C
$
 E##F
C
"+4
 0"7
!EM
 F
 
*
(0N
 EF8
D
D

Interfejsy
Rysunek 8.24. Zwr uwag, e typem parametru
metody Communicate jest IHuman. Do metody
mona przekaza dowolny obiekt, ktry implementuje
interfejs. Kada z trzech klas implementuje interfejs
w inny sposb. Metoda Communicate zwraca inny
cig znakw w zalenoci od przekazanego obiektu

 !"

C
 
.AEF8
D
 G-6"'

C
  
.AEF
C
 
 244 8
D
D

 $ 
6"'

C
  
.AEF
C
 
 T-OP-VY-T-U S

ST-X 8
D
D

Polimorfizm to mechanizm polegajcy na tym,

e dwie powizane ze sob klasy maj nieznacznie
rnice si implementacje tej samej metody.
W przypadku wykorzystania interfejsw jako
typw, programista moe zdefiniowa funkcje,
ktre akceptuj jako parametry dowolne obiekty
implementujce interfejs. Nastpnie, w zalenoci
od obiektu przesanego do funkcji, wykonywany
jest nieco inny kod.

Aby wykorzysta polimorfizm:

1. W dowolnej klasie zdefiniuj metod,

w ktrej jeden z parametrw wejciowych

jest typu interfejsu.
2. Wywoaj metody interfejsu.
3. Przeka do metody dowolny obiekt

obsugujcy interfejs (rysunek 8.24).

Wskazwka

Przed przekazaniem obiektu do metody

naley si upewni, czy obiekt rzeczywicie

obsuguje interfejs (wicej informacji
na ten temat znalazo si w podrozdziale
Rozpoznawanie interfejsu
we wczeniejszej czci tego rozdziau).

  

C
 

E
 
F
C
 
 
.AEF8
D
+ -*
EF
C
 

N 8
. %&8

N 
EF8
$ 
!  I
%&8

N 
E
F8
G- 1
%&8

N 
E
F8
D
D

271

Wykorzystanie interfejsw

 .6"'

C
  
.AEF
C
 
 T-SAU
N-A X 8
D
D

Wykorzystanie interfejsw
do polimorfizmu

Rozdzia 8.

Interfejs bdcy pochodn

innego interfejsu

Interfejs pochodn innego interfejsu

Jeeli inni programici wykorzystuj nasz

obiekt poprzez okrelony interfejs, a niezbdne
okae si ulepszenie interfejsu, wwczas
najlepiej pozostawi definicj oryginalnego
interfejsu bez zmian. W jzyku C# istnieje
mechanizm umoliwiajcy rozszerzanie
interfejsu bez dodawania metod do interfejsu
oryginalnego. Dziaanie tego mechanizmu
polega na tworzeniu interfejsw pochodnych.

Aby utworzy interfejs bdcy

pochodn innego interfejsu:
1. Zakadajc, e wczeniej zdefiniowae

jeden interfejs, zdefiniuj drugi.

2. Za nazw interfejsu wpisz dwukropek,
nastpnie $ , gdzie
$  jest nazw interfejsu,

ktry chcesz rozszerzy.

3. Oba interfejsy: oryginalny i rozszerzony

moesz zaimplementowa w ramach

tej samej klasy (rysunek 8.25).

272

Rysunek 8.25. Interfejs IPresident stanowi

rozszerzenie interfejsu IParent. Oznacza to,
e przy implementacji interfejsu IPresident naley
zaimplementowa nie tylko metody interfejsu
IPresident, ale take metody interfejsu IParent

 !" 

C
.
Z( -EF8
D

 !" 
6" 

C
+ -EF8
D
 2 6*

.
AAimplementacja metod dla obu interfejsw
AAIparent oraz IPresident
 .
Z( -EF
C
D
 + -EF
C
D
D

Interfejsy
Rysunek 8.26. Zaimplementowanie obu interfejsw:
nadrzdnego i pochodnego jest tym samym,
co zaimplementowanie tylko interfejsu pochodnego,
poniewa interfejs pochodny zawiera wszystkie
skadowe interfejsu nadrzdnego

 !" 

C
.
Z( -EF8
D

 !" 
6" 

C
+ -EF8
D

Definicje klas zaprezentowanych

na rysunku 8.26 s sobie rwnowane.

Zaimplementowanie interfejsu oryginalnego
i pochodnego jest tym samym,
co zaimplementowanie tylko interfejsu
pochodnego. W obu przypadkach uzyskuje
si klas zgodn z obydwoma interfejsami.

Definicje klas przedstawionych na rysunku

8.27 nie s sobie rwnowane. Chocia

interfejs 05+: jest kombinacj
interfejsw: : oraz 
0,
to zaimplementowanie interfejsu
05+: nie jest tym samym,
co oddzielne zaimplementowanie interfejsw
: i 
0. Interfejs 05+:
moe zawiera inne metody ni kombinacja
metod interfejsw: : oraz 
0.

 + -EF

C
D
D

Rysunek 8.27. Mimo e klasa Telemarketer

implementuje zarwno interfejs IPerson, jak
ISendGifts, klasa ta nie jest zgodna z interfejsem
IGivingPerson

 !"2
 
6" 
K
".
2!
C
D
 2 
6=$"*

C
D
 (  A 6*
' =
C
D

273

Interfejs pochodn innego interfejsu

 2 6*

.
AAimplementacja metod dla obu interfejsw:
AAIparent oraz IPresident
 .
Z( -EF
C
D

Wskazwki

Rozdzia 8.

Refaktoryzacja
Refaktoryzacja (ang. refactoring) to mechanizm
wykorzystywany w programowaniu obiektowym
do dziaa z klasami i interfejsami. Polega
on na tym, e jeli dwie klasy speniajce
podobne funkcje maj wsplny kod, wwczas
ze wsplnego kodu tworzy si klas bazow,
a nastpnie, na podstawie tej klasy bazowej,
tworzy si podklasy. Podklasy zawieraj tylko
ten kod, ktry je od siebie odrnia1.

Aby dokona refaktoryzacji klas

z wykorzystaniem interfejsw:
1. Jeeli kilka klas implementuje ten

sam interfejs w podobny sposb

(kod implementacyjny jest identyczny
dla wszystkich klas), utwrz klas bazow.

Refaktoryzacja

2. Zaimplementuj interfejs w klasie bazowej.

3. Wprowad w klasie bazowej kod

implementacyjny dla kadej metody

interfejsu.
4. Utwrz klasy pochodne na podstawie klasy

bazowej.
5. Teraz moesz wykorzysta klasy pochodne

poprzez interfejs (rysunek 8.28).

Wskazwki

Jeeli klasa bazowa implementuje interfejs,

klasy pochodne s take zgodne z interfejsem.

W czasie projektowania klas, najpierw

Rysunek 8.28. Obiektu Checking mona uy

poprzez interfejs IAccount, poniewa klasa
Checking jest pochodn klasy AccountImpl, a klasa
AccountImpl implementuje interfejs IAccount.
Innymi sowy, jeeli dowolna klasa w hierarchii
nadrzdnej implementuje interfejs, to klasa
pochodna take obsuguje ten interfejs

 !"

C
)A+E

F8
)A N E

F8
D

 -  -
C
 )A+E

F
C
D
 )A N E

F
C
D
D
 A
6-
C
D
 .
6-
C
D
 G
A
C
0

EF
C
"

NA
EF8
)A+E%77F8
D
D

naley zdefiniowa interfejsy, pniej

utworzy klas bazow implementujc
te interfejsy, a nastpnie utworzy podklasy
dziedziczce cechy klasy bazowej.
Klasy pochodne wykorzystuje si poprzez
interfejs. Wanie taki mechanizm czsto
wykorzystuj dowiadczeni programici
podczas pisania aplikacji.

Z treci tego akapitu nie wynika, czym naprawd jest refaktoryzacja. Jest to po prostu upraszczanie kodu,
czyli midzy innymi wydzielanie podklas przyp. tum.

274

Interfejsy
Rysunek 8.29. Klasa Dog implementuje interfejs
IAnimal. Klasa GreatDane jest pochodn klasy
Dog, a zatem przejmuje implementacj interfejsu
IAnimal. Jednak co zrobi, aby zaimplementowa
metod Speak interfejsu IAnimal inaczej ni
w implementacji Dog, a implementacj metody
Eat pozostawi bez zmian? W takiej sytuacji mona
ponownie zaimplementowa interfejs IAnimal
w klasie GreatDane i zmieni implementacj
wybranych metod

 !"

C
 
.AEF8
 
EF8
D

 
"
 EF
C
 
 [M 8
D
D

Czytelnicy, ktrzy przeczytali wczeniejszy

podrozdzia o refaktoryzacji, wiedz o tym,
e mona utworzy klas bazow obsugujc
interfejs, a nastpnie napisa klas pochodn
dla tej klasy bazowej. Klasa pochodna rwnie
obsuguje interfejs. Czasami jednak trzeba
przesoni jedn metod lub kilka metod
implementacyjnych w klasie bazowej. W tym
celu mona ponownie zaimplementowa
interfejs w klasie pochodnej.

Aby ponownie zaimplementowa

interfejs w klasie pochodnej:
1. Za nazw klasy pochodnej wpisz dwukropek,

a po nim nazw interfejsu, ktry chcesz

zaimplementowa ponownie.
2. Wprowad implementacj tylko dla tych

metod, ktre maj by rne od metod klasy

bazowej (rysunek 8.29).

 2 +
6+K-

C

" -
+
%&
C
 
  AN!M AN!M 8
D
D

275

Ponowna implementacja interfejsw

 +6"

C
 
"
 .AEF
C
 
 N!MN!M 8
D

Ponowna implementacja
interfejsw w klasie pochodnej

Rozdzia 8.
Wskazwka

Innym sposobem ponownej implementacji

metody interfejsu jest zaznaczenie oryginalnej

metody implementacyjnej jako wirtualnej,
a nastpnie przesonicie jej w podklasie
(rysunek 8.30).

Rysunek 8.30. Ta metoda wymaga od autora

klasy bazowej zaznaczenia metody jako wirtualnej,
co nie zawsze jest moliwe

 !"

C
 
.AEF8
 
EF8
D
 +6"

C
 $

 
.AEF
C
 
 N!MN!M 8
D

Ponowna implementacja interfejsw

  
EF
C
 
 [M 8
D
D
 2 +
6+
C
 $

 
.AEF
C
 
 00$M00$M 8
D
D

276

Interfejsy
Rysunek 8.31. rodowisko ASP .NET przed
rozpoczciem aplikacji odczytuje ustawienia
w pliku web.config. Ustawienia w tym pliku mona
wykorzysta w celu zarzdzania sposobem
uruchamiania aplikacji przez system ASP .NET

) &


 +


- 
 ! # K

 ! # ,&

,) &

Koczymy przykadow
aplikacj
Pozostao jedynie kilka czynnoci, ktre trzeba
wykona, aby nasza aplikacja staa si w peni
funkcjonalna. W tym podrozdziale uzupenimy
pozostay kod.
Najpierw upewnimy si, e rodowisko
ASP .NET wie o module uytkownika.

Aby uaktywni modu uytkownika

w aplikacji:
1. W module Solution Explorer kliknij

dwukrotnie plik web.config.

na rysunku 8.31 zaraz za wierszem
;< &=.

277

Koczymy przykadow aplikacj

2. Przewi plik do koca i wpisz kod pokazany

Rozdzia 8.
To wszystko, co trzeba zrobi, aby uaktywni
modu uytkownika dla naszej aplikacji.
Nastpny krok polega na wprowadzeniu kodu
na stronie dimensions.aspx, aby upewni si,
czy modu dziaa.

Aby zakoczy stron dimensions.aspx:

1. Dwukrotnie kliknij pozycj dimension.aspx

w oknie Solution Explorer.

2. Dwukrotnie kliknij pusty obszar

na formularzu, co spowoduje wywoanie

edytora kodu. Kreator doda zdarzenie
:+>
.

Rysunek 8.32. W tym kodzie sprawdzana jest

kolekcja Items i pobierane wartoci __ClientWidth
oraz __ClientHeight zapisane przez modu
uytkownika
 /*E#
 K
.-
 F
C
+C 6
%%&>+F9GG>9H&+
C
"%&7
"+C 6
%%&>+F9GG>"9H&+
C
"%&7
D

Koczymy przykadow aplikacj

3. Wewntrz metody :+>

wprowad kod

zaprezentowany na rysunku 8.32. Kod ten

spowoduje wywietlenie wartoci szerokoci
i wysokoci w dwch polach tekstowych
(rysunek 8.33).
Wskazwki

Aby przekona si, e modu dziaa, wystarczy

zmieni rozmiar okna przegldarki, a nastpnie

klikn przycisk Odwie znajdujcy si pod
polami tekstowymi. W polach tekstowych
powinny pojawi si nowe rozmiary okna.

Dzisiejszej nocy warto si dobrze wyspa.

278

Rysunek 8.33. Aby przetestowa modu uytkownika,

wystarczy zmieni rozmiary okna przegldarki,
a nastpnie klikn cze Odwie. Wartoci
szerokoci i wysokoci okna powinny ulec zmianie