IDZ DO
IDZ DO
PRZYKŁADOWY ROZDZIAŁ
PRZYKŁADOWY ROZDZIAŁ
Visual Basic .NET.
SPIS TRE CI
SPIS TRE CI
Ćwiczenia
KATALOG KSIĄŻEK
KATALOG KSIĄŻEK
Autor: Marcin Szeliga
KATALOG ONLINE
KATALOG ONLINE ISBN: 83-7361-432-X
Format: B5, stron: 176
ZAMÓW DRUKOWANY KATALOG
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
TWÓJ KOSZYK
Kolejna, siódma już wersja języka Visual Basic (Visual Basic .NET) to prawdziwa
DODAJ DO KOSZYKA
DODAJ DO KOSZYKA
rewolucja firma Microsoft opracowała jednolite rodowisko programistyczne,
a jednym z jego podstawowych języków (oprócz Visual C++ i Visual C#) jest wła nie
Visual Basic. Dzięki wsparciu potężnej firmy, jaką jest Microsoft i rozpowszechnieniu
CENNIK I INFORMACJE
CENNIK I INFORMACJE
systemu Windows, Visual Basic .NET stał się jednym z najczę ciej używanych
języków programowania na wiecie.
ZAMÓW INFORMACJE
ZAMÓW INFORMACJE
O NOWO CIACH
O NOWO CIACH
Książka Visual Basic .NET. Ćwiczenia adresowana jest do osób, które chcą poznać
podstawowe zasady tworzenia w języku VB .NET programów sterowanych zdarzeniami.
ZAMÓW CENNIK Jak wszystkie książki z tej serii jest ona skonstruowana w formie praktycznych
ZAMÓW CENNIK
ćwiczeń, pozwalających stopniowo zagłębiać się w niuanse programowania bez
zbędnych rozważań teoretycznych.
CZYTELNIA
CZYTELNIA
Poznasz:
" Platformę .NET
FRAGMENTY KSIĄŻEK ONLINE
FRAGMENTY KSIĄŻEK ONLINE
" Programowanie sterowane zdarzeniami
" Zmienne i stałe
" Sterowanie przebiegiem wykonywania programu
" Podstawy programowania obiektowego
" Korzystanie z baz danych
" Obsługę błędów w Visual Basic .NET
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
Spis treści
Wstęp.............................................................................................................................................................. 5
Rozdział 1. Microsoft Visual Studio .NET ............................................................................................................... 9
Platforma .NET ............................................................................................................................9
.NET Framework ...................................................................................................................9
Serwery .NET ......................................................................................................................10
Visual Studio .NET..............................................................................................................11
Visual Basic .NET ...............................................................................................................19
Rozdział 2. Programy sterowane zdarzeniami ................................................................................................20
Klasy...........................................................................................................................................20
Obiekty .......................................................................................................................................21
Konwencje nazewnicze ..............................................................................................................37
Zasady ..................................................................................................................................37
Wskazówki...........................................................................................................................38
Jak czytelnie zapisywać kod programu? ....................................................................................38
Rozdział 3. Zmienne....................................................................................................................................................... 41
Zmienne i stałe ...........................................................................................................................41
Stałe......................................................................................................................................45
Operatory....................................................................................................................................46
Typy danych...............................................................................................................................49
Zmienne ...............................................................................................................................50
Wskazniki ............................................................................................................................50
Konwersja typów .................................................................................................................51
Poprawność wprowadzanych przez użytkowników danych................................................54
Zakres zmiennych ......................................................................................................................55
Czas życia zmiennych ................................................................................................................59
Struktury.....................................................................................................................................60
Tablice........................................................................................................................................62
Konwencje nazewnicze ..............................................................................................................64
Zasady ..................................................................................................................................64
Wskazówki...........................................................................................................................65
4 Visual Basic .NET. Ćwiczenia
Rozdział 4. Procedury i funkcje.............................................................................................................................. 66
Procedury ...................................................................................................................................66
Funkcje .......................................................................................................................................73
Rozdział 5. Sterowanie wykonaniem programu............................................................................................. 78
Instrukcje warunkowe ................................................................................................................78
Instrukcja If & Then............................................................................................................79
Instrukcja Select Case ..........................................................................................................81
Pą tle............................................................................................................................................84
Instrukcja For & Next .........................................................................................................84
Instrukcja For Each & Next ................................................................................................87
Instrukcja Do & Loop .........................................................................................................91
Rozdział 6. Programowanie obiektowe.............................................................................................................. 93
Podejście proceduralne...............................................................................................................93
Podejście obiektowe...................................................................................................................94
Klasa ....................................................................................................................................94
Obiekt...................................................................................................................................95
Abstrakcja ............................................................................................................................95
Dziedziczenie.......................................................................................................................95
Hermetyzacja .......................................................................................................................96
Interfejs ................................................................................................................................96
Polimorfizm .........................................................................................................................98
Projektowanie programów zbudowanych z obiektów ...............................................................98
Projekt klas...........................................................................................................................99
Tworzenie programów zbudowanych z niezależnych obiektów..............................................101
Podstawowe techniki programowania obiektowego..........................................................101
Składowe współdzielone....................................................................................................112
Zaawansowane techniki programowania obiektowego .....................................................114
Rozdział 7. Dane ............................................................................................................................................................120
Relacyjny model baz danych....................................................................................................120
XML .........................................................................................................................................121
ADO .NET ...............................................................................................................................122
Przestrzenie nazw...............................................................................................................122
Klasy ..................................................................................................................................122
Obiekt Connection .............................................................................................................123
Obiekt Command ...............................................................................................................127
Kreatory danych.................................................................................................................132
Lokalne kopie danych ........................................................................................................136
Rozdział 8. Sprawdzanie poprawności danych ............................................................................................146
Uniemożliwianie użytkownikom programu wpisania niepoprawnych danych .......................147
Korzystamy z kontrolek.....................................................................................................147
Korzystamy ze zdarzeń ......................................................................................................154
Sprawdzanie poprawności poszczególnych danych.................................................................154
Sprawdzanie poprawności wszystkich danych ........................................................................158
Rozdział 9. Wyszukiwanie i programowe przechwytywanie błędów ............................................... 160
Wyszukiwanie błą dów .............................................................................................................160
Przechwytywanie błą dów.........................................................................................................171
Klasa Exception .................................................................................................................172
Instrukcja Try & Catch & Finally ....................................................................................172
Rozdział 9. Wyszukiwanie i programowe przechwytywanie błędów 161
Ćwiczenie 9.1.
Wyszukujemy błędy syntaktyczne
Błąd syntaktyczny polega na nieprzestrzeganiu reguł ją zyka, w którym tworzony jest
program. Na przykład, próba użycia instrukcji For bez odpowiadającej jej instrukcji Next
jest błą dem syntaktycznym.
1. Utwórz nowy projekt typu Windows Application i nazwij go .
2. Zmień nazwą formularza Form1 na , jego etykietą na
, a rozmiar na .
3. W oknie zadań wyświetlony zostanie komunikat błą du po zmianie nazwy
formularza nie istnieje obiekt startowy projektu. Okno zadań nie tylko informuje
o błędach, ale również ułatwia ich wyszukanie i naprawienie. Aby naprawić błąd:
a. dwukrotnie kliknij lewym przyciskiem myszy opis błą du,
b. wyświetlone zostanie okno dialogowe pozwalające na wybranie nowego obiektu
startowego projektu (rysunek 9.1) zaznacz formularz frmBledy i kliknij
przycisk OK.
Rysunek 9.1.
W tym projekcie
jest tylko jeden
formularz
i nie ma procedury
o nazwie Main
4. Po zmianie obiektu startowego okno zadań nie bą dzie zawierać żadnych komunikatów.
Dodaj do formularza przycisk polecenia i ustaw nastą pujące wartości jego atrybutów:
Name , Text , Location .
5. Wyświetl okno edytora kodu.
6. Zadeklaruj zmienną formularza decWynik typu Decimmal: .
7. Ponieważ przy deklaracji zmiennej popełniliśmy błąd, niewłaściwe słowo zostało
podkreślone niebieską, falistą linią aby dowiedzieć sią , na czym polegał nasz
błąd, ustaw kursor myszy nad zaznaczonym słowem (rysunek 9.2).
8. Zauważ, że ten sam komunikat Type Decimmal is not definied. wyświetlany
jest w oknie zadań. Napraw błąd przez podanie prawidłowej nazwy typu .
9. Utwórz procedurą zdarzenia Click przycisku cmdSilnia.
10. W ramach procedury zdarzenia:
162Visual Basic .NET. Ćwiczenia
Rysunek 9.2.
W Visual Studio
wyświetlony zostanie
krótki opis
błędów syntaktycznych
a. zadeklaruj zmienną intLiczba typu Integer: ,
b. przypisz zadeklarowanej zmiennej liczbą podaną przez użytkownika (zwróć
uwagą na błą dną nazwą funkcji):
.
11. Zadeklaruj funkcją SilniaIteracja oczekującą na argument liczba typu Integer
i zwracającą dane typu Double:
.
12. Usuń z sekcji deklaracji formularza deklaracją zmiennej decWynik.
13. W ramach funkcji SilniaIteracja:
a. zadeklaruj zmienną dblWynik typu Double: ,
b. zadeklaruj zmienną licznik typu Integer: ,
c. w pą tli powtarzanej przekazaną jako argument liczbą razy wylicz wartość
zmiennej decWynik mnożąc ją za każdym razem przez wartość zmiennej licznik:
d. zwróć wyliczoną silnią : .
14. W procedurze zdarzenia cmdSilnia_Click wywołaj funkcją SilniaIteracja
z argumentem pobranym od użytkownika i wyświetl na ekranie otrzymany wynik:
.
15. W oknie zadań wyświetlone zostaną dwa komunikaty o błą dach:
a. pierwszy informuje o próbie odwołania sią do nieistniejącej funkcji InpurBox,
b. drugi o brakującej instrukcji Next (rysunek 9.3).
Rysunek 9.3.
Lista błędów
syntaktycznych
(składniowych)
Rozdział 9. Wyszukiwanie i programowe przechwytywanie błędów 163
16. Dwukrotnie kliknij pierwszy komunikat błą du kursor zostanie ustawiony
w miejscu wystą powania błą du. Popraw nazwą funkcji na .
17. W ten sam sposób zlokalizuj drugi błąd tym razem zaznaczona zostanie instrukcja
For, która nie została zakończona słowem kluczowym Next. Dopisz je przed
zwracającą wynik działania funkcji instrukcją Return:
18. Zapisz projekt.
Ćwiczenie 9.2.
Wyszukujemy błędy konwersji typu
To, że w programie nie ma błą dów syntaktycznych, nie oznacza, że bą dzie on działał.
Wynika to stąd, że próba wykonania poprawnie zapisanych instrukcji może spowodować
wystąpienie błą du wykonania, a błą dy tego typu nie są zaznaczane podczas tworzenia
programu.
1. Uruchom projekt .
2. Po podaniu liczby, której silnią chcemy obliczyć, i kliknią ciu przycisku OK,
na ekranie wyświetlony zostanie komunikat o błą dzie pokazany na rysunku 9.4.
Rysunek 9.4.
Uruchomienie
poprawnego składniowo
programu może
zakończyć się błędem
3. W tym przypadku błąd spowodowała próba połączenia ciągu znaków "Silnia
wynosi" z liczbą typu Double. Jeżeli w programie wystąpi błąd, jego działanie
zostaje przerywane, a na ekranie użytkownika wyświetlony jest niewiele mu
mówiący komunikat o wystąpieniu błą du.
4. Kliknij przycisk Break. Wyświetlone zostanie okno edytora kodu z zaznaczoną
na zielono instrukcją, której próba wykonania spowodowała błąd.
5. W tym momencie program znajduje sią w specjalnym trybie diagnostycznym,
nazywanym trybem przerwania. Opis tego trybu znajduje sią w dalszej czą ści
rozdziału, na razie zatrzymaj działanie tego trybu klikając znajdującą sią na pasku
narzą dzi Debug ikoną Stop Debugging albo wybierając z menu Debug opcją Stop
Debugging. W obu przypadkach tryb przerwania zostanie wyłączony i zniknie
zaznaczenie błą dnej instrukcji.
164 Visual Basic .NET. Ćwiczenia
6. Popraw błąd przez skonwertowanie na dane tekstowe zwracanego przez funkcją
SilniaIteracja wyniku:
.
7. Uruchom program i przetestuj jego działanie. Jak widać, wyeliminowanie błędów
wykonania nie oznacza, że program będzie działał prawidłowo.
8. Zakończ działanie programu i zapisz wprowadzone w nim zmiany.
Ćwiczenie 9.3.
Wyszukujemy błędy związane z przekazaniem nieprawidłowych danych
1. Wyświetl projekt formularza frmBledy.
2. Utwórz nową funkcją SilniaRekurencja wywoływaną z jednym parametrem liczba
typu Integer i zwracającą dane typu Double.
3. W ramach funkcji:
a. zadeklaruj zmienną dblWynik typu Double,
b. sprawdz, czy wartość parametru liczba jest mniejsza od zera i, jeżeli tak, zwróć
wartość , w przeciwnym razie wywołaj funkcją SilniaRekurencja z parametrem
o jeden wią kszym przypisując wynik jej wywołania do zmiennej dblWynik,
Wywołanie funkcji przez siebie samą jest charakterystyczne dla algorytmów rekurencyjnych.
c. zwróć obliczoną wartość zmiennej dblWynik:
4. W procedurze zdarzenia cmdSilnia_Click wywołaj funkcją SilniaRekurencja
z argumentem pobranym od użytkownika i wyświetl na ekranie otrzymany wynik:
.
5. Uruchom program. Po chwili jego działanie zostanie przerwane, a na ekranie
zostanie wyświetlony komunikat o błą dzie z informacją o przepełnieniu stosu.
Naciśnij klawisz Break.
6. Tym razem na żółto zaznaczona została deklaracja funkcji, której wywołanie
spowodowało wystąpienie błą du. W naszym przypadku funkcja wywoływała samą
siebie bez końca (rysunek 9.5).
7. Przerwij tryb diagnostyczny i popraw wywołanie funkcji SilniaRekurencja
na nastą pujące: .
Rozdział 9. Wyszukiwanie i programowe przechwytywanie błędów 165
Rysunek 9.5.
Korzystając
z rekurencji musimy
tak sformułować
warunek wywoływania
funkcji przez samą
siebie, aby proces
zagnieżdżania został
kiedyś zakończony
8. Uruchom program i przetestuj jego działanie. Po raz kolejny okazuje sią , że działający
program nie musi być dobrze działającym programem.
9. Zakończ działanie programu i zapisz wprowadzone w nim zmiany.
Ćwiczenie 9.4.
Uruchamiamy tryb przerwania
Najłatwiejsze jest znalezienie i poprawienie błą dów syntaktycznych w tym przypadku
przeważającą czą ść pracy wykona za nas Visual Studio. Znalezienie i poprawienie błą dów
wykonania jest już trudniejsze i wymaga uruchamiania programu z różnymi zestawami
testowymi danych wejściowych. Najtrudniejsze jest jednak znalezienie i poprawienie
błą dów logicznych, ponieważ ich wystąpienie nie powoduje przerwania działania pro-
gramu, ale jego nieprawidłowe działanie. Wyszukiwanie błą dów tego typu ułatwia spe-
cjalny tryb przerwania (tryb diagnostyczny) i dostą pne w tym trybie narzą dzia.
Tryb przerwania jest dostępny tylko wtedy, gdy program został skompilowany w wersji Debug.
Po zmianie trybu na Release kompilator wygeneruje kod wynikowy, z którego usunią te zostaną
wszystkie informacje diagnostyczne. Ta wersja programu przeznaczona jest dla użytkowników
końcowych.
1. Wyświetl okno edytora kodu formularza frmBledy.
2. Możemy przejść w tryb przerwania na kilka sposobów. Po pierwsze, wstawiając
w wykonywalnym wierszu programu pułapkę (ang. Breakpoint) najprościej
wstawić ją przez kliknią cie lewego marginesu okna edytora kodu. Kliknij lewy
margines na wysokości instrukcji
. Wybrany wiersz zostanie zaznaczony.
166 Visual Basic .NET. Ćwiczenia
3. Uruchom program. Po kliknią ciu przycisku Silnia jego działanie zostanie wstrzymane,
a na ekranie wyświetlone zostanie okno edytora kodu z zaznaczoną na żółto
wykonywaną właśnie instrukcją.
4. Skasuj ustawioną pułapkę przez kliknięcie jej znaku wyświetlanego na lewym
marginesie.
5. Wznów działanie programu (np. naciskając klawisz F5 lub klikając ikoną paska
narzą dzi Debug Contine).
6. Przerwij działanie programu. Innym sposobem na przejście w tryb przerwania
jest wykonanie instrukcji Stop. Wpisz tą instrukcją przed wywołaniem funkcji
SilniaIteracja i uruchom program.
7. Tym razem jego działanie zostało przerwane po zamknią ciu okna dialogowego
umożliwiającego podanie liczby i ponownie zaznaczona na żółto jest ostatnio
wykonywania instrukcja instrukcja Stop.
8. W trybie przerwania nie jest możliwa zmiana kodu programu. Przerwij jego
działanie i usuń instrukcją Stop.
9. Sposobem na warunkowe przejście w tryb przerwania jest wywołanie metody
Assert obiektu specjalnego Debug. Działanie programu zostanie wstrzymane, jeżeli
wynikiem testu logicznego będzie fałsz. W miejsce usunią tej instrukcji Stop wpisz:
.
10. Uruchom program i podaj liczbą wią kszą niż 1. Ponieważ warunek został spełniony,
działanie programu nie zostało wstrzymane. Raz jeszcze kliknij przycisk Silnia,
ale nie zmieniaj domyślnej liczby 1. Tym razem warunek nie został spełniony
(1 nie jest wią ksze niż 1) i wyświetlone zostało okno umożliwiające wstrzymanie
działania programu (rysunek 9.6).
Rysunek 9.6. Wyjątkowo nieeleganckie rozwiązanie na pasku tytułu okna wyświetlone zostało zmienione
znaczenie przycisków. W tym przypadku kliknięcie przycisku Przerwij kończy działanie programu (uruchamia
tryb projektowania), kliknięcie przycisku Ponów próbę uruchamia tryb diagnostyczny, a kliknięcie przycisku
Ignoruj kontynuuje wykonywanie programu
11. Kliknij przycisk Ponów próbę wyświetlone zostanie okno edytora kodu
z zaznaczoną ostatnio wykonywaną instrukcją.
Rozdział 9. Wyszukiwanie i programowe przechwytywanie błędów 167
12. Zatrzymaj działanie trybu przerwania i skasuj dodany wiersz.
13. Możemy w każdej chwili wstrzymać działanie programu naciskając kombinację
klawiszy Ctr+Break lub klikając ikonę paska narzędzi Debug Break All.
Ćwiczenie 9.5.
Modyfikujemy pułapki
Visual Studio pozwala na warunkowe wstrzymywanie działania programu za pomocą
ustawionych w nim pułapek, dzią ki czemu niektóre błą dy mogą zostać wykryte bez
konieczności krokowego uruchamiania programu (uruchamiania programu wiersz po
wierszu). Wykonując bieżące ćwiczenie, nauczymy sią konfigurować ustawione pułapki.
1. Wyświetl okno edytora kodu formularza frmBledy.
2. Ustaw pułapką w wierszu funkcji SilniaRekurencja.
3. Przywróć poprzednie, błą dne wywołanie funkcji:
.
4. Kliknij prawym przyciskiem myszy symbol koła oznaczający ustawioną pułapką
i z menu kontekstowego wybierz opcją Breakpoint Properties& .
5. Wyświetlone zostanie okno dialogowe pokazane na rysunku 9.7. Pozwala ono
na warunkowe wstrzymanie programu oraz na wstrzymanie programu po którymś
z kolei wykonaniu instrukcji, dla której ustawiono pułapką .
Rysunek 9.7.
Okno właściwości
ustawionej pułapki
6. Kliknij przycisk Hit Count& .
7. Wyświetlone zostanie okno dialogowe pozwalające określić, kiedy (po ilu wykonaniach
instrukcji) wstrzymać działanie programu. Skonfiguruj pułapką tak, aby działanie
programu zostało wstrzymane po 5 lub wią cej wywołaniach (rysunek 9.8).
168 Visual Basic .NET. Ćwiczenia
Rysunek 9.8.
Często pojedyncze
wykonanie instrukcji
jest poprawne,
a wielokrotne
jej wykonanie świadczy
o błędzie programu
8. Uruchom program i oblicz silnią liczby 4.
9. Działanie programu zostało wstrzymane. Ponieważ obliczenie silni liczby 4 nie
wymaga pią ciu lub wią cej wywołań funkcji SilniaRekurencja (4! = 1 " 2 " 3 " 4)
błą du należy szukać albo w zle określonym warunku brzegowym, albo w sposobie
wywołania funkcji SilniaRekurencja.
10. Ustaw kursor nad nazwą zmiennej liczba. Zostanie wyświetlona aktualna wartość
zmiennej ( ). Aby dowiedzieć sią , ile razy instrukcja została wykonana, wyświetl
okienko Breakpoints. Można to zrobić klikając znajdującą sią na pasku narzą dzi
Debug ikoną Breakpoints.
11. Licznik pułapki wskazuje wartość , czyli warunek If liczba < 0 Then sprawdzany
jest po raz piąty. Skoro wartość zmiennej licznik wynosi , a warunek sprawdzany
jest piąty raz przy obliczaniu silni liczby 4 błąd znajduje sią w sposobie wywołania
funkcji, a nie w sposobie sprawdzania warunku brzegowego rekurencji. Rzeczywiście
tak jest zamiast przy kolejnych wywołaniach zmniejszać liczbą o jeden,
my dodajemy do niej jeden, co powoduje, że warunek brzegowy nigdy nie zostanie
spełniony.
12. Popraw znaleziony błąd i usuń pułapką .
13. Ustaw pułapką w wierszu funkcji SilniaIteracja.
14. Wyświetl właściwości pułapki i kliknij przycisk Condition& .
15. Zostanie wyświetlone okno dialogowe pozwalające na określenie warunku
logicznego, którego spełnienie spowoduje wyzwolenie pułapki (rysunek 9.9).
Rysunek 9.9.
Warunkowe
wywoływanie
ustawionej pułapki
16. Wpisz warunek, którego spełnienie spowoduje wywołanie pułapki: .
W ten sposób działanie programu zostanie wstrzymane, jeżeli pą tla bą dzie wykonana
tyle samo lub wią cej razy, niż podana przez użytkownika liczba, której silnia
ma zostać wyliczona.
17. Uruchom program. Po chwili jego działanie zostanie wstrzymane.
Rozdział 9. Wyszukiwanie i programowe przechwytywanie błędów 169
18. Odczytując (przez ustawienie kursora myszy) wartości zmiennych licznik i dblWynik
dowiemy sią , że niezależnie od tego, ile razy wykonywane jest mnożenie, wartość
zmiennej dblWynik zawsze jest równa 0.
19. Pewnie już domyślasz sią , gdzie znajduje sią błąd w tej funkcji. Nie poprawiaj go na
razie wykorzystamy go w nastą pnym ćwiczeniu.
20. Skasuj ustawioną pułapką .
Ćwiczenie 9.6.
Poznajemy tryb przerwania
Tryb przerwania pozwala na:
wykonywanie programu wiersz po wierszu,
śledzenie wyników wykonania poszczególnych instrukcji wykonania,
odczytywanie i modyfikowanie wartości zmiennych,
natychmiastowe wykonanie dowolnej instrukcji, procedury lub funkcji.
Operacje te możemy wykonywać za pomocą paska narzą dzi Debug (rysunek 9.10).
Poszczególne ikony (zaczynając od lewej) umożliwiają:
Rysunek 9.10.
Pasek narzędzi
diagnostycznych
1. Uruchomienie programu.
2. Włączenie trybu przerwania.
3. Zatrzymanie wykonywania programu.
4. Wznowienie wykonywania programu.
5. Ustawienie kursora w wierszu instrukcji, która właśnie bą dzie wykonana.
6. Trzy kolejne przyciski służą do sterowania wykonaniem programu:
a. wybranie opcji Step Into powoduje wykonanie programu instrukcja po instrukcji;
jeżeli wywołana zostanie procedura lub funkcja, jej wykonanie również bą dzie
odbywało sią instrukcja po instrukcji,
b. kliknią cie ikony Step Over także spowoduje wykonanie programu instrukcja po
instrukcji; jeżeli jednak zostanie wywołana podprocedura lub funkcja, zostanie
ona wykonana w całości, tak jakby była pojedynczą instrukcją,
c. wybranie opcji Step Out spowoduje wykonanie całej podprocedury
lub wywoływanej funkcji i ustawienie kursora w nastą pnym wierszu procedury
nadrzą dnej.
7. Wyświetlanie danych w postaci heksadecymalnej.
170 Visual Basic .NET. Ćwiczenia
8. Wyświetlenie okna Breakpoints oraz, po kliknią ciu skierowanej w dół strzałki, m.in.
okienek:
a. Locals zawierającego nazwą , aktualną wartość i typ wszystkich zmiennych
zdefiniowanych dla procedury, w której nastąpiło przerwanie wykonywania
programu,
b. Immediate pozwalającego na wykonywanie dowolnych instrukcji ją zyka Visual
Basic lub dyrektyw kompilatora,
c. Autos pozwalającego na śledzenie aktualnych wartości wybranych zmiennych,
d. Call Stack zawierającego hierarchią nazw wszystkich procedur lub funkcji,
z których wywołany został zaznaczony fragment podprogramu.
1. Ustaw pułapką w wierszu funkcji SilniaIteracja.
2. Uruchom program i podaj liczbą .
3. Działanie programu zostanie wstrzymane i wyświetlone zostanie okno edytora kodu.
4. Wyświetl na ekranie okno Autos (rysunek 9.11).
Rysunek 9.11.
Okno Autos
pozwala odczytywać
i modyfikować wartości
zmiennych w trybie
przerwania programu
5. W tym momencie wynik równa sią 0, pą tla jest wykonywana po raz pierwszy,
a przekazaną liczbą jest 8. Wykonaj nastą pną instrukcją naciskając klawisz F8
lub klikając ikoną paska narzą dzi Debug Step Into.
6. Po wykonaniu mnożenia dblWynik *= licznik wartość zmiennej dblWynik nadal
wynosi zero. Przekonaj sią , wykonując kilka kolejnych instrukcji, że jej wartość
nigdy sią nie zmienia.
7. W tym przypadku błąd polegał na braku przypisania wartości początkowej zmiennej
dblWynik. Domyślnie, po zadeklarowaniu zmiennej liczbowej uzyskuje ona wartość
0, a ponieważ zero pomnożone przez dowolną liczbą daje zero, nasza funkcja zwraca
zero niezależnie od wartości argumentu jej wywołania. Przekonaj sią , czy nasze
podejrzenia są słuszne zmieniając w oknie Autos wartość zmiennej dblWynik na
i wykonując kilka kolejnych iteracji.
8. Zatrzymaj tryb przerwania i zmień deklaracją zmiennej dblWynik:
. Dobrą praktyką programowania jest jawne nadawanie
zmiennym, podczas ich deklarowania, wartości początkowych.
9. Ponownie uruchom program.
10. Prześledz aktualne wartości zmiennych w trakcie wykonywania kolejnych iteracji.
11. Zatrzymaj działanie programu, skasuj ustawioną pułapką i raz jeszcze przetestuj
jego działanie.
Rozdział 9. Wyszukiwanie i programowe przechwytywanie błędów 171
12. Pierwsza funkcja działa już poprawnie, druga nadal zwraca zero. W jej przypadku
błąd nie jest spowodowany brakiem nadania wartości początkowej zmiennej.
13. Ustaw pułapką w wierszu funkcji SilniaRekurencja i uruchom
program.
14. Oblicz silnią liczby 3. Pierwsza funkcja zwróci wynik, a nastą pnie działanie programu
zostanie wstrzymane.
15. Tym razem do wyszukania błą du posłużymy sią oknem Call Stack. Skoro algorytmy
rekurencyjne polegają na wielokrotnym wywoływaniu danej procedury lub funkcji
(zagnieżdżaniu wywołań aż do osiągnią cia warunku brzegowego, po czym nastą puje
cykliczne przekazywanie obliczonych wartości zewną trznym wywołaniom), śledzenie
ich działania umożliwi właśnie to okno.
16. Wykonuj krok po kroku funkcją śledząc jednocześnie w oknie Call Stack poziom jej
zagnieżdżenia (rysunek 9.12).
Rysunek 9.12. Dzięki oknie Call Stack dowiedzieliśmy się, że funkcja SilniaRekurencja wywoływana jest
o jeden raz za dużo do obliczenia silni 3 powinna zostać wywołana 4 razy (jedno wywołanie zewnętrzne
i trzy rekurencyjne: 3! = 1 " 2 " 3)
17. Przekonaj sią , w jaki sposób, po osiągnią ciu warunku brzegowego, kolejno obliczone
wartości przekazywane są zewną trznym wywołaniom funkcji i zatrzymaj działanie
programu. Wykorzystaj do tego celu możliwość wykonywania programu instrukcja
po instrukcji.
18. Popraw definicją warunku brzegowego rekurencji: .
19. Usuń pułapką i uruchom program.
20. Wylicz silnią kilku liczb.
21. Zakończ działanie programu i zapisz wprowadzone w nim zmiany.
Przechwytywanie błędów
Program, który doskonale działa w przypadku 95% danych, może nie działać albo działać
niepoprawnie (zwracać fałszywe wyniki) dla nietypowych danych wejściowych lub
w nietypowych sytuacjach. Tworząc program, powinniśmy zabezpieczyć sią przed takimi
błą dami.
172Visual Basic .NET. Ćwiczenia
Klasa Exception
Visual Basic po raz pierwszy, dzią ki zaimplementowaniu bazowej klasy platformy .NET
Exception (wyjątek), pozwala na strukturalną obsługą błą dów. Wyjątek jest wywoływany
z tego miejsca programu, w którym wystąpił błąd wykonania. W rezultacie, tworzony
jest obiekt specjalny Exception, którego wartości atrybutów możemy programowo odczytać.
Najważniejsze atrybuty obiektu Exception to:
Message zwraca komunikat błą du,
Source zwraca oraz pozwala ustawić nazwą programu, w ramach którego
wystąpił błąd,
StackTrace zwraca listą metod, których wywołanie spowodowało wystąpienie błą du.
Instrukcja Try & Catch & Finally
Strukturalna obsługa błą dów polega na ich przechwytywaniu i reagowaniu na błą dy wyko-
nania programu. Po przechwyceniu możemy sprawdzić, jaki wyjątek został wywołany
(jaki błąd wystąpił) i spróbować programowo go naprawić.
Jeżeli w programie wystąpi nieprzechwycony błąd wykonania, działanie programu zostaje
zatrzymane, a na ekranie użytkownika wyświetlany jest systemowy komunikat o błą dzie.
Ćwiczenie 9.7.
Odczytujemy komunikaty o błędach
Instrukcje, których wykonanie może spowodować wystąpienie błą du, należy zabezpieczać
umieszczając je w bloku Try instrukcji Try & Catch & Finally. Nastą pnie, w ramach bloku
Catch należy sprawdzić, jaki wyjątek został wywołany i prawidłowo na niego zareagować.
1. Wyświetl okno edytora kodu formularza frmBledy.
2. Instrukcją, której wykonanie może spowodować wystąpienie błą du, jest przypisanie
do zmiennej liczbowej podanej przez użytkownika wartości. Dodaj nowy wiersz
powyżej instrukcji:
.
3. Wpisz i naciśnij Enter.
4. Zostaną dodane klauzule Catch oraz End Try. Przenieś do sekcji Try instrukcją ,
której wykonanie powinno zostać zabezpieczone.
5. W klauzuli Catch wyświetl użytkownikowi opis błą du i miejsca jego wystąpienia:
Rozdział 9. Wyszukiwanie i programowe przechwytywanie błędów 173
Jeżeli planujesz jedynie przechwycić błąd i zapobiec w ten sposób przerwaniu działania
programu, pozostaw pustą klauzulą Catch.
6. Uruchom program i przetestuj jego działanie przez podanie nieprawidłowych danych
wejściowych. Zwróć uwagą , że działanie programu nie jest dłużej przerywane, a po
podaniu nieprawidłowych danych przyjmowana jest domyślna wartość 1.
7. Zakończ działanie programu i zapisz wprowadzone w nim zmiany.
Ćwiczenie 9.8.
Sprawdzamy typ błędów
Klasa Exception jest klasą bazową dla nastą pujących klas:
System.ApplicationException,
System.IO.IsolatedStorage.IsolatedStorageException,
System.Runtime.Remoting.MetadataServices.SUDSGeneratorException,
System.Runtime.Remoting.MetadataServices.SUDSParserException,
System.SystemException,
System.Windows.Forms.AxHost.InvalidActiveXStateException.
Najciekawsza z naszego punktu widzenia klasa SystemException jest z kolei klasą bazową
dla kilkudziesią ciu klas definiujących konkretne typy błą dów, np.:
System.ArithmeticException,
System.IndexOutOfRangeException,
System.InvalidCastException,
System.NullReferenceException,
System.OutOfMemoryException,
System.UnauthorizedAccessException.
Umożliwiają nam one dokładne sprawdzenie typu błą du wykonania i odpowiednie zarea-
gowanie.
1. Wyświetl projekt formularza frmBledy.
2. Dodaj do formularza przycisk polecenia i ustaw nastą pujące wartości jego atrybutów:
Name , Text , Location .
3. Utwórz procedurą zdarzenia Click przycisku cmdOtwórz.
4. W ramach procedury zdarzenia spróbujemy otworzyć plik tekstowy. W trakcie
wykonywania tej operacji może wystąpić kilka błą dów: plik o podanej nazwie może
nie istnieć, niewłaściwie może zostać podana jego lokalizacja, sam plik może
zwierać niepoprawne dane itp. Dlatego pierwszą instrukcją procedury powinna być
instrukcja Try.
174 Visual Basic .NET. Ćwiczenia
5. W ramach bloku Try otwórz do odczytu plik tekstowy:
.
6. Po pierwsze, sprawdzimy, czy wykonanie tej instrukcji nie spowodowało wywołania
błą du związanego z odwołaniem sią do nieistniejącego pliku:
7. W drugiej kolejności zweryfikujmy poprawność lokalizacji pliku:
8. Nastą pnie sprawdzimy, czy dostą p do pliku nie został zablokowany:
9. I wreszcie sprawdzimy, czy plik nie został uszkodzony:
10. Ponieważ nieprzechwycony błąd spowoduje zatrzymanie programu, na końcu
wyświetlimy komunikat pozostałych błą dów:
Wyjątki są sprawdzane w określonej przez programistą kolejności, a po spełnieniu pierwszego
warunku kolejne nie są już sprawdzane. Wynika z tego, że najogólniejszy warunek powinien
być sprawdzany jako ostatni.
11. Uruchom program i przetestuj jego działanie. Wywołaj kolejno wyjątek klasy
FileNotFoundException wystarczy wpisać w wierszu Dim fs As New
System.IO.FileStream("c:\plik.txt", IO.FileMode.Open) nazwą nieistniejącego pliku;
DirectoryNotFoundException np. wpisując literą nieistniejącego napą du
i UnauthorizedAccessException np. podając poprawną nazwą i lokalizacją pliku
z ustawionym atrybutem Tylko do odczytu.
12. Zakończ działanie programu i zapisz wprowadzone w nim zmiany.
Ćwiczenie 9.9.
Wywołujemy własne wyjątki
Chociaż lista klas predefiniowanych wyjątków jest dość długa, pisząc zorientowane
obiektowo programy bą dziemy chcieli wywołać własne, odpowiadające logice progra-
mu, błą dy. W naszym przypadku próba wywołania funkcji SilniaRekurencja z ujemnym
argumentem spowoduje błąd.
1. Wyświetl okno edytora kodu formularza frmBledy.
2. Umieść wywołanie funkcji SilniaRekurencja w utworzonym bloku Try.
3. W bloku Catch wyświetl użytkownikowi komunikat o błą dzie.
Rozdział 9. Wyszukiwanie i programowe przechwytywanie błędów 175
4. Przed instrukcją End Try dodaj blok Finally. Instrukcje umieszczone w tym bloku
wykonywane są zawsze, niezależnie od tego, czy wystąpi jakikolwiek błąd.
5. W ramach bloku Finally:
a. zadeklaruj zmienną statyczną licznikWywolan typu Integer,
b. zwią ksz wartość tej zmiennej o jeden,
c. wyświetl bieżącą wartość zmiennej na ekranie.
6. Zmodyfikowane wywołanie funkcji powinno wyglądać nastą pująco:
7. Znajdz definicją funkcji SilniaRekurencja.
8. W pierwszym wierszu funkcji dodaj warunek sprawdzający, czy wartość
przekazanego argumentu jest ujemna: .
9. Możemy wywołać wyjątek za pomocą instrukcji Throw podając typ wyjątku
i ewentualnie komunikat o błą dzie wywołaj wyjątek klasy
ArgumentOutOfRangeException:
10. Uruchom program i przetestuj jego działanie. Zwróć uwagą , że błąd, który wystąpił
w wywołanej funkcji, został przekazany do procedury wywołującej i tam
dopiero został przechwycony.
11. Zakończ działanie programu i zapisz wprowadzone w nim zmiany.
Wyszukiwarka
Podobne podstrony:
02 Wprowadzenie do Visual Basic cwiczenia przygotowujaceVisual?sic NET Encyklopedia vbneto01 Wprowadzenie do Visual Studio cwiczenia przygotowujaceVisual?sic NET w praktyce Blyskawiczne tworzenie aplikacji vbneprVisual C NET Encyklopedia vcnetoVisual Basic ćwiczeniaVisual C NET Encyklopedia vcsneoVisual Basic Net Szybki startProgramowanie Obiektowe W Visual Basic Net Dla Ka degoVisual Basic NET Praktyczny kurswięcej podobnych podstron