Darmowy fragment publikacji:
Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej
publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną,
fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym
powoduje naruszenie praw autorskich niniejszej publikacji.
Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi
ich właścicieli.
Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje
były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie,
ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz
Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody
wynikłe z wykorzystania informacji zawartych w książce.
Redaktor prowadzący: Ewelina Burska
Projekt okładki: Magdalena Stasik
Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock.
Wydawnictwo HELION
ul. Kościuszki 1c, 44-100 GLIWICE
tel. 32 231 22 19, 32 230 98 63
e-mail: helion@helion.pl
WWW: http://helion.pl (księgarnia internetowa, katalog książek)
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie?vbnepr
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Dodatkowe materiały do książki są dostępne pod adresem:
ftp://ftp.helion.pl/przyklady/vbnepr.zip
ISBN: 978-83-246-4898-6
Copyright © Helion 2012
Printed in Poland.
• Kup książkę
• Poleć książkę
• Oceń książkę
• Księgarnia internetowa
• Lubię to! » Nasza społeczność
Spis treĈci
Wstöp ............................................................................................ 11
CzöĈè I Projektowanie aplikacji Windows .................................. 13
Rozdziaä 1. ćrodowisko Visual Studio ................................................................ 15
Projektowanie interfejsu aplikacji .................................................................................. 15
Tworzenie projektu .................................................................................................. 16
Dokowanie palety komponentów Toolbox ............................................................... 18
Tworzenie interfejsu za pomocą komponentów Windows Forms ............................ 19
Zapisywanie i wczytywanie projektu ....................................................................... 20
Ukryta prawda ................................................................................................................ 21
Analiza kodu pierwszej aplikacji .................................................................................... 22
Metody zdarzeniowe ....................................................................................................... 26
Metoda uruchamiana w przypadku wystąpienia zdarzenia kontrolki ....................... 26
Testowanie metody zdarzeniowej ............................................................................ 27
Przypisywanie istniejącej metody do zdarzeĔ komponentów ................................... 29
Edycja metody zdarzeniowej .................................................................................... 30
Modyfikowanie wáasnoĞci komponentów ................................................................ 30
Wywoáywanie metody zdarzeniowej z poziomu kodu ............................................. 31
Reakcja aplikacji na naciskanie klawiszy ................................................................. 32
Platforma aplikacji (application framework) .................................................................. 32
Rozdziaä 2. Debugowanie kodu ......................................................................... 35
Skąd biorą siĊ báĊdy i jak ich unikaü? ............................................................................. 35
Kontrolowane uruchamianie aplikacji ............................................................................ 36
Program z báĊdem — pole do popisu dla debuggera ................................................ 36
ĝledzenie wykonywania programu krok po kroku (klawisze F10 i F11) .................. 37
Run to Cursor (klawisze Ctrl+F10) .......................................................................... 38
Breakpoint (klawisz F9) ........................................................................................... 39
Okna Locals i Watch ................................................................................................ 40
Stan wyjątkowy .............................................................................................................. 42
Przechwytywanie wyjątków w konstrukcji try..catch ............................................... 43
Zgáaszanie wyjątków ................................................................................................ 45
4
Visual Basic .NET w praktyce. Bäyskawiczne tworzenie aplikacji
Rozdziaä 3. Jözyk Visual Basic .......................................................................... 47
Platforma .NET .............................................................................................................. 47
Trivia .............................................................................................................................. 49
Podstawowe typy danych ............................................................................................... 49
Deklaracja i zmiana wartoĞci zmiennej .................................................................... 49
Typy liczbowe oraz znakowy ................................................................................... 50
Opcje Strict, Infer i Explicit ..................................................................................... 53
Priorytety operatorów ............................................................................................... 56
Weryfikacja typów ................................................................................................... 58
àaĔcuchy .................................................................................................................. 59
Weryfikowanie zgodnoĞci áaĔcucha ze wzorcem ..................................................... 62
Typ wyliczeniowy .................................................................................................... 63
Leniwe inicjowanie zmiennych ................................................................................ 65
Funkcje i metody ............................................................................................................ 65
PrzeciąĪanie metod ................................................................................................... 66
DomyĞlne wartoĞci argumentów metod — argumenty opcjonalne .......................... 67
WartoĞci zwracane przez metody ............................................................................. 68
Zwracanie wartoĞci przez argument metody (ByRef) .............................................. 68
Delegacje i zdarzenia ............................................................................................... 70
WyraĪenia lambda .................................................................................................... 71
Typy wartoĞciowe i referencyjne .................................................................................... 72
Nullable .................................................................................................................... 74
Pudeákowanie ........................................................................................................... 75
Sterowanie przepáywem ................................................................................................. 76
Instrukcja warunkowa If..Else .................................................................................. 76
Instrukcja wyboru Select .......................................................................................... 77
PĊtle .......................................................................................................................... 77
Wyjątki ........................................................................................................................... 79
Dyrektywy preprocesora ................................................................................................. 82
Kompilacja warunkowa — ostrzeĪenia .................................................................... 82
Definiowanie staáych preprocesora .......................................................................... 83
Bloki ......................................................................................................................... 83
Atrybuty ......................................................................................................................... 84
Kolekcje ......................................................................................................................... 84
„Zwykáe” tablice ...................................................................................................... 85
PĊtla foreach ............................................................................................................. 88
Sortowanie ............................................................................................................... 89
Kolekcja List ............................................................................................................ 90
Kolekcja SortedList i inne sáowniki ......................................................................... 91
Kolejka i stos ............................................................................................................ 92
Rozdziaä 4. Projektowanie zorientowane obiektowo ........................................... 95
Przykáad struktury (Ulamek) .......................................................................................... 96
Przygotowanie projektu ............................................................................................ 96
Konstruktor i wspóádzielone obiekty skáadowe ........................................................ 97
Pierwsze testy ........................................................................................................... 98
Konwersje na áaĔcuch (metoda ToString) i na typ double ........................................ 99
Metoda upraszczająca uáamek .................................................................................. 99
WáasnoĞci ............................................................................................................... 100
Operatory arytmetyczne ......................................................................................... 101
Operatory porównania oraz metody Equals i GetHashCode .................................. 103
Operatory konwersji ............................................................................................... 104
Implementacja interfejsu (na przykáadzie IComparable) .............................................. 105
Spis treĈci
5
Definiowanie typów parametrycznych ......................................................................... 107
Definiowanie typów ogólnych ............................................................................... 108
OkreĞlanie warunków, jakie mają speániaü parametry ............................................ 109
Implementacja interfejsów przez typ ogólny .......................................................... 110
Definiowanie aliasów ............................................................................................. 112
Typy ogólne z wieloma parametrami ..................................................................... 113
Rozszerzenia ................................................................................................................. 114
Sáowo kluczowe With ................................................................................................... 116
Typy anonimowe .......................................................................................................... 117
Rozdziaä 5. Przeglñd komponentów biblioteki Windows Forms .......................... 119
Notatnik.NET ............................................................................................................... 119
Projektowanie interfejsu aplikacji i menu gáówne .................................................. 120
Okna dialogowe i pliki tekstowe ............................................................................ 126
Edycja i korzystanie ze schowka ............................................................................ 134
Drukowanie ............................................................................................................ 135
Elektroniczna kukuáka .................................................................................................. 145
Ekran powitalny (splash screen) ............................................................................. 145
Przygotowanie ikony w obszarze powiadamiania .................................................. 148
Odtwarzanie pliku dĨwiĊkowego ........................................................................... 151
Ustawienia aplikacji ..................................................................................................... 153
Tworzenie ustawieĔ w trakcie projektowania aplikacji .......................................... 153
Odczytywanie ustawieĔ z poziomu kodu ............................................................... 154
Zapisywanie ustawieĔ z poziomu kodu .................................................................. 155
Dywan graficzny .......................................................................................................... 156
Zdarzenie Paint formy ............................................................................................ 156
Kolorowy wzór ....................................................................................................... 157
Buforowanie ........................................................................................................... 158
Zapisywanie obrazu dywanu do pliku .................................................................... 159
Rysowanie zbiorów Mandelbrota i Julii ....................................................................... 160
TrochĊ teorii ........................................................................................................... 160
Implementacja ........................................................................................................ 163
Lista uruchomionych procesów .................................................................................... 166
Rozdziaä 6. Przeciñgnij i upuĈè ........................................................................ 169
Podstawy ...................................................................................................................... 169
Interfejs przykáadowej aplikacji ............................................................................. 170
Inicjacja procesu przeciągania ................................................................................ 171
Akceptacja upuszczenia elementu .......................................................................... 173
Reakcja na upuszczenie elementu .......................................................................... 174
CzynnoĞci wykonywane po zakoĔczeniu procesu przenoszenia i upuszczania ...... 175
Przenoszenie elementów miĊdzy róĪnymi aplikacjami .......................................... 176
Zagadnienia zaawansowane .......................................................................................... 176
OpóĨnione inicjowanie procesu przenoszenia ........................................................ 176
Przenoszenie wielu elementów ............................................................................... 179
Przenoszenie plików ............................................................................................... 181
Rozdziaä 7. Przezroczyste okna o dowolnym ksztaäcie ...................................... 183
Konfiguracja formy ...................................................................................................... 183
Wczytywanie obrazu .................................................................................................... 184
PrzezroczystoĞü i áagodne znikanie okna ...................................................................... 186
Zamykanie klawiszem Esc ........................................................................................... 187
Przenoszenie formy za dowolny punkt ......................................................................... 188
Menu kontekstowe ........................................................................................................ 189
6
Visual Basic .NET w praktyce. Bäyskawiczne tworzenie aplikacji
Rozdziaä 8. Projektowanie kontrolek ............................................................... 193
Komponent FileListBox ............................................................................................... 194
Implementacja podstawowych funkcjonalnoĞci ..................................................... 194
Rozbudowa komponentu o moĪliwoĞü zmiany katalogu ........................................ 203
WáaĞciwoĞci ........................................................................................................... 205
Zdarzenia — interakcja z komponentem ................................................................ 210
OdĞwieĪanie komponentu i automatyczne Ğledzenie zmian
w prezentowanym katalogu ................................................................................. 216
Kompilacja komponentu do postaci biblioteki DLL .............................................. 219
Prosty przykáad wykorzystania komponentu FileListBox:
przeglądanie plików tekstowych .......................................................................... 224
Kolorowy pasek postĊpu .............................................................................................. 228
Tworzenie projektu ................................................................................................ 228
Rysowanie obramowania kontrolki ........................................................................ 229
Pola i wáasnoĞci ...................................................................................................... 230
Rysowanie paska postĊpu ....................................................................................... 233
Metody ................................................................................................................... 234
Zdarzenia ................................................................................................................ 235
Rozdziaä 9. Zarzñdzane biblioteki DLL i mechanizm rozpoznawania typów ......... 239
Tworzenie zarządzanej biblioteki DLL ........................................................................ 240
Projekt biblioteki DLL ........................................................................................... 240
Dodawanie referencji do biblioteki systemowej platformy .NET ........................... 241
WyĞwietlanie informacji o systemie i platformie .NET ......................................... 242
Zmiana przestrzeni nazw biblioteki .............................................................................. 243
Statyczne áadowanie bibliotek DLL ............................................................................. 243
Doáączanie do projektu bibliotek DLL uĪytkownika .............................................. 243
Dynamiczne áadowanie zarządzanych bibliotek DLL
i dynamiczne rozpoznawanie typów .......................................................................... 245
Dynamiczne áadowanie zarządzanej biblioteki .dll ................................................ 245
Analiza zawartoĞci biblioteki zaáadowanej dynamicznie ....................................... 246
Weryfikacja obecnoĞci w bibliotece DLL klasy o znanej nazwie .......................... 247
Lista metod w klasie z biblioteki DLL ................................................................... 248
Weryfikacja obecnoĞci konkretnej metody w klasie z biblioteki DLL ................... 249
Lista argumentów wybranej metody ...................................................................... 250
Uruchamianie metody wspóádzielonej z klasy wczytanej z biblioteki DLL ........... 252
Uruchamianie metody na rzecz instancji obiektu.
Przekazywanie parametrów i odczytywanie zwracanej wartoĞci ......................... 254
PóĨne wiązanie na typie Object .................................................................................... 255
Rozdziaä 10. Aplikacje konsolowe i informacje o systemie ................................ 257
Klasa Console ............................................................................................................... 257
Projekt aplikacji konsolowej .................................................................................. 257
Drukowanie napisów w konsoli ............................................................................. 259
Czekanie na akceptacjĊ uĪytkownika ..................................................................... 259
Odczytywanie danych z klawiatury ........................................................................ 260
Komunikat „okienkowy” w aplikacji konsolowej .................................................. 261
Informacje o Ğrodowisku aplikacji ................................................................................ 262
Podstawowe informacje o systemie i profilu uĪytkownika .................................... 263
Katalogi specjalne zdefiniowane w bieĪącym profilu uĪytkownika ....................... 264
Odczytywanie zmiennych Ğrodowiskowych ........................................................... 264
Lista dysków logicznych ........................................................................................ 265
Spis treĈci
7
Rozdziaä 11. Wñtki, równolegäa pötla Parallel.For
oraz programowanie asynchroniczne (Async/Await) .................... 267
Monte Carlo .................................................................................................................. 268
Obliczenia bez uĪycia dodatkowych wątków ............................................................... 269
Przeniesienie obliczeĔ do osobnego wątku ................................................................... 270
Usypianie wątku ........................................................................................................... 272
Przerywanie dziaáania wątku (Abort) ........................................................................... 273
Wstrzymywanie i wznawianie dziaáania wątku ............................................................ 274
Wątki dziaáające w tle ................................................................................................... 275
Zmiana priorytetu wątku .............................................................................................. 276
UĪycie wielu wątków i problemy z generatorem liczb pseudolosowych ...................... 276
Czekanie na ukoĔczenie pracy wątku (Join) ................................................................. 280
Sekcje krytyczne (lock) ................................................................................................ 282
Przesyáanie danych do wątku ........................................................................................ 283
Pula wątków ................................................................................................................. 285
Jeszcze raz o komunikacji miĊdzy wątkami ................................................................. 288
Korzystanie z muteksów w celu zapobiegania
uruchamianiu wielu instancji aplikacji ....................................................................... 290
Klasa Parallel z biblioteki TPL ..................................................................................... 290
Równolegáa pĊtla For ............................................................................................. 291
Przerywanie pĊtli .................................................................................................... 293
Programowanie asynchroniczne (Async/Await) ........................................................... 294
Rozdziaä 12. Podstawy ADO.NET i SQL Server .................................................. 297
Bardzo krótki wstĊp do SQL ........................................................................................ 298
Select ...................................................................................................................... 298
Insert ...................................................................................................................... 299
Delete ..................................................................................................................... 299
Aplikacje „bazodanowe” .............................................................................................. 299
Projekt aplikacji z bazą danych .............................................................................. 299
Konfiguracja komponentu DataSet ........................................................................ 302
Server Explorer ...................................................................................................... 304
Podgląd danych udostĊpnianych przez komponent DataSet ................................... 304
Prezentacja danych w siatce DataGridView ........................................................... 305
Edycja danych ........................................................................................................ 307
Projektowanie formularzy prezentujących pojedyncze rekordy ............................. 309
Sortowanie ............................................................................................................. 312
Filtrowanie ............................................................................................................. 312
Odczytywanie z poziomu kodu wartoĞci przechowywanych w komórkach ........... 313
CzöĈè II LINQ .......................................................................... 315
Rozdziaä 13. Wprowadzenie do zapytaþ LINQ
na przykäadzie kolekcji (LINQ to Objects) .................................... 317
Pobieranie danych (filtrowanie i sortowanie) ............................................................... 319
Najprostsza prezentacja pobranych danych .................................................................. 320
Analiza pobranych danych ........................................................................................... 320
Wybór elementu ........................................................................................................... 320
Weryfikowanie danych ................................................................................................. 321
Prezentacja w grupach .................................................................................................. 321
àączenie zbiorów danych ............................................................................................. 322
àączenie danych z róĪnych Ĩródeá w zapytaniu LINQ — operator join ....................... 322
MoĪliwoĞü modyfikacji danych Ĩródáa ......................................................................... 323
8
Visual Basic .NET w praktyce. Bäyskawiczne tworzenie aplikacji
Rozdziaä 14. LINQ to DataSet .......................................................................... 325
Konfiguracja kontrolki DataSet .................................................................................... 326
LINQ to DataSet, czyli tam i z powrotem .................................................................... 328
Rozszerzenie AsEnumerable klasy DataTable ............................................................. 332
Obliczenia wykonywane na danych z tabeli ........................................................... 332
DowolnoĞü sortowania i filtrowania pobieranych danych ...................................... 332
Rozdziaä 15. LINQ to SQL ................................................................................. 335
Klasa encji .................................................................................................................... 336
Pobieranie danych ........................................................................................................ 337
Aktualizacja danych w bazie ........................................................................................ 338
Modyfikacje istniejących rekordów ....................................................................... 339
Dodawanie i usuwanie rekordów ........................................................................... 340
Inne operacje .......................................................................................................... 341
Wizualne projektowanie klasy encji ............................................................................. 342
O/R Designer .......................................................................................................... 342
Wspóápraca z kontrolkami tworzącymi interfejs aplikacji ..................................... 346
Kreator Ĩródáa danych i automatyczne tworzenie interfejsu uĪytkownika ............. 347
àączenie danych z dwóch tabel — operator join .................................................... 349
Relacje (Associations) ............................................................................................ 351
Korzystanie z procedur skáadowanych ......................................................................... 353
Pobieranie danych za pomocą procedur skáadowanych .......................................... 353
Modyfikowanie danych za pomocą procedur skáadowanych ................................. 355
Wykonywanie dowolnych poleceĔ SQL ................................................................ 355
Rozdziaä 16. Kilka sposobów na odczytywanie
i zapisywanie danych w plikach XML .......................................... 357
Podstawy jĊzyka XML ................................................................................................. 357
Deklaracja .............................................................................................................. 358
Elementy ................................................................................................................ 358
Atrybuty ................................................................................................................. 359
Komentarze ............................................................................................................ 359
Klasy XmlTextReader i XmlTextWriter ...................................................................... 359
Zapis do pliku XML ............................................................................................... 359
Odczyt danych z pliku XML .................................................................................. 361
Analiza i odczyt pliku XML o nieznanej strukturze ............................................... 363
Serializacja obiektów do pliku XML ............................................................................ 365
Serializacja obiektu do pliku XML ........................................................................ 366
Deserializacja obiektu z pliku XML ....................................................................... 367
XML i ADO.NET ......................................................................................................... 368
Wczytywanie danych z pliku XML do komponentu DataSet ................................. 369
Zapisywanie zmian do pliku XML za poĞrednictwem DataSet .............................. 370
LINQ to XML .............................................................................................................. 371
Tworzenie pliku XML za pomocą klas XDocument i XElement ........................... 371
Pobieranie wartoĞci z elementów o znanej pozycji w drzewie ............................... 373
Przenoszenie danych z kolekcji do pliku XML ...................................................... 375
Przenoszenie danych z bazy danych (komponentu DataSet) do pliku XML .......... 377
Zapytania LINQ ..................................................................................................... 378
Modyfikacja pliku XML ........................................................................................ 379
Spis treĈci
9
CzöĈè III Technologie Windows ................................................. 381
Rozdziaä 17. Rejestr systemu Windows ............................................................ 383
Korzystanie z rejestru ................................................................................................... 383
Odczytywanie danych z rejestru ............................................................................. 383
Zapisywanie oraz odczytywanie poáoĪenia
i rozmiaru formy w prywatnym kluczu aplikacji ................................................. 386
Usuwanie klucza z rejestru ..................................................................................... 388
Przeglądarka skojarzeĔ plików ..................................................................................... 389
Informacja o typach plików przechowywana w rejestrze ....................................... 389
Przygotowanie interfejsu ........................................................................................ 391
Odczytywanie listy rozszerzeĔ ............................................................................... 392
Pobieranie opisu, polecenia gáównego
i domyĞlnego edytora dla podanego typu plików ................................................. 394
Rozdziaä 18. Mechanizm PInvoke ..................................................................... 399
Funkcja bez argumentów .............................................................................................. 399
Problemy z argumentami .............................................................................................. 401
Zwracanie wartoĞci przez argumenty ........................................................................... 403
Zwracanie tablicy znaków w funkcjach WinAPI .......................................................... 406
Rozdziaä 19. Komunikaty Windows ................................................................... 407
Wysyáanie komunikatów Windows .............................................................................. 407
Identyfikacja aplikacji ............................................................................................ 408
Wysyáanie komunikatu do okna o znanym uchwycie ............................................. 409
Komunikaty jako sposób porozumiewania siĊ z systemem .................................... 410
Odbieranie komunikatów Windows ............................................................................. 411
Monitor komunikatów ............................................................................................ 411
Reakcja na wybrany komunikat ............................................................................. 412
Skorowidz ..................................................................................................... 415
10
Visual Basic .NET w praktyce. Bäyskawiczne tworzenie aplikacji
Rozdziaä 2.
Debugowanie kodu
Skñd biorñ siö bäödy i jak ich unikaè?
Za báĊdy w kodzie jest (niemal) wyáącznie odpowiedzialny programista. Ale to oczy-
wiste stwierdzenie niewiele nam pomaga w ich unikaniu. Zresztą báĊdów w ogóle nie
moĪna uniknąü. Ich powstawanie jest nierozerwalnie związane z samym procesem
tworzenia kodu. Co wiĊcej, liczba báĊdów w kodzie zaleĪy proporcjonalnie od liczby
linii kodu, a wspóáczynnik proporcjonalnoĞci jest powiązany ze stopniem doĞwiad-
czenia i niewyspania programisty. Prosty wniosek jest taki, Īe pisany przez nas kod
powinien mieü jak najmniejszą liczbĊ linii. Do tego celu trzeba dąĪyü za pomocą
wszelkich moĪliwych sposobów i sztuczek. Przede wszystkim naleĪy unikaü powta-
rzania kodu. Lepiej przygotowaü jedną metodĊ, którą moĪemy porządnie przetestowaü,
niĪ powielaü jej fragmenty w kilku miejscach, co uniemoĪliwia ich kontrolĊ w przy-
padku jakichkolwiek modyfikacji. Zatem lepiej wywoáaü porządnie napisaną metodĊ,
zamiast korzystaü z „kopiuj i wklej”. Poza tym, jeĪeli moĪemy uĪyü gotowego przete-
stowanego kodu (np. kontrolki), to warto z tego skorzystaü. W tworzeniu kodu moĪe nas
teĪ wyrĊczyü Ğrodowisko programistyczne. W przypadku aplikacji Windows Forms dzieje
siĊ tak zresztą juĪ w momencie, gdy bawiąc siĊ myszą, budujemy interfejs aplikacji.
Z pozornie bezuĪytecznego faktu, Īe báĊdów w kodzie nie da siĊ uniknąü, co dobitnie
wyraĪa prawo Murphy’ego: „Nie ma aplikacji bez báĊdów”, moĪna wyciągnąü jeszcze
jeden wniosek: otóĪ, skoro wystĊpowanie báĊdów jest niemal pewne, trzeba siĊ na nie
przygotowaü. Nie moĪna zakáadaü, Īe báĊdy bĊdą zdarzaü siĊ na tyle rzadko, iĪ praw-
dopodobieĔstwo ich wystąpienia bĊdzie tak maáe, Īe nie bĊdą dla uĪytkownika uciąĪliwe.
Inne prawo Murphy’ego mówi bowiem: „JeĪeli báąd moĪe wystąpiü, wystąpi na pewno,
i to w takim momencie, gdy uĪytkownikowi dopiecze to najbardziej” (np. gdy koĔ-
cząc pracĊ nad dokumentem, bĊdzie chciaá zapisaü go do pliku). Jak wspomniaáem,
jest zatem konieczne przygotowanie programu na moĪliwoĞü wystąpienia báĊdów. Korzy-
stajmy wobec tego z obsáugi wyjątków w kaĪdej budzącej wątpliwoĞci sytuacji, nawet
tam, gdzie — jak siĊ nam wydaje — usunĊliĞmy juĪ wszystkie usterki. PrzemyĞlana
reakcja na wyjątki moĪe pozwoliü na zminimalizowanie skutków wystąpienia báĊdu,
czasem nawet do tego stopnia, Īe uĪytkownik nie musi siĊ dowiedzieü, iĪ coĞ záego
siĊ wydarzyáo.
36
CzöĈè I i Projektowanie aplikacji Windows
Teoria Murphy’ego wypowiada siĊ takĪe na temat najmniej lubianej czynnoĞci pro-
gramistów, a wiĊc na temat testowania i tropienia báĊdów logicznych z kodu. Jak juĪ
wiemy, nie ma aplikacji bezbáĊdnych, liczbĊ báĊdów moĪna jedynie redukowaü. NaleĪy
jednak zdawaü sobie sprawĊ, Īe tzw. znalezienie ostatniego báĊdu to idea regulatywna
debugowania. NaleĪy w nią wierzyü, ale z góry wiadomo, Īe jest nieosiągalna. Warto
teĪ uĞwiadomiü sobie zaskakującą, ale w Ğwietle teorii Murphy’ego oczywistą prawdĊ:
poprawiając báĊdy w kodzie, tworzymy nowe.
Kontrolowane uruchamianie aplikacji
Na szczĊĞcie, w procesie usuwania báĊdów (debugowania) kodu Visual Basic dla platfor-
my .NET mamy potĊĪnego sprzymierzeĔca. Jest nim Ğrodowisko programistyczne Visual
Studio z wbudowanym debuggerem, wskazującym linie kodu, które nie podobają siĊ
kompilatorowi, pozwalającym na kontrolĊ uruchamianego kodu, a nawet na Ğledzenie
jego wykonywania linia po linii. Przyjrzyjmy siĊ bliĪej kilku jego moĪliwoĞciom.
Program z bäödem — pole do popisu dla debuggera
Zacznijmy od przygotowania aplikacji, której metody zawierają báąd powodujący
wystąpienie wyjątku. W tym celu:
1. Utwórz nowy projekt typu Windows Forms Application o nazwie Debugowanie.
2. W widoku projektowania umieĞü na formie przycisk Button.
3. Kliknij dwukrotnie ów przycisk, aby utworzyü domyĞlną metodĊ zdarzeniową
(w tym przypadku do zdarzenia Button1.Click). Zostaniesz automatycznie
przeniesiony do edytora kodu.
4. Zanim uzupeánisz zawartoĞü metody zdarzeniowej, utwórz definicjĊ metody
Kwadrat (umieĞü ją np. bezpoĞrednio przed utworzonym automatycznie
„szkieletem” metody Button1_Click, listing 2.1).
Listing 2.1. Metoda, w której ukryliĞmy perfidny báąd
Public Class Form1
Private Function Kwadrat(argument As Integer) As Integer
Dim wartosc As Integer
wartosc = argument * argument
Return wartosc
End Function
Private Sub Button1_Click(sender As System.Object, e As System.EventArgs)
´Handles Button1.Click
End Sub
End Class
Rozdziaä 2. i Debugowanie kodu
37
5. Teraz przejdĨ do metody Button1_Click i wpisz do niej polecenia wyróĪnione
w listingu 2.2.
Listing 2.2. Z pozoru wszystko jest w porządku…
Private Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles
´Button1.Click
Dim x As Integer = 1234
Dim y As Integer = Kwadrat(x)
y = Kwadrat(y)
Dim sy As String = y.ToString()
MessageBox.Show( Wynik: sy)
End Sub
OczywiĞcie, obie metody moĪna by „skompresowaü” do jednej lub dwóch linii, ale
wáaĞnie taka forma uáatwi naukĊ debugowania.
Uruchomimy najpierw aplikacjĊ (klawisz F5), Īeby przekonaü siĊ, Īe nie dziaáa prawi-
dáowo. Po klikniĊciu przycisku zamiast komunikatu z wynikiem zobaczymy komuni-
kat o wyjątku z informacją, Īe nastąpiáo przekroczenie zakresu zmiennej (Arithmetic
operation resulted in an overflow). Miejsce wystąpienia wyjątku wskaĪe nam Ğro-
dowisko Visual Studio — program zatrzyma siĊ na mnoĪeniu w metodzie Kwadrat.
Nie jest jednak oczywiste, które wywoáanie tej metody (a wywoáywana jest dwa razy)
prowadzi do báĊdu. Mamy zatem do czynienia z báĊdem logicznym ukrytym gdzieĞ
w naszym kodzie. I to wáaĞnie jego tropienie bĊdzie motywem przewodnim wiĊkszej
czĊĞci tego rozdziaáu.
ćledzenie wykonywania programu krok po kroku
(klawisze F10 i F11)
NaciĞnijmy klawisz F10 lub F11 (wszystkie klawisze skrótów wykorzystywane podczas
debugowania zebrane zostaáy w tabeli 2.1). JeĪeli wáączona jest wspomniana w po-
przednim rozdziale platforma aplikacji (ang. application framework), to aplikacja
uruchomi siĊ normalnie. Dopiero gdy klikniemy przycisk na formie, jej dziaáanie za-
trzyma siĊ i zobaczymy zaznaczoną na Īóáto sygnaturĊ metody zdarzeniowej związanej
z tym zdarzeniem (rysunek 2.1). Inaczej jest, gdy platforma aplikacji jest wyáączona,
a my zdefiniowaliĞmy wáasną metodĊ Main. Wówczas po naciĞniĊciu F10 lub F11 na
Īóáto zaznaczona zostanie jej sygnatura, a Ğrodowisko bĊdzie czekaáo na dalsze polecenia.
KaĪde naciĞniĊcie klawisza F10 powoduje wówczas wykonanie jednej linii kodu (tej
zaznaczonej na Īóáto), bez wzglĊdu na to, czy jest to inicjacja zmiennej, czy wywoáanie
metody. CzynnoĞü taka nazywa siĊ Step Over (menu Debug), czyli „krok nad”. Na-
zwa bierze siĊ z tego, Īe jeĪeli w wykonywanej linii znajduje siĊ wywoáanie metody,
jest ona wykonywana w caáoĞci. Natomiast F11 powoduje wykonanie „kroku w gáąb”
(ang. step into), co w przypadku wywoáania metody oznacza, Īe zostaniemy przenie-
sieni do pierwszej linii jej definicji i tam bĊdziemy kontynuowaü Ğledzenie dziaáania
aplikacji. W przypadku gdy ta metoda zawiera wywoáanie kolejnej metody, klawisze
F10 i F11 pozwolą zdecydowaü, czy chcemy ją wykonaü w caáoĞci, czy przeanalizowaü
linia po linii. JeĪeli zorientujemy siĊ, Īe zeszliĞmy zbyt gáĊboko — moĪemy nacisnąü
Shift+F11, aby wykonaü pozostaáą czĊĞü metody i ją opuĞciü (ang. step out — wyjĞcie z).
38
CzöĈè I i Projektowanie aplikacji Windows
Tabela 2.1. Związane z debugowaniem klawisze skrótów Ğrodowiska Visual Basic
Funkcja
Uruchomienie z debugowaniem
Uruchomienie bez debugowania
Uruchomienie i zatrzymanie w linii, w której jest kursor
Krok do nastĊpnej linii kodu (Step over)
Krok z wejĞciem w gáąb metody (Step into)
Krok z wyjĞciem z metody (Step out)
Ustawienie breakpointu (funkcja edytora)
ZakoĔczenie debugowania (zakoĔczenie dziaáania aplikacji)
Klawisz skrótu
F5
Ctrl+F5
Ctrl+F10
F10
F11
Shift+F11
F9
Shift+F5
Rysunek 2.1. Na rysunku rozwiniĊte jest menu Debug, zawierające instrukcje sterujące procesem
kontrolowanego uruchamiania aplikacji
Run to Cursor (klawisze Ctrl+F10)
W przypadku gdy platforma aplikacji jest wyáączona i mamy zdefiniowaną metodĊ
Main, korzystanie z klawiszy F10 i F11 moĪe nie byü zbyt wygodne. Dla przykáadu,
jeĪeli interesuje nas tylko kod metody zdarzeniowej Button1_Click, to przechodzenie
krok po kroku przez zawartoĞü metody Main jest caákowicie zbĊdne. Wówczas wy-
godniej jest posáuĪyü siĊ kombinacją klawiszy Ctrl+F10. Podobnie jak klawisz F5,
uruchamia ona aplikacjĊ, ale zatrzymuje ją w momencie, gdy wykonana ma byü in-
strukcja z linii, w której znajduje siĊ kursor edytora. Ta kombinacja klawiszy dziaáa
takĪe wtedy, gdy aplikacja jest juĪ uruchomiona w trybie debugowania. Po zatrzymaniu
Rozdziaä 2. i Debugowanie kodu
39
dziaáania aplikacji znowu moĪemy korzystaü z klawiszy F10 i F11 do Ğledzenia dziaáa-
nia metod krok po kroku.
Aby natychmiast przerwaè debugowanie programu i powróciè do normalnego trybu
edycji Visual Studio, naleĔy nacisnñè klawisze Shift+F5.
Breakpoint (klawisz F9)
Gdy przewidujemy, Īe bĊdziemy wielokrotnie kontrolowaü wykonywanie pewnych
poleceĔ, np. z metody Button1_Click, moĪemy w jej pierwszej linii ustawiü tzw. bre-
akpoint. W tym celu przechodzimy do wybranej linii w edytorze kodu i naciskamy
klawisz F9. Linia zostanie zaznaczona bordowym kolorem oraz czerwoną kropką na
lewym marginesie (rysunek 2.2). Po uruchomieniu programu w trybie debugowania jego
dziaáanie zostanie zatrzymane, gdy wątek dotrze do tej linii. MoĪemy wówczas obejrzeü
wartoĞci zmiennych (o tym za chwilĊ), przejĞü do Ğledzenia kodu (klawisze F10 i F11) lub
nacisnąü klawisz F5, aby wznowiü jego dziaáanie w normalnym trybie debugowania. Gdy
jednak wątek znowu dotrze do linii z ustawionym breakpointem, dziaáanie programu
jeszcze raz zostanie wstrzymane. Aby anulowaü breakpoint, naleĪy ustawiü kursor
w odpowiedniej linii i jeszcze raz nacisnąü F9 lub kliknąü widoczną na lewym marginesie
czerwoną kropkĊ.
Rysunek 2.2. WyróĪnienie linii kodu, w której ustawiony jest breakpoint
Breakpoint bywa szczególnie poĪyteczny przy Ğledzeniu wykonywania pĊtli. JeĪeli
ustawimy go w interesującej nas linii wewnątrz pĊtli, kaĪda jej iteracja zostanie prze-
rwana, co pozwala np. na przyjrzenie siĊ wartoĞciom zmiennych.
40
CzöĈè I i Projektowanie aplikacji Windows
Okna Locals i Watch
MoĪliwoĞü obserwacji wartoĞci zmiennych uĪywanych w programie to bardzo waĪne
narzĊdzie debuggerów. DziĊki niemu moĪemy w kaĪdej chwili sprawdziü, czy warto-
Ğci zmiennych są zgodne z naszymi oczekiwaniami, a to pozwala oceniü, czy program
dziaáa prawidáowo. Wykonywanie aplikacji linia po linii z równoczesnym wpatrywa-
niem siĊ w wartoĞci zmiennych jest w praktyce najczĊĞciej wykorzystywanym sposo-
bem na odszukanie owego „ostatniego báĊdu”. W Visual Studio sáuĪy do tego okno
Locals (rysunek 2.3), które zawiera listĊ wszystkich pól zadeklarowanych wewnątrz
obiektów i zmiennych lokalnych zadeklarowanych w aktualnie wykonywanej meto-
dzie wraz z ich wartoĞciami. JeĪeli zmienne są obiektami, moĪemy zobaczyü takĪe
ich pola skáadowe. Poza tym mamy do dyspozycji okno Watch, do którego moĪemy
dodaü nie tylko poszczególne pola i zmienne, ale równieĪ poprawne wyraĪenia jĊzyka
Visual Basic, np. x*x.
Rysunek 2.3. Podglądanie wartoĞci zmiennych w edytorze
WartoĈci zmiennych moĔna równieĔ zobaczyè, jeĔeli w trybie debugowania w edytorze
przytrzymamy przez chwilö kursor myszy nad zmiennñ widocznñ w kodzie. Po chwili
pojawi siö okienko podpowiedzi zawierajñce wartoĈè wskazanej w ten sposób
zmiennej (rysunek 2.4). NaleĔy jednak pamiötaè, Ĕe pokazywana wartoĈè dotyczy
aktualnie wykonywanej linii, a nie linii wskazanej kursorem. W Visual Studio 2010
takñ podejrzanñ w oknie edytora wartoĈè moĔna przypiñè (ikona pinezki), przez co
podczas pracy w trybie debugowania pozostaje stale widoczna na ekranie (rysunek
2.4). MoĔliwoĈè podglñdania wartoĈci zmiennych w oknie edytora dotyczy takĔe
obiektów — zobaczymy wówczas wartoĈci wszystkich dostöpnych pól i wäasnoĈci.
Rozdziaä 2. i Debugowanie kodu
41
Rysunek 2.4. U doáu okna VS widoczne są dwa podokna: z lewej okno Locals, z prawej — Call Stack
PrzejdĨmy w edytorze kodu (zakáadka Form1.vb) do linii w metodzie Button1_Click,
w której zdefiniowana jest zmienna y. Zaznaczmy tĊ zmienną i prawym przyciskiem
myszy rozwiĔmy menu kontekstowe. Z niego wybierzmy polecenie Add Watch (do-
stĊpne tylko, gdy uruchomione jest debugowanie). Zmienna ta zostanie dodana do listy
w oknie Watch, w której zobaczymy jej nazwĊ, wartoĞü i typ. WartoĞü jest aktualizowana
przy kaĪdym naciĞniĊciu klawisza F10 lub F11, co pozwala na Ğledzenie jej zmian
w trakcie wykonywania metody. MoĪemy siĊ przekonaü, wykonując kolejne polecenia
metody Button1_Click ponownymi naciĞniĊciami klawisza F10, Īe po pierwszym
uruchomieniu metody Kwadrat zmienna y ma wartoĞü równą 1522756. Jest zatem po-
prawna. Niestety, przy drugim uruchomieniu metody Kwadrat pojawi siĊ wyjątek. Aby
sprawdziü, co jest przyczyną báĊdu, wchodzimy do jej „Ğrodka”, uĪywając klawisza F11.
W metodzie Kwadrat nie ma zmiennej y, a jej wartoĞü przejmuje zmienna argument.
Dodajmy ją zatem do listy obserwowanych zmiennych, wpisując jej nazwĊ do pierw-
szej kolumny w podoknie Watch. Dodajmy takĪe wyraĪenie argument*argument.
W trakcie drugiego przebiegu metody Kwadrat przy tym wyraĪeniu pojawi siĊ komu-
nikat Constant expression not representable in type „Integer”, czyli „wartoĞü nie moĪe
byü przedstawiona w zmiennej typu »Integer«”.
Informacja ta wyjaĞnia przyczynĊ báĊdu — podczas mnoĪenia zostaá przekroczony, i to
znacznie, zakres moĪliwych wartoĞci zmiennej Integer (1 522 756·1 522 756 =
2 318 785 835 536 2 147 483 647). Innymi sáowy, 32 bity, jakie oferuje typ Integer, nie
wystarczają do zapisania wyniku. Aby poprawiü ów báąd, przynajmniej w pewnym
zakresie wartoĞci argumentów, naleĪaáoby uĪyü 64-bitowego typu Long. Ponadto, po-
niewaĪ kwadrat liczby caákowitej nie moĪe byü ujemny, warto pozbyü siĊ takĪe znaku
42
CzöĈè I i Projektowanie aplikacji Windows
i uĪyü typu ULong. Kod pozbawiony báĊdu widoczny jest na listingu 2.3. Na razie tych
zmian jednak nie wprowadzajmy — korzystając z obecnoĞci báĊdu, chciaábym zapre-
zentowaü mechanizm przechwytywania wyjątków.
Listing 2.3. Poprawiony kod, którego na razie nie wstawiajmy do projektu
Private Function Kwadrat(argument As Integer) As Long
Dim wartosc As ULong
wartosc = CULng(argument) * CULng(argument)
Return wartosc
End Function
Private Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles
´Button1.Click
Dim x As Integer = 1234
Dim y As ULong = Kwadrat(x)
y = Kwadrat(y)
Dim sy As String = y.ToString()
MessageBox.Show( Wynik: sy)
End Sub
Na rysunku 2.4 z prawej strony na dole widoczne jest okno Call Stack (z ang. stos wy-
woäaþ). Wymienione sñ w nim wszystkie metody, poczñwszy od metody Button1_
´Click, a skoþczywszy na metodzie, której polecenie jest obecnie wykonywane. W bar-
dziej rozbudowanych programach pomaga to w zorientowaniu siö, co siö aktual-
nie dzieje w aplikacji, szczególnie po jej zatrzymaniu w wyniku dziaäania breakpointu.
Stan wyjñtkowy
JeĪeli nie wprowadziliĞmy zmian z listingu 2.3 do projektu, w razie uruchomieniu
projektu z debugowaniem (klawisz F5) po klikniĊciu przycisku Button1 pojawi siĊ
komunikat debuggera informujący o wyjątku (rysunek 2.5). Przyjrzyjmy siĊ temu
komunikatowi. Przede wszystkim na pasku tytuáu widoczne jest ostrzeĪenie Overflo-
wException was unhandled, co oznacza, Īe wyjątek zostaá zgáoszony przez fragment
kodu, który nie byá otoczony obsáugą wyjątków. Nie znajdowaá siĊ zatem w sekcji try
konstrukcji try..catch ani w metodzie, która byáaby z tej sekcji wywoáana. W efekcie
w przypadku uruchomienia aplikacji poza Ğrodowiskiem Visual Studio wyjątek ten
nie byáby w Īaden sposób obsáuĪony przez aplikacjĊ i musiaáaby siĊ nim zająü sama
platforma .NET, co raczej nie powinno mieü miejsca. W oknie komunikatu debuggera
widoczna jest takĪe treĞü przekazywanego przez wyjątek komunikatu oraz link do do-
kumentacji klasy wyjątku (w naszym przypadku klasy OverflowException). Po klik-
niĊciu View Detail... moĪna obejrzeü stan przesyáanego obiektu w widocznym na dole
okna odpowiedniku okna Locals.
Po wystąpieniu wyjątku Ğrodowisko Visual Studio wstrzymuje dziaáanie aplikacji na
tej samej zasadzie jak breakpoint, tzn. zwykle moĪemy przywróciü jej dziaáanie, np.
za pomocą klawiszy F5 lub F10. MoĪemy takĪe zupeánie przerwaü dziaáanie aplikacji
i przejĞü do poprawiania kodu, naciskając kombinacjĊ klawiszy Shift+F5.
Rozdziaä 2. i Debugowanie kodu
43
Rysunek 2.5. Komunikat o wyjątku zgáoszony przez Visual Studio
JeĪeli aplikacja zostanie uruchomiona poza debuggerem przez naciĞniĊcie kombinacji
klawiszy Ctrl+F5 lub samodzielne uruchomienie pliku .exe poza Ğrodowiskiem Visu-
al Studio, nieobsáuĪony wyjątek jest przechwytywany przez platformĊ .NET. O takiej
sytuacji uĪytkownik powiadamiany jest komunikatem widocznym na rysunku 2.6.
ProszĊ zwróciü uwagĊ na to, Īe w przeciwieĔstwie do platformy Win32, w której
analogiczny komunikat oznaczaáby awaryjne zamkniĊcie aplikacji, tu istnieje moĪli-
woĞü kontynuowania jej dziaáania (przycisk Kontynuuj widoczny na rysunku 2.6).
OczywiĞcie, wyjątek pojawi siĊ znowu, jeĪeli klikniemy przycisk Button1 na formie
i uruchomiona zostanie metoda Kwadrat, ale aplikacja nie zawiesza siĊ. Warto doceniü
tĊ wáasnoĞü platformy .NET — jeĪeli nasza aplikacja byáaby edytorem, a báąd pojawiaáby
siĊ np. podczas drukowania, platforma .NET, nie zamykając caáej aplikacji w przy-
padku wystąpienia báĊdu, daáaby nam moĪliwoĞü m.in. zachowania niezapisanego
dokumentu na dysku.
Przechwytywanie wyjñtków w konstrukcji try..catch
Teraz spróbujmy wykryü wystąpienie wyjątku z poziomu aplikacji. W tym celu w meto-
dzie zdarzeniowej przycisku Button1_Click otoczymy wywoáanie metody Kwadrat
konstrukcją przechwytywania wyjątków.
1. NaciĞnij Shift+F5, aby zakoĔczyü dziaáanie debuggera.
2. Do metody Button1_Click dodaj obsáugĊ wyjątku zgodnie ze wzorem na
listingu 2.4.
CzöĈè I i Projektowanie aplikacji Windows
44
Rysunek 2.6.
Wyjątek nieobsáuĪony
w aplikacji jest
przechwytywany przez
Ğrodowisko .NET
(aplikacja uruchomiona
jest bez debuggera)
Listing 2.4. Wszystkie dotychczasowe polecenia metody Button1_Click umieĞciliĞmy w jednej sekcji Try
Private Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles
´Button1.Click
Try
Dim x As Integer = 1234
Dim y As Integer = Kwadrat(x)
y = Kwadrat(y)
Dim sy As String = y.ToString()
MessageBox.Show( Wynik: sy)
Catch ex As Exception
MessageBox.Show( Bđæd: ex.Message,
Przechwycony wyjætek w metodzie Button1_Click ,
MessageBoxButtons.OK,
MessageBoxIcon.Error)
End Try
End Sub
3. Skompiluj i uruchom aplikacjĊ w trybie debugowania (klawisz F5).
Teraz po uruchomieniu aplikacji i klikniĊciu przycisku zamiast komunikatu debuggera
lub komunikatu platformy .NET zobaczymy wáasny komunikat o báĊdzie (rysunek 2.7).
Debugger nie zainterweniuje w przypadku obsáuĪonego wyjątku.
Wszystkie polecenia metody Button1_Click umieĞciliĞmy w jednej sekcji Try. To ma
sens, gdy kaĪde wystąpienie báĊdu powoduje, Īe wykonywanie dalszej czĊĞci metody po-
zbawione jest celu. JeĞli natomiast po pojawieniu siĊ báĊdu chcielibyĞmy podjąü jakąĞ
akcjĊ ratunkową i próbowaü kontynuowaü dziaáanie metody, to kaĪda budząca wąt-
pliwoĞci instrukcja powinna byü otoczona oddzielną konstrukcją obsáugi wyjątków.
Dodatkowe informacje na temat wyjñtków moĔna znaleĒè w rozdziale 3.
Rozdziaä 2. i Debugowanie kodu
45
Rysunek 2.7.
Komunikat wyĞwietlany
uĪytkownikowi po
przechwyceniu wyjątku
Zgäaszanie wyjñtków
Ostatnią rzeczą, o której chciaábym wspomnieü w kontekĞcie wyjątków, jest ich zgáa-
szanie. JeĪeli w kodzie wykryjemy báąd, dla przykáadu jeĪeli sprawdzimy, Īe argument
metody Kwadrat jest zbyt duĪy, to moĪemy samodzielnie zgáosiü wyjątek. W takim
przypadku naleĪy uĪyü instrukcji Throw zgodnie ze wzorem widocznym na listingu 2.5.
Kod ten uĪywa dodatkowego pola (zmiennej zdefiniowanej w obrĊbie klasy) o nazwie
MaxArgumentKwadrat, której definicja równieĪ widoczna jest na poniĪszym listingu.
Listing 2.5. WartoĞü pierwiastka obliczana jest tylko raz, wiĊc kontrola argumentu nie obciąĪa
nadmiernie procesora
Dim MaxArgumentKwadrat As Integer = Math.Sqrt(Integer.MaxValue)
Private Function Kwadrat(argument As Integer) As Integer
Dim wartosc As Integer
If argument MaxArgumentKwadrat Then
Throw New Exception( Argument metody kwadrat ma zbyt duľæ wartoħè )
End If
wartosc = argument * argument
Return wartosc
End Function.
Gdy teraz po uruchomieniu aplikacji klikniemy przycisk Button1, zamiast dotychcza-
sowego komunikatu informującego o przepeánieniu zobaczymy nasz wáasny, bardziej
konkretny komunikat.
46
CzöĈè I i Projektowanie aplikacji Windows
Skorowidz
A
ADO.NET, 297, 368
aktualizacja danych, 338
aktualizowanie ĞcieĪki, 218
algorytm
generujący zbiór Julii, 165
testowania, 162
alias, 112
analiza pliku XML, 363
aplikacja Patrz projekt
aplikacje
konsolowe, 261
okienkowe, 16
Windows Forms, 80
argumenty metody, 251
atrybut, 84, 359
DllImport, 84
Extension, 114
atrybuty elementów, 365
automatyczne
mapowanie struktury, 342
tworzenie klasy encji, 345
B
baza danych, 297
Access, 304
Telefony.mdf, 350
biblioteka
DLL, 84
Metro, 12
STL, 107
System.Drawing.dll, 224
System.Numerics, 163
System.Windows.Forms.dll,
224
SystemInfo.dll, 253
TPL, 267
User32.dll, 401
VCL, 171
VCL.NET, 171
Windows Forms, 119, 171
WPF, 12, 119
biblioteki
.dll, 193, 239
.NET, 47
.ocx, 241
bloki kodu, 83
báąd, 278
kompilacji, 54
logiczny, 37
w kodzie pĊtli, 91
breakpoint, 39
budowanie tabeli, 330
bufor obiektu, 340
buforowanie, 158
C
CAS, Code Access Security, 48
CLR, Common Language
Runtime, 48
CLS, Common Language
Specification, 48
CTS, Common Type System, 48
D
dane
aktualizowanie, 338
analizowanie, 320
filtrowanie, 332
grupowanie, 321
áączenie zbiorów, 322
prezentacja, 320
sortowanie, 332
weryfikowanie, 321
debugowanie, 36
definicja
delegacji, 70
typu
Okno, 366
WielkoĞüOkna, 366
uchwytu do metody, 70
wáaĞciwoĞci
CzyKatalogiWidoczne, 207
Filtr, 207
ĝcieĪkaDoZaznaczonego-
Elementu, 208
definiowanie
aliasów, 112
symboli preprocesora, 83
tablicy, 85
typów ogólnych, 108
wáasnego zdarzenia, 211
deklaracja pola typu Panel, 24
deklaracja zmiennej, 49
deserializacja z pliku XML, 367
dáugie linie, 141
dodawanie
pól do klasy, 188
kontrolki, 195
referencji do biblioteki,
163, 241
rekordów, 340
dokowanie palety, 18
domyĞlna wartoĞü argumentu, 67
dostĊp do pola, 25
dostĊp przez referencjĊ Me, 127
drukowanie, 135
drukowanie w tle, 144
dymek, balloon tip, 150
dynamiczne áadowanie
bibliotek, 239
416
Visual Basic .NET w praktyce. Bäyskawiczne tworzenie aplikacji
G
K
garbage collector, 62
generator liczb pseudolosowych,
GUI, graphical user interface,
77, 276, 279
15, 119
kanaá alpha, 30
katalogi specjalne, 265
klasa, 95
dyrektywa
#Const, 83
#End Region, 83
#If, 82
#Region, 83
dyrektywy preprocesora, 82
dystrybucja biblioteki, 221
E
I
edycja
edytor
bazy danych, 301
menu kontekstowego, 190
pliku XML, 369
gáównego menu, 125
kodu, 21
menu kontekstowego, 148
relacji, 351
wáasnoĞci Dock, 121
ekran powitalny, splash
screen, 145
element listy, 92
elementy, 358
encje, entity, 359
F
fabryka, 65
fazy procesu drag drop, 175
fazy przenoszenia elementu, 174
FIFO, first in, first out, 92
FILO, first in, last out, 92
filtr okna dialogowego, 132
filtrowanie, 201, 312, 352
filtrowanie wyjątków, 80
filtry, 131
flaga daneZmienione, 307
focus, 25
forma
kolor, 184
ksztaát, 184
formularz, 309, 311
funkcja
CreateProcess, 403
FindWindow, 409
MessageBeep, 399, 400, 401
MsgBox, 49
SendMessage, 409
ShellExecute, 403
WinAPI, 404
WinExec, 402
funkcje bez argumentów, 399
identyfikacja aplikacji, 408
IL, Intermediate Language, 48
implementacja
interfejsu, 106
interfejsu IComparable, 110
listy, 90
import funkcji WinAPI, 408
importowanie przestrzeni
nazw, 83
informacje o
kontrolce, 222
systemie, 253, 263
ĞcieĪkach, 384
typie aplikacji, 395
inicjowanie zmiennej, 54
instancja klasy, 95
instrukcja
Continue For, 79
If..Else, 76
If..Then, 32
Select, 77
IntelliSense, 28, 118
interfejs
aplikacji, 348, 392
graficzny, 15
IComparable, 90
IComparable(Of T), 110
IConvertible, 99
IDictionary, 92
IEnumerable, 332
IEnumerable(Of ), 315
komponentu, 194
przeglądarki, 225
WinExec, 403
izomorficznoĞü relacji, 336
J
jawne deklarowanie
zmiennych, 12
jĊzyk funkcyjny F#, 47
JIT, Just-In-Time, 48
AdresyDataSet, 303, 304
Application, 127
CategoryAttribute, 205
ColorProgressBar, 232
Console, 257
DataContext, 335, 341
DataTable, 332
DescriptionAttribute, 205
encji, entity class, 336
Environment, 264
EventWaitHandle, 288, 289
Exception, 130
FileListBox, 196
Form1, 22, 177
Graphics, 136, 229
Lazy, 65
Monitor, 288
Mutex, 290
OverflowException, 42
Panel, 19, 25
Para, 113
Parallel, 267, 290, 292
ParameterizedThreadStart, 283
Process, 167
Program, 264
Queue, 91
Random, 77
Regex, 62
Registry, 392
RegistryKey, 385
SoundPlayer, 152
Stack, 92
StreamReader, 130
String, 60
StringBuilder, 61, 406
System.Array, 85
System.Enum, 63
System.Environment, 262
System.IO.DriveInfo, 404
SystemInfo, 242, 243, 244
Thread, 267
ThreadPool, 285
TrackBar, 19
XDocument, 372, 374
XmlTextReader, 359
XmlTextWriter, 361
zagnieĪdĪona, 246
klasy, 72
opakowujące, 50
rozszerzające, 116
Skorowidz
417
klawisz Enter, 259
klawisze skrótów
VB, 28
do debugowania, 38
menu, 125
klucz, key, 92
gáówny, 383, 393
prywatny, 397
prywatny aplikacji, 386
rejestru, 384
uĪytkownika, 395
kod
klasy Form1, 22
klasy kontrolki, 197
niezarządzany, unmanaged
code, 240
niezrównoleglony, 269
poĞredni MSIL, 48
zarządzany, managed code, 48
zbioru Mandelbrota, 164
kolejka, queue, 91
kolekcja, 84
Dictionary, 92
List, 90
áaĔcuchów, 379
SortedList, 91
SortedDictionary, 92
kolory
komponentów, 120
paska postĊpu, 236
w .NET, 30
komentarze, 359
kompilacja
dwustopniowa, 47
kodu poĞredniego, 48
komponentu, 219
warunkowa, 82
kompilator Visual Basic, 49
komponent, 193
BackgroundWorker, 268
ComboBox1, 396
DataGridView, 307
DataSet, 302, 304
FileListBox, 194, 224, 228
ListBox, 171, 179
NumericUpDown, 313
OsobyBindingSource, 312
PrintDocument, 137
SerialPort, 193
SoundPlayer, 145
StatusStrip, 123
TextBox, 129, 130
Timer, 146, 151
kompozycja Klasyczny
Windows, 228
komunikat, 412
o wyjątku, 43
WM_NCMOUSEMOVE, 413
komunikaty Windows, 407
konfiguracja
timera, 152
konfigurowanie
formy, 183
interfejsu, 392
komponentu DataSet, 302, 325
kontrolki DataSet, 326
paska stanu, 123
konstrukcja
SyncLock .. End SyncLock,
282
Try..Catch, 314
Try..Catch..End Try, 130
Using..End Using, 130
konstruktor
klasy opisującej formĊ, 31
obiektu Form1, 167
konstruktory domyĞlne, 25, 97
kontrola typów, 53
kontrolka
ColorProgressBar, 230, 236
DataGridView, 346
DataSet, 326
FileListBox, 194, 223–228
panel, 19
PrintDialog, 137
ProgressBar, 228, 230, 235
suwak, 19
kontrolki ActiveX, 193
kontynuacja polecenia, 49
konwersja typu, 74
kopiowanie pliku tekstowego, 129
L
leniwe inicjowanie zmiennych, 65
liczba instancji aplikacji, 34
LIFO, last in, first out 92
LINQ, Language Integrated
Query, 317
LINQ to DataSet, 315, 325–328
LINQ to Objects, 315, 317
LINQ to SQL, 315, 335, 337
LINQ to XML, 315, 371, 373
LINQ to XSD, 380
lista, 90
argumentów metody, 250
dysków logicznych, 266
klas, 247
komunikatów, 412
metod, 248
osób, 318
parametryczna, 85, 92
procesów, 168
przenoszonych plików, 181
rozszerzeĔ, 392
typów, 247
z báĊdami, 90
ã
áadowanie
dynamiczne bibliotek, 245
statyczne bibliotek, 243
áaĔcuch, 59
áączenie
danych, 349
zbiorów, 322
M
Pobierz darmowy fragment (pdf)