Visual Basic .NET. Księga eksperta

1,301 views

Published on

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ę.

Published in: Technology, Business
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
1,301
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
11
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Visual Basic .NET. Księga eksperta

  1. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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.

×