Błyskawiczny kurs tworzenia aplikacji WWW w języku C# C# to całkiem nowy język programowania zaprojektowany przez firmę Microsoft. Wygląda on jak mieszanka C++ i Javy, jest jednak tak prosty jak Visual Basic. Z jego pomocą można tworzyć aplikacje WWW i programy wyposażone w graficzny interfejs użytkownika. Język ten związany jest z platformą .NET, umożliwiającą tworzenie zaawansowanych aplikacji biznesowych działających w środowisku sieciowym, w tym także z technologią budowania dynamicznych serwisów internetowych ASP.NET. Programy działające na platformie .NET można pisać w wielu językach programowania, ale wiele wskazuje na to, że właśnie C# stanie się najpopularniejszym z nich. Książka "C# i ASP.NET. Szybki start" jest doskonałym podręcznikiem dla początkujących programistów. Jak każda pozycja z serii "Szybki start", składa się z kilkudziesięciu rozdziałów, z których każdy przedstawia kolejne kroki, które należy wykonać, by osiągnąć zamierzony cel. Dodatkową zaletę stanowią liczne ilustracje. Opisano między innymi: * Instalację niezbędnego oprogramowania * Składniki języka C# * Instrukcje warunkowe i pętle * Pracę z ciągami znaków * Programowanie obiektowe w C# * Korzystanie z tablic i kolekcji * Delegaty, zdarzenie, obsługę błędów * Tworzenie dynamicznych serwisów WWW w języku C# Programista chcący tworzyć zaawansowane aplikacje internetowe ma wybór pomiędzy dwoma platformami: Java 2 EE Suna i .NET Microsoftu. Jeśli wybierze tę drugą, dzięki książce "C# i ASP.NET. Szybki start" szybko będzie mógł tworzyć funkcjonalne aplikacje WWW w nowym, ekscytującym języku C#.

1. IDZ DO
PRZYK£ADOWY ROZDZIA£
SPIS TRE CI C# i ASP.NET. Szybki start
Autor: Jose Mojica
KATALOG KSI¥¯EK T³umaczenie: Wojciech Moch (rozdz. 1 - 6),
Rados³aw Meryk (rozdz. 7 - 13)
ISBN: 83-7361-389-7
KATALOG ONLINE Tytu³ orygina³u: C# Web Development with ASP.NET:
Visual QuickStart Guide
ZAMÓW DRUKOWANY KATALOG Format: B5, stron: 456
Przyk³ady na ftp: 1127 kB
TWÓJ KOSZYK
DODAJ DO KOSZYKA C# to ca³kiem nowy jêzyk programowania zaprojektowany przez firmê Microsoft.
Wygl¹da on jak mieszanka C++ i Javy, jest jednak tak prosty jak Visual Basic.
Z jego pomoc¹ mo¿na tworzyæ aplikacje WWW i programy wyposa¿one w graficzny
CENNIK I INFORMACJE interfejs u¿ytkownika. Jêzyk ten zwi¹zany jest z platform¹ .NET, umo¿liwiaj¹c¹
tworzenie zaawansowanych aplikacji biznesowych dzia³aj¹cych w rodowisku
ZAMÓW INFORMACJE sieciowym, w tym tak¿e z technologi¹ budowania dynamicznych serwisów
O NOWO CIACH internetowych ASP.NET. Programy dzia³aj¹ce na platformie .NET mo¿na pisaæ
w wielu jêzykach programowania, ale wiele wskazuje na to, ¿e w³a nie C# stanie siê
ZAMÓW CENNIK najpopularniejszym z nich.
Ksi¹¿ka „C# i ASP.NET. Szybki start” jest doskona³ym podrêcznikiem dla
pocz¹tkuj¹cych programistów. Jak ka¿da pozycja z serii „Szybki start”, sk³ada siê
CZYTELNIA z kilkudziesiêciu rozdzia³ów, z których ka¿dy przedstawia kolejne kroki, które nale¿y
wykonaæ, by osi¹gn¹æ zamierzony cel. Dodatkow¹ zaletê stanowi¹ liczne ilustracje.
FRAGMENTY KSI¥¯EK ONLINE Opisano miêdzy innymi:
• Instalacjê niezbêdnego oprogramowania
• Sk³adniki jêzyka C#
• Instrukcje warunkowe i pêtle
• Pracê z ci¹gami znaków
• Programowanie obiektowe w C#
• Korzystanie z tablic i kolekcji
• Delegaty, zdarzenie, obs³ugê b³êdów
• Tworzenie dynamicznych serwisów WWW w jêzyku C#
Programista chc¹cy tworzyæ zaawansowane aplikacje internetowe ma wybór pomiêdzy
dwoma platformami: Java 2 EE Suna i .NET Microsoftu. Je li wybierze tê drug¹, dziêki
Wydawnictwo Helion ksi¹¿ce „C# i ASP.NET. Szybki start” szybko bêdzie móg³ tworzyæ funkcjonalne
ul. Chopina 6
aplikacje WWW w nowym, ekscytuj¹cym jêzyku C#.
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl

2. Spis treści
Spis treści
Wstęp 11
Rozdział 1. Zaczynamy 23
Jak zdobyć C# ...........................................................................................24
Instalowanie IIS.........................................................................................26
Tworzenie projektu aplikacji sieciowej w Visual Studio .NET ................28
Uruchamianie projektów sieciowych za pomocą Visual Studio .NET........ 31
Pisanie prostej strony ASP .NET ..............................................................33
Wyszukiwanie błędów w aplikacjach ASP .NET .....................................35
Ręczne uruchamianie kompilatora ............................................................38
Kompilowanie i uruchamianie programów C# bez pomocy VS.NET ........ 39
Wyszukiwanie błędów w programach bez pomocy VS.NET ...................41
Spis treści
Rozdział 2. Składniki języka C# 43
Praca z elementami języka ........................................................................44
Pisanie kodu C#.........................................................................................48
Deklarowanie zmiennych ..........................................................................50
Definiowanie stałych.................................................................................53
Grupowanie stałych w typy wyliczeniowe................................................54
Deklarowanie funkcji ................................................................................56
Deklarowanie funkcji z parametrami ........................................................58
Zwracanie wartości funkcji .......................................................................62
Definiowanie klas......................................................................................64
Dodawanie klas do przykładowej aplikacji...............................................67
Tworzenie i stosowanie obiektów .............................................................68
Tworzenie obiektów w przykładowej aplikacji.........................................70
Włączanie definicji klas ze źródeł zewnętrznych......................................71
Grupowanie klas w przestrzeniach nazw ..................................................74
Dodawanie pól do klas ..............................................................................78
Inicjalizowanie pól w momencie ich deklarowania ...................................79
Dodawanie właściwości do klas................................................................80
5

3. Spis treści
Dodawanie metod do klasy .......................................................................86
Dodawanie składowych do klas przykładowego programu ......................89
Uruchamianie przykładowej aplikacji.......................................................90
Dodawanie komentarzy.............................................................................95
Kierunki parametrów w typach referencyjnych ........................................97
Rozdział 3. Wyrażenia warunkowe i pętle 99
Praca z pętlami i warunkami ...................................................................100
Porównywanie typów numerycznych .....................................................104
Porównywanie typów referencyjnych .....................................................105
Łączenie porównań .................................................................................109
Instrukcje warunkowe .............................................................................110
Sprawdzanie wielu warunków za pomocą instrukcji switch ...................112
Operator warunku....................................................................................114
Dodawanie instrukcji warunkowych do przykładowego programu ........115
Stosowanie pętli while ............................................................................122
Stosowanie pętli do .................................................................................123
Spis treści
Stosowanie pętli for.................................................................................124
Zakończenie i kontynuacja pętli..............................................................126
Dodawanie pętli do przykładowego programu........................................129
Rozdział 4. Ciągi znaków 133
Przygotowanie komputera do pracy z ciągami znaków ..........................135
Praca z ciągami znaków ..........................................................................137
Inicjalizowanie ciągów znaków ..............................................................140
Porównywanie ciągów znaków ...............................................................142
Łączenie ciągów znaków.........................................................................145
Określanie długości ciągu znaków ..........................................................147
Porównywanie i łączenie ciągów znaków w przykładowej aplikacji........ 148
Tworzenie ciągów z pojedynczych znaków ............................................151
Znaki specjalne........................................................................................154
Stosowanie ciągów literałów...................................................................156
Dostęp do poszczególnych znaków ciągu ...............................................158
Wyszukiwanie podciągów wewnątrz ciągów znaków ............................159
Pobieranie wycinka ciągu........................................................................160
Dzielenie ciągu znaków...........................................................................161
Składanie ciągów.....................................................................................163
6

4. Spis treści
Zamiana liter na małe lub wielkie ...........................................................164
Formatowanie ciągów znaków................................................................165
Uruchomienie przykładowej aplikacji.....................................................166
Zamiana obiektów na ciągi znaków ........................................................171
Tworzenie ciągów znaków za pomocą klasy StringBuilder .....................172
Rozdział 5. Dziedziczenie klas 173
Praca z dziedziczeniem klas ....................................................................174
Dziedziczenie z innej klasy .....................................................................177
Udostępnianie składowych klas i ograniczanie dostępu do nich.............180
Rozbudowa przykładowej aplikacji ........................................................183
Ukrywanie metod klasy bazowej ............................................................188
Pokrywanie funkcji w klasie wywiedzionej ............................................190
Dodawanie standardowego klawisza do przykładowej aplikacji ............194
Stosowanie nowego klawisza na formularzu WorkOrder .......................197
Dodawanie funkcji, które muszą zostać pokryte.....................................200
Wymóg dziedziczenia .............................................................................201
Spis treści
Blokowanie dziedziczenia.......................................................................202
Rozdział 6. Składowe specjalne 203
Dodawanie wielu funkcji o takich samych nazwach,
czyli przecią anie funkcji........................................................................204
Definiowane funkcji o zmiennej liczbie parametrów .................................207
Dodawanie konstruktorów ......................................................................209
Wywoływanie konstruktora klasy bazowej.............................................210
Dodawanie finalizerów ...........................................................................212
Tworzenie bibliotek kodu za pomocą składowych statycznych..............213
Zmiana znaczenia operatora (przecią anie operatorów) .........................216
Definiowanie równowa ności klas przez przecią enie
operatora równości ..................................................................................220
Definiowanie równowa ności klas przez pokrycie funkcji Equals .........222
Praca ze składowymi specjalnymi...........................................................224
Rozdział 7. Typy 229
Działania z typami...................................................................................230
Uzyskiwanie typu klasy ..........................................................................234
Sprawdzanie zgodności typów ................................................................236
7

5. Spis treści
Konwersja jednego typu na inny .............................................................237
Rozwinięcie przykładowej aplikacji .......................................................240
Definiowanie reguł konwersji (przecią anie operatora konwersji) ........... 246
Rozdział 8. Interfejsy 249
Działania z interfejsami...........................................................................251
Definiowanie interfejsów ........................................................................255
Niejawna implementacja składowych interfejsu .....................................257
Jawna implementacja składowych interfejsu ..........................................260
Usprawnianie przykładowej aplikacji .....................................................261
Wykorzystanie obiektów poprzez interfejsy ...........................................268
Rozpoznawanie interfejsu .......................................................................269
Wykorzystanie interfejsów do polimorfizmu..........................................271
Interfejs będący pochodną innego interfejsu...........................................272
Refaktoryzacja.........................................................................................274
Ponowna implementacja interfejsów w klasie pochodnej.......................275
Kończymy przykładową aplikację ..........................................................277
Spis treści
Rozdział 9. Tablice i kolekcje 279
Działania z tablicami i kolekcjami ..........................................................281
Tworzenie tablic wartości .......................................................................285
Tworzenie tablic typów referencyjnych ..................................................287
Poruszanie się po tablicy .........................................................................291
Inicjowanie elementów tablicy w miejscu ..............................................294
Tworzenie tablic wielowymiarowych .....................................................296
Usprawnianie przykładowej aplikacji .....................................................298
Odnajdywanie elementów tablicy
za pomocą wyszukiwania liniowego.......................................................... 301
Sortowanie tablic.....................................................................................304
Odnajdywanie elementów tablicy
za pomocą wyszukiwania binarnego.......................................................... 307
Klasy działające jak tablice (definiowanie indeksatorów) ......................309
Wprowadzenie indeksatorów do przykładowej aplikacji........................312
Kopiowanie tablic ...................................................................................313
Tworzenie list dynamicznych..................................................................314
Tworzenie kolejek ...................................................................................316
8

6. Spis treści
Tworzenie stosów....................................................................................317
Tworzenie tabel mieszających.................................................................318
Przeglądanie elementów tabel mieszających...........................................320
Kończymy przykładową aplikację ..........................................................321
Testowanie kontrolki CodeGridWeb.......................................................323
Rozdział 10. Delegaty i zdarzenia 325
Działania z delegatami i zdarzeniami......................................................327
Deklarowanie delegatów .........................................................................330
Tworzenie i wywoływanie delegatów .....................................................331
Łączenie delegatów .................................................................................333
Odłączanie delegatów .............................................................................334
Deklarowanie i wyzwalanie zdarzeń .......................................................336
Deklarowanie zdarzeń przyjaznych dla WWW ......................................338
Subskrypcja zdarzeń................................................................................340
Asynchroniczne wyzwalanie delegatów .................................................342
Oczekiwanie na zakończenie działania delegatów asynchronicznych ...... 346
Spis treści
Pobieranie wyników działania delegatów asynchronicznych .................348
Kończymy przykładową aplikację ..........................................................350
Rozdział 11. Obsługa błędów 353
Wykonywanie działań z wyjątkami ........................................................354
Przechwytywanie wyjątków....................................................................360
Przechwytywanie wybranych wyjątków .................................................363
Uzyskiwanie informacji o wyjątku..........................................................366
Działania z łańcuchami wyjątków...........................................................368
Deklarowanie własnych wyjątków..........................................................372
Definiowanie komunikatów o błędach....................................................374
Zgłaszanie wyjątku..................................................................................375
Przechwytywanie i ponowne zgłaszanie wyjątków ................................376
Tworzenie łańcucha wyjątków................................................................377
Wprowadzanie kodu,
który wykonuje się przed zakończeniem działania funkcji.....................378
Zastosowanie słowa kluczowego using...................................................380
Wprowadzanie zabezpieczeń formularzy do przykładowej aplikacji........ 382
Obsługa nieobsłu onych błędów w aplikacjach WWW .........................385
9

7. Spis treści
Rozdział 12. Odbicia i atrybuty 389
Działania z odbiciami i atrybutami .........................................................390
Identyfikacja kompilata...........................................................................394
Działania z wyświetlanymi nazwami ......................................................395
Działania z ciągami znaków opisu ście ek .............................................398
Dynamiczne ładowanie programu na podstawie nazwy wyświetlanej...... 399
Dynamiczne ładowanie programu na podstawie ście ki dostępu ...........400
Tworzenie egzemplarza klasy w kompilacie...........................................401
Uzyskiwanie listy klas w kompilacie ......................................................403
Wyszczególnienie składowych klasy ......................................................404
Dynamiczne ustawianie lub pobieranie pól.............................................406
Dynamiczne wywoływanie metody ........................................................409
Kończymy zadanie pierwsze w przykładowej aplikacji..........................411
Stosowanie atrybutów kodu ....................................................................413
Definiowanie atrybutów ..........................................................................414
Wyszukiwanie atrybutów w kodzie ........................................................417
Kończymy zadanie drugie w przykładowej aplikacji..............................420
Spis treści
Rozdział 13. Projekty WWW w języku C# 423
Tworzenie projektu DLL za pomocą Visual Studio .NET ......................424
Odwoływanie się do kodu DLL i jego wykonywanie .............................428
Udostępnianie bibliotek DLL do globalnego wykorzystania ..................429
Tworzenie serwisów WWW ...................................................................432
Wykorzystywanie serwisów WWW .......................................................436
Skorowidz 439
10

8. Interfejsy
Interfejsy
Interfejsy
Interfejsy to typy pozwalające na definiowanie
wielu klas spełniających podobne funkcje.
Wyobraźmy sobie klasę 'UEQTV. W klasie 'UEQTV
są takie metody, jak: ,CFC, <CVT[OCPKG,
1FVYCTCPKG/W[MK itp. U ytkownik jest
zadowolony z klasy 'UEQTV, poniewa umo liwia
mu ona dojazdy do pracy i z powrotem. W pewnym
momencie jego koledzy zaczęli jednak artować
z klasy 'UEQTV, dlatego postanowił zastąpić ją
klasą (GTTCTK. Przed zastąpieniem klasy 'UEQTV
klasą (GTTCTK u ytkownik chce mieć jednak
pewność, e klasa ta spełnia co najmniej takie
same funkcje, co klasa Escort. Musi więc
oferować metody ,CFC, <CVT[OCPKG,
1FVYCTCPKG/W[MK. Wszystkie te działania mogą
być wykonywane inaczej ni w klasie 'UEQTV,
Interfejsy
ale wa ne jest, aby istniały co najmniej takie
same metody. Ich zestaw nazywa się interfejsem.
Interfejs mo e np. nosić nazwę +5COQEJQF.
Wszystkie samochody, aby mogły być tak
nazywane, będą musiały zawierać implementację
interfejsu +5COQEJQF (przynajmniej z naszego
punktu widzenia).
W świecie, w którym yjemy, obowiązują zasady
interfejsów. Implementacjami podobnych
interfejsów są, na przykład, .WFKG. Wielu z nas
oddycha i je (jeśli ktoś się z tym nie zgadza,
proszę natychmiast przestać czytać tę ksią kę).
Ka dy egzemplarz klasy .WFKG mo e w inny
sposób oddychać lub jeść, ale, niezale nie od tego,
takie firmy, jak np. McDonald będą mogły odnosić
sukcesy tylko wtedy, gdy zostanie wykonana
metoda ,GFGPKG nale ąca do interfejsu +%NQYKGM.
249

9. Rozdział 8.
W terminologii języka C# interfejsy są typami.
W stosunku do definicji interfejsów w języku C++
ró nią 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 działań. Przypominają
interfejs +%NQYKGM bez konkretnego egzemplarza
człowieka — to tylko pojęcie, a nie rzeczywista
implementacja. Aby mo na było skorzystać
z interfejsu, nale y go zaimplementować
w obrębie klasy. Kiedy klasa implementuje
interfejs, ogłasza wszem i wobec, e obsługuje
wszystkie zdefiniowane w nim metody. Je eli
sprzedawca u ywanych samochodów twierdzi,
e jego towar jest implementacją interfejsu
+5COQEJQF, to tak samo, jakby mówił, e zawiera
co najmniej metody: ,CFC, <CVT[OCPKG,
1FVYCTCPKG/W[MK. Je eli któraś z metod
interfejsu nie zostanie zaimplementowana,
kompilator języka C# zgłosi błąd.
Interfejsy
Zastosowanie interfejsów pozwala programistom
pisać kod wykorzystujący funkcje i nie martwić
się ich implementacją. Dzięki temu mo na
rozpocząć od jakiejś implementacji, a potem
całkowicie ją zastąpić bez konieczności
przepisywania kodu. Sprawdza się to w przypadku
interfejsu +5COQEJQF. Kierowcy nie uczą się
prowadzenia konkretnego samochodu — uczą się
prowadzić dowolny samochód, poniewa wszystkie
samochody realizują ten sam, podstawowy interfejs.
Posłu my się, jako przykładem rzeczywistego
zastosowania interfejsów, technologią ADO .NET,
która pozwala na realizację połączenia z bazą
danych. Firma Microsoft, mo na w to wierzyć
lub nie, nie ma zamiaru wymuszać u ycia tylko
jednej bazy danych. Zamiast zmuszać do u ycia
tego samego zestawu klas, zdefiniowała interfejs
funkcji umo liwiających zrealizowanie połączenia
z bazą danych. Producenci baz danych mają więc
mo liwość napisania klas będących implementacją
tego interfejsu. Idea kodowania z wykorzystaniem
interfejsów polega na tym, e mo na zmienić
wykorzystywany pakiet bazy danych bez
konieczności przepisywania aplikacji.
250

10. Interfejsy
Działania z interfejsami
Jako przykładową aplikację w tym rozdziale
napiszemy moduł ASP .NET. Nie będzie
to aplikacja bardzo rozbudowana, ale za to będzie
ją mo na wykorzystać w rzeczywistych
aplikacjach (w tym rozdziale nie będzie aplikacji
dotyczącej supermenów).
A zatem, czym jest moduł ASP .NET?
Moduł jest klasą, która mo e przechwytywać
ądania dowolnych stron w aplikacji. Moduły
wykorzystuje się do wykonywania takich
działań, jak np. testy zabezpieczeń. Mogą one
przechwycić ka de ądanie i albo je zatrzymać,
albo kontynuować lub te zmodyfikować
w pewien sposób. Moduły mogą tak e
wykonywać działania po obsłudze ądania
przez odpowiednią stronę. Programistom
Działania z interfejsami
doświadczonym w programowaniu aplikacji
WWW z pewnością pomo e wyjaśnienie,
e moduły są odpowiednikiem filtrów IIS
w środowisku .NET.
Celem modułu, który utworzymy, będzie
dostarczenie wszystkim stronom informacji
o rozmiarach obszaru klienta w przeglądarce.
Obszar klienta w przeglądarce to miejsce,
w którym jest wyświetlana strona WWW
(wewnątrz okna przeglądarki, bez pasków menu
i stanu). Interesujące, e środowisko .NET nie
przekazuje tych wymiarów za pośrednictwem
adnej z właściwości. Mo na jednak uzyskać
te wielkości za pomocą skryptów działających
po stronie serwera (VBScript lub JavaScript
działające na komputerze-kliencie, a nie na
serwerze tak, jak strony ASP). Mo na zapytać,
dlaczego interesują nas te wymiary? Otó są
nam potrzebne, poniewa czasami chcemy
zastosować grafikę o mniejszych wymiarach,
jeśli wymiary okna są mniejsze lub większych
wymiarach, jeśli wymiary okna są większe.
251

11. Rozdział 8.
Rozwiązanie problemu jest następujące. Kiedy
klient za ąda strony po raz pierwszy, moduł
zatrzyma ądanie i zwróci stronę z odpowiednim
skryptem działającym po stronie klienta.
Zadaniem skryptu będzie określenie wymiarów
obszaru klienta. Skrypt zapisze wymiary
w ukrytym polu, a następnie za ąda natychmiast
tej samej strony, której klient ądał poprzednio.
Wysłanie skryptu działającego po stronie klienta
i zwrócenie pierwotnie ądanej strony powinno
nastąpić na tyle szybko, aby u ytkownik niczego
nie zauwa ył. Za drugim razem, gdy moduł
otrzyma ądanie tej samej strony (teraz za ąda Rysunek 8.1. Do utworzenia modułu potrzebny jest
jej skrypt działający po stronie klienta), tylko projekt biblioteki, a nie cały projekt WWW
moduł odnajdzie ukryte pola zawierające ASP .NET. Jednak utworzenie projektu WWW
wymiary, utworzy niewielki obiekt słu ący ASP .NET pozwala na napisanie i przetestowanie
do przechowywania potrzebnych informacji modułu w jednym projekcie
i przeka e je do ądanej strony. Strona pobierze
obiekt z informacjami i zwróci wynik do klienta,
Działania z interfejsami
który wykorzysta informacje o rozmiarze obszaru
klienta. W naszym przypadku na stronie wymiary
wyświetlone 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 górnego paska menu.
252

12. Interfejsy
7. Kliknij prawym klawiszem myszy formularz
dimensions.aspx i wybierz polecenie
Properties. W tabelce właściwości,
pokazanej poni ej na rysunku 8.2, zmień
właściwość FileName z WebForm1.aspx
na dimensions.aspx.
8. Zmodyfikuj formularz dimension.aspx
w taki sposób, aby wyglądał tak, jak formularz
pokazany na rysunku 8.3. Oczywiście,
w ręczne wykonanie tego zadanie trzeba
wło yć wiele pracy. Zamiast tego mo esz
wprowadzić kod HTML bezpośrednio
w edytorze. Na rysunku 8.4, na następnej
stronie, zaprezentowano kod HTML niezbędny
do utworzenia formularza. Aby bezpośrednio
wprowadzić kod HTML, kliknij przycisk
HTML w oknie edytora. Alternatywnie
mo esz pobrać plik szkieletu dla tego projektu
Działania z interfejsami
(patrz „Wskazówki” na następnej stronie).
Rysunek 8.2. Zmiana nazwy pliku nie powinna
sprawiać teraz adnych problemów
Rysunek 8.3. Bardzo prosty formularz, który łatwo
utworzyć od nowa. Zawiera dwie etykiety, dwa pola
tekstowe oraz jedno łącze
253

13. Rozdział 8.
Wskazówki Rysunek 8.4. Kod HTML pokazany na tym rysunku
mo na wykorzystać jako wzorzec. Dzięki formularzowi
To, co do tej pory zrobiliśmy w przykładowej mo liwe jest uzyskanie informacji o wymiarach
aplikacji, nie ma nic wspólnego z modułem i pozycji wszystkich elementów sterujących
u ytkownika. Formularz projektowany
w tym podrozdziale zostanie u yty 2CIG NCPIWCIG E
do przetestowania modułu. Kod modułu %QFGDGJKPF FKOGPUKQPUCURZEU
zostanie dodany natychmiast po tym, jak #WVQ'XGPV9KTGWR HCNUG
dowiemy się czegoś na temat implementacji +PJGTKVU
interfejsów. KPVGTHCEGURTQLGEV9GD(QTO
*6/.
Podobnie jak w przypadku innych projektów *'#
w tej ksią ce, utworzenie projektu nie VKVNG 9GD(QTOVKVNG
jest konieczne do poznania pojęć *'#
DQF[ /5A215+6+10+0) )TKF.C[QWV
zaprezentowanych w niniejszym rozdziale. HQTO KF (QTO OGVJQF RQUV
Szkielety wszystkich projektów mo na TWPCV UGTXGT
CURNCDGN KF NDN9KFVJ
pobrać z witryny WWW Wydawnictwa UV[NG +0': .'(6
Peachpit pod adresem http://www.peachpit. RZ
com/vqs/csharp. 215+6+10 CDUQNWVG 612 RZ
Działania z interfejsami
TWPCV UGTXGT
5GTQMQ è
CURNCDGN
CURNCDGN KF NDN*GKIJV
UV[NG +0': .'(6
RZ
215+6+10 CDUQNWVG 612 RZ
TWPCV UGTXGT
9[UQMQ è
CURNCDGN
CURVGZVDQZ KF VZV9KFVJ
UV[NG +0': .'(6
RZ
215+6+10 CDUQNWVG 612 RZ
TWPCV UGTXGT
CURVGZVDQZ
CURVGZVDQZ KF VZV*GKIJV
UV[NG +0': .'(6
RZ
215+6+10 CDUQNWVG 612 RZ
TWPCV UGTXGT
CURVGZVDQZ
CURJ[RGTNKPM KF NPM5GNH
UV[NG +0': .'(6
RZ
215+6+10 CDUQNWVG 612 RZ
TWPCV UGTXGT
0CXKICVG7TN FKOGPUKQPUCURZ
1F YKG
CURJ[RGTNKPM
HQTO
DQF[
*6/.
254

14. Interfejsy
Tabela 8.1. Składowe interfejsu (składowe, które
mo na wprowadzić do definicji interfejsu)
Definiowanie interfejsów
Nazwa Przykład Interfejsy definiuje się za pomocą słowa
Metoda UVTKPI /GVJQF
kluczowego KPVGTHCEG. Dla interfejsów mo na
Właściwość KPV #IG] IGV UGV_ definiować metody, właściwości, delegaty,
Właściwość tylko KPV #IG]IGV_
zdarzenia itp. Ka dy z elementów wewnątrz
do odczytu interfejsu musi być jednak tylko deklaracją
Indeks NQPI VJKU=KPV elementu i nie mo e zawierać implementacji.
KPFGZ?]IGV UGV_
Zdarzenie GXGPV 'XGPV*CPFNGT Aby zdefiniować interfejs:
1P%NKEM
1. Wpisz słowo kluczowe RWDNKE lub KPVGTPCN,
w zale ności od zasięgu, jaki ma mieć
interfejs.
Rysunek 8.5. Składowe interfejsu to tylko definicje,
które nie zawierają kodu. W definicjach nie stosuje 2. Wprowadź słowo kluczowe KPVGTHCEG,
się tak e modyfikatorów dostępu — wszystkie a po nim spację.
metody interfejsu są publiczne
3. Wpisz nazwę interfejsu.
4. Otwórz nawias klamrowy ].
Definiowanie interfejsów
RWDNKE KPVGTHCEG +*WOCP
] 5. Wprowadź definicje składowych (tabela 8.1).
UVTKPI 0COG ] IGV _ właściwość tylko
do odczytu 6. Zamknij nawias klamrowy _ (rysunek 8.5).
XQKF 'CV
KPV #OQWPV metoda
XQKF $TGCVJG
metoda
_
255

15. Rozdział 8.
Wskazówki Rysunek 8.6. Po zdefiniowaniu interfejsu mo na
go wykorzystać jako typ danych w deklaracjach
Wszystkie metody interfejsu z definicji są zmiennych lub parametrów
publiczne — w definicji metody nie mo na
wprowadzić modyfikatorów dostępu
ENCUU CKN[4QWVKPG
(dotyczy to tak e modyfikatora RWDNKE). ]
Danych typu interfejsu mo na u yć XQKF 6CUMU
]
w definicjach parametrów lub zmiennych +*WOCP OCP
(rysunek 8.6). W przypadku interfejsów +*WOCP YQOCP
nie mo na jednak tworzyć nowych _
egzemplarzy — na przykład nie mo na
napisać PGY +#EEQWPV. RWDNKE XQKF )Q6QKPPGT
+*WOCP RGTUQP
]
W interfejsach mo na przecią ać metody RGTUQP 'CV
(rysunek 8.7). _
_
Je eli jakiś programista u yje interfejsu,
najlepiej nie zmieniać jego definicji. Rysunek 8.7. Przecią anie metod to mo liwość
W przeciwnym razie istnieje ryzyko, istnienia kilku metod o tej samej nazwie.
Definiowanie interfejsów
e napisany program przestanie działać. Pamiętaj, e mo na to zrobić tylko pod warunkiem,
W takiej sytuacji najlepiej zdefiniować nowy e zmieni się liczbę parametrów lub zmodyfikuje
interfejs. Więcej informacji na ten temat typ jednego z nich
znajdzie się w dalszej części tego rozdziału,
w podrozdziale „Tworzenie interfejsów RWDNKE KPVGTHCEG +*WOCP
pochodnych od innych interfejsów”. ]
UVTKPI 0COG ]IGV _
właściwość tylko do odczytu
XQKF 'CV
KPV #OQWPV metoda
XQKF 'CV
UVTKPI HQQF6[RG KPV #OQWPV
przecią anie
_
256

16. Interfejsy
Rysunek 8.8. Implementacja interfejsu przypomina
dziedziczenie. W przypadku metody niejawnej Niejawna implementacja
wystarczy zaimplementować składowe interfejsu
jako metody publiczne
składowych interfejsu
Interfejsy są implementowane przez klasy.
RWDNKE KPVGTHCEG +*WOCP Zaimplementowanie interfejsu oznacza
] wprowadzenie kodu dla wszystkich
UVTKPI 0COG ]IGV _
XQKF 5NGGR
UJQTV JQWTU
zdefiniowanych w nim metod. Kompilator
_ wymusza wprowadzenie kodu dla wszystkich
metod bez wyjątku. Wynika to stąd,
RWDNKE ENCUU 2GTUQP +*WOCP e programista wykorzystujący interfejs
] spodziewa się, e klasa implementująca
RWDNKE UVTKPI 0COG
interfejs będzie zawierać definicje wszystkich
]
IGV
zawartych w nim metod. Istnieją dwa
] mechanizmy implementowania interfejsów
TGVWTP 2CWN w klasie: mechanizm niejawny i jawny.
Niejawna implementacja składowych
_ Najpierw zaprezentujemy mechanizm niejawny.
_
RWDNKE XQKF 5NGGR
UJQTV JQWTU
Aby zaimplementować interfejs
] w sposób niejawny:
HQT
UJQTV EQWPVGT
EQWPVGTJQWTU EQWPVGT
1. Po nazwie klasy, która będzie implementować
] interfejs, wpisz dwukropek, a po nim nazwę
*VVR%QPVGZV EQPVGZV interfejsu, który będzie implementowany.
*VVR%QPVGZV%WTTGPV
EQPVGZV4GURQPUG9TKVG
%JTCRKG 2. Wprowadź składowe odpowiadające
_ wszystkim składowym interfejsu.
_
_ 3. Oznacz metody implementacyjne jako
publiczne.
4. Wpisz kod składowych interfejsu
(rysunek 8.8).
257

17. Rozdział 8.
Wskazówki Rysunek 8.9. Klasa Person implementuje
zarówno interfejs IHuman, jak i IManager.
Ten mechanizm implementacji interfejsu Zaimplementowanie interfejsu ustanawia relację
cechuje wada polegająca na tym, e ka dą „jest”. Innymi słowy, osoba (Person) jest
metodę implementacyjną nale y oznaczyć człowiekiem (Human) i mened erem (Manager)
jako publiczną.
Aby zaimplementować więcej ni jeden RWDNKE KPVGTHCEG +*WOCP
]
interfejs, nale y oddzielić poszczególne
UVTKPI 0COG ]IGV _
nazwy interfejsu przecinkiem (rysunek 8.9). XQKF 5NGGR
UJQTV JQWTU
_
RWDNKE KPVGTHCEG +/CPCIGT
]
XQKF 5R[1P'ORNQ[GG
UVTKPI PCOG DQQN
+U7PCYCTG
_
Niejawna implementacja składowych
RWDNKE ENCUU 2GTUQP +*WOCP +/CPCIGT
]
RWDNKE UVTKPI 0COG
]
IGV
]
TGVWTP 2CWN
_
_
RWDNKE XQKF 5NGGR
UJQTV JQWTU
]
HQT
UJQTV EQWPVGT
EQWPVGTJQWTU EQWPVGT
]
*VVR%QPVGZV EQPVGZV
*VVR%QPVGZV%WTTGPV
EQPVGZV4GURQPUG9TKVG
%JTCRKG
_
_
RWDNKE XQKF 5R[1P'ORNQ[GG
UVTKPI PCOG
DQQN +U7PCYCTG
]
YJKNG
+U7PCYCTG
]
.QQM1XGT5JQWNFGT
PCOG
_
_
_
258

18. Interfejsy
Rysunek 8.10. W powy szym kodzie zdefiniowano Je eli klasa jest pochodną innej klasy
klasę Person, która implementuje interfejs IHuman. (nie interfejsu), najpierw nale y wymienić
Następnie, biorąc pod uwagę to, e nie wszystkie klasę, która nie nale y do interfejsu,
osoby są mened erami, zdefiniowano klasę a następnie implementowane interfejsy.
opisującą mened erów. Jednak, ze względu na to,
e mened erowie są ludźmi (persons), klasa
Wszystkie te elementy trzeba oddzielić
ta dziedziczy wszystkie składowe klasy Person przecinkami (rysunek 8.10).
(zasada dziedziczenia). Na końcu znajduje się
implementacja interfejsu IManager
RWDNKE KPVGTHCEG +*WOCP
]
UVTKPI 0COG ]IGV _
XQKF 5NGGR
UJQTV JQWTU
_
RWDNKE KPVGTHCEG +/CPCIGT
Niejawna implementacja składowych
]
XQKF 5R[1P'ORNQ[GG
UVTKPI PCOG DQQN
+U7PCYCTG
_
RWDNKE ENCUU 2GTUQP +*WOCP
]
RWDNKE UVTKPI 0COG
]
IGV
]
TGVWTP 2CWN
_
_
RWDNKE XQKF 5NGGR
UJQTV JQWTU
]
HQT
UJQTV EQWPVGT
EQWPVGTJQWTU EQWPVGT
]
*VVR%QPVGZV EQPVGZV
*VVR%QPVGZV%WTTGPV
EQPVGZV4GURQPUG9TKVG
%JTCRKG
_
_
_
RWDNKE ENCUU /CPCIGT 2GTUQP +/CPCIGT
RWDNKE XQKF 5R[1P'ORNQ[GG
UVTKPI PCOG
DQQN +U7PCYCTG
]
YJKNG
+U7PCYCTG
]
.QQM1XGT5JQWNFGT
PCOG
_
_
_
259

19. Rozdział 8.
Rysunek 8.11. W przypadku jawnego
Jawna implementacja implementowania interfejsu nie wprowadza się
składowych interfejsu modyfikatorów dostępu. Nale y wpisać nazwę
interfejsu, po nim kropkę, a po niej nazwę metody
Podczas implementowania interfejsu przez
wprowadzanie składowych publicznych RWDNKE KPVGTHCEG +*WOCP
powstaje problem polegający na tym, e czasami ]
dwa interfejsy zawierają metodę o takiej samej UVTKPI 0COG ]IGV _
nazwie i takich samych parametrach, XQKF 5NGGR
UJQTV JQWTU
ale konieczne jest zaimplementowanie tych _
metod na dwa ró ne sposoby. W przypadku
RWDNKE ENCUU 2GTUQP +*WOCP
zastosowania metody niejawnej jedna metoda ]
publiczna będzie stanowiła implementację UVTKPI +*WOCP0COG
metod o takiej samej nazwie i tym samym ]
zbiorze parametrów dla wszystkich interfejsów. IGV
Metoda jawna umo liwia poinformowanie ]
TGVWTP 2CWN
kompilatora o tym, którą metodę, którego _
Jawna implementacja składowych
interfejsu mieliśmy zamiar zaimplementować. _
Aby jawnie zaimplementować XQKF +*WOCP5NGGR
UJQTV JQWTU
]
interfejs: HQT
UJQTV EQWPVGT
1. Po nazwie klasy, która będzie implementować EQWPVGTJQWTU EQWPVGT
]
interfejs, wpisz dwukropek, a po nim nazwę *VVR%QPVGZV EQPVGZV
interfejsu, który będzie implementowany. *VVR%QPVGZV%WTTGPV
EQPVGZV4GURQPUG9TKVG
%JTCRKG
2. Wpisz typ zwracanej wartości dla składowej
_
interfejsu. _
_
3. Wpisz +0CYC+PVGTHGLUW/GVQFC+PVGTHGLUW.
Mówiąc inaczej, wpisz nazwę interfejsu,
po nim kropkę, a po niej nazwę metody
interfejsu.
4. Wprowadź parametry składowej interfejsu.
5. Wpisz kod składowej interfejsu (rysunek 8.11).
Wskazówka
Wszystkie metody implementowane w ten
sposób są prywatne. Nie mo na wprowadzić
modyfikatora dostępu na początku definicji.
260

20. Interfejsy
Usprawnianie
przykładowej aplikacji
Teraz, kiedy wiemy ju , w jaki sposób definiuje
się interfejsy oraz jak nale y implementować
interfejsy za pomocą klas, czas usprawnić
przykładową aplikację. Dokładniej rzecz ujmując,
zdefiniujemy klasę, która będzie słu yć jako
moduł u ytkownika. Aby przekształcić klasę
w moduł, nale y zaimplementować w niej
interfejs 5[UVGO9GD+*VVR/QFWNG. Jego
zaimplementowanie nie jest trudne — zawiera
tylko dwie metody: +PKV i KURQUG. Środowisko
ASP .NET wywołuje metodę +PKV w momencie,
gdy moduł jest po raz pierwszy ładowany
Usprawnianie przykładowej aplikacji
do pamięci. Metoda KURQUG wywoływana jest
w momencie usuwania modułu z pamięci.
Jedyna trudność polega na wykorzystaniu
zdarzenia. Zdarzenia zostaną opisane
w rozdziale 10. „Delegaty i zdarzenia”.
Nie zamierzamy poświęcać w tym rozdziale
wiele miejsca na tłumaczenie, czym jest
zdarzenie. Na razie wystarczy, abyśmy wiedzieli,
e zdarzenie jest metodą wywoływaną w wyniku
działania. Implementacja zdarzeń pod wieloma
względami przypomina implementację
interfejsów. Ró nica polega na tym, e interfejs
mo e zawierać kilka metod, natomiast zdarzenie
zawiera tylko jedną metodę. Przykładem
zdarzenia jest kliknięcie przycisku. Klasa ąda
od zdarzenia ENKEM informacji od przycisku
formularza. Kiedy u ytkownik kliknie przycisk,
serwer informuje klasę, e miało miejsce
zdarzenie. Moduł mo na wykorzystać
np. do nasłuchiwania wystąpienia zdarzenia
$GIKP4GSWGUV. Środowisko ASP .NET wyzwala
to zdarzenie za ka dym razem, gdy przeglądarka
klienta za ąda strony.
261

21. Rozdział 8.
Aby zdefiniować
klasę modułu użytkownika:
1. Z paska menu wybierz polecenie Project/
Add class. Wpisz custommodule.cs jako
nazwę klasy i wciśnij Enter (rysunek 8.12).
2. W górnej części kodu modułu, poni ej
wiersza o treści WUKPI 5[UVGO, wpisz wiersz
WUKPI 5[UVGO9GD.
3. W wierszu w postaci: RWDNKE ENCUU
EWUVQOOQFWNG dodaj na końcu: +*VVR/QFWNG
tak, aby wiersz ten przyjął postać: RWDNKE Rysunek 8.12. Wszystkie właściwości funkcjonalne
ENCUU EWUVQOOQFWNG +*VVR/QFWNG. modułu u ytkownika zostaną zaimplementowane
w klasie custommodule. Dzięki wykorzystaniu okna
4. Teraz trzeba trochę „pooszukiwać”. dialogowego pokazanego na rysunku u yjemy
Usprawnianie przykładowej aplikacji
W systemie Visual Studio .NET znajduje się kreatora do wygenerowania szkieletu klasy
kreator pozwalający na łatwą implementację
interfejsu. Z menu wybierz polecenie
View/Class View.
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 ka dej składowej interfejsu definiowane są
elementy publiczne
262

22. Interfejsy
Rysunek 8.14. Interfejs IHttpModule spełnia 6. Kreator spowoduje dodanie namiastek
dwie funkcje. Po pierwsze, informuje środowisko metod +PKV i KURQUG. Kod przyjmie postać
ASP .NET, e klasa jest modułem u ytkownika. widoczną na rysunku 8.14.
Po drugie, środowisko zyskuje mo liwość
poinformowania klasy, kiedy moduł jest ładowany 7. Dodaj do klasy metodę $GIKP4GSWGUV
po raz pierwszy (metoda Init) oraz kiedy nie jest ju (rysunek 8.15).
potrzebny (metoda Dispose)
WUKPI 5[UVGO
WUKPI 5[UVGO9GD
PCOGURCEG KPVGTHCEGURTQLGEV
]
UWOOCT[ Rysunek 8.15. Metoda BeginRequest nie jest częścią
interfejsu IHttpModule. Jest to zdarzenie zdefiniowane
Ogólny opis modułu custommodule dla klasy HttpApplication, informujące o tym,
UWOOCT[ e występują ądania do dowolnej ze stron w aplikacji
RWDNKE ENCUU EWUVQOOQFWNG +*VVR/QFWNG
Usprawnianie przykładowej aplikacji
]
RWDNKE EWUVQOOQFWNG
WUKPI 5[UVGO
] WUKPI 5[UVGO9GD
DO ZROBIENIA: Tutaj nale y PCOGURCEG KPVGTHCEGURTQLGEV
wprowadzić logikę konstruktora ]
UWOOCT[
_
Ogólny opis modułu custommodule
TGIKQP +ORNGOGPVCVKQP QH +*VVR/QFWNG UWOOCT[
RWDNKE XQKF RWDNKE ENCUU EWUVQOOQFWNG +*VVR/QFWNG
+PKV
5[UVGO9GD*VVR#RRNKECVKQP EQPVGZV ]
] RWDNKE EWUVQOOQFWNG
_ ]
RWDNKE XQKF KURQUG
DO ZROBIENIA: Tutaj nale y wprowadzić
] logikę konstruktora
_
GPFTGIKQP _
_
_ TGIKQP +ORNGOGPVCVKQP QH +*VVR/QFWNG
RWDNKE XQKF
+PKV
5[UVGO9GD*VVR#RRNKECVKQP EQPVGZV
]
_
RWDNKE XQKF KURQUG
]
_
GPFTGIKQP
XQKF $GIKP4GSWGUV
QDLGEV UGPFGT
'XGPV#TIU CTIU
]
_
_
_
263

23. Rozdział 8.
8. W metodzie +PKV wprowadź kod wią ący Rysunek 8.16. Zwróć uwagę, e w celu powiązania
zdarzenie $GIKP4GSWGUV z metodą klasy zdarzenia klasy z metodą do zdarzenia odwołujemy
$GIKP4GSWGUV (rysunek 8.16). Nie martw się, się w taki sposób, jakby było ono właściwością
je eli na razie kod ten jest niejasny, jego obiektu (obiekt.nazwazdarzenia), następnie
u ywamy operatora += i przypisujemy mu nowy
szczegółowe wyjaśnienie znajdzie się obiekt (delegat). Metodę przekazujemy jako
w rozdziale 10. „Delegaty i zdarzenia”. parametr konstruktora obiektu
WUKPI 5[UVGO
WUKPI 5[UVGO9GD
PCOGURCEG KPVGTHCEGURTQLGEV
]
UWOOCT[
1IÎNP[ QRKU OQFW W EWUVQOOQFWNG
UWOOCT[
RWDNKE ENCUU EWUVQOOQFWNG +*VVR/QFWNG
Usprawnianie przykładowej aplikacji
]
RWDNKE EWUVQOOQFWNG
]
DO ZROBIENIA: Tutaj nale y
wprowadzić logikę konstruktora
_
TGIKQP +ORNGOGPVCVKQP QH +*VVR/QFWNG
RWDNKE XQKF
+PKV
5[UVGO9GD*VVR#RRNKECVKQP EQPVGZV
]
EQPVGZV$GIKP4GSWGUV
PGY
'XGPV*CPFNGT
$GIKP4GSWGUV
_
RWDNKE XQKF KURQUG
]
_
GPFTGIKQP
XQKF $GIKP4GSWGUV
QDLGEV UGPFGT
'XGPV#TIU CTIU
]
_
_
_
264

24. Interfejsy
Rysunek 8.17. Doceń piękno literałów znakowych. 9. Wprowadź kod w metodzie +PKV w celu
Zwróć uwagę, jak łatwo — korzystając z literałów utworzenia ciągu znaków stanowiącego
znakowych — mo na umieścić znaki końca wiersza skrypt działający po stronie klienta i zapisz
w ciągu znaków. Po prostu formatujemy ciąg go w obiekcie #RRNKECVKQP. Pamiętaj,
znaków, tak jak chcemy, umieszczając gdzie nale y
znaki końca wiersza
e obiekt #RRNKECVKQP jest dostępny
na wszystkich stronach i dla ka dego
klienta (rysunek 8.17).
RWDNKE XQKF +PKV
5[UVGO9GD*VVR#RRNKECVKQP
EQPVGZV
]
EQPVGZV$GIKP4GSWGUV
PGY
'XGPV*CPFNGT
$GIKP4GSWGUV
UVTKPI JVON
JVON
CFQYCPKG
UETKRV NCPIWCIGXDUETKRV
5WD )GVKOGPUKQPU
KO ENKGPV9KFVJ
Usprawnianie przykładowej aplikacji
KO ENKGPV*GKIJV
ENKGPV9KFVJ FQEWOGPVDQF[%NKGPV9KFVJ
ENKGPV*GKIJV
FQEWOGPVDQF[%NKGPV*GKIJV
FQEWOGPVO[HQTOVZVKOGPUKQPU8CNWG
ENKGPV9KFVJ ENKGPV*GKIJV
FQEWOGPVO[HQTOUWDOKV
'PF 5WD
UETKRV
DQF[ QP.QCF )GVKOGPUKQPU
HQTO PCOG O[HQTO OGVJQF 2156
CEVKQP ]_
R KPRWV V[RG JKFFGP
PCOG VZVKOGPUKQPU
UKG R
HQTO
DQF[
JVON
EQPVGZV#RRNKECVKQP= AAKUEQXGT*6/. ?JVON
_
265

25. Rozdział 8.
10. Teraz, w treści metody $GIKP4GSWGUV wpisz Rysunek 8.18. Na tym rysunku znalazł się kod,
kod pokazany na rysunku 8.18. Zadaniem który wymaga wyjaśnienia. Szczegółowe
tego kodu jest sprawdzenie, czy są dostępne informacje na jego temat mo na znaleźć w ramce
informacje o wymiarach. Informacje pt. „Szczegóły zdarzenia BeginRequest”
te powinny być dostępne za pośrednictwem
pola ukrytego. Je eli pole tekstowe nie istnieje, XQKF $GIKP4GSWGUV
QDLGEV UGPFGT 'XGPV#TIU
moduł zablokuje ądanie strony i wyśle CTIU
skrypt działający po stronie klienta. Skrypt ]
zarejestruje wymiary okna w ukrytym polu )NQDCN I
)NQDCNUGPFGT
UVTKPI FKOGPUKQPU
i natychmiast za ąda strony ponownie. Moduł
I4GSWGUV(QTO= VZVKOGPUKQPU ?
sprawdzi, czy pole tekstowe istnieje i, je eli KH
FKOGPUKQPU PWNN ^^ FKOGPUKQPU
istnieje, wprowadzi wymiary do obiektu +VGO
(więcej informacji na ten temat znajdzie się ]
w ramce na następnej stronie). UVTKPI JVON
UVTKPII%QPVGZV
å#RRNKECVKQP= AAKUEQXGT*6/. ?
Wskazówki UVTKPI PGY7TN UVTKPI(QTOCV
JVON
I4GSWGUV7TN#DUQNWVG2CVJ
Usprawnianie przykładowej aplikacji
Kod zaprezentowany w tym podrozdziale I4GURQPUG9TKVG
PGY7TN
to kompletny kod potrzebny do utworzenia I%QORNGVG4GSWGUV
modułu u ytkownika. Jednak moduł ten nie _
GNUG KH
będzie działać dopóty, dopóki nie uzupełnimy
FKOGPUKQPU+PFGZ1H
%NKGPV9KFVJ
przykładu kodem pokazanym w dalszej części ]
tego rozdziału. UVTKPI=? UKGU FKOGPUKQPU5RNKV
KPV ENKGPV9KFVJ 5[UVGO%QPXGTV
Kreator implementujący interfejsy wprowadza 6Q+PV
UKGU=?
kod TGIKQP +ORNGOGPVCVKQP QH +*VVR/QFWNG KPV ENKGPV*GKIJV
na początku bloku metod implementacyjnych 5[UVGO%QPXGTV6Q+PV
UKGU=?
oraz GPFTGIKQP na końcu tego bloku. I%QPVGZV+VGOU= AA%NKGPV9KFVJ ?
Te instrukcje nie dotyczą bezpośrednio ENKGPV9KFVJ
kompilatora. Umo liwiają one uzyskanie I%QPVGZV+VGOU= AA%NKGPV*GKIJV ?
rozwijanego kodu w edytorze. Jak mo na ENKGPV*GKIJV
_
zauwa yć, w edytorze pojawi się znak minus _
z lewej strony deklaracji regionu (rysunek 8.19).
Kliknięcie znaku minus w edytorze spowoduje
ukrycie kodu umieszczonego w obszarze
i zastąpienie znaku minus plusem
(rysunek 8.20). Kliknięcie znaku plus
spowoduje ponowne pojawienie się kodu.
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. Kliknięcie znaku minus powoduje
rozwinięcie kodu obszaru i wyświetlenie opisu
za słowem #region, umo liwiającego identyfikację
kodu. Słowo kluczowe #region w kodzie nie ma adnego
znaczenia funkcjonalnego. Jest ono wykorzystywane
wyłącznie przez edytor, zatem, je eli komuś wydaje się
niepotrzebne, mo e je usunąć
266

26. Interfejsy
Szczegóły zdarzenia BeginRequest
W pierwszym wierszu metody $GIKP4GSWGUV znajduje się instrukcja konwersji obiektu UGPFGT
(pierwszy parametr metody) na obiekt )NQDCN. )NQDCN jest klasą generowaną przez kreator
podczas tworzenia projektu ASP .NET. Jest to pochodna klasy *VVR#RRNKECVKQP. Obiekt tej klasy
tworzy się za pierwszym razem, gdy dowolny klient skorzysta z dowolnej strony w aplikacji.
Z obiektu )NQDCN mo na uzyskać dostęp do innych obiektów — np. 4GURQPUG lub 4GSWGUV.
W drugim wierszu kodu u yto obiektu )NQDCN do uzyskania obiektu 4GSWGUV. Jak pamiętamy,
obiekt 4GSWGUV umo liwia uzyskanie informacji na temat ądania klienta. Je eli skorzystamy
z właściwości (QTO, mo emy uzyskać dostęp do ukrytego pola, które zostało utworzone
przez skrypt działający po stronie klienta. Nazwa tego ukrytego pola to VZVKOGPUKQPU.
W wierszu I4GSWGUV(QTO= VZVKOGPUKQPU ? następuje pobranie tekstu z ukrytego pola.
Je eli pole nie istnieje, zwrócony wynik będzie wartością PWNN. W przeciwnym razie będą
to współrzędne obszaru klienta. Skrypt działający po stronie klienta zapisuje współrzędne
w postaci: szerokość;wysokość (np. 800;600). Je eli wynik wynosi PWNN, do klienta wysyłany
jest skrypt za pomocą funkcji 4GURQPUG9TKVG. Potem następuje wywołanie funkcji
Usprawnianie przykładowej aplikacji
%QORNGVG4GSWGUV, której działanie polega na zatrzymaniu ądania strony. Je eli wymiary są
dostępne, następuje rozbicie ciągu znaków o formacie szerokość;wysokość na dwie liczby
i konwersja tych liczb na typ KPVGIGT. Wartości te są następnie umieszczone w obiekcie +VGOU.
Do tej pory nie u ywaliśmy obiektu +VGOU, ale przypomina on obiekty 5GUUKQP oraz #RRNKECVKQP.
Ogólnie rzecz biorąc, jest to jeszcze jeden sposób utrwalania informacji. Ró nica między
tymi obiektami polega na czasie dostępności informacji. W obiekcie +VGOU informacje są
dostępne tylko na czas trwania ądania klienta. W przypadku obiektu #RRNKECVKQP informacje
są dostępne tak długo, jak serwer WWW przetwarza aplikację i mają do nich dostęp wszystkie
klienty korzystające z aplikacji. Informacje zapisane w obiekcie 5GUUKQP są dostępne na czas
trwania programu, ale są one specyficzne dla ka dego klienta. Obiekt +VGOU istnieje tylko
na czas ądania. Je eli zatem klient przechodzi z jednej strony na drugą, informacje zostają
utracone. W ramach tego samego ądania moduł mo e jednak umieścić informacje
w obiekcie +VGOU i strona będzie miała do nich dostęp przez odwołanie I%QPVGZV+VGOU.
267

27. Rozdział 8.
Rysunek 8.21. Chocia typem zmiennej jest ICar,
Wykorzystanie obiektów nie mo na napisać new ICar. Trzeba utworzyć
poprzez interfejsy egzemplarz klasy implementującej interfejs.
Nie mo na tworzyć egzemplarzy interfejsu
Kiedy programista zdefiniuje interfejs
i zaimplementuje go jako konkretną klasę, KPVGTHCEG +%CT
mo e u ywać tej klasy poprzez interfejs. ]
UVTKPI 4WP
Aby używać klasy poprzez interfejs: UVTKPI 5VQR
UVTKPI 2NC[/WUKE
1. Zdefiniuj zmienną typu interfejsu. _
Wpisz na przykład +%CT XCT.
ENCUU 'UEQTV +%CT
2. Ustaw zmienną typu interfejsu na wartość ]
równą klasie, która ten interfejs implementuje. RWDNKE UVTKPI 4WP
Wpisz na przykład PGY 'UEQTV
]
TGVWTP ,CFú VCM U[DMQ LCM WOKGO
(rysunek 8.21). _
RWDNKE UVTKPI 5VQR
Wskazówka ]
TGVWTP ,CM FQDTG 9TGUEKG UKú OQIú
Nie mo na tworzyć egzemplarzy interfejsu.
Wykorzystanie obiektów
CVT[OCè
Interfejs jest typem abstrakcyjnym, _
co oznacza, e nie jest to klasa, której RWDNKE UVTKPI 2NC[/WUKE
obiekty mo na utworzyć. Zamiast tego ]
tworzy się egzemplarze klasy TGVWTP ,GUVG O[ RKTCVCOK MVÎT[ PKE
implementującej interfejs. PKG TQDKæ
_
_
ENCUU TKXGT
]
RWDNKE UVTKPI )Q6Q9QTM
]
+%CT ECT PGY 'UEQTV
UVTKPI OUI
OUI
ECT4WP
OUI
ECT2NC[/WUKE
OUI
ECT5VQR
TGVWTP OUI
_
_
268

28. Interfejsy
Rysunek 8.22. Zmienna obj jest typu object.
Oznacza to, e mo e wskazywać na obiekt Cat Rozpoznawanie interfejsu
lub na obiekt Dog. Powy szy kod testuje zawartość Przed u yciem obiektu poprzez interfejs warto
zmiennej obj przez sprawdzenie, czy obiekt obj
obsługuje interfejs IDog
sprawdzić, czy obiekt rzeczywiście obsługuje
interfejs. Oczywiście, je eli mamy dostęp
do definicji klasy, mo emy na nią spojrzeć
KPVGTHCEG +%CV i przekonać się, czy klasa implementuje interfejs.
] Czasami jednak mamy do czynienia z danymi
UVTKPI +IPQTG1YPGT
_
typu QDLGEV, dla których trzeba zweryfikować,
czy obiekt, na który wskazuje zmienna, jest
KPVGTHCEG +QI zgodny z interfejsem, którego chcemy u yć.
] Istnieją dwa sposoby sprawdzenia, czy obiekt
UVTKPI .KUVGP6Q1YPGT
obsługuje interfejs.
_
ENCUU 2QQFNG +QI Aby sprawdzić,
] czy obiekt obsługuje interfejs:
_
1. Wpisz KH
QDL KU +#P[VJKPI, gdzie QDL
ENCUU 5KCOGUG +%CV jest zmienną wskazującą na obiekt, który
Rozpoznawanie interfejsu
] chcesz sprawdzić, natomiast +#P[VJKPI
_
jest nazwą interfejsu, dla którego chcesz
ENCUU 1YPGT przeprowadzić test (rysunek 8.22).
]
lub
XQKF (GGF#PKOCN
QDLGEV QDL
] Wpisz +#P[VJKPI XCT QDL CU +#P[VJKPI,
KH
QDL KU +QI
gdzie +#P[VJKPI jest interfejsem, dla którego
]
+QI FQI
+QIQDL chcesz przeprowadzić test, XCT jest dowolną
UVTKPI EOF FQI.KUVGP6Q1YPGT
zmienną słu ącą do przechowywania
_ odwołania do obiektu, a QDL jest obiektem,
_ który chcesz sprawdzić.
_
269

29. Rozdział 8.
2. Wpisz instrukcję KH
XCT PWNN. Je eli Rysunek 8.23. Kiedy do sprawdzenia, czy obiekt
po wykonaniu pierwszego kroku zmienna obsługuje interfejs, u yjemy polecenia as, uzyskamy
XCT jest równa null, obiekt nie obsługuje wynik null wtedy, gdy obiekt go nie obsługuje
interfejsu. Jeśli test zwróci wartość ró ną
od null, obiekt obsługuje interfejs, a zmienna KPVGTHCEG +%CV
XCT wskazuje na odwołanie do interfejsu ]
(rysunek 8.23). UVTKPI +IPQTG1YPGT
_
Wskazówki
KPVGTHCEG +QI
Podczas korzystania z pierwszego ]
UVTKPI .KUVGP6Q1YPGT
mechanizmu, po uzyskaniu informacji,
_
e obiekt obsługuje interfejs, aby u yć
obiektu poprzez interfejs, nale y zadeklarować ENCUU 2QQFNG +QI
zmienną typu interfejsu, po czym dokonać ]
konwersji obiektu na interfejs. _
W przypadku drugiego mechanizmu ENCUU 5KCOGUG +%CV
rozpoznawania interfejsu, zarówno konwersja ]
obiektu, jak i rozpoznanie następuje _
Rozpoznawanie interfejsu
w jednym kroku. Je eli obiekt obsługuje
ENCUU 1YPGT
interfejs, zmienna XCT będzie wskazywać ]
na obiekt, w przeciwnym razie zmienna XCT XQKF (GGF#PKOCN
QDLGEV QDL
przyjmie wartość null. ]
+QI FQI QDL CU +QI
Istnieje trzeci mechanizm rozpoznawania, KH
FQI PWNN
czy obiekt obsługuje interfejs. Mo na UVTKPI EOF FQI.KUVGP6Q1YPGT
spróbować dokonać konwersji obiektu _
na interfejs. Je eli obiekt nie obsługuje _
interfejsu, konwersja spowoduje zgłoszenie
wyjątku (błędu). Wyjątki zostaną omówione
w rozdziale 11. „Obsługa błędów”.
Wykorzystywanie wyjątków nie jest
zalecane jako sposób rozpoznawania
obsługi interfejsu przez obiekty, poniewa
wyjątki mogą wpłynąć niekorzystnie
na wydajność działania programu.
270