Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00395 008660 10487740 na godz. na dobę w sumie
Visual Basic .NET. Alchemia programowania - książka
Visual Basic .NET. Alchemia programowania - książka
Autor: Liczba stron: 712
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-0292-6 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> visual basic - programowanie
Porównaj ceny (książka, ebook, audiobook).
Utwórz własne aplikacje dla systemu Windows.

Visual Basic to jeden z najpowszechniej używanych języków programowania. Ostatnie badania potwierdzają jego popularność - korzysta z niego ponad 5 milionów programistów z całego świata. Jego ostatnia wersja, zintegrowana z platformą .NET, to w pełni obiektowy język, który jednak nadal zachował charakterystyczne dla siebie cechy, czyli prostą i czytelną składnię, łatwość tworzenia nawet najbardziej rozbudowanych aplikacji oraz ogromną elastyczność. Za jego pomocą można budować dla systemu Windows wydajne aplikacje, korzystające z baz danych oraz połączeń internetowych.

Książka 'Visual Basic .NET. Alchemia programowania' to podręcznik wprowadzający w tajniki tworzenia aplikacji w tym języku. Dzięki niemu poznasz język Visual Basic .NET i nauczysz się pisać własne programy przeznaczone dla systemu Windows, opierające się na mechanizmach oferowanych przez platformę .NET. Zanim jednak przystąpisz do pisania aplikacji, dowiesz się, na czym polega programowanie obiektowe, poznasz elementy języka Visual Basic .NET i technologie, jakie możesz wykorzystać w swoich aplikacjach. Zdobędziesz wiedzę niezbędną do tego, aby budować złożone aplikacje oparte o bazy danych i mechanizmy sieciowe.

Dołącz do grona milionów fanów języka Visual Basic.

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

Darmowy fragment publikacji:

Visual Basic .NET. Alchemia programowania Autor: Jack Purdum T‡umaczenie: Rados‡aw Wroæski, Ma‡gorzata D„bkowska-Kowalik ISBN: 978-83-246-0292-6 Tytu‡ orygina‡u: Visual Basic .NET Primer Plus Stron: 712 Utw(cid:243)rz w‡asne aplikacje dla systemu Windows (cid:149) Poznaj zasady projektowania obiektowego. (cid:149) Wykorzystaj komponenty platformy .NET. (cid:149) Zastosuj zaawansowane techniki programowania. Visual Basic to jeden z najpowszechniej u¿ywanych jŒzyk(cid:243)w programowania. Ostatnie badania potwierdzaj„ jego popularno(cid:156)(cid:230) (cid:150) korzysta z niego ponad 5 milion(cid:243)w programist(cid:243)w z ca‡ego (cid:156)wiata. Jego ostatnia wersja, zintegrowana z platform„ .NET, to w pe‡ni obiektowy jŒzyk, kt(cid:243)ry jednak nadal zachowa‡ charakterystyczne dla siebie cechy, czyli prost„ i czyteln„ sk‡adniŒ, ‡atwo(cid:156)(cid:230) tworzenia nawet najbardziej rozbudowanych aplikacji oraz ogromn„ elastyczno(cid:156)(cid:230). Za jego pomoc„ mo¿na budowa(cid:230) dla systemu Windows wydajne aplikacje, korzystaj„ce z baz danych oraz po‡„czeæ internetowych. Ksi„¿ka (cid:132)Visual Basic .NET. Alchemia programowania(cid:148) to podrŒcznik wprowadzaj„cy w tajniki tworzenia aplikacji w tym jŒzyku. DziŒki niemu poznasz jŒzyk Visual Basic .NET i nauczysz siŒ pisa(cid:230) w‡asne programy przeznaczone dla systemu Windows, opieraj„ce siŒ na mechanizmach oferowanych przez platformŒ .NET. Zanim jednak przyst„pisz do pisania aplikacji, dowiesz siŒ, na czym polega programowanie obiektowe, poznasz elementy jŒzyka Visual Basic .NET i technologie, jakie mo¿esz wykorzysta(cid:230) w swoich aplikacjach. ZdobŒdziesz wiedzŒ niezbŒdn„ do tego, aby budowa(cid:230) z‡o¿one aplikacje oparte o bazy danych i mechanizmy sieciowe. (cid:149) Podstawy programowania obiektowego (cid:149) Typy danych w Visual Basicu (cid:149) Operatory (cid:149) Podprogramy i funkcje (cid:149) Przetwarzanie tablic (cid:149) Stosowanie komponent(cid:243)w .NET (cid:149) Po‡„czenia z bazami danych Do‡„cz do grona milion(cid:243)w fan(cid:243)w jŒzyka Visual Basic Wydawnictwo Helion ul. Ko(cid:156)ciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl SPIS TREŚCI 5 SPIS TREŚCI O autorze .......................................................................................................................................... 17 Wprowadzenie ................................................................................................................................. 19 Rozdział 1. Zaczynamy pracę w Visual Studio .Net ................................................................. 25 Instalacja Visual Studio .NET ............................................................................................ 26 Kontrola poprawności działania zainstalowanego Visual Basic .NET ....................... 35 Uruchamianie Visual Studio .NET ............................................................................. 35 Zintegrowane środowisko programistyczne Visual Basic .NET ............................ 37 Przenoszenie obiektu z przybornika na formularz .................................................. 38 Zmienianie wartości właściwości ................................................................................ 39 Uruchamianie pierwszego programu .............................................................................. 39 Konsolidacja a kompilacja ............................................................................................ 39 Inne sposoby uruchomienia programu ..................................................................... 40 Kończenie sesji programowania w Visual Basic .NET .................................................... 40 Podsumowanie .................................................................................................................... 41 Pytania kontrolne ................................................................................................................ 41 Rozdział 2. Podstawy programowania obiektowego ................................................................ 43 Krótka historia programowania komputerowego ......................................................... 44 Języki programowania .................................................................................................. 44 Programowanie strukturalne ...................................................................................... 51 Programowanie obiektowe .......................................................................................... 52 Przykład programu obiektowego ..................................................................................... 56 Okno projektu (Design Window) ............................................................................... 58 Okno właściwości (Properties Window) ................................................................... 58 Umieszczanie na formularzu innych obiektów ........................................................ 61 Kompilacja pierwszego programu ................................................................................... 63 Uruchamianie programu w Visual Basic .NET ............................................................... 65 6 VISUAL BASIC .NET. ALCHEMIA PROGRAMOWANIA Pisanie kodu programu ...................................................................................................... 66 Operator kropki ............................................................................................................. 68 Wywoływanie metody obiektu ................................................................................... 69 Słowo kluczowe Me ...................................................................................................... 71 Eksperymenty z przykładowym programem .......................................................... 72 Podsumowanie .................................................................................................................... 73 Pytania kontrolne ................................................................................................................ 74 Rozdział 3. Jak zaprojektować program ...................................................................................... 77 Po co się tym w ogóle zajmować? ..................................................................................... 77 Algorytmy ............................................................................................................................. 78 Algorytmy makro i mikro ............................................................................................. 78 Pięć kroków programowania ............................................................................................ 79 Krok inicjalizacji ............................................................................................................. 79 Krok wprowadzania danych ....................................................................................... 80 Krok przetwarzania ....................................................................................................... 80 Krok prezentacji wyniku .............................................................................................. 81 Krok porządkowania .................................................................................................... 81 Pięć kroków w każdym programie? ........................................................................... 82 Uściślanie .............................................................................................................................. 82 Uściślanie kroku inicjalizacji ........................................................................................ 83 Pseudokod ...................................................................................................................... 83 Co to jest UML? ................................................................................................................... 84 Krótka historia UML ..................................................................................................... 84 Diagramy UML .............................................................................................................. 85 OOA, OOD i OOP ........................................................................................................ 85 Diagramy klas UML ............................................................................................................ 87 Właściwości (atrybuty) klasy ....................................................................................... 88 Metody (operacje) klasy ............................................................................................... 88 Podsumowanie .................................................................................................................... 91 Pytania kontrolne ................................................................................................................ 91 Rozdział 4. Typy danych i zmienne liczbowe ............................................................................ 93 Typy danych w języku Visual Basic .NET ....................................................................... 93 Którego typu danych użyć? ......................................................................................... 94 Szczegółowe omówienie typów danych języka Visual Basic .NET ............................ 96 Typ Boolean .................................................................................................................... 96 Typ Byte .......................................................................................................................... 97 Typ Char ......................................................................................................................... 97 Typ Decimal ................................................................................................................... 98 Typy danych Double i Single ...................................................................................... 99 Typy danych Integer, Long i Short ............................................................................ 99 Typ Object .................................................................................................................... 100 Typ danych String ....................................................................................................... 100 Typ User Defined (zdefiniowany przez użytkownika) ........................................ 101 SPIS TREŚCI 7 Zmienne .............................................................................................................................. 101 Nazwa zmiennej .......................................................................................................... 102 Słowa kluczowe ........................................................................................................... 103 Polecnie Dim: definiowanie zmiennych .................................................................. 104 Za kurtyną: tablica symboli Visual Basic .NET ............................................................. 105 Tablica symboli ............................................................................................................ 105 lvalue i rvalue ............................................................................................................... 106 Argumenty i operatory ............................................................................................... 107 W jaki sposób Visual Basic .NET przetwarza instrukcję przypisania? ............... 108 Program Inspector ............................................................................................................. 108 Błędy w programach w Visual Basic .NET .................................................................... 111 Błędy semantyczne ..................................................................................................... 112 Prosty program matematyczny ....................................................................................... 113 Konwersje typów danych .......................................................................................... 114 Biblioteki Visual Basic .NET ....................................................................................... 115 Liczby binarne .................................................................................................................... 116 Podsumowanie .................................................................................................................. 118 Pytania kontrolne .............................................................................................................. 119 Rozdział 5. Podprogramy i funkcje ............................................................................................ 121 Podprogramy ..................................................................................................................... 121 Dlaczego używa się podprogramów? ...................................................................... 122 Piszemy prosty podprogram ..................................................................................... 122 Wywoływanie podprogramu .................................................................................... 124 Parametry podprogramów ........................................................................................ 125 Przykładowy program z parametrami podprogramu .......................................... 125 Funkcje ................................................................................................................................ 137 Podsumowanie .................................................................................................................. 139 Pytania kontrolne .............................................................................................................. 139 Rozdział 6. Zmienne tekstowe .................................................................................................... 143 Łańcuchy znaków ............................................................................................................. 143 Pola tekstowe i łańcuchy znaków ............................................................................. 144 Operacje na danych znakowych w Visual Basic .NET .......................................... 144 Łączenie łańcuchów znaków ..................................................................................... 145 Długość tekstu .............................................................................................................. 147 Operacje na fragmentach łańcuchów znaków ....................................................... 148 Funkcja InStr() ............................................................................................................. 152 Bezpośrednie operowanie na danych typu String ................................................ 153 Korzystanie z klasy String języka Visual Basic .NET ................................................... 153 Metoda Length ............................................................................................................ 153 Metoda Concat ............................................................................................................. 154 Metoda SubString ........................................................................................................ 156 Imitowanie funkcji Left() i Right() przy użyciu metody SubString .................... 158 Szukanie fragmentów ciągów znaków .................................................................... 159 8 VISUAL BASIC .NET. ALCHEMIA PROGRAMOWANIA Sprawdzanie, co jest zapisane na danej pozycji w ciągu znaków — metoda Chars .................................................................................................... 160 Porównywanie tekstów — metoda Compare ........................................................ 161 Metoda Insert klasy String ......................................................................................... 163 Metoda Replace klasy String ..................................................................................... 164 Inne metody klasy String ................................................................................................. 165 Podsumowanie .................................................................................................................. 165 Pytania kontrolne .............................................................................................................. 166 Rozdział 7. Tablice ......................................................................................................................... 169 Organizacja danych przy użyciu tablic ......................................................................... 169 Elementy tablicy .......................................................................................................... 170 Indeksy tablicy ............................................................................................................. 171 Prosty program przykładowy korzystający z tablicy elementów typu String ......................................................................... 171 Udoskonalanie programu .......................................................................................... 173 Zmiana podstawowego indeksu tablicy ........................................................................ 174 Tablice dynamiczne ........................................................................................................... 176 Korzystanie z subtelnej właściwości instrukcji ReDim w czasie działania programu ............................................................................... 178 Wymuszanie błędu ..................................................................................................... 179 Słowo kluczowe Preserve ........................................................................................... 179 Tablice wielowymiarowe ................................................................................................. 180 Tablice wielowymiarowe o więcej niż dwóch wymiarach ......................................... 184 Dynamiczne tablice wielowymiarowe ..................................................................... 184 Poznawanie rozmiaru tablicy .......................................................................................... 185 Podsumowanie .................................................................................................................. 186 Pytania kontrolne .............................................................................................................. 187 Rozdział 8. Zasięg i czas życia zmiennych ................................................................................ 191 Co to jest zasięg? ................................................................................................................ 191 Zasięg lokalny (proceduralny) .................................................................................. 192 Zasięg blokowy .................................................................................................................. 196 Ta sama nazwa zmiennej na różnych poziomach zasięgu ................................... 197 Zasięg modułowy .............................................................................................................. 198 Definicja klasy .............................................................................................................. 199 Dim, Private i zasięg modułowy ............................................................................... 200 Przestrzenie nazw ............................................................................................................. 200 Przeznaczenie przestrzeni nazw ............................................................................... 201 Zasięg przestrzeni nazw ............................................................................................. 202 Współdzielenie zmiennych pomiędzy formularzami ........................................... 204 Czasy życia ......................................................................................................................... 206 Klasa pamięci Static ..................................................................................................... 207 Podsumowanie .................................................................................................................. 207 Pytania kontrolne .............................................................................................................. 208 SPIS TREŚCI 9 Rozdział 9. Operatory arytmetyczne i przypisania ................................................................. 211 Operatory arytmetyczne .................................................................................................. 211 Unarny plus i unarny minus ..................................................................................... 213 Przykładowy program ilustrujący wykorzystanie operatorów arytmetycznych ........................................................................................................... 213 Operatory skrócone .......................................................................................................... 218 Priorytet operatorów ......................................................................................................... 219 Wiązanie ....................................................................................................................... 220 Zmienianie kolejności wykonywania działań ........................................................ 221 Podsumowanie .................................................................................................................. 222 Ćwiczenie ............................................................................................................................ 222 Pytania kontrolne .............................................................................................................. 223 Rozdział 10. Operatory relacyjne i logiczne ............................................................................. 225 Operatory relacyjne .......................................................................................................... 225 Proste wyrażenie If-Then-Else .................................................................................. 226 Operatory logiczne ............................................................................................................ 229 Operator logiczny And ............................................................................................... 230 Operator logiczny Or .................................................................................................. 231 Operator logiczny Xor ................................................................................................ 232 Operacje poziomu bitowego wykonywane za pomocą operatorów logicznych ..................................................................... 233 Priorytety operatorów ...................................................................................................... 237 Podsumowanie .................................................................................................................. 239 Pytania kontrolne .............................................................................................................. 239 Rozdział 11. Podejmowanie decyzji ........................................................................................... 243 Proste wyrażenia z instrukcją If ...................................................................................... 244 Korzystanie z debugera Visual Basic .NET do śledzenia przepływu sterowania w programie ...................................................................................... 246 Upraszczanie programu ............................................................................................. 248 Wywołania funkcji a testy If ...................................................................................... 249 Konstrukcja If-Then-Else .................................................................................................. 251 Blok instrukcji If, blok instrukcji Then i blok instrukcji Else ................................ 252 Wybór jednej z wielu możliwości przy użyciu instrukcji If ....................................... 252 Instrukcja ElseIf ........................................................................................................... 253 Konstrukcja Select Case .................................................................................................... 254 Odmiany instrukcji Select Case ................................................................................ 255 Instrukcje Select Case z zakresami wartości ........................................................... 256 Instrukcje Select Case z ograniczonymi zakresami ............................................... 256 Wyliczanie: poprawianie czytelności bloków Select Case .......................................... 258 Operatory skrótowe .......................................................................................................... 259 Operator AndAlso ....................................................................................................... 259 Operator OrElse ........................................................................................................... 260 Podsumowanie .................................................................................................................. 261 Pytania kontrolne .............................................................................................................. 261 10 VISUAL BASIC .NET. ALCHEMIA PROGRAMOWANIA Rozdział 12. Pętle .......................................................................................................................... 267 Struktura pętli .................................................................................................................... 267 Prosta pętla w programie ................................................................................................. 268 Czy jest to dobrze zachowująca się pętla? .............................................................. 271 Pętla For-Next .................................................................................................................... 272 Instrukcja Next ............................................................................................................. 273 Zastosowanie pętli For-Next w implementacji algorytmu ......................................... 274 Alternatywny format definiowania zmiennych ..................................................... 276 Śledzenie kodu ............................................................................................................. 276 Dyskomfort myślowy ................................................................................................. 277 Która wersja jest lepsza? ............................................................................................ 278 Pętle For i tablice ................................................................................................................ 279 Typy danych Structure ............................................................................................... 279 Zdarzenie btnAdd_Click ............................................................................................ 281 Zdarzenie btnDone_Click .......................................................................................... 283 Exit For — wcześniejsze opuszczenie pętli ................................................................... 284 Zagnieżdżone pętle For .................................................................................................... 285 Podsumowanie .................................................................................................................. 287 Pytania kontrolne .............................................................................................................. 287 Rozdział 13. Pętle While ............................................................................................................... 293 Pętle While-End While ..................................................................................................... 293 Reguły składniowe dotyczące bloku While-End While ........................................ 294 Program do konwersji liczb binarnych .......................................................................... 295 To, czego nie widać gołym okiem ............................................................................. 295 Funkcja ConvertToBinary() ....................................................................................... 296 Funkcja ConvertToDecimal() .................................................................................... 299 Pętle Do While — odmiana pierwsza ............................................................................ 301 Pętle Do While — odmiana druga .................................................................................. 303 Pętle Until ........................................................................................................................... 305 Do Until ......................................................................................................................... 305 Loop Until ..................................................................................................................... 306 Wcześniejsze wychodzenie z pętli Do ........................................................................... 306 Zagnieżdżone pętle Do i Exit Do .............................................................................. 307 Wartownicy ........................................................................................................................ 307 Podsumowanie .................................................................................................................. 309 Pytania kontrolne .............................................................................................................. 310 Rozdział 14. Zaawansowane przetwarzanie tablic .................................................................. 313 Deklarowanie i definiowanie tablic ................................................................................ 313 Skalary tablic ................................................................................................................ 314 Indeksowanie tablic .................................................................................................... 314 Sortowanie tablicy ............................................................................................................. 315 Przeszukiwanie tablicy ..................................................................................................... 318 Przeszukiwanie sekwencyjne .................................................................................... 319 Przeszukiwanie binarne ............................................................................................. 319 SPIS TREŚCI 11 Inne właściwości i metody dotyczące tablic .................................................................. 323 Length ........................................................................................................................... 323 Rank ............................................................................................................................... 323 Clear ............................................................................................................................... 323 Copy .............................................................................................................................. 324 GetLength ..................................................................................................................... 324 Reverse .......................................................................................................................... 325 Tablice jako obiekty ........................................................................................................... 325 Zmienne referencyjne ................................................................................................. 326 Listy inicjalizujące obiektów tablic ........................................................................... 329 Przykładowy program korzystający z obiektu tablicy ................................................ 330 Kolekcje ............................................................................................................................... 334 Magiczne kwadraty ..................................................................................................... 334 Podsumowanie .................................................................................................................. 339 Pytania kontrolne .............................................................................................................. 339 Rozdział 15. Hermetyzacja .......................................................................................................... 343 Tworzenie własnych klas ................................................................................................. 344 Krok 1. Tworzenie ogólnego szkicu projektu ......................................................... 344 Krok 2. Analiza opcji tworzenia klasy ...................................................................... 345 Uściślenie projektu ...................................................................................................... 346 Dodawanie klasy do projektu ......................................................................................... 349 Dodawanie składników do klas ................................................................................ 351 Dodawanie konstruktorów do klasy ........................................................................ 352 Dodawanie do klasy nowego użytkownika ............................................................ 355 Procedury publiczne i interfejs klasy ....................................................................... 357 Procedury pomocnicze klasy ..................................................................................... 359 Dodawanie reszty kodu klasy CPassword .............................................................. 360 Testowanie kodu klasy CPassword ................................................................................ 364 Kod TestPassword ....................................................................................................... 365 Sprawdzanie użytkownika i hasła ............................................................................ 367 Stopniowe zwalnianie obiektów ............................................................................... 368 Tworzenie własnej biblioteki klasy ................................................................................. 369 Korzystanie z plików bibliotecznych ....................................................................... 371 Podsumowanie .................................................................................................................. 371 Pytania kontrolne .............................................................................................................. 372 Rozdział 16. Właściwości klasy ................................................................................................... 375 Tworzenie projektu programu ........................................................................................ 375 Metody akcesora właściwości .................................................................................... 377 Kod klasy COven ......................................................................................................... 378 Testowanie klasy COven .................................................................................................. 382 Kod do testowania klasy COven .............................................................................. 383 Właściwości ReadOnly i WriteOnly ............................................................................... 389 Podsumowanie .................................................................................................................. 390 Pytania kontrolne .............................................................................................................. 390 12 VISUAL BASIC .NET. ALCHEMIA PROGRAMOWANIA Rozdział 17. Dziedziczenie .......................................................................................................... 393 Klasy bazowe i pochodne ................................................................................................ 394 Relacja „Is a” ................................................................................................................. 394 Po co nam klasa bazowa i klasy pochodne? ............................................................ 395 Klasa bazowa Building ..................................................................................................... 396 Specyfikator dostępu Protected ................................................................................ 399 Klasy pochodne Apartment, Commercial i Home ....................................................... 400 Dane składowe i akcesory właściwości .................................................................... 403 Metody klas pochodnych ........................................................................................... 403 Zdefiniować a zadeklarować ........................................................................................... 404 Czym metody różnią się od funkcji i podprogramów? ........................................ 404 Testowanie klasy Building ............................................................................................... 406 Użycie pól kombi ......................................................................................................... 406 Dane składowe klasy pochodnej .............................................................................. 407 Proste zmiany ulepszające program do testowania klasy Building .................... 412 Klasy wirtualne .................................................................................................................. 413 Słowo kluczowe MustInherit ..................................................................................... 413 Słowa kluczowe, które dotyczą dziedziczenia ....................................................... 414 Podsumowanie .................................................................................................................. 419 Pytania kontrolne .............................................................................................................. 419 Rozdział 18. Polimorfizm ............................................................................................................. 423 Czym jest polimorfizm? .................................................................................................... 423 Przykład dziedziczenia i polimorfizmu ......................................................................... 424 Konstruktor klasy bazowej ........................................................................................ 424 Konstruktory z listą inicjalizującą ............................................................................. 425 Testowanie polimorfizmu ................................................................................................ 435 Praca z klasami wirtualnymi ..................................................................................... 437 Użycie konstrukcji For Each dla obiektów tabeli ................................................... 437 Tworzenie interfejsu ......................................................................................................... 439 Deklaracje interfejsu ................................................................................................... 439 Implementowanie interfejsu ..................................................................................... 440 Podsumowanie .................................................................................................................. 444 Pytania kontrolne .............................................................................................................. 444 Rozdział 19. Obsługa błędów i debugowanie .......................................................................... 447 Typy błędów ...................................................................................................................... 448 Błędy składniowe ........................................................................................................ 448 Błędy semantyczne ..................................................................................................... 449 Błędy logiczne .............................................................................................................. 451 Przykładowy program do testowania debugera .......................................................... 451 Użycie debugera języka Visual Basic .NET ................................................................... 454 Ustawianie punktu przerwania ................................................................................ 455 Okno Locals .................................................................................................................. 456 Okno Autos .................................................................................................................. 456 SPIS TREŚCI 13 Okno Watch ................................................................................................................. 458 Licznik trafień .............................................................................................................. 459 Okno Command .......................................................................................................... 460 Wartości graniczne ...................................................................................................... 460 Inne okna ...................................................................................................................... 461 Niestrukturalna obsługa błędów .................................................................................... 462 Instrukcja On Error Goto ........................................................................................... 462 Me.Update() ................................................................................................................. 464 Exit Sub .......................................................................................................................... 465 Resume Next ................................................................................................................ 465 Resume .......................................................................................................................... 465 On Error Goto 0 ........................................................................................................... 465 Strukturalna obsługa błędów .......................................................................................... 466 Blok instrukcji Try ....................................................................................................... 467 Blok instrukcji Catch ................................................................................................... 467 Blok instrukcji Finally ................................................................................................. 469 Instrukcja End Try ....................................................................................................... 469 Przykład programu z obsługą wyjątków ...................................................................... 470 Zdarzenie kliknięcia btnCalc ..................................................................................... 473 Funkcja StandardDeviation() .................................................................................... 473 Słowo kluczowe Throw .............................................................................................. 475 Blok instrukcji Finally ................................................................................................. 476 Podsumowanie .................................................................................................................. 476 Pytania kontrolne .............................................................................................................. 477 Rozdział 20. Formanty w Visual Basic .NET ............................................................................. 481 Formant Form .................................................................................................................... 482 Zdarzenie Load() formantu Form ............................................................................. 482 Właściwości sterujące formantem Form .................................................................. 484 Metody formantu Form .............................................................................................. 490 Przykładowy program z obiektami formantów ........................................................... 491 Pole kombi .................................................................................................................... 492 Przyciski radiowe ........................................................................................................ 498 Uruchomienie przykładowego programu .................................................................... 499 Zdarzenie Load() formularza .................................................................................... 501 Zdarzenie Click() obiektu btnCheck ........................................................................ 501 Podsumowanie .................................................................................................................. 503 Pytania kontrolne .............................................................................................................. 504 Rozdział 21. Tworzenie własnych formantów ......................................................................... 507 Formant PhoneSSN ........................................................................................................... 508 Rozpoczynanie projektu ............................................................................................ 510 Formularz UserControl .............................................................................................. 510 Nadawanie nazwy formantowi ................................................................................ 511 Umieszczanie pól tekstowych w formancie ............................................................ 511 14 VISUAL BASIC .NET. ALCHEMIA PROGRAMOWANIA Dodawanie kodu do niestandardowego formantu PhoneSSN ........................... 512 Atrybuty komponentu ................................................................................................ 513 Użycie typów danych Enum do wyboru właściwości .......................................... 515 Opisywanie i określanie kategorii procedury właściwości .................................. 515 Kod procedury właściwości InputType ................................................................... 516 Dodawanie nowej zakładki do przybornika .......................................................... 517 Pozostały kod klasy PhoneSSN ................................................................................. 517 Kod zdarzenia Resizing() ........................................................................................... 520 Zmiana rozmiaru pól tekstowych ............................................................................. 520 Testowanie formantu PhoneSSN .............................................................................. 521 Dodawanie projektu TestPS ...................................................................................... 521 Dodawanie formantu PhoneSSN do przybornika ................................................. 522 Obsługa zdarzeń ................................................................................................................ 524 Sygnatury programów obsługi zdarzeń .................................................................. 524 Nadawcy, delegaty i procedury obsługi zdarzeń .................................................. 526 Podsumowanie .................................................................................................................. 527 Pytania kontrolne .............................................................................................................. 527 Rozdział 22. Grafika w Visual Basic .NET ................................................................................. 529 Ekran komputera ............................................................................................................... 530 Układ współrzędnych graficznych w Visual Basic .NET ...................................... 531 Formant PictureBox .................................................................................................... 532 Rozmiar pamięci obrazu ............................................................................................. 532 Projekt ImageViewer ........................................................................................................ 533 Formant OpenFileDialog ........................................................................................... 534 Metoda ShowDialog() ................................................................................................. 537 Procedura CalculateControlSize() ............................................................................ 537 Współczynnik kształtu ............................................................................................... 538 Tworzenie własnych obiektów graficznych ................................................................. 540 Kod formantu Gauge .................................................................................................. 540 Ustawianie czcionki .......................................................................................................... 549 Użycie własności Yellowline i Redline ........................................................................... 551 Testowanie formantu Gauge ........................................................................................... 556 Podsumowanie .................................................................................................................. 557 Pytania kontrolne .............................................................................................................. 557 Rozdział 23. Dyskowe pliki danych ........................................................................................... 561 Wprowadzenie do plików danych ................................................................................. 561 Sekwencyjne dyskowe pliki danych ........................................................................ 562 Zapisywanie pliku tekstowego ................................................................................. 566 Pliki danych o dostępie swobodnym ....................................................................... 573 Kod klasy frmRandom ................................................................................................ 576 Podsumowanie .................................................................................................................. 590 Pytania kontrolne .............................................................................................................. 590 SPIS TREŚCI 15 Rozdział 24. Podstawy baz danych ............................................................................................ 593 Czym jest baza danych? ................................................................................................... 593 Co zawiera baza danych? ........................................................................................... 594 SQL ................................................................................................................................ 594 Struktura organizacyjna nowoczesnej bazy danych ............................................. 595 Po co te wszystkie tabele? .......................................................................................... 598 ADO.NET ............................................................................................................................ 600 Użycie ADO.NET ........................................................................................................ 600 Korzystanie z języka SQL ................................................................................................ 601 SELECT ......................................................................................................................... 601 Predykat WHERE ........................................................................................................ 603 Klauzula ORDER BY ................................................................................................... 605 Używanie języka SQL ...................................................................................................... 606 Dodawanie predykatu WHERE ................................................................................ 608 Użycie klauzuli ORDER BY ....................................................................................... 609 Podsumowanie .................................................................................................................. 611 Pytania kontrolne .............................................................................................................. 611 Rozdział 25. Programowanie baz danych w Visual Basic .NET ............................................ 613 Wykorzystanie kreatorów Visual Basic .NET do współpracy z bazą danych .............614 Dodawanie obiektu DataSet ............................................................................................ 621 Dodawanie formantu DataGrid ................................................................................ 623 Życie bez kreatorów .......................................................................................................... 625 Konfigurowanie formularza ...................................................................................... 625 Dodawanie kodu ......................................................................................................... 627 Łańcuch połączenia ..................................................................................................... 629 Korzystanie z ADO ..................................................................................................... 629 Wybieranie nazw pól do zapytania .......................................................................... 631 Dodawanie predykatu WHERE ................................................................................ 632 Przekazywanie zapytania do wykonania ................................................................ 635 Poruszanie się po bazie danych ................................................................................ 636 Modyfikowanie bazy danych .......................................................................................... 642 Dygresja na temat kasowania .................................................................................... 642 Projekt ModifyDB ........................................................................................................ 643 Podsumowanie .................................................................................................................. 649 Pytania kontrolne .............................................................................................................. 649 Rozdział 26. Programowanie WWW w Visual Basic .NET ..................................................... 653 Wprowadzenie ................................................................................................................... 653 HTML i statyczne strony WWW ............................................................................... 653 Jak działa strona WWW? ............................................................................................ 654 Konfigurowanie własnego serwera WWW ............................................................. 656 Dynamiczny HTML .......................................................................................................... 661 Przetwarzanie po stronie klienta i po stronie serwera .......................................... 661 16 VISUAL BASIC .NET. ALCHEMIA PROGRAMOWANIA Strona WWW poświęcona kredytom hipotecznym .................................................... 662 Różnice w IDE dla WWW .......................................................................................... 663 Kalkulator kredytu hipotecznego ............................................................................. 664 Skrypt HTML kalkulatora kredytu hipotecznego .................................................. 667 Podsumowanie .................................................................................................................. 673 Pytania kontrolne .............................................................................................................. 673 Dodatek A Tabela ASCII .............................................................................................................. 677 Skorowidz ..................................................................................................................................... 681 10 OPERATORY RELACYJNE I LOGICZNE W tym rozdziale dowiesz się: (cid:122) Co to są operatory relacyjne i jak je wykorzystywać (cid:122) Co to są operatory logiczne i jak ich używać (cid:122) Jak stosować operatory poziomu bitowego (cid:122) Jakie priorytety mają operatory relacyjne i logiczne J ednym z podstawowych zadań niemal każdego programu komputerowego jest zdolność podejmowania decyzji na podstawie dostarczonych danych. Kluczowe znaczenie dla tej zdolności mają operatory relacyjne i logiczne. W programach służą one do podejmowania decyzji na podstawie porównania jednych wartości z innymi. W tym rozdziale zajmiemy się takimi operatorami dostępnymi w języku Visual Basic .NET. Operatory relacyjne Operatory relacyjne (relational operators) służą do porównywania wartości. Tabela 10.1 przedstawia ich zestawienie. Wszystkie operatory relacyjne są binarne, to znaczy, że (jak przypominamy sobie z poprzednich rozdziałów) wymagają dwóch argumentów. Ogólna składnia grupy operatorów relacyjnych wygląda następująco: Argument1 OperatorRelacyjny Argument2 226 VISUAL BASIC .NET. ALCHEMIA PROGRAMOWANIA TABELA 10.1. Operatory relacyjne języka Visual Basic .NET Operator relacyjny = = = Znaczenie Równe Różne Mniejszy od Większy od Mniejszy lub równy Większy lub równy Gdy w jakimś wyrażeniu wykorzystywany jest operator relacyjny, mówi się, że pomiędzy dwiema wartościami (to jest argumentami) wykonywany jest test relacyjny (relational test). Test taki może dać tylko jeden z dwóch wyników: logiczną prawdę (wartość True) lub logiczny fałsz (wartość False). Proste wyrażenie If-Then-Else Testy relacyjne są często wykonywane przy użyciu wyrażeń If-Then-Else. Mimo iż używaliśmy ich już w poprzednich rozdziałach, nie zapoznaliśmy się do tej pory z ich składnią: If Wyrażenie1 Then Wykonaj, jeśli Wyrażenie1 jest prawdziwe Else Wykonaj, jeśli Wyrażenie1 nie jest prawdziwe End If Blok wyrażenia If rozpoczyna się od słowa kluczowego If, a kończy instrukcją End If. Wyrażenie1 jest zwykle testem logicznym, którego wynikiem może być jedna z wartości: True lub False. Jeśli w wyniku przeprowadzenia testu Wyrażenie1 otrzy- mamy wartość True, wykonywana jest druga linia bloku If. Jeśli otrzymamy wartość False, wykonywana jest linia znajdująca się po słowie kluczowym Else. Porada dla programistów Wyrażenia do wykonania w wyniku przeprowadzenia testu logicznego w bloku If-Then-Else, zgodnie z obowiązującą konwencją, są wcięte o jeden tabula- tor. Więcej na temat wyrażenia If-Then-Else powiemy w rozdziale 11. Napiszemy teraz prosty program, który pozwoli przećwiczyć zarówno składnię If, jak i operatory relacyjne. Rozpocznijmy nowy projekt i nazwijmy go RelationalO- perators (Operatory relacyjne). Dodajmy do jego formularza pola tekstowe i przyciski pokazane na rysunku 10.1. (Można wykorzystać program napisany w rozdziale 9. w celu testowania operatorów arytmetycznych). Rozdział 10. • OPERATORY RELACYJNE I LOGICZNE 227 RYSUNEK 10.1. Program do wykonywania testów relacyjnych Na rysunku 10.1 widzimy pola tekstowe przeznaczone na oba argumenty: txtAr- gument1 i txtArgument2, oraz trzecie pole tekstowe służące do pokazania całego sprawdzanego wyrażenia. W polu o nazwie txtExpression widać będzie całe Wyrażenie1 z przedstawionej przed chwilą składni bloku If-Then-Else. U dołu formularza widocznego na rysunku 10.1 znajduje się pole grupy zawierające dwa pola wyboru. Będą one służyć do prezentacji wyniku przeprowadzanego testu logicznego. Kod programu jest bardzo prosty. Pole grupy o nazwie Operator zawiera sześć przycisków opcji, po jednym dla każdego operatora relacyjnego. Poniżej przedsta- wiony jest kod związany z pierwszym przyciskiem opcji: Private Sub RadioButton1_CheckedChanged(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles RadioButton1.CheckedChanged WhichOne = 1 End Sub W wyniku kliknięcia określonego przycisku opcji zmienna WhichOne przyjmuje war- tość odpowiadającą temu przyciskowi. WhichOne jest zmienną typu Integer zdefi- niowaną z zasięgiem modułowym. Po wpisaniu argumentów do pól tekstowych i wybraniu operatora relacyjnego użyt- kownik klika przycisk Test. Pełny kod obsługi zdarzenia Click() obiektu btnTest jest pokazany na listingu 10.1. LISTING 10.1. Kod obsługi zdarzenia Click() obiektu btnTest Private Sub btnTest_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) _ Handles btnTest.Click ckbTrue.Checked = False Rozpoczynamy od ustawienia wartości False ckbFalse.Checked = False 228 VISUAL BASIC .NET. ALCHEMIA PROGRAMOWANIA Select Case WhichOne Case 1 txtExpression.Text = txtArgument1.Text = txtArgument2.Text If txtArgument1.Text = txtArgument2.Text Then A1 równa się A2 ckbTrue.Checked = True Else ckbFalse.Checked = True End If Case 2 txtExpression.Text = txtArgument1.Text txtArgument2.Text If txtArgument1.Text txtArgument2.Text Then A1 jest różny od A2 ckbTrue.Checked = True Else ckbFalse.Checked = True End If Case 3 txtExpression.Text = txtArgument1.Text txtArgument2.Text If txtArgument1.Text txtArgument2.Text Then A1 jest większy od A2 ckbTrue.Checked = True Else ckbFalse.Checked = True End If Case 4 txtExpression.Text = txtArgument1.Text txtArgument2.Text If txtArgument1.Text txtArgument2.Text Then A1 jest mniejszy od A2 ckbTrue.Checked = True Else ckbFalse.Checked = True End If Case 5 txtExpression.Text = txtArgument1.Text = txtArgument2.Text If txtArgument1.Text = txtArgument2.Text Then A1 jest większy
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Visual Basic .NET. Alchemia programowania
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ą: