Visual Basic przeszedł generalny remont. Istnieje wiele powodów, dla których programiści Visual Basica 6 powinni przesiąść się na nowy Visual Basic .NET. Należy do nich zaliczyć chociażby formularze Web, możliwość tworzenia aplikacji i usług WWW, strukturalną obsługę wyjątków, prawdziwe programowanie zorientowane obiektowo czy też wielowątkowość.
"Visual Basic .NET. Księga eksperta" zawiera dokładne omówienie nowego języka Visual Basic .NET, zunifikowanego środowiska programowania Visual Studio IDE, programowania formularzy WWW, ADO.NET, usługi WWW, GDI+ i wiele innych.
Visual Studio .NET jest środowiskiem bardzo rozbudowanym i potężnym. Aby w pełni je wykorzystać, poznasz także sposoby tworzenia makr oraz znajdziesz omówienie modelu automatyzacji służącego do indywidualizacji zadań i interfejsu IDE w Visual Studio. Książka zawiera wiele przykładów wziętych z praktyki programistycznej.
Książka omawia:
* Środowisko programistyczne Visual Studio, korzystanie z SourceSafe
* Język Visual Basic .NET, programowanie zorientowane obiektowo w VB .NET
* Rozszerzanie środowiska programistycznego za pomocą makr
* Zaawansowane programowanie w VB .NET: refleksje, przeciążanie, programowane oparte na zdarzeniach, polimorfizm, definiowanie atrybutów
* Tworzenie interfejsu użytkownika (aplikacje konsolowe, aplikacje z interfejsem Windows)
* Pisanie aplikacji wielowątkowych
* Uruchamianie usług WWW (Web Services)
"Visual Basic .NET. Księga eksperta" jest doskonałym podręcznikiem dla wszystkich osób, dla których osiągnięcie wysokiej sprawności w posługiwaniu się językiem Visual Basic stanowi podstawę kariery programistycznej. Niezależnie, od tego, czy używałeś poprzedniej wersji tego języka, czy też nie: jeśli chcesz stać się ekspertem Visual Basica, trzymasz w ręku odpowiednią książkę.
1. IDZ DO
PRZYK£ADOWY ROZDZIA£
SPIS TRE CI Visual Basic .NET.
Ksiêga eksperta
KATALOG KSI¥¯EK
Autor: Paul Kimmel
KATALOG ONLINE T³umaczenie: Krzysztof Jurczyk, Marek Pa³czyñski
ISBN: 83-7197-771-9
ZAMÓW DRUKOWANY KATALOG Tytu³ orygina³u: Visual Basic .NET Unleashed
Format: B5, stron: 682
Przyk³ady na ftp: 3044 kB
TWÓJ KOSZYK
DODAJ DO KOSZYKA Visual Basic przeszed³ generalny remont. Istnieje wiele powodów, dla których
programi ci Visual Basica 6 powinni przesi¹ æ siê na nowy Visual Basic .NET.
Nale¿y do nich zaliczyæ chocia¿by formularze Web, mo¿liwo æ tworzenia aplikacji
CENNIK I INFORMACJE i us³ug WWW, strukturaln¹ obs³ugê wyj¹tków, prawdziwe programowanie
zorientowane obiektowo czy te¿ wielow¹tkowo æ.
ZAMÓW INFORMACJE „Visual Basic .NET. Ksiêga eksperta” zawiera dok³adne omówienie nowego jêzyka
O NOWO CIACH Visual Basic .NET, zunifikowanego rodowiska programowania Visual Studio IDE,
programowania formularzy WWW, ADO.NET, us³ugi WWW, GDI+ i wiele innych.
ZAMÓW CENNIK Visual Studio .NET jest rodowiskiem bardzo rozbudowanym i potê¿nym. Aby w pe³ni
je wykorzystaæ, poznasz tak¿e sposoby tworzenia makr oraz znajdziesz omówienie
modelu automatyzacji s³u¿¹cego do indywidualizacji zadañ i interfejsu IDE w Visual
CZYTELNIA Studio. Ksi¹¿ka zawiera wiele przyk³adów wziêtych z praktyki programistycznej.
Ksi¹¿ka omawia:
FRAGMENTY KSI¥¯EK ONLINE
• rodowisko programistyczne Visual Studio, korzystanie z SourceSafe
• Jêzyk Visual Basic .NET, programowanie zorientowane obiektowo w VB .NET
• Rozszerzanie rodowiska programistycznego za pomoc¹ makr
• Zaawansowane programowanie w VB .NET: refleksje, przeci¹¿anie,
programowane oparte na zdarzeniach, polimorfizm, definiowanie atrybutów
• Tworzenie interfejsu u¿ytkownika (aplikacje konsolowe, aplikacje z interfejsem
Windows)
• Pisanie aplikacji wielow¹tkowych
• Uruchamianie us³ug WWW (Web Services)
„Visual Basic .NET. Ksiêga eksperta” jest doskona³ym podrêcznikiem dla wszystkich
osób, dla których osi¹gniêcie wysokiej sprawno ci w pos³ugiwaniu siê jêzykiem Visual
Wydawnictwo Helion Basic stanowi podstawê kariery programistycznej. Niezale¿nie, od tego, czy u¿ywa³e
ul. Chopina 6
poprzedniej wersji tego jêzyka, czy te¿ nie: je li chcesz staæ siê ekspertem Visual
44-100 Gliwice
Basica, trzymasz w rêku odpowiedni¹ ksi¹¿kê.
tel. (32)230-98-63
e-mail: helion@helion.pl
2. 5RKU VTG EK
1 #WVQTG
9UVúR
%ú è + 9RTQYCFGPKG FQ 8KUWCN $CUKE 0'6
4QFKC 7LGFPQNKEQPG TQFQYKUMQ RTCE[ 8KUWCN 5VWFKQ
Profile u ytkownika.................................................................................................................. 30
Tworzenie projektu .................................................................................................................. 31
Pliki i katalogi projektu ....................................................................................................... 31
Dodawanie projektu do kontroli kodu źródłowego ................................................................. 33
Kompilacja projektów............................................................................................................... 35
Korzystanie z mened era konfiguracji................................................................................... 36
Właściwości wspólne .......................................................................................................... 36
Opcje konfiguracyjne .......................................................................................................... 38
Debug Build ....................................................................................................................... 38
Release Build ..................................................................................................................... 38
Kompilacje typu Command-Line oraz korzystanie z Make File ............................................... 39
Organizacja kodu źródłowego formularza ................................................................................... 39
Przełączanie się pomiędzy widokiem kodu a widokiem obiektów............................................ 42
Przestrzenie nazw ............................................................................................................... 43
Skracanie kodu ................................................................................................................... 44
Dyrektywa #Region ............................................................................................................ 45
Edytowanie kodu i cechy ułatwiające tworzenie dokumentacji ................................................ 45
Konfiguracja opcji IDE ............................................................................................................. 48
Opcje środowiska ............................................................................................................... 49
Opcje kontroli kodu źródłowego........................................................................................... 49
Opcje edytora tekstu ........................................................................................................... 49
Opcje projektanta formularzy (Windows Forms Designer)...................................................... 50
Opcje analizatora ................................................................................................................ 50
Opcje narzędzi bazy danych ................................................................................................ 50
Opcje debugowania............................................................................................................. 50
Opcje projektanta HTML .................................................................................................... 51
Opcje projektu.................................................................................................................... 51
Opcje projektanta XML ...................................................................................................... 51
Proces debugowania w nowym IDE ........................................................................................... 51
Podstawowe klawisze skrótów podczas debugowania............................................................. 52
Strukturalna obsługa wyjątków ............................................................................................ 53
Przegląd Szablonów Projektów.................................................................................................. 53
Windows Application.......................................................................................................... 53
Class Library...................................................................................................................... 54
3. 6 Visual Basic .NET. Księga eksperta
Windows Control Library .................................................................................................... 55
ASP.NET Web Applications ................................................................................................ 55
ASP.NET Web Service ....................................................................................................... 57
Web Control Library ........................................................................................................... 58
Empty Project .................................................................................................................... 58
Empty Web Project............................................................................................................. 58
New Project in Existing Folder............................................................................................. 58
Projekty w wersji Enterprise ................................................................................................ 58
Technologia IntelliSense ........................................................................................................... 60
Składowe klas..................................................................................................................... 60
Informacja o parametrach.................................................................................................... 60
Szybka podpowiedź ............................................................................................................ 60
Dokańczanie wyrazów ........................................................................................................ 60
Cechy IntelliSense specyficzne dla VB ................................................................................. 61
Korzystanie z widoków............................................................................................................. 61
Solution Explorer................................................................................................................ 61
Class View......................................................................................................................... 62
Server Explorer................................................................................................................... 62
Resource View ................................................................................................................... 63
Properties Window ............................................................................................................. 63
Toolbox ............................................................................................................................. 63
Pendind Check-ins .............................................................................................................. 63
Web Browser ..................................................................................................................... 63
Inne okna........................................................................................................................... 64
Dokumentacja.......................................................................................................................... 67
Podsumowanie......................................................................................................................... 67
4QFKC %CU PC OKCP[
Rozszerzenia plików ................................................................................................................. 69
Grupy Visual Basic jako rozwiązania.................................................................................... 69
Nowe rozszerzenia plików źródłowych ................................................................................. 69
Przestrzenie nazw..................................................................................................................... 71
Referencje ............................................................................................................................... 72
Dyrektywy Option.................................................................................................................... 72
Option Explicit ................................................................................................................... 72
Option Compare ................................................................................................................. 74
Option Strict....................................................................................................................... 74
Moduł Option Private.......................................................................................................... 75
Option Base ....................................................................................................................... 76
Typy danych............................................................................................................................ 76
Typy Object ....................................................................................................................... 77
Typy całkowite ................................................................................................................... 80
Typy niecałkowite............................................................................................................... 81
Typ Char ........................................................................................................................... 85
Typ String.......................................................................................................................... 86
Typ Boolean....................................................................................................................... 89
Typ DateTime .................................................................................................................... 91
Deklaracje zmiennych............................................................................................................... 94
Deklarowanie i inicjowanie pojedynczej zmiennej ................................................................. 95
Deklaracje wielu zmiennych jednocześnie............................................................................. 96
4. Spis treści 7
Inicjowanie wielu zmiennych jednocześnie ........................................................................... 97
Definiowanie stałych........................................................................................................... 98
Tworzenie egzemplarzy obiektów ........................................................................................ 98
Listy inicjujące zmienne ...................................................................................................... 99
Operatory ................................................................................................................................ 99
Funkcje konwersji typów ........................................................................................................ 101
Zmiany zasięgu zmiennych w VB .NET................................................................................... 103
Instrukcje sterowania pracą programu ...................................................................................... 103
Tablice i kolekcje ................................................................................................................... 104
Tablice o określonych granicach......................................................................................... 105
Tablice N-wymiarowe ....................................................................................................... 105
Modyfikacja rozmiarów tablic............................................................................................ 106
Zwracanie tablic przez funkcje........................................................................................... 106
Tablice jako podklasy System.Array................................................................................... 107
Abstrakcyjne typy danych ................................................................................................. 107
Strukturalna obsługa wyjątków ................................................................................................ 109
Korzystanie ze słów zastrze onych w Visual Basic .NET........................................................... 110
Kompatybilność pomiędzy aplikacjami VB6 a VB .NET ........................................................... 110
Microsoft.VisualBasic ....................................................................................................... 110
Elementy programowania VB6 zmienione w Visual Basic .NET........................................... 111
Podsumowanie....................................................................................................................... 111
4QFKC 2QFUVCY[ RTQITCOQYCPKC Y 8KUWCN $CUKE 0'6
Deklarowanie i inicjowanie zmiennych..................................................................................... 113
Inicjowanie zmiennych...................................................................................................... 114
Deklarowanie i inicjowanie zmiennych w pojedynczej instrukcji........................................... 116
Deklarowanie zmiennych tu przed ich pierwszym u yciem ................................................. 116
Deklarowanie zmiennych o jak najmniejszym zasięgu.......................................................... 116
Korzystanie z refaktoringu: zamiana zmiennych tymczasowych na kwerendy ........................ 117
Praca z zasięgiem blokowym ................................................................................................... 119
Zmienne statyczne.................................................................................................................. 120
U ywanie zmiennych statycznych ...................................................................................... 120
Zmienne statyczne a pamięć .............................................................................................. 121
Korzystanie z tablic ................................................................................................................ 121
Tablice są instancjami klasy System.Array .......................................................................... 121
Deklarowanie tablic .......................................................................................................... 122
Korzystanie z metod tablicowych ....................................................................................... 122
Tablice wielowymiarowe................................................................................................... 123
Praca z abstrakcyjnymi typami danych ..................................................................................... 125
Składowe klasy ArrayList.................................................................................................. 126
U ywanie ArrayList .......................................................................................................... 127
HashTable........................................................................................................................ 128
SortedList ........................................................................................................................ 129
Queue.............................................................................................................................. 130
Podsumowanie Abstrakcyjnych Typów Danych .................................................................. 130
Przesłanianie zmiennych ......................................................................................................... 131
Funkcje i podprogramy ........................................................................................................... 132
Definiowanie struktur ............................................................................................................. 132
5. 8 Visual Basic .NET. Księga eksperta
U ywanie obiektów ................................................................................................................ 132
Co to jest konstruktor? ...................................................................................................... 133
Konstruktory sparametryzowane ........................................................................................ 134
Destruktory ...................................................................................................................... 134
Obsługa wyjątków.................................................................................................................. 135
Try...Catch....................................................................................................................... 135
Try...Finally ..................................................................................................................... 139
Podsumowanie....................................................................................................................... 140
4QFKC /CMTC K TQUGTGPKC 8KUWCN 5VWFKQ
Automatyzacja zadań powtarzających się ................................................................................. 142
Przykład: nagrywanie makra .............................................................................................. 142
Podgląd zarejestrowanego makra........................................................................................ 143
Edycja makra tymczasowego ............................................................................................. 144
Uruchamianie makra ......................................................................................................... 148
Przypisywanie klawiszy skrótu do makra ............................................................................ 149
Dodawanie klawisza makra do paska narzędziowego ........................................................... 149
Korzystanie z Eksploratora Makr ............................................................................................. 151
Eksport makra........................................................................................................................ 151
Makra włączające i wyłączające pułapki ............................................................................. 151
Wysyłanie informacji do okna wyjściowego Output............................................................. 153
Eksportowanie modułów makra ......................................................................................... 155
Importowanie modułów makra........................................................................................... 155
Korzystanie z Macros IDE ...................................................................................................... 155
Bezpieczeństwo makr........................................................................................................ 156
Współdzielenie makr......................................................................................................... 156
Tworzenie projektu makra ...................................................................................................... 156
Obsługa Visual Studio poprzez okno Command........................................................................ 158
Odpowiadanie na zdarzenia IDE .............................................................................................. 158
Dostosowanie Visual Studio do własnych wymagań .................................................................. 160
Ogólny opis Extensibility Object Model.............................................................................. 161
Ogólny opis Project-Neutral Extensibility Object Model....................................................... 165
Tworzenie przystawek ............................................................................................................ 167
Tworzenie projektu przystawki .......................................................................................... 168
Rejestracja przystawek...................................................................................................... 172
Dodawanie zachowań do przystawki .................................................................................. 173
Tworzenie kreatorów.............................................................................................................. 174
Tworzenie pliku uruchomieniowego kreatora ...................................................................... 176
Rejestracja biblioteki klas kreatora ..................................................................................... 176
Testowanie kreatora.......................................................................................................... 176
Program Integracji Visual Studio ............................................................................................. 177
Podsumowanie....................................................................................................................... 178
4QFKC 2TQEGFWT[ HWPMELG K UVTWMVWT[
Pisanie procedur..................................................................................................................... 179
Pisanie procedur ............................................................................................................... 180
Pisanie funkcji .................................................................................................................. 182
Definiowanie argumentów procedury ....................................................................................... 185
Domyślne przekazywanie parametrów ................................................................................ 186
Korzystanie z parametrów opcjonalnych ............................................................................. 190
6. Spis treści 9
Definiowanie argumentów ParamArray .............................................................................. 193
Redukowanie liczby parametrów........................................................................................ 194
Praca z rekurencją .................................................................................................................. 199
Definiowanie procedur rekurencyjnych............................................................................... 199
Zamiana rekurencji na algorytm nierekurencyjny................................................................. 199
Definiowanie struktur ............................................................................................................. 200
Definiowanie pól i właściwości .......................................................................................... 201
Dodawanie metod do struktur ............................................................................................ 202
Implementowanie konstruktorów ....................................................................................... 203
Definiowanie zdarzeń strukturalnych .................................................................................. 205
Deklarowanie zmiennych w strukturze................................................................................ 207
Ukrywanie informacji........................................................................................................ 208
Argumenty struktur i typy zwracane ................................................................................... 208
Cechy niedostępne dla struktur........................................................................................... 208
Korzystanie z typów wyliczeniowych....................................................................................... 209
Podsumowanie....................................................................................................................... 210
%ú è ++ CCYCPUQYCPG RTQITCOQYCPKG QTKGPVQYCPG QDKGMVQYQ
4QFKC 4GHNGMULG
Przestrzeń nazw Reflection...................................................................................................... 213
Pakiety ............................................................................................................................ 214
Manifest jako źródło informacji o zasobach......................................................................... 216
Obiekt modułu.................................................................................................................. 216
Obiekt File ....................................................................................................................... 219
Właściwość Location ........................................................................................................ 221
Właściwość EntryPoint ..................................................................................................... 221
Właściwość GlobalAssemblyCache .................................................................................... 221
Type................................................................................................................................ 221
Wiązania.......................................................................................................................... 222
Klasa MethodInfo ............................................................................................................. 227
Klasa ParameterInfo ......................................................................................................... 228
Klasa FieldInfo ................................................................................................................. 228
Klasa PropertyInfo............................................................................................................ 228
Klasa EventInfo................................................................................................................ 228
Tworzenie typów w trakcie działania aplikacji z wykorzystaniem refleksji .................................. 229
Inne przypadki korzystania z refleksji....................................................................................... 232
Lokalizacja ............................................................................................................................ 233
Podsumowanie....................................................................................................................... 233
4QFKC 6YQTGPKG MNCU
Definiowanie klas................................................................................................................... 235
U ywanie specyfikatorów dostępu do klas .......................................................................... 237
Hermetyzacja i ukrywanie informacji ....................................................................................... 239
Specyfikatory dostępu ....................................................................................................... 240
Praca z zasięgiem.............................................................................................................. 240
Dodawanie pól i właściwości................................................................................................... 240
Hermetyzacja i właściwości ............................................................................................... 242
Definiowanie właściwości indeksowanych .......................................................................... 243
Korzystanie z modyfikatorów właściwości .......................................................................... 250
7. 10 Visual Basic .NET. Księga eksperta
Definiowanie właściwości współdzielonych ........................................................................ 253
Dodawanie atrybutów właściwości ..................................................................................... 253
Dodawanie metod do klas ....................................................................................................... 254
Implementowanie konstruktorów i destruktorów.................................................................. 256
Dodawanie funkcji i procedur do metod.............................................................................. 260
Korzystanie z modyfikatorów metod .................................................................................. 263
Korzystanie ze specyfikatorów dostępu............................................................................... 265
Dodawanie zdarzeń do klas ..................................................................................................... 266
Definiowanie klas zagnie d onych........................................................................................... 267
Zrozumienie celu korzystania z klas zagnie d onych ........................................................... 271
Definiowanie klasy Signal ................................................................................................. 272
Definiowanie abstrakcyjnej klasy bazowej Light.................................................................. 276
Implementowanie świateł sygnalizacji ................................................................................ 276
Podsumowanie programu TrafficLight................................................................................ 277
Tworzenie egzemplarzy klas.................................................................................................... 277
Podsumowanie....................................................................................................................... 278
4QFKC QFCYCPKG FCTG
Rozumienie zdarzeń i procedur ich obsługi ............................................................................... 279
Podstawowa delegacja: EventHandler................................................................................. 281
Dołączanie wielu zdarzeń do jednej procedury obsługi ......................................................... 288
Tworzenie procedur obsługi zdarzeń w edytorze kodu ............................................................... 290
Pisanie procedur obsługi zdarzeń w edytorze kodu .............................................................. 293
Przypisywanie procedur obsługi zdarzeń w trakcie pracy aplikacji......................................... 294
Tworzenie procedur obsługi zdarzeń w trakcie pracy aplikacji .................................................... 294
Tworzenie procedur obsługi zdarzeń w WebForms Designer ...................................................... 296
Deklarowanie i wywoływanie zdarzeń...................................................................................... 296
Deklarowanie zdarzeń ....................................................................................................... 298
Generowanie zdarzeń ........................................................................................................ 299
Implementowanie procedur obsługi zdarzeń klasy................................................................ 300
Implementowanie procedur obsługi zdarzeń współdzielonych............................................... 300
Implementowanie procedur obsługi zdarzeń modułowych .................................................... 300
Implementowanie procedur obsługi zdarzeń struktury .......................................................... 302
Niedostępne właściwości zdarzeń....................................................................................... 303
Podsumowanie....................................................................................................................... 303
4QFKC GNGICELG
U ywanie delegacji EventHandler............................................................................................ 306
Korzystanie z argumentów obiektu EventHandler ................................................................ 306
Korzystanie z argumentu EventHandler System.EventArgs................................................... 315
Przegląd składowych delegacji ................................................................................................ 315
Definiowanie delegacji............................................................................................................ 317
Deklarowanie procedur odpowiadających sygnaturom delegacji............................................ 317
Inicjowanie delegacji......................................................................................................... 318
Cel stosowania delegacji.................................................................................................... 318
Przekazywanie delegacji jako argumentów ............................................................................... 319
Przegląd algorytmów sortowania i opis działania aplikacji.................................................... 320
Algorytmy sortowania ....................................................................................................... 321
Analiza działania aplikacji SortAlgorithms.......................................................................... 321
Alternatywa dla typów proceduralnych ............................................................................... 326
8. Spis treści 11
Delegacje grupowe ................................................................................................................. 327
Metoda Combine .............................................................................................................. 329
Korzystanie z delegacji grupowych..................................................................................... 329
Korzystanie z delegacji poza granicami projektu ....................................................................... 330
Podsumowanie....................................................................................................................... 333
4QFKC KGFKEGPKG K RQNKOQTHKO
Podstawy dziedziczenia........................................................................................................... 335
Co to jest dziedziczenie? ......................................................................................................... 336
Podstawowa składnia dziedziczenia.................................................................................... 337
Dziedziczenie w przykładach ............................................................................................. 338
Implementowanie właściwości, zdarzeń i metod w edytorze kodu......................................... 339
Dziedziczenie pojedyncze a dziedziczenie wielokrotne......................................................... 342
Definiowanie klas, które muszą być dziedziczone...................................................................... 342
Przykład wirtualnej klasy abstrakcyjnej .............................................................................. 343
Definiowanie klas, które nie mogą być dziedziczone.................................................................. 345
Polimorfizm........................................................................................................................... 346
Trzy rodzaje polimorfizmu ................................................................................................ 348
Wywoływanie metod dziedziczonych ................................................................................. 350
Przesłanianie metody klasy nadrzędnej ............................................................................... 350
Dynamiczne rzutowanie typów ................................................................................................ 352
Definiowanie interfejsów ........................................................................................................ 354
Interfejsy a klasy .............................................................................................................. 354
Definiowanie interfejsu ..................................................................................................... 355
Podsumowanie....................................................................................................................... 357
4QFKC 5M CFQYG YURÎ FKGNQPG
Deklarowanie pól współdzielonych .......................................................................................... 359
Definiowanie właściwości współdzielonych.............................................................................. 360
U ywanie metod współdzielonych ........................................................................................... 364
Definiowanie konstruktorów współdzielonych .......................................................................... 369
Konstruktory współdzielone i singletony............................................................................. 369
Przykład konstruktora współdzielonego .............................................................................. 370
Implementowanie metod fabrycznych ...................................................................................... 375
Przecią anie składowych współdzielonych ............................................................................... 378
Generowanie zdarzeń współdzielonych .................................................................................... 380
Podsumowanie....................................................................................................................... 382
4QFKC GHKPKQYCPKG CVT[DWVÎY
Rola atrybutów....................................................................................................................... 384
Czym są metadane? .......................................................................................................... 384
Nazwy atrybutów ............................................................................................................. 390
Elementy opisywane przez atrybuty.................................................................................... 391
Opisywanie pakietu........................................................................................................... 391
Oznaczanie typów i składowych .............................................................................................. 393
Dodawanie atrybutów typu ................................................................................................ 393
Dodawanie atrybutów metod ............................................................................................. 396
Dodawanie atrybutów pól i własności ................................................................................. 399
Przeglądanie atrybutów za pomocą deasemblera MSIL.............................................................. 403
Pozyskiwanie atrybutów za pomocą refleksji ............................................................................ 403
9. 12 Visual Basic .NET. Księga eksperta
Tworzenie atrybutów u ytkownika .......................................................................................... 405
Implementacja HelpAttribute ............................................................................................. 405
Deklarowanie klasy atrybutu.............................................................................................. 405
Określanie zasad u ycia atrybutu — AttributeUsage ............................................................ 406
Dziedziczenie z System.Attribute ....................................................................................... 407
Implementowanie konstruktora .......................................................................................... 407
Dodawanie nazwanych argumentów ................................................................................... 408
Atrybutu komponentów .......................................................................................................... 408
Atrybuty współpracy z COM................................................................................................... 409
Podsumowanie....................................................................................................................... 409
%ú è +++ 2TQLGMV KPVGTHGLUW W [VMQYPKMC
4QFKC #RNKMCELC MQPUQNQYC
Podstawy aplikacji konsolowych.............................................................................................. 413
Procedura Sub Main implementowana w module ................................................................. 414
Procedura Sub Main implementowana w klasie ................................................................... 415
Pozyskiwanie argumentów wierszy poleceń ........................................................................ 416
Klasa Console ........................................................................................................................ 420
Odczyt i zapis w standardowych urządzeniach wejścia-wyjścia............................................. 421
Zapis do urządzenia informacji o błędach............................................................................ 423
Zmiana urządzenia informacji o błędach ............................................................................. 424
Implementacja programu FileSort ............................................................................................ 425
Stosowanie TextReader ..................................................................................................... 426
Stosowanie TextWriter ...................................................................................................... 430
Pliki tymczasowe.............................................................................................................. 430
Stosowanie interfejsu IEnumerator ..................................................................................... 431
Sortowanie w ArrayList..................................................................................................... 432
Implementowanie interfejsu IComparer .............................................................................. 432
Przestrzenie nazw aplikacji konsolowych.................................................................................. 433
Wielowątkowość w aplikacji konsolowej.................................................................................. 433
Debugowanie aplikacji konsolowych........................................................................................ 436
Ustalanie argumentów wiersza poleceń za pomocą IDE ....................................................... 436
Przyłączanie debugera do uruchomionej aplikacji ................................................................ 436
Monitorowanie systemu plików ............................................................................................... 439
Podsumowanie....................................................................................................................... 440
4QFKC #RNKMCELG YKGNQYæVMQYG
Przetwarzanie asynchroniczne bez udziału wątków.................................................................... 442
Stosowanie timera............................................................................................................. 442
Zdarzenie Application.Idle................................................................................................. 442
Lekkie wątki — pule wątków .................................................................................................. 444
Czym jest pula wątków?.................................................................................................... 444
Jak działa pula wątków? .................................................................................................... 445
Stosowanie puli wątków .................................................................................................... 445
Synchronizacja — WaitHandle .......................................................................................... 449
Synchronizacja z wykorzystaniem klasy Monitor................................................................. 455
Wielowątkowość — waga cię ka ............................................................................................. 457
Tworzenie i korzystanie z wątków...................................................................................... 457
Przykład wątku................................................................................................................. 457
10. Spis treści 13
Dołączanie atrybutu ThreadStatic ............................................................................................ 459
Wielowątkowość a formularze Windows .................................................................................. 461
Strategie wielowątkowości dla formularzy Windows............................................................ 462
Invoke i wywołania synchroniczne ..................................................................................... 462
Wywołania asynchroniczne — BeginInvoke i EndInvoke..................................................... 463
Podsumowanie....................................................................................................................... 466
4QFKC 5VQUQYCPKG HQTOWNCT[ 9KPFQYU
Przegląd przestrzeni nazw Forms ............................................................................................. 467
Klasy przestrzeni nazw Forms............................................................................................ 468
Interfejsy przestrzeni nazw Forms ...................................................................................... 478
Struktury przestrzeni nazw Forms ...................................................................................... 479
Delegacje przestrzeni nazw Forms...................................................................................... 480
Wyliczenia przestrzeni nazw Forms.................................................................................... 481
Przegląd przestrzeni nazw System.Drawing .............................................................................. 482
Klasy przestrzeni nazw System.Drawing............................................................................. 482
Struktury przestrzeni nazw System.Drawing........................................................................ 489
Klasa Form ............................................................................................................................ 489
Powoływanie obiektu formularza ....................................................................................... 490
Projektowanie interfejsu u ytkownika................................................................................. 491
Dynamiczne tworzenie kontrolek ....................................................................................... 493
Procedury obsługi zdarzeń dynamicznie tworzonych kontrolek ............................................. 494
Wyszukiwanie aktywnego formularza................................................................................. 494
Dołączanie kodu do formularzy.......................................................................................... 494
Tworzenie formularzy u ytkownika za pomocą GDI+ ............................................................... 495
Podsumowanie....................................................................................................................... 495
4QFKC 2TQLGMVQYCPKG KPVGTHGLUW W [VMQYPKMC
Rozmieszczanie kontrolek ....................................................................................................... 497
Kotwiczenie kontrolek....................................................................................................... 498
Dokowanie kontrolek ........................................................................................................ 499
Zachowanie marginesu kontrolek ....................................................................................... 499
Ustalanie poło enia i rozmiaru ........................................................................................... 499
Praca z Menu......................................................................................................................... 500
Definiowanie MainMenu i ContextMenu ............................................................................ 500
Dołączanie kodu menu ...................................................................................................... 501
Ró nice pomiędzy MainMenu i ContextMenu ..................................................................... 503
Dynamiczne dodawanie pozycji menu ................................................................................ 504
Zaawansowane techniki projektowania formularzy .................................................................... 507
Własność Form.AutoScale................................................................................................. 507
Automatyczne przewijanie................................................................................................. 507
Rozmiar AutoScrollMargin................................................................................................ 508
Stosowanie obiektu CreateParams ...................................................................................... 508
Czym zajmują się klasy Component i Control ........................................................................... 510
Klasa Component ............................................................................................................. 510
Klasa Control ................................................................................................................... 511
Dynamiczne dodawanie kontrolek............................................................................................ 512
Kontrolki u ytkownika — UserControls ................................................................................... 513
Wprowadzanie kontrolek do kontrolki u ytkownika............................................................. 513
Zdarzenia w kontrolkach u ytkownika ................................................................................ 514
11. 14 Visual Basic .NET. Księga eksperta
Kod w kontrolkach u ytkownika ........................................................................................ 516
Umieszczanie kontrolki u ytkownika w Visual Studio .NET ................................................ 516
Przypisywanie kontrolce bitmapy pojawiającej się oknie narzędziowym ................................ 517
Tworzenie własnych kontrolek ................................................................................................ 517
Tworzenie niewidocznych komponentów............................................................................ 518
Określanie domyślnego zdarzenia....................................................................................... 519
Podsumowanie....................................................................................................................... 520
4QFKC 2TQITCOQYCPKG )+
Podstawy GDI+ ..................................................................................................................... 521
Stosowanie obiektów Graphics........................................................................................... 522
Podstawowe klasy związane z rysowaniem ......................................................................... 524
Proste operacje z wykorzystaniem GDI+............................................................................. 525
Kreślenie figur płaskich i tekstu ......................................................................................... 526
Zaawansowane metody graficzne............................................................................................. 530
Kreślenie krzywych .......................................................................................................... 530
Kreślenie skomplikowanych krzywych — krzywe Bézier..................................................... 531
Ście ka graficzna — klasa GraphicsPath............................................................................. 532
Klasa Region .................................................................................................................... 537
Formularze o niestandardowych kształtach.......................................................................... 537
Klasa Icon........................................................................................................................ 540
Przestrzeń nazw Imaging ................................................................................................... 540
Grafika u ytkownika w formularzach Windows ........................................................................ 541
Drukowanie grafiki................................................................................................................. 542
Podsumowanie....................................................................................................................... 543
%ú è +8 $WFQYCPKG WU WI 999 9GD 5GTXKEGU
4QFKC 5VQUQYCPKG K KORNGOGPVCELC WU WI 999
9GD 5GTXKEGU
Przegląd usług Web Services ................................................................................................... 547
Wyszukiwanie usług Web Services za pomocą UDDI................................................................ 549
uddi.microsoft.com ........................................................................................................... 550
Lokalne usługi Web Services ............................................................................................. 550
Cztery aspekty pracy z Web Services.................................................................................. 551
Wywoływanie usług WWW .................................................................................................... 552
Odwołania do WebServices ............................................................................................... 552
Aplikacje formularzy Windows.......................................................................................... 554
Aplikacje formularzy WWW ............................................................................................. 555
Implementowanie usług WWW ............................................................................................... 556
Plik global.asax ................................................................................................................ 556
Plik web.config................................................................................................................. 557
Plik disco ......................................................................................................................... 559
Plik .asmx ........................................................................................................................ 560
Kiedy usługi Web Servcies mogą okazać się przydatne ........................................................ 561
Tworzenie usługi Web Service ........................................................................................... 562
Wybór metody dostępu sieciowego .......................................................................................... 566
Zarządzanie informacjami stanu............................................................................................... 567
Obsługa i generowanie wyjątków w usługach Web Services....................................................... 569
12. Spis treści 15
Debugowanie usług Web Services............................................................................................ 570
Zintegrowane debugowanie ............................................................................................... 571
Uruchamianie bez debugowania ......................................................................................... 571
Uruchamianie w przeglądarce ............................................................................................ 571
Kompilowanie i rozpowszechnianie projektów sieciowych......................................................... 572
Podsumowanie....................................................................................................................... 573
4QFKC 2TQITCOQYCPKG UKGEKQYG #520'6
Formularze WWW ................................................................................................................. 576
Okno projektowania formularzy WWW.............................................................................. 576
Kod formularzy WWW ..................................................................................................... 578
Kompilowanie i uruchamianie aplikacji ASP.NET............................................................... 580
Request i Response................................................................................................................. 580
ASP.NET i ADO.NET............................................................................................................ 581
Baza danych przykładowych programów ............................................................................ 582
Sortowanie danych w formularzu WWW ............................................................................ 584
Stronicowanie danych przy u yciu DataGrid ....................................................................... 586
Buforowanie danych wyjściowych ........................................................................................... 587
Dodawanie i usuwanie elementów bufora............................................................................ 590
Deklarowanie terminu wa ności elementów pamięci podręcznej ........................................... 591
Względy wydajnościowe......................................................................................................... 591
Przygotowywanie kontrolek do wyświetlenia ............................................................................ 592
Dynamiczne dodawanie kontrolek do strony ............................................................................. 594
Programowe dodawanie tekstu statycznego ......................................................................... 594
Modyfikowanie własności kontrolek przy u yciu kolekcji Attributes ..................................... 595
Programowe dodawanie kontrolek LiteralControl ................................................................ 595
Dodawanie kontrolek przy u yciu kontrolki PlaceHolder...................................................... 596
Programowe dodawanie kontrolek prezentacji danych.......................................................... 597
Wyposa anie kontrolek dynamicznych w procedury obsługi zdarzeń..................................... 598
Tworzenie własnych kontrolek WWW ..................................................................................... 599
Zapisywanie strony WWW jako kontrolki serwerowej ......................................................... 600
Tworzenie własnej kontrolki u ytkownika........................................................................... 606
Tworzenie biblioteki kontrolek WWW ............................................................................... 607
Podsumowanie....................................................................................................................... 609
4QFKC KGPPKM FCTG
Źródło zdarzeń ....................................................................................................................... 612
Tworzenia źródła zdarzeń.................................................................................................. 612
Usuwanie źródła zdarzeń ................................................................................................... 614
Pozyskiwanie tablicy dzienników zdarzeń........................................................................... 614
Wyszukiwanie nazwy logu na podstawie nazwy źródła ........................................................ 615
Usuwanie dziennika .......................................................................................................... 615
Dokonywanie wpisów do istniejącego dziennika ....................................................................... 615
Własny dziennik zdarzeń......................................................................................................... 617
Pobieranie zawartości dziennika zdarzeń .................................................................................. 618
Czyszczenie dziennika zdarzeń ................................................................................................ 620
Powiadamianie o zdarzeniu ..................................................................................................... 620
Zdalny dziennik zdarzeń ......................................................................................................... 621
EventLogTraceListener........................................................................................................... 621
Podsumowanie....................................................................................................................... 622
13. 16 Visual Basic .NET. Księga eksperta
QFCVMK
QFCVGM # 'NGOGPV[ RTQITCOQYCPKC 8$ OKGPKQPG Y 8$0'6
Elementy usunięte z VB. NET................................................................................................. 625
Zmiany w deklaracji i składni .................................................................................................. 627
As Any ............................................................................................................................ 627
Deklarowanie zmiennych................................................................................................... 627
Numerowanie wierszy ....................................................................................................... 628
Zmiany zakresu widoczności zmiennych .................................................................................. 629
Zmiany w deklaracji procedur ................................................................................................. 629
Brak IsMissing ................................................................................................................. 630
Wywoływanie procedur..................................................................................................... 630
Przekazywanie własności przez referencję .......................................................................... 631
ByVal — domyślny modyfikator argumentu ....................................................................... 632
Argumenty ParamArray .................................................................................................... 632
Modyfikator Static ............................................................................................................ 633
Zmiany we własnościach......................................................................................................... 633
Ujednolicona deklaracja własności w Visual Basic .NET ..................................................... 634
Let nie jest ju obsługiwane ............................................................................................... 634
Własności domyślne nie mogą być współdzielone lub prywatne............................................ 634
Własności domyślne muszą pobierać argumenty.................................................................. 634
Argumenty własności nie mogą być przekazywane przez referencję...................................... 635
Zmiany zakresu tablic ............................................................................................................. 636
Rozmiar tablicy mo e się zmienić, ale liczba wymiarów jest stała ......................................... 636
Zmiany w typach danych ........................................................................................................ 637
Typ Currency ................................................................................................................... 637
Brak DefTyp .................................................................................................................... 637
Konstrukcja Type zastąpiona przez Structure ...................................................................... 637
Visual Basic .NET nie obsługuje ciągów tekstowych o ustalonej długości.............................. 638
Zmiany w wartościach całkowitoliczbowych ....................................................................... 638
Zmiany operatorów ................................................................................................................ 639
Operatory równowa ności i implikacji ................................................................................ 639
And, Or, Xor i Not............................................................................................................ 639
Szybkie oszacowanie......................................................................................................... 640
Zmiany w sterowaniu przebiegiem programu ............................................................................ 640
Wywołanie funkcji zamiast GoSub..................................................................................... 640
Brak On ... GoSub i On ... Goto ......................................................................................... 642
Zmiany w klasach i interfejsach ............................................................................................... 643
Parametryzowane konstruktory .......................................................................................... 643
Brak Option Private Module .............................................................................................. 643
Zmiany w interfejsach ....................................................................................................... 643
Zastąpione elementy programowania........................................................................................ 644
Arcustangens (Atn) ........................................................................................................... 644
Circle............................................................................................................................... 645
Debug.Print i Debug.Assert ............................................................................................... 645
DoEvents ......................................................................................................................... 645
IsNull .............................................................................................................................. 645
IsObject ........................................................................................................................... 645
Line................................................................................................................................. 646
14. Spis treści 17
LSet i RSet....................................................................................................................... 646
MsgBox ........................................................................................................................... 646
Wend............................................................................................................................... 646
Elementy programowania obsługiwane w inny sposób............................................................... 647
Calendar .......................................................................................................................... 647
Date ................................................................................................................................ 647
Empty zastąpiono przez Nothing ........................................................................................ 648
Now ................................................................................................................................ 648
Rnd i Round..................................................................................................................... 648
PSet i Scale nie są obsługiwane w Visual Basic .NET .......................................................... 649
Sgn i Sqr.......................................................................................................................... 649
String............................................................................................................................... 649
Time................................................................................................................................ 650
VarType .......................................................................................................................... 650
Typ Variant zastąpiony przez Object........................................................................................ 650
5MQTQYKF
15. 4QFKC
6YQTGPKG MNCU
Mo liwość definiowania klas i tworzenia ich egzemplarzy (instancji) jest jedną z naj-
wa niejszych cech ka dego języka zorientowanego obiektowo. A do chwili obecnej
Visual Basic nie obsługiwał w pełni obiektowości. Mimo e moduły w VB6 nazywane
były modułami klas, tak naprawdę były interfejsami w sensie technologii COM (ang.
Component Object Model). Oznacza to, e VB6 nie obsługiwał idiomu klasy; nie umo -
liwiał korzystania z innej bardzo po ytecznej cechy programowania obiektowego —
dziedziczenia.
Zasadniczą ró nicą pomiędzy interfejsami, a klasami jest dziedziczenie. Ka da imple-
mentacja interfejsu VB6 (modułu klasy) wymagała wprowadzenia wszystkich publicz-
nych metod dla tego interfejsu. Klasy, w przeciwieństwie do interfejsu, obsługują dziedzi-
czenie. Dziedziczenie oznacza, e mogą istnieć podklasy zawierające pola, właściwości,
metody i zdarzenia klasy nadrzędnej. Tworząc nowe klasy, mo esz je wykorzystywać do
rozszerzania istniejących klas bazowych.
Zarówno zorientowane obiektowo klasy, jak i interfejsy COM udostępniają twórcom
oprogramowania potę ne marzędzia do tworzenia i zarządzania zaawansowanymi pro-
jektami. Obie technologie są bardzo przydatne i obie zostały zaimplementowane w Vi-
sual Basic .NET. Dodatkowo, Microsoft udoskonalił i poprawił interfejsy i opisy klas
w celu zapobiegnięcia niejednoznaczności podczas ich stosowania. Obie technologie po-
siadają odmienne zasady składni.
W tym rozdziale zostanie przedstawiona zmieniona składnia interfejsów oraz właściwości
nowej definicji klasy, włączając w to dziedziczenie, polimorfizm, przecią anie i prze-
słanianie metod. Dodatkowo, rozdział ten zawiera kolejne przykłady wykorzystania ob-
sługi wyjątków i wielowątkowości w Visual Basic .NET.
GHKPKQYCPKG MNCU
Klasa w Visual Basic .NET nie jest klasą VB6. Klasy VB6 są w VB .NET deklarowane
i definiowane przy u yciu słowa kluczowego KPVGTHCEG. Klasy VB .NET są definiowa-
nymi przez u ytkownika typami agregacyjnymi, umo liwiającymi dziedziczenie. Ró nią
się one od interfejsów COM, które są dokładnie tym, czym w VB6 były moduły klasy.
16. 236 Część II Zaawansowane programowanie zorientowane obiektowo
Wszystkie klasy w Visual Basic .NET są definiowane w pliku .VB (w przeciwieństwie
do pliku .CLS), a w pliku takim mo e być zawarta jedna lub kilka klas. (Klasy, struktury
i moduły mogą być zgromadzone w jednym pliku). Podstawowa składnia klasy jest na-
stępująca:
%NCUU ENCUUPCOG
'PF %NCUU
Jeśli przez przypadek popełnisz błąd podczas deklarowania klasy, Visual Studio.NET
IDE podkreśli linią falistą miejsce, w którym ten błąd występuje (zobacz rysunek 7.1)
4[UWPGM
Visual Studio .NET
IDE zaznacza linią
falistą miejsca
zawierające błąd
Najczęściej klasy poprzedzone są specyfikatorem dostępu 2WDNKE, mo esz jednak wyko-
rzystać inne specyfikatory. W podrozdziale „U ywanie specyfikatorów dostępu do klas”
znajdziesz więcej informacji na ten temat.
Instrukcje %NCUU i 'PF %NCUU tworzą jednostkę hermetyzacji dla klasy. Wszystkie skła-
dowe klasy umieszczane są pomiędzy tymi instrukcjami.
Mo esz dodawać dowolną liczbę pól, właściwości, metod i zdarzeń w celu zdefiniowania
klasy, która ma spełniać określone wymagania w dziedzinie rozwiązania jakiegoś pro-
blemu. Jakkolwiek liczba składowych w klasie mo e być dowolna, jednak przestrzeganie
następujących zasad w większości przypadków pozwoli na zachowanie przejrzystości
w kodzie i uproszczenie tworzonych konstrukcji.
Klasy powinny składać się z maksymalnie sześciu składowych publicznych,
włączając w to właściwości i metody. Liczba składowych niepublicznych mo e być
większa, gdy nie wpływają one na prostotę korzystania z klasy przez u ytkownika.
W ogólnym przypadku jakiekolwiek składowe niepubliczne powinny być chronione
i wirtualne — posiadając modyfikator QXGTTKFCDNG.
17. Rozdział 7. Tworzenie klas 237
Pola, właściwości, zdarzenia wspólnie określane są mianem składowych. Termin skła-
dowa odnosi się po prostu do czegoś, co zostało zdefiniowane jako część klasy.
Jak we wszystkich regułach, tak e i tu są wyjątki. Istnieje zasada „wystarczająco dobry”,
wprowadzona przez Grady Boocha, mówiąca, e jeśli ró norodność oraz liczba składo-
wych jest rozsądna i wystarczająca, to liczba ta jest wystarczająco dobra. W ksią ce Ja-
mesa Coplien „Zaawansowany C++” zostały przedstawione zaawansowane zagadnienia,
które łamią ogólne zasady. Kolejnym przykładem wyjątku od opisanych powy ej reguł
są klasy ze wszystkimi składowymi typu 5JCTGF, jak np. klasa /CVJ w CLR.
Jak zostało wspomniane wcześniej, podstawowe wskazówki do definiowania klas są do-
brym punktem startowym, istnieją jednak inne zasady i motywacje, którymi mo na się
kierować podczas tworzenia klas. Na przykład technika refaktoringu „Zastosuj obiekt pa-
rametryczny”, której zastosowanie ulepsza przekazywanie parametrów, wymaga utwo-
rzenia dodatkowych klas.
7 [YCPKG URGE[HKMCVQTÎY FQUVúRW FQ MNCU
W Visual Basic .NET występuje pięć specyfikatorów dostępu, opisanych w kolejnych
podrozdziałach.
2WDNKE
Specyfikator dostępu 2WDNKE, zastosowany na poziomie klasy, jest najczęściej u ywa-
nym specyfikatorem. Klasy publiczne są to klasy, do których przewidziany jest dostęp
przez ka dego u ytkownika. Specyfikator dostępu 2WDNKE występuje w kodzie po atry-
butach i bezpośrednio przed słowem kluczowym %NCUU. (W rozdziale 12., „Definiowa-
nie atrybutów”, znajdziesz więcej informacji o atrybutach).
2WDNKE %NCUU /[%NCUU
'PF %NCUU
2TQVGEVGF
Specyfikator 2TQVGEVGF ma zastosowanie wyłącznie w klasach zagnie d onych. Klasy
zagnie d one są są dostępne wyłącznie w danej klasie i w klasach potomnych. Nie mo-
esz zdefiniować składników egzemplarza klasy zagnie d onej z widocznością większą
ni definicja klasy.
Definicja zagnie d onej klasy 2TQVGEVGF%NCUU przedstawia się następująco:
2WDNKE %NCUU *CU2TQVGEVGF
2TQVGEVGF %NCUU 2TQVGEVGF%NCUU
'PF %NCUU
'PF %NCUU
Klasa *CU2TQVGEVGF zawiera zagnie d oną klasę 2TQVGEVGF%NCUU. *CU2TQVGEVGF mo e
implementować egzemplarze 2TQVGEVGF%NCUU, a klasy dziedziczące z *CU2TQVGEVGF mo-
gą deklarować i tworzyć egzemplarze zagnie d onej klasy 2TQVGEVGF%NCUU.
18. 238 Część II Zaawansowane programowanie zorientowane obiektowo
(TKGPF
Klasy zaprzyjaźnione są dostępne wyłącznie w programie, w którym zostały zdefinio-
wane. Jeśli dodasz specyfikator dostępu (TKGPF do definicji klasy, egzemplarze tej klasy
mogą być tworzone wyłącznie w tym samym programie.
Załó my, e mamy bibliotekę klas z klasą o trybie dostępu (TKGPF o nazwie (TKGPF%NCUU.
Moglibyśmy utworzyć egzemplarze tej klasy w bibliotece klas, lecz nie mo emy uczynić
tego z poziomu u ytkownika tej biblioteki. Mo na zatem powiedzieć, e (TKGPF%NCUU jest
wyłącznie do u ytku wewnętrznego. Oto przykład:
(TKGPF %NCUU (TKGPF%NCUU
2WDNKE 5JCTGF 5WD 2WDNKE/GVJQF
/UI$QZ
(TKGPF%NCUU2WDNKE/GVJQF
'PF 5WD
'PF %NCUU
Korzystaj ze specyfikatora dostępu (TKGPF, gdy chcesz utworzyć klasę zawierającą detale
implementacyjne biblioteki klas lub jakiejś innej aplikacji, uniemo liwiając tym samym
dostęp do takiej klasy u ytkownikom danej aplikacji.
2TQVGEVGF (TKGPF
Klasy 2TQVGEVGF (TKGPF reprezentują połączenie specyfikatorów 2TQVGEVGF i (TKGPF.
Klasy chronione muszą być zagnie d one; z tego względu klasy 2TQVGEVGF (TKGPF rów-
nie muszą być zagnie d one. Przykład pokazuje zagnie d oną klasę 2TQVGEVGF (TKGPF:
2WDNKE %NCUU *CU2TQVGEVGF(TKGPF
2TQVGEVGF (TKGPF %NCUU 2TQVGEVGF(TKGPF
2WDNKE 5JCTGF 5WD 6GUV
/UI$QZ
6GZV
'PF 5WD
'PF %NCUU
'PF %NCUU
Klasy 2TQVGEVGF (TKGPF są najczęściej wykorzystywane jako klasy realizacyjne dla klasy,
która je zawiera. Metody definiowane w klasach zagnie d onych mogą być wywoływane
pośrednio przez metody proxy zawierającej je klasy. Nie mo esz zwrócić egzemplarza klasy
2TQVGEVGF (TKGPF. Poni szy przykład, bazując na kodzie powy ej, jest więc niepoprawny:
2WDNKE %NCUU *CU2TQVGEVGF(TKGPF
2TQVGEVGF (TKGPF %NCUU 2TQVGEVGF(TKGPF
2WDNKE 5JCTGF 5WD 6GUV
/UI$QZ
6GZV
'PF 5WD
'PF %NCUU
2WDNKE 5JCTGF (WPEVKQP (CEVQT[
#U 2TQVGEVGF(TKGPF
'PF (WPEVKQP
'PF %NCUU
19. Rozdział 7. Tworzenie klas 239
Taka definicja funkcji spowoduje wystąpienie błędu, wyraz 2TQVGEVGF(TKGPF zostanie
podkreślony linią falistą, a w liście zadań pojawi się uwaga, e (CEVQT[ niewłaściwie
udostępnia typ 2TQVGEVGF(TKGPF poza klasą RWDNKEPæ *CU2TQVGEVGF(TKGPF .
2TKXCVG
Specyfikator dostępu 2TKXCVG ma zastosowanie wyłącznie w klasach zagnie d onych.
Klasy zagnie d one 2TKXCVG reprezentują szczegóły implementacyjne danej klasy. Gdy
pojawi się wewnętrzny problem, którego rozwiązanie jest bardziej zło one i wymaga
mocy, jakiej nie są w stanie zapewnić proste metody, definiuje się wówczas zagnie -
d oną klasę prywatną, która rozwiązuje ten problem. Przykład składni takiej klasy wy-
gląda następująco:
2WDNKE %NCUU *CU2TKXCVG
2TKXCVG %NCUU 2TKXCVG%NCUU
'PF %NCUU
'PF %NCUU
Egzemplarze 2TKXCVG%NCUU mogą być tworzone wyłącznie w egzemplarzach *CU2TKXCVG.
Cel korzystania z klasy prywatnej pojawia się wówczas, gdy mamy grupę metod i wła-
ściwości i musimy przechować wiele egzemplarzy stanu ka dego z tych obiektów. Ró -
nica polega na tym, e nie chcemy, aby prywatne klasy zagnie d one były widoczne dla
u ytkownika z zewnątrz.
Stosunkowo rzadko w swych aplikacjach będziesz wykorzystywał klasy chronione i pry-
watne. Miej jednak na uwadze, e takie konstrukcje istnieją i w razie potrzeby nie bój się
ich u yć
*GTOGV[CELC K WMT[YCPKG KPHQTOCELK
Hermetyzacja i ukrywanie informacji to zagadnienia bezpośrednio związane z progra-
mowaniem zorientowanym obiektowo; mogłeś się z nimi spotkać ju wcześniej. Termi-
ny te dotyczą strategii programowania. Hermetyzacja literalnie oznacza dodawanie
składowych — pól, właściwości, metod i zdarzeń — do klas lub struktur. Ogólną zasa-
dą jest to, e składowe dodaje się w tych miejscach, w których ich pojawienie się będzie
najbardziej korzystne; to znaczy, gdzie będą mogły być najczęściej wykorzystywane lub
zapewnią najlepsze udoskonalenie Twojej implementacji.
Konsument klasy jest to programista, który tworzy egzemplarze klasy. Twórca klasy
(producent) mo e być równie jednocześnie konsumentem.
Generalizer jest konsumentem, który będzie dziedziczył Twoje klasy.
Ukrywanie informacji jest to przypisywanie egzemplarzom określonych mo liwości
dostępu — mogą one być prywatne, chronione, publiczne i zaprzyjaźnione — w celu
uwolnienia konsumentów lub generalizatorów od konieczności poznawania wszystkich
składowych danej klasy lub struktury. Ograniczając liczbę składowych klasy, których
muszą się oni nauczyć — poprzez właśnie ukrycie informacji — tworzone klasy są ła-
twiejsze do wykorzystania.
20. 240 Część II Zaawansowane programowanie zorientowane obiektowo
5RGE[HKMCVQT[ FQUVúRW
Do ukrywania informacji wykorzystuje się następujące specyfikatory dostępu: 2TKXCVG,
2TQVGEVGF, 2WDNKE, (TKGPF oraz 5JCFQYU (tymi ostatnimi zajmiemy się w dalszej części
rozdziału).
Kod klasy, który chcesz, aby był dostępny dla wszystkich, jest określany jako 2WDNKE.
Mówimy, e interfejs publiczny jest utworzony ze składowych publicznych. Składowe
2WDNKE są implementowane dla potrzeb konsumentów klas. Gdy chcesz natomiast ukryć
część informacji przed konsumentami publicznymi, jednak generalizatorzy mają mieć
mo liwość dostępu do tej informacji, zastosuj specyfikator dostępu 2TQVGEVGF.
Składowe 2TKXCVG słu ą wyłącznie do u ytku wewnętrznego i mówimy, e zawierają
szczegóły implementacyjne klasy. Ze szczegółami tymi jedynie producent klasy musi
być zaznajomiony.
Ostatnie ze specyfikatorów — (TKGPF oraz 2TQVGEVGF (TKGPF — u ywane są w tych
przypadkach, w których klasy wykorzystywane są przez jednostki w tej samej aplikacji.
Dostęp zaprzyjaźniony oznacza dostęp wyłącznie wewnątrzaplikacyjny. Na przykład,
jeśli definiujesz bibliotekę klas, a u ytkownicy z zewnątrz nie muszą lub nie powinni
mieć dostępu do niektórych klas z tej biblioteki, oznaczasz je jako klasy (TKGPF.
Ogólna zasada jest taka, e nale y wszystkie metody definiować jako 2TQVGEVGF, chyba e
muszą być publiczne. Jeśli musisz ujawniać składowe, rób to bardzo rozsądnie i rozmyślnie.
2TCEC CUKúIKGO
Zagadnienie zasięgu zostało rozszerzone w Visual Basic .NET o zasięg blokowy. Nowe
reguły rządzące zasięgami zostały przedstawione w rozdziale 3., „Podstawy programo-
wania w Visual Basic .NET”. Oprócz istniejących zasad i tych związanych z nowym
zasięgiem blokowym, pojawił się nowy aspekt pracy — wsparcie dla dziedziczenia,
wprowadzające dodatkowe względy, na które nale y zwracać uwagę.
Gdy dziedziczysz z istniejącej klasy, Twoja nowa klasa posiada w swoim zasięgu
wszystkie z odziedziczonych składników — 2TQVGEVGF, (TKGPF i 2WDNKE. Na szczęście,
Visual Basic .NET nie pozwala na pojawienie się problemów z nazwami tych składni-
ków; gdy wystąpi konflikt nazw, kompilator od razu o tym ostrze e. Będziesz mógł
wówczas zmienić nazwy konfliktowych składników, tworząc dwie oddzielne jednostki,
lub wykorzystać słowo 5JCFQYU do rozwiązania problemu. (Więcej informacji znaj-
dziesz w podrozdziale „Korzystanie z modyfikatora Shadows”).
QFCYCPKG RÎN K Y C EKYQ EK
Pole jest daną składową klasy. Pola mogą być składowymi typu 8CNWG6[RG, jak np. +P
VGIGT lub CVG, lub te typu zło onego, czyli strukturą, wyliczeniem lub klasą. Właści-
wości są specjalnymi metodami, które ogólnie u ywane są do zapewnienia określonego
dostępu do pól.
21. Rozdział 7. Tworzenie klas 241
Generalnie, pola są prywatnymi elementami klasy. Jeśli zapewniony jest dostęp do pola,
jest to zrealizowane za pomocą właściwości. Z tego powodu pola są zazwyczaj prywat-
ne, a właściwości — publiczne. Jednak e czasami pola nie są w ogóle udostępnione po-
przez właściwości. Właściwości równie nie zawsze reprezentują pole. Czasami repre-
zentują one dane istniejące w bazie danych, rejestrze systemowym, pliku INI lub inną
wartość, nie będącą bezpośrednio polem.
Motywacją tworzenia pól w postaci elementów prywatnych jest to, e nieograniczony
dostęp do danych jest z natury ryzykowny. Rozwa my sposób przyrządzania sosu ho-
lenderskiego. Jeśli ugotujesz ółtka zbyt szybko, dostaniesz jajecznicę. Jednak jeśli bę-
dziesz powoli je gotował — kurek gazu w kuchence jest tu analogią do właściwości
zmniejszającej lub zwiększającej ogień — otrzymasz prawidłową konsystencję sosu.
Kurek gazu jest metaforą na określenie metody właściwości. Pole reprezentuje ilość ciepła,
a kurek — właściwość umo liwiającą jej zmianę. Osoba obsługująca kuchenkę nie jest
uprawniona do zwiększenia ilości gazu poza określoną wartość. Wydruki 7.1 oraz 7.2
przedstawiają dwie częściowe klasy reprezentujące kuchenkę oraz ustawianie ilości wy-
pływającego gazu.
9[FTWM Klasa reprezentująca pole i właściwość dla ustawień temperatury kuchenki gazowej
2WDNKE %NCUU 5VQXG
2TKXCVG (6GORGTCVWTG #U QWDNG
2WDNKE 2TQRGTV[ 6GORGTCVWTG
#U QWDNG
)GV
4GVWTP (6GORGTCVWTG
'PF )GV
5GV
$[8CN 8CNWG #U QWDNG
GDWI#UUGTV
8CNWG #PF 8CNWG
+H
(6GORGTCVWTG 6JGP 'ZKV 2TQRGTV[
(6GORGTCVWTG 8CNWG
GDWI9TKVG.KPG
(6GORGTCVWTG
'PF 5GV
'PF 2TQRGTV[
'PF %NCUU
Na wydruku 7.1 widzimy zdefiniowane pole (6GORGTCVWTG jako QWDNG, dostępne poprzez
właściwość 6GORGTCVWTG. Metoda właściwości )GV zwraca wartość pola, a 5GV przypisuje
nową wartość do wartości pola. W wierszu 13. sprawdzany jest warunek, czy nie zostały
ustawione niedopuszczalne wartości temperatury podczas tworzenia klasy. Przy jej wdra-
aniu metoda GDWI#UUGTV zostanie wyłączona przez kompilator. Jeśli 5VQXG byłaby u y-
wana do kontroli rzeczywistej kuchenki, na pewno nie chciałbyś, aby temperatura mogła
przekroczyć mo liwości fizyczne kuchenki. W celu upewnienia się, e ustawienia tempe-
ratury są prawidłowe podczas normalnej pracy urządzenia, w wierszu 13. skorzystano
z lustrzanego warunku +H w celu utrzymania temperatury w dopuszczalnych granicach.