Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00278 009092 10486285 na godz. na dobę w sumie
Visual Basic .NET. Ćwiczenia - książka
Visual Basic .NET. Ćwiczenia - książka
Autor: Liczba stron: 176
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-432-X Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> visual basic - programowanie
Porównaj ceny (książka, ebook, audiobook).

Kolejna, siódma już wersja języka Visual Basic (Visual Basic .NET) to prawdziwa 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 systemu Windows, Visual Basic .NET stał się jednym z najczęściej używanych języków programowania na świecie.

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. Jak wszystkie książki z tej serii jest ona skonstruowana w formie praktycznych ćwiczeń, pozwalających stopniowo zagłębiać się w niuanse programowania bez zbędnych rozważań teoretycznych.

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

Darmowy fragment publikacji:

Visual Basic .NET. Æwiczenia Autor: Marcin Szeliga ISBN: 83-7361-432-X Format: B5, stron: 176 Kolejna, siódma ju¿ wersja jêzyka Visual Basic (Visual Basic .NET) to prawdziwa 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 systemu Windows, Visual Basic .NET sta³ siê jednym z najczêġciej u¿ywanych jêzyków programowania na ġwiecie. 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. Jak wszystkie ksi¹¿ki z tej serii jest ona skonstruowana w formie praktycznych æwiczeñ, pozwalaj¹cych stopniowo zag³êbiaæ siê w niuanse programowania bez zbêdnych rozwa¿añ teoretycznych. Poznasz: • Platformê .NET • 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 IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl Spis treści Wstęp...................................................z...................................................z.................... .................................... 5 Rozdział 1. Microsoft Visual Studio .NET...................................................z............................................................ 9 Platforma .NET ..............................................................................................................................9 .NET Framework .....................................................................................................................9 Serwery .NET ........................................................................................................................10 Visual Studio .NET ................................................................................................................11 Visual Basic .NET .................................................................................................................19 Rozdział 2. Programy sterowane zdarzeniami ...................................................z.............................................20 Klasy.............................................................................................................................................20 Obiekty .........................................................................................................................................21 Konwencje nazewnicze ................................................................................................................37 Zasady ....................................................................................................................................37 Wskazówki.............................................................................................................................38 Jak czytelnie zapisywać kod programu? .....................................................................................38 Rozdział 3. Zmienne...................................................z...................................................z...... ........................................... 41 Zmienne i stałe .............................................................................................................................41 Stałe........................................................................................................................................45 Operatory......................................................................................................................................46 Typy danych .................................................................................................................................49 Zmienne .................................................................................................................................50 Wskaźniki ..............................................................................................................................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...................................................z........................................................................... 66 Procedury .....................................................................................................................................66 Funkcje .........................................................................................................................................73 Rozdział 5. Sterowanie wykonaniem programu...................................................z.......................................... 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...................................................z........................................................... 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 ...................................................z...................................................z......... .............................................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 ...................................................z.........................................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. (cid:1) 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 4QFKCN. 2. Zmień nazwę formularza Form1 na HTO$NGF[, jego etykietę na 9[UWMWLGO[ KRTGEJY[VWLGO[DđúF[, a rozmiar na . 3. W oknie zadań wyświetlony zostanie komunikat błędu — pao 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łęadu, b. wyświetlone zostanie okno dialogowe pozwalające na awybranie 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 — EOF5KNPKC, Text — 5KNPKC, Location — . 5. Wyświetl okno edytora kodu. 6. Zadeklaruj zmienną formularza decWynik typu Decimmal: KOFGE9[PKM#U GEKOOCN. 7. Ponieważ przy deklaracji zmiennej popełniliśmy błąd,a niewłaściwe słowo zostało podkreślone niebieską, falistą linią — aby dowiedzieća się, na czym polegał nasz błąd, ustaw kursor myszy nad zaznaczonym słowem (ryasunek 9.2). 8. Zauważ, że ten sam komunikat — Type ‘Decimmal’ is not definied. — wyświetlany jest w oknie zadań. Napraw błąd przez podanie prawiadłowej nazwy typu GEKOCN. 9. Utwórz procedurę zdarzenia Click przycisku cmdSilnia. 10. W ramach procedury zdarzenia: 162 Rysunek 9.2. W Visual Studio wyświetlony zostanie krótki opis błędów syntaktycznych Visual Basic .NET. Ćwiczenia a. zadeklaruj zmienną intLiczba typu Integer: KOKPV.KEDC#U+PVGIGT, b. przypisz zadeklarowanej zmiennej liczbę podaną przeaz użytkownika (zwróć uwagę na błędną nazwę funkcji): KPV.KEDC+PRWT$QZ 2QFCLNKEDúMVÎTGL UKNPKCOCQUVCèY[NKEQPC . 11. Zadeklaruj funkcję SilniaIteracja oczekującą na argument liczba typu Integer i zwracającą dane typu Double: (WPEVKQP5KNPKC+VGTCELC $[8CNNKEDC #U+PVGIGT #U QWDNG. 12. Usuń z sekcji deklaracji formularza deklarację zmiennaej decWynik. 13. W ramach funkcji SilniaIteracja: a. zadeklaruj zmienną dblWynik typu Double: KOFDN9[PKM#U QWDNG, b. zadeklaruj zmienną licznik typu Integer: KONKEPKM#U+PVGIGT, c. w pętli powtarzanej przekazaną jako argument liczbęa razy wylicz wartość zmiennej decWynik mnożąc ją za każdym razem przez wartość zmiennej liacznik: (QTNKEPKM6QNKEDC FGE9[PKM NKEPKM d. zwróć wyliczoną silnię: 4GVWTPFGE9[PKM. 14. W procedurze zdarzenia cmdSilnia_Click wywołaj funkcję SilniaIteracja z argumentem pobranym od użytkownika i wyświetl na aekranie otrzymany wynik: /UI$QZ 5KNPKCY[PQUK 5KNPKC+VGTCELC KPV.KEDC . 15. W oknie zadań wyświetlone zostaną dwa komunikaty o błaędach: a. pierwszy informuje o próbie odwołania się do nieistanieją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. (cid:1) Wyszukiwanie i programowe przechwytywanie błędów 163 16. Dwukrotnie kliknij pierwszy komunikat błędu — kursora zostanie ustawiony w miejscu występowania błędu. Popraw nazwę funkcji naa +PRWV$QZ. 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: (WPEVKQP5KNPKC+VGTCELC $[8CNNKEDC#U+PVGIGT #U QWDNG  KOFDN9[PKM#U QWDNG  KONKEPKM#U+PVGIGT (QTNKEPKM6QNKEDC FGE9[PKM NKEPKM 0GZV 4GVWTPFGE9[PKM PF(WPEVKQP 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 4QFKCN. 2. Po podaniu liczby, której silnię chcemy obliczyć, i kaliknięciu przycisku OK, na ekranie wyświetlony zostanie komunikat o błędziea 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 caią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 niewielae 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 spowoldowała błąd. 5. W tym momencie program znajduje się w specjalnym traybie diagnostycznym, nazywanym trybem przerwania. Opis tego trybu znajduaje się w dalszej części rozdziału, na razie zatrzymaj działanie tego trybu aklikają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łączoany i zniknie zaznaczenie błędnej instrukcji. 164 Visual Basic .NET. Ćwiczenia 6. Popraw błąd przez skonwertowanie na dane tekstowe zawracanego przez funkcję SilniaIteracja wyniku: /UI$QZ 5KNPKCY[PQUK 5KNPKC+VGTCELC KPV.KEDC 6Q5VTKPI . 7. Uruchom program i przetestuj jego działanie. Jak widaać, wyeliminowanie błędów wykonania nie oznacza, że program będzie działał priawidłowo. 8. Zakończ działanie programu i zapisz wprowadzone w niam 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. sprawdź, 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 doa zmiennej dblWynik, Wywołanie funkcji przez siebie samą jest charaktery styczne dla algorytmów rekurencyjnych. c. zwróć obliczoną wartość zmiennej dblWynik: (WPEVKQP5KNPKC4GMWTGPELC $[8CNNKEDC#U+PVGIGT #U QWDNG  KOFDN9[PKM#U QWDNG +HNKEDC6JGP 4GVWTP  NUG FDN9[PKMNKEDC 5KNPKC4GMWTGPELC NKEDC   PF+H 4GVWTPFDN9[PKM PF(WPEVKQP 4. W procedurze zdarzenia cmdSilnia_Click wywołaj funkcję SilniaRekurencja z argumentem pobranym od użytkownika i wyświetl na aekranie otrzymany wynik: /UI$QZ 5KNPKCY[PQUK 5KNPKC4GMWTGPELC KPV.KEDC 6Q5VTKPI . 5. Uruchom program. Po chwili jego działanie zostanie przaerwane, a na ekranie zostanie wyświetlony komunikat o błędzie z informacjaą o przepełnieniu stosu. Naciśnij klawisz Break. 6. Tym razem na żółto zaznaczona została deklaracja funakcji, której wywołanie spowodowało wystąpienie błędu. W naszym przypadku fuankcja wywoływała samą siebie bez końca (rysunek 9.5). 7. Przerwij tryb diagnostyczny i popraw wywołanie funkcaji SilniaRekurencja na następujące: FDN9[PKMNKEDC 5KNPKC4GMWTGPELC NKEDC . Rozdział 9. (cid:1) 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 niam 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ępane w tym trybie narzędzia. Tryb przerwania jest dostępny tylko wtedy, gdy progaram 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. Pao pierwsze, wstawiając w wykonywalnym wierszu programu pułapkę (ang. Breakpoint) — najprościej wstawić ją przez kliknięcie lewego marginesu okna eadytora kodu. Kliknij lewy margines na wysokości instrukcji KPV.KEDC+PRWV$QZ 2QFCLNKEDúMVÎTGL UKNPKCOCQUVCèY[NKEQPC . 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 kodua z zaznaczoną na żółto wykonywaną właśnie instrukcją. 4. Skasuj ustawioną pułapkę przez kliknięcie jej znakul 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 zamknaięciu okna dialogowego umożliwiającego podanie liczby i ponownie zaznaczonaa na żółto jest ostatnio wykonywania instrukcja — instrukcja Stop. 8. W trybie przerwania nie jest możliwa zmiana kodu priogramu. Przerwij jego działanie i usuń instrukcję Stop. 9. Sposobem na warunkowe przejście w tryb przerwania jlest 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: GDWI#UUGTV KPV.KEDC  . 10. Uruchom program i podaj liczbę większą niż 1. Ponieważa 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 waruneak nie został spełniony (1 nie jest większe niż 1) i wyświetlone zostało okno aumoż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. (cid:1) Wyszukiwanie i programowe przechwytywanie błędów 167 12. Zatrzymaj działanie trybu przerwania i skasuj dodanay wiersz. 13. Możemy w każdej chwili wstrzymać działanie programu nalciskają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ę kaonfigurować ustawione pułapki. 1. Wyświetl okno edytora kodu formularza frmBledy. 2. Ustaw pułapkę w wierszu +HNKEDC6JGP funkcji SilniaRekurencja. 3. Przywróć poprzednie, błędne wywołanie funkcji: FDN9[PKMNKEDC 5KNPKC4GMWTGPELC NKEDC  . 4. Kliknij prawym przyciskiem myszy symbol koła oznaczaający ustawioną pułapkę i z menu kontekstowego wybierz opcję Breakpoint Properties…. 5. Wyświetlone zostanie okno dialogowe pokazane na rysuanku 9.7. Pozwala ono na warunkowe wstrzymanie programu oraz na wstrzymanaie programu po którymś z kolei wykonaniu instrukcji, dla której ustawiono apuł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 okreaślić, kiedy (po ilu wykonaniach instrukcji) wstrzymać działanie programu. Skonfiguruja pułapkę tak, aby działanie programu zostało wstrzymane po 5 lub więcej wywołanaiach (rysunek 9.8). 168 Rysunek 9.8. Często pojedyncze wykonanie instrukcji jest poprawne, a wielokrotne jej wykonanie świadczy o błędzie programu Visual Basic .NET. Ćwiczenia 8. Uruchom program i oblicz silnię liczby 4. 9. Działanie programu zostało wstrzymane. Ponieważ obliaczenie 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 źle określonym warunku brzaegowym, 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 wyakonana, wyświetl okienko Breakpoints. Można to zrobić klikając znajdującą się na pasku naarzę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 wynaosi , a warunek sprawdzany jest piąty raz przy obliczaniu silni liczby 4 błąd aznajduje się w sposobie wywołania funkcji, a nie w sposobie sprawdzania warunku brzegowego rekurencji. Rzeczywiście tak jest — zamiast przy kolejnych wywołaniach zmniejsazać liczbę o jeden, my dodajemy do niej jeden, co powoduje, że warunek abrzegowy nigdy nie zostanie spełniony. 12. Popraw znaleziony błąd i usuń pułapkę. 13. Ustaw pułapkę w wierszu FDN9[PKM NKEPKM funkcji SilniaIteracja. 14. Wyświetl właściwości pułapki i kliknij przycisk Condition…. 15. Zostanie wyświetlone okno dialogowe pozwalające na oakreślenie warunku logicznego, którego spełnienie spowoduje wyzwoleniea pułapki (rysunek 9.9). Rysunek 9.9. Warunkowe wywoływanie ustawionej pułapki 16. Wpisz warunek, którego spełnienie spowoduje wywołanaie pułapki: NKEPKM NKEDC. 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żytkowanika liczba, której silnia ma zostać wyliczona. 17. Uruchom program. Po chwili jego działanie zostanie wstarzymane. Rozdział 9. (cid:1) Wyszukiwanie i programowe przechwytywanie błędów 169 18. Odczytując (przez ustawienie kursora myszy) wartości zamiennych licznik i dblWynik dowiemy się, że niezależnie od tego, ile razy wykonaywane jest mnożenie, wartość zmiennej dblWynik zawsze jest równa 0. 19. Pewnie już domyślasz się, gdzie znajduje się błąd w atej 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: (cid:1) wykonywanie programu wiersz po wierszu, (cid:1) śledzenie wyników wykonania poszczególnych instrukcjai wykonania, (cid:1) odczytywanie i modyfikowanie wartości zmiennych, (cid:1) natychmiastowe wykonanie dowolnej instrukcji, proceadury 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śnaie będzie wykonana. 6. Trzy kolejne przyciski służą do sterowania wykonaniaem programu: a. wybranie opcji Step Into powoduje wykonanie programu instrukcja po instrukcaji; jeżeli wywołana zostanie procedura lub funkcja, jeja 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 podprocaedura lub funkcja, zostanie ona wykonana w całości, tak jakby była pojedynczą ianstrukcją, c. wybranie opcji Step Out spowoduje wykonanie całej podprocedury lub wywoływanej funkcji i ustawienie kursora w nastaę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.ain. okienek: a. Locals zawierającego nazwę, aktualną wartość i typ wszystkaich zmiennych zdefiniowanych dla procedury, w której nastąpiło przaerwanie wykonywania programu, b. Immediate pozwalającego na wykonywanie dowolnych instrukcji ajęzyka Visual Basic lub dyrektyw kompilatora, c. Autos pozwalającego na śledzenie aktualnych wartości wybraanych zmiennych, d. Call Stack zawierającego hierarchię nazw wszystkich procedur luab funkcji, z których wywołany został zaznaczony fragment podproagramu. 1. Ustaw pułapkę w wierszu FDN9[PKM NKEPKM funkcji SilniaIteracja. 2. Uruchom program i podaj liczbę . 3. Działanie programu zostanie wstrzymane i wyświetlonea 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 kolejnyach instrukcji, że jej wartość nigdy się nie zmienia. 7. W tym przypadku błąd polegał na braku przypisania waartości początkowej  zmiennej dblWynik. Domyślnie, po zadeklarowaniu zmiennej liczbowej uzayskuje 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łaniaa. 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ę zmienneaj dblWynik: KOFDN9[PKM #U QWDNG. Dobrą praktyką programowania jest jawne nadawanie zmiennym, podczas ich deklarowania, wartości początkiowych. 9. Ponownie uruchom program. 10. Prześledź aktualne wartości zmiennych w trakcie wykonyawania kolejnych iteracji. 11. Zatrzymaj działanie programu, skasuj ustawioną pułaapkę i raz jeszcze przetestuj jego działanie. Rozdział 9. (cid:1) Wyszukiwanie i programowe przechwytywanie błędów 171 12. Pierwsza funkcja działa już poprawnie, druga nadal zawraca zero. W jej przypadku błąd nie jest spowodowany brakiem nadania wartości apoczątkowej zmiennej. 13. Ustaw pułapkę w wierszu +HNKEDC6JGP 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 daanej procedury lub funkcji (zagnieżdżaniu wywołań aż do osiągnięcia warunku brzaegowego, 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 oaknie Call Stack poziom jej zagnieżdżenia (rysunek 9.12). Rysunek 9.12. Dzięki oknie Call Stack dowiedzieliśmy się, że funkcjea 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 funkacji i zatrzymaj działanie programu. Wykorzystaj do tego celu możliwość wykonywaania programu instrukcja po instrukcji. 18. Popraw definicję warunku brzegowego rekurencji: +HNKEDC6JGP. 19. Usuń pułapkę i uruchom program. 20. Wylicz silnię kilku liczb. 21. Zakończ działanie programu i zapisz wprowadzone w niam 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. 172 Visual 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 odczaytać. Najważniejsze atrybuty obiektu Exception to: (cid:1) Message — zwraca komunikat błędu, (cid:1) Source — zwraca oraz pozwala ustawić nazwę programu, w ramaach którego wystąpił błąd, (cid:1) StackTrace — zwraca listę metod, których wywołanie spowodowałoa 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 naprawaić. Jeżeli w programie wystąpi nieprzechwycony błąd wyko nania, działanie programu zostaje zatrzymane, a na ekranie użytkownika wyświetlany jes t 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 parawidłowo na niego zareagować. 1. Wyświetl okno edytora kodu formularza frmBledy. 2. Instrukcją, której wykonanie może spowodować wystąpiaenie błędu, jest przypisanie do zmiennej liczbowej podanej przez użytkownika waratości. Dodaj nowy wiersz powyżej instrukcji: KPV.KEDC+PRWV$QZ 2QFCLNKEDúMVÎTGLUKNPKC OCQUVCèY[NKEQPC . 3. Wpisz 6T[ 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 waystąpienia: 6T[ KPV.KEDC+PRWV$QZ 2QFCLNKEDúMVÎTGLUKNPKCOCQUVCèY[NKEQPC CVEJGZ#U ZEGRVKQP /UI$QZ 9[UVæRKđDđæF GZ/GUUCIG XD T.HA  9[YQđCP[RTG GZ5VCEM6TCEG PF6T[ Rozdział 9. (cid:1) 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 jaest dłużej przerywane, a po podaniu nieprawidłowych danych przyjmowana jest domyaślna wartość 1. 7. Zakończ działanie programu i zapisz wprowadzone w niam zmiany. Ćwiczenie 9.8. Sprawdzamy typ błędów Klasa Exception jest klasą bazową dla następujących klas: (cid:1) System.ApplicationException, (cid:1) System.IO.IsolatedStorage.IsolatedStorageException, (cid:1) System.Runtime.Remoting.MetadataServices.SUDSGeneratorExceptio n, (cid:1) System.Runtime.Remoting.MetadataServices.SUDSParserException, (cid:1) System.SystemException, (cid:1) System.Windows.Forms.AxHost.InvalidActiveXStateException. Najciekawsza z naszego punktu widzenia klasa SystemException jest z kolei klasą bazową dla kilkudziesięciu klas definiujących konkretne typay błędów, np.: (cid:1) System.ArithmeticException, (cid:1) System.IndexOutOfRangeException, (cid:1) System.InvalidCastException, (cid:1) System.NullReferenceException, (cid:1) System.OutOfMemoryException, (cid:1) 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 — EOF1VYQT, Text — 1VYÎT, Location — . 3. Utwórz procedurę zdarzenia Click przycisku cmdOtwórz. 4. W ramach procedury zdarzenia spróbujemy otworzyć plika tekstowy. W trakcie wykonywania tej operacji może wystąpić kilka błędówa: plik o podanej nazwie może nie istnieć, niewłaściwie może zostać podana jego loakalizacja, sam plik może zwierać niepoprawne dane itp. Dlatego pierwszą instraukcją procedury powinna być instrukcja Try. 174 Visual Basic .NET. Ćwiczenia 5. W ramach bloku Try otwórz do odczytu plik tekstowy: KOHU#U0GY5[UVGO+1(KNG5VTGCO E RNKMVZV+1(KNG/QFG1RGP . 6. Po pierwsze, sprawdzimy, czy wykonanie tej instrukcaji nie spowodowało wywołania błędu związanego z odwołaniem się do nieistniejącegao pliku: CVEJGZ#U5[UVGO+1(KNG0QV(QWPF ZEGRVKQP /UI$QZ 0KGPCNCđGOQMTGħNQPGIQRNKMW 7. W drugiej kolejności zweryfikujmy poprawność lokalizacaji pliku: CVEJGZ#U5[UVGO+1 KTGEVQT[0QV(QWPF ZEGRVKQP /UI$QZ 0KGRQRTCYPCNQMCNKCELCRNKMW 8. Następnie sprawdzimy, czy dostęp do pliku nie zostaał zablokowany: CVEJGZ#U5[UVGO7PCWVJQTKGF#EEGUU ZEGRVKQP /UI$QZ 1FOQYCFQUVúRW 9. I wreszcie sprawdzimy, czy plik nie został uszkodzoany: CVEJGZ#U5[UVGO+1(KNG.QCF ZEGRVKQP /UI$QZ 7UMQFQP[RNKMFCP[OK 10. Ponieważ nieprzechwycony błąd spowoduje zatrzymanie aprogramu, na końcu wyświetlimy komunikat pozostałych błędów: CVEJGZ#U ZEGRVKQP /UI$QZ 0KGQEGMKYCP[DđæF GZ/GUUCIG 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 akolejno 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 niam 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. (cid:1) 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 wystlą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ć nastaępująco: 6T[ /UI$QZ 5KNPKCY[PQUK 5KNPKC4GMWTGPELC KPV.KEDC 6Q5VTKPI CVEJGZ#U ZEGRVKQP /UI$QZ GZ/GUUCIG (KPCNN[ 5VCVKENKEPKM9[YQNCP#U+PVGIGT NKEPKM9[YQNCP  /UI$QZ .KEPKMY[PQUK NKEPKM9[YQNCP6Q5VTKPI PF6T[ 7. Znajdź definicję funkcji SilniaRekurencja. 8. W pierwszym wierszu funkcji dodaj warunek sprawdzająacy, czy wartość przekazanego argumentu jest ujemna: +HNKEDC6JGP. 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ąteka klasy ArgumentOutOfRangeException: +HNKEDC6JGP 6JTQY0GY#TIWOGPV1WV1H4CPIG ZEGRVKQP 7LGOP[CTIWOGPVY[YQđCPKC PF+H 10. Uruchom program i przetestuj jego działanie. Zwróć uwaagę, że błąd, który wystąpił w wywołanej funkcji, został przekazany do proceduryi wywołującej i tam dopiero został przechwycony. 11. Zakończ działanie programu i zapisz wprowadzone w niam zmiany.
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Visual Basic .NET. Ćwiczenia
Autor:

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ą: