Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00180 008355 24109920 na godz. na dobę w sumie
wyszukaj dokładnie | pobierz wtyczkę
Visual Basic .NET w praktyce. Błyskawiczne tworzenie aplikacji - książka
Visual Basic .NET w praktyce. Błyskawiczne tworzenie aplikacji - książka
Autor: Liczba stron: 424
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-4898-6 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> visual basic - programowanie
Porównaj ceny (książka, ebook, audiobook).
Czytaj online.
Komentuj

Wykorzystaj potęgę technologii Windows!

Visual Basic to język programowania o bardzo długiej tradycji. Kiedy kilka lat temu przeniesiono go na platformę .NET, zyskał nowe możliwości rozwoju. Dziś chętnie używają go osoby, które potrzebują wygodnego narzędzia, pozwalającego szybko stworzyć aplikację do prezentacji i analizy konkretnych danych. Jasna, niezbyt skomplikowana składnia, doskonała biblioteka gotowych kontrolek i bezkolizyjna współpraca z bazą danych to najważniejsze atuty VB.NET.

Jeśli jesteś początkującym użytkownikiem Visual Basic na platformie .NET, trafiłeś w dziesiątkę. Tu znajdziesz podstawy języka oraz wszystkie funkcje potrzebne do swobodnego projektowania aplikacji - bez nadmiernego wchodzenia w szczegóły. Zorientujesz się, jak działa środowisko Visual Studio i jak za pomocą jego narzędzi tworzyć aplikacje VB.NET. Dowiesz się więcej o debugowaniu kodu, programowaniu zorientowanym obiektowo i używaniu kontrolek, zarówno tych z biblioteki Windows Forms, jak i zaprojektowanych osobiście. Odkryjesz, jak można połączyć aplikację z bazą danych i jak wykorzystać technologie systemu Windows. To wszystko, czego Ci trzeba!

Wypróbuj Visual Basic i twórz dynamiczne rozwiązania!

Znajdź podobne książki Ostatnio czytane w tej kategorii

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)

Gdzie kupić całą publikację:

Visual Basic .NET w praktyce. Błyskawiczne tworzenie aplikacji
Autor:
Sklep
Format
Cena
Helion.pl Helion.pl
książka
69,00 zł
Idź do sklepu »

Opinie na temat publikacji:

Inne popularne pozycje z tej kategorii:

Czytaj również:

Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: