Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
IDZ DO
IDZ DO
KATALOG KSI¥¯EK
KATALOG KSI¥¯EK
TWÓJ KOSZYK
TWÓJ KOSZYK
CENNIK I INFORMACJE
CENNIK I INFORMACJE
CZYTELNIA
CZYTELNIA
Visual Basic. NET
dla ka¿dego
Autorzy: Duncan Mackenzie, Kent Sharkey
T³umaczenie: Tomasz Miszkiel
ISBN: 83-7197-700-X
Tytu³ orygina³u:
Teach Yourself Visual Basic .NET in 21 Days
Format: B5, stron: 624
O znaczeniu jêzyka Visual Basic nie trzeba nikogo przekonywaæ: jest to
najpopularniejszy jêzyk programowania na wiecie, umo¿liwiaj¹cy nawet
pocz¹tkuj¹cym rozpoczêcie przygody z programowaniem w rodowisku Windows. Teraz
jednak jego rola jest jeszcze wiêksza: sta³ siê on bowiem, w nowej wersji nazwanej
VisualBasic.NET, sk³adnikiem platformy .NET Microsoftu. Dziêki zintegrowaniu z .NET
VisualBasic przesta³ byæ jêzykiem „drugiej kategorii”: jego mo¿liwoci s¹ obecnie
prawie porównywalne z C++.
21 napisanych przystêpnym jêzykiem rozdzia³ów opisuje miêdzy innymi:
•
ewolucjê VisualBasica i budowê platformy .NET
•
sk³adniê jêzyka
•
sposoby eliminowania b³êdów w aplikacjach
•
programowanie zorientowane obiektowo
•
tworzenie interfejsu aplikacji za pomoc¹ Windows Forms
•
pisanie aplikacji dzia³aj¹cych w Internecie
•
korzystanie z baz danych, plików tekstowych i graficznych
Ksi¹¿ka, napisana przed dwóch dowiadczonych programistów, bêd¹cych
pracownikami Microsoftu, opisuje wiêc nie tylko sam VisualBasic.NET, ale tak¿e
platformê .NET oraz narzêdzia przeznaczone do tworzenia aplikacji. Na koñcu ka¿dego
rozdzia³u znajduj¹ siê æwiczenia, pozwalaj¹ce czytelnikowi sprawdziæ swoj¹ wiedzê.
Jest to zarówno ksi¹¿ka dla tych, którzy programowali w VisualBasicu wczeniej,
a teraz chc¹ poznaæ jego nowe mo¿liwoci, jak i dla zupe³nych nowicjuszy.
Spis treści
O Autorach ...................................................................................... 15
Wprowadzenie ................................................................................. 17
Rozdział 1. Wprowadzenie do Visual Basic .NET ................................................. 23
Programowanie komputerów ............................................................................................23
Zadania systemu operacyjnego ...................................................................................24
Języki programowania ................................................................................................25
Programy komputerowe ....................................................................................................28
Historia Visual Basica.......................................................................................................29
Czym jest .NET? ...............................................................................................................31
.NET Servers...............................................................................................................32
.NET Framework ........................................................................................................33
.NET Services .............................................................................................................34
.NET Devices ..............................................................................................................35
Pierwsza aplikacja w środowisku Visual Basic .NET.......................................................35
Instalacja środowiska Visual Studio .NET .................................................................35
Programowanie bez wsparcia środowiska programistycznego...................................39
Proste zadanie do wykonania......................................................................................39
Pisanie kodu źródłowego ............................................................................................39
Podsumowanie ..................................................................................................................44
Pytania i odpowiedzi .........................................................................................................44
Warsztat.............................................................................................................................45
Quiz.............................................................................................................................45
Ćwiczenia....................................................................................................................46
Rozdział 2. Praca z Visual Basic .NET ................................................................ 47
Środowisko Visual Studio.................................................................................................47
Zanim zaczniemy ........................................................................................................47
Główne okna środowiska Visual Studio .....................................................................50
Rozwiązania i projekty ...............................................................................................65
Pliki .............................................................................................................................66
Tworzenie pierwszej aplikacji dla systemu Windows ......................................................68
Tworzenie projektu .....................................................................................................68
Interfejs użytkownika..................................................................................................68
Uruchomienie aplikacji ...............................................................................................70
Tworzenie pliku wykonywalnego...............................................................................70
Wpisywanie kodu źródłowego....................................................................................73
Podsumowanie ..................................................................................................................74
Pytania i odpowiedzi .........................................................................................................74
6
Visual Basic .NET dla każdego
Warsztat.............................................................................................................................75
Quiz.............................................................................................................................75
Ćwiczenie....................................................................................................................75
Rozdział 3. Wprowadzenie do programowania w Visual Basic .NET ...................... 77
Zmienna i przypisanie .......................................................................................................77
Czym jest zmienna? ....................................................................................................77
Typy zmiennych..........................................................................................................78
Zmienne proste............................................................................................................78
Deklaracja zmiennych.................................................................................................82
Tablice.........................................................................................................................83
Przypisanie wartości zmiennym .................................................................................85
Stałe.............................................................................................................................86
Nazewnictwo zmiennych ..................................................................................................86
Obliczenia w Visual Basic .NET.......................................................................................87
Praca z operatorami.....................................................................................................88
Funkcje wbudowane ...................................................................................................88
Tworzenie własnych procedur ..........................................................................................92
Procedury Sub.............................................................................................................92
Funkcje........................................................................................................................93
Zakres działania ..........................................................................................................94
Przykład aplikacji: obliczanie zysku z inwestycji.............................................................95
Podsumowanie ................................................................................................................100
Pytania i odpowiedzi .......................................................................................................100
Warsztat...........................................................................................................................101
Quiz...........................................................................................................................101
Ćwiczenia..................................................................................................................101
Rozdział 4. Sterowanie wykonywaniem programu ............................................. 103
Instrukcje warunkowe .....................................................................................................103
Instrukcja warunkowa If ...........................................................................................104
Rozszerzenie instrukcji If .........................................................................................107
Instrukcje warunkowe w jednej linii.........................................................................110
Logika i wyrażenia logiczne ...........................................................................................111
Operatory porównania ..............................................................................................111
Operatory logiczne....................................................................................................112
Skrócony zapis wyrażeń ...........................................................................................113
Instrukcja warunkowa Select Case..................................................................................114
Instrukcje iteracyjne ........................................................................................................116
Pętla For ... Next .......................................................................................................116
Pętla While................................................................................................................119
Pętla Do-Loop ...........................................................................................................120
Warunek wyjścia.......................................................................................................122
Pętle nieskończone....................................................................................................123
Optymalizacja pętli ...................................................................................................124
Wykorzystanie klas .NET Framework w aplikacjach .....................................................125
Odczyt danych z pliku ..............................................................................................125
Prosta gra ..................................................................................................................127
Rekurencje, czyli unikanie zagmatwanych pętli .............................................................129
Podsumowanie ................................................................................................................131
Pytania i odpowiedzi .......................................................................................................131
Warsztat...........................................................................................................................132
Quiz...........................................................................................................................132
Ćwiczenia..................................................................................................................132
Spis treści
7
Rozdział 5. Architektura aplikacji w .NET ......................................................... 133
Architektura aplikacji......................................................................................................133
Rola architekta oprogramowania ..............................................................................134
Części systemu związane z architekturą aplikacji ....................................................135
Rozwiązania architektury w .NET ..................................................................................138
Trzy główne elementy każdej aplikacji ....................................................................139
Z ilu warstw skorzystać?...........................................................................................139
Windows DNA..........................................................................................................140
Gdzie jest miejsce .NET?..........................................................................................140
Wybór technologii klienta.........................................................................................141
Wybór architektury .........................................................................................................144
Co wpływa na decyzję wyboru? ...............................................................................144
Przykładowe scenariusze ..........................................................................................146
Podsumowanie ................................................................................................................149
Pytania i odpowiedzi .......................................................................................................150
Warsztat...........................................................................................................................150
Quiz...........................................................................................................................150
Rozdział 6. Wykrywanie błędów w programach
i zapobieganie ich występowaniu .................................................... 151
Strukturalna obsługa wyjątków.......................................................................................151
Co to jest strukturalna obsługa wyjątków? ...............................................................151
Błędy i wyjątki ..........................................................................................................152
Blok Try ....................................................................................................................153
Sekcja Catch..............................................................................................................153
Zagnieżdżanie bloków Try ... End Try .....................................................................158
Sekcja Finally............................................................................................................159
Zgłaszanie wyjątków ................................................................................................160
Wykrywanie i usuwanie błędów programu.....................................................................161
Źródła błędów ...........................................................................................................161
Śledzenie działania programu ...................................................................................162
Tryby pracy środowiska programistycznego podczas tworzenia programu.............165
Krokowe wykonywanie programu............................................................................167
Sprawdzanie wartości zmiennych.............................................................................170
Inne narzędzia do śledzenia przebiegu programu .....................................................174
Podsumowanie ................................................................................................................175
Pytania i odpowiedzi .......................................................................................................175
Warsztat...........................................................................................................................176
Quiz...........................................................................................................................176
Ćwiczenia..................................................................................................................176
Rozdział 7. Praca z obiektami .......................................................................... 179
Czym są obiekty? ............................................................................................................179
Klasy i obiekty ..........................................................................................................179
Wskaźniki .................................................................................................................180
Tworzenie obiektów........................................................................................................181
Właściwości ..............................................................................................................182
Tworzenie przykładowych obiektów ........................................................................183
Hermetyzacja obiektów ............................................................................................185
Zaawansowane funkcje obiektów ...................................................................................187
Przeciążenie ..............................................................................................................188
Dziedziczenie ............................................................................................................190
Konstruktory .............................................................................................................194
Przestrzenie nazw......................................................................................................196
Obiekty i składniki współdzielone............................................................................197
8
Visual Basic .NET dla każdego
Posumowanie ..................................................................................................................198
Pytania i odpowiedzi .......................................................................................................198
Warsztat...........................................................................................................................199
Quiz...........................................................................................................................199
Ćwiczenia..................................................................................................................200
Rozdział 8. Wprowadzenie do .NET Framework ................................................. 201
Czym jest .NET Framework............................................................................................201
Najważniejsze klasy środowiska .NET Framework........................................................202
Klasa Console ...........................................................................................................202
Klasa Environment....................................................................................................208
Klasa Random ...........................................................................................................209
Klasa Math ................................................................................................................209
Klasy kolekcji w .NET Framework ..........................................................................210
Wyszukiwanie odpowiednich komponentów w .NET Framework ................................214
Reguły wyszukiwania ...............................................................................................214
Wyszukiwanie przykładowej klasy...........................................................................214
Podsumowanie ................................................................................................................218
Pytania i odpowiedzi .......................................................................................................218
Warsztat...........................................................................................................................219
Quiz...........................................................................................................................219
Ćwiczenia..................................................................................................................219
Rozdział 9. Tworzenie interfejsu użytkownika za pomocą form Windows ............ 221
Okna aplikacji w systemie Windows, czyli formy..........................................................221
Tworzenie aplikacji korzystającej z okien ......................................................................223
Tworzenie interfejsu użytkownika............................................................................223
Dodawanie obiektów kontrolnych do formy ............................................................224
Nazewnictwo obiektów kontrolnych ........................................................................225
Obsługa zdarzenia .....................................................................................................226
Korzystanie z wielu procedur obsługujących jedno zdarzenie .................................228
Wyszukiwanie obiektów i zdarzeń w oknie edycji kodu źródłowego ......................228
Obsługa wielu zdarzeń za pomocą jednej procedury................................................229
Więcej informacji o kontrolkach.....................................................................................229
Grupa przycisków opcji ............................................................................................230
Korzystanie z pól wyboru .........................................................................................232
Kontrola informacji wpisywanych przez użytkownika...................................................234
Korzystanie z klasy MessageBox....................................................................................237
Parametry metody Show ...........................................................................................237
Przechwycenie wartości............................................................................................238
Niewidoczne obiekty kontrolne ......................................................................................241
Kontrolka Timer........................................................................................................242
Kontrolka NotifyIcon................................................................................................243
Kontrolka ErrorProvider ...........................................................................................243
Kontrolki systemowych okien dialogowych.............................................................244
Tworzenie własnych okien dialogowych ........................................................................248
Okno dialogowe ........................................................................................................248
Przechwycenie informacji.........................................................................................249
Wyświetlanie okna dialogowego ..............................................................................250
Podsumowanie ................................................................................................................252
Pytania i odpowiedzi .......................................................................................................252
Warsztat...........................................................................................................................252
Quiz...........................................................................................................................252
Ćwiczenia..................................................................................................................253
Spis treści
9
Rozdział 10. Tworzenie interfejsu użytkownika za pomocą stron WWW ............... 255
Model programowania sieciowego .................................................................................255
ASP.NET ..................................................................................................................257
Różnice pomiędzy tworzeniem aplikacji dla Windows a programem WWW .........258
Standardowe kontrolki wykorzystywane w stronach WWW .........................................260
Korzystanie ze złożonych kontrolek ...............................................................................267
Korzystanie z obiektów kontrolujących informacje
wprowadzane przez użytkownika.................................................................................269
Podsumowanie ................................................................................................................272
Pytania i odpowiedzi .......................................................................................................273
Warsztat...........................................................................................................................274
Quiz...........................................................................................................................274
Ćwiczenia..................................................................................................................274
Rozdział 11. Wprowadzenie do baz danych ......................................................... 275
Baza danych ....................................................................................................................275
Podjęto decyzję .........................................................................................................276
Prawdziwa baza danych ............................................................................................277
Wprowadzenie do języka zapytań SQL ..........................................................................277
Odczytywanie rekordów za pomocą polecenia SELECT .........................................278
Dodawanie nowych rekordów ..................................................................................280
Modyfikacja rekordów..............................................................................................280
Usuwanie zbędnych rekordów ..................................................................................281
Gdzie szukać informacji dotyczących języka SQL?.................................................281
Rozwiązywanie problemów dotyczących baz danych ....................................................282
Błędne uaktualnienie danych ....................................................................................283
Pola zawierające kilka danych ..................................................................................286
Łączenie danych, czyli otrzymywanie informacji z kilku tabel na raz.....................287
Jednoznaczność odwołań ..........................................................................................289
Tworzenie kluczy głównych .....................................................................................290
Tworzenie przykładowej bazy danych ............................................................................292
Z których plików skorzystamy?................................................................................293
Access 2000, Access 2002........................................................................................293
MSDE i SQL Server .................................................................................................293
Testowanie ustawień za pomocą programu korzystającego z klas
zawartych w przestrzeni System.Data ..........................................................................294
Podsumowanie ................................................................................................................296
Pytania i odpowiedzi .......................................................................................................296
Warsztat...........................................................................................................................297
Quiz...........................................................................................................................297
Ćwiczenia..................................................................................................................298
Rozdział 12. Dostęp do danych w .NET .............................................................. 299
Dostęp do danych w .NET ..............................................................................................299
ADO i OLEDB .........................................................................................................299
ADO.NET .................................................................................................................301
Podstawowe zadania obiektów współpracujących z bazą danych ..................................302
Łączenie się z bazą danych .......................................................................................302
Wykonywanie zapytań SQL .....................................................................................307
Odczytywanie danych z bazy....................................................................................308
Obiekt DataSet ................................................................................................................310
Umieszczanie danych w obiekcie DataSet ...............................................................310
Przemieszczanie się w obiekcie DataTable ..............................................................312
Modyfikacja danych..................................................................................................314
10
Visual Basic .NET dla każdego
Uaktualnienie bazy danych .......................................................................................319
Praca z kilkoma tabelami ..........................................................................................329
Obiekt DataView ......................................................................................................330
Wykorzystywanie danych w aplikacjach ...........................................................................332
Używanie danych w aplikacji Windows...................................................................333
Podsumowanie ................................................................................................................336
Pytania i odpowiedzi .......................................................................................................336
Warsztat...........................................................................................................................337
Quiz...........................................................................................................................337
Ćwiczenia..................................................................................................................337
Rozdział 13. Server Explorer .............................................................................. 339
Co to jest Server Explorer? .............................................................................................339
Co to jest usługa? ......................................................................................................340
Wyświetlanie usług .........................................................................................................341
Data Connections ......................................................................................................341
Praktyczny przykład połączenia z bazą danych........................................................345
Praca z usługami..............................................................................................................346
Przegląd usług ...........................................................................................................346
Połączenie z innym serwerem...................................................................................346
Aplikacje korzystające z usług........................................................................................348
Dostęp do bazy danych za pomocą Server Explorera...............................................348
Korzystanie z liczników wydajności ........................................................................351
Podsumowanie ................................................................................................................359
Pytania i odpowiedzi .......................................................................................................360
Warsztat...........................................................................................................................360
Quiz...........................................................................................................................360
Ćwiczenia..................................................................................................................360
Rozdział 14. Wprowadzenie do programowania zorientowanego obiektowo .......... 361
Podstawy programowania zorientowanego obiektowo...................................................361
Porównanie programowania proceduralnego i zorientowanego obiektowo .............362
Wykorzystanie obiektów do organizacji kodu..........................................................364
Najważniejsze zagadnienia związane z OOP..................................................................364
Klasy i obiekty ..........................................................................................................365
Właściwości ..............................................................................................................366
Metody ......................................................................................................................368
Dziedziczenie ............................................................................................................369
Konstruktory .............................................................................................................372
Projektowanie aplikacji zgodnie z OOP..........................................................................374
Identyfikacja wymaganych obiektów .......................................................................375
Określenie właściwości i metod................................................................................376
Modelowanie obiektów.............................................................................................377
Podsumowanie ................................................................................................................378
Pytania i odpowiedzi .......................................................................................................378
Warsztat...........................................................................................................................378
Quiz...........................................................................................................................378
Ćwiczenia..................................................................................................................379
Rozdział 15. Tworzenie obiektów w Visual Basic .NET ........................................ 381
Tworzenie obiektów........................................................................................................381
Deklaracja nowej klasy w Visual Basic .NET ..........................................................381
Dodawanie właściwości............................................................................................384
Tworzenie metod ......................................................................................................390
Spis treści
11
Dodawanie zdarzeń ...................................................................................................395
Definiowanie i korzystanie z interfejsów .................................................................397
Wykorzystywanie utworzonych obiektów w aplikacji ...................................................404
Przestrzenie nazw......................................................................................................404
Tworzenie i wykorzystywanie biblioteki DLL .........................................................406
Podsumowanie ................................................................................................................408
Pytania i odpowiedzi .......................................................................................................408
Warsztat...........................................................................................................................408
Quiz...........................................................................................................................409
Ćwiczenia..................................................................................................................409
Rozdział 16. Zaawansowane aplikacje dla Windows ........................................... 411
System menu w aplikacji.................................................................................................411
Dodawanie menu do okna aplikacji ..........................................................................411
Dostęp do elementów menu za pomocą klawiatury .................................................413
Dodanie kodu źródłowego związanego z polami menu ...........................................415
Kilka sugestii dotyczących tworzenia systemów menu............................................417
Aplikacje typu MDI (Multiple Document Interface) ......................................................418
Co to jest aplikacja typu MDI? .................................................................................418
Dodawanie okna głównego.......................................................................................419
Menu w aplikacji MDI..............................................................................................420
Zaawansowane kontrolki form Windows .......................................................................426
TreeView...................................................................................................................427
ListView....................................................................................................................429
Dzielenie okna ..........................................................................................................431
Podsumowanie ................................................................................................................437
Pytania i odpowiedzi .......................................................................................................437
Warsztat...........................................................................................................................438
Quiz...........................................................................................................................438
Ćwiczenia..................................................................................................................438
Rozdział 17. Korzystanie z .NET Framework ....................................................... 439
Strumienie danych i pliki ................................................................................................439
Co to jest strumień danych? ......................................................................................440
Pliki i katalogi ...........................................................................................................440
Odczytywanie danych z pliku tekstowego................................................................441
Zapisywanie danych w pliku ....................................................................................443
Rysowanie za pomocą klas graficznych..........................................................................455
Poszukiwanie klas graficznych .................................................................................455
Gdzie można rysować? .............................................................................................462
Rysowanie figur ........................................................................................................467
Zapisywanie rysunku ................................................................................................470
Podsumowanie ................................................................................................................472
Pytania i odpowiedzi .......................................................................................................473
Warsztat...........................................................................................................................473
Quiz...........................................................................................................................474
Ćwiczenia..................................................................................................................474
Rozdział 18. Prace wykończeniowe .................................................................... 475
Dokumentacja aplikacji...................................................................................................475
Korzystanie z najprostszych rozwiązań ....................................................................476
Dokumentacja dla wszystkich...................................................................................479
Nie komentujemy faktów oczywistych.....................................................................479
Opisujemy zasadę działania całego systemu, nie tylko kodu źródłowego ...............480
12
Visual Basic .NET dla każdego
Standardy dotyczące konstrukcji kodu źródłowego........................................................482
Nazewnictwo zmiennych, obiektów i kontrolek.......................................................482
Komentarze ...............................................................................................................484
Kontrola kodu źródłowego..............................................................................................485
Wykorzystanie systemu kontroli kodu źródłowego..................................................486
Wprowadzanie kodu do repozytorium Source Safe..................................................490
Wyświetlanie i cofanie zmian dokonanych w kodzie...............................................490
Bezpieczeństwo kodu w Visual Source Safe ............................................................492
Podsumowanie ................................................................................................................492
Pytania i odpowiedzi .......................................................................................................493
Warsztat...........................................................................................................................493
Quiz...........................................................................................................................493
Rozdział 19. Wdrażanie aplikacji ........................................................................ 495
Podstawowe informacje dotyczące wdrażania aplikacji .................................................495
Tworzenie programu instalacyjnego.........................................................................497
Pliki konfiguracyjne..................................................................................................504
Wdrażanie aplikacji składających się z wielu projektów................................................505
Podsumowanie ................................................................................................................508
Pytania i odpowiedzi .......................................................................................................509
Warsztat...........................................................................................................................509
Quiz...........................................................................................................................509
Ćwiczenia..................................................................................................................510
Rozdział 20. Wprowadzenie do XML-a ................................................................ 511
Co to jest XML?..............................................................................................................511
Elementy ...................................................................................................................515
Atrybuty ....................................................................................................................516
Schematy...................................................................................................................517
Praca z XML-em .............................................................................................................519
Obiektowy model opisu dokumentu (DOM) ............................................................520
Obiekty pozwalające na odczyt danych z pliku XML i ich zapis.............................523
Odczytywanie zawartości pliku XML ......................................................................524
Zapisywanie dokumentu XML .................................................................................529
Podsumowanie ................................................................................................................531
Pytania i odpowiedzi .......................................................................................................531
Warsztat...........................................................................................................................533
Quiz...........................................................................................................................533
Ćwiczenia..................................................................................................................533
Rozdział 21. Tworzenie usług sieci Web w Visual Basic .NET .............................. 535
Co to jest usługa sieci Web? ...........................................................................................535
SOAP — Simple Object Access Protocol.......................................................................537
Protokół.....................................................................................................................538
Web Service Description Language (WSDL)...........................................................538
Wykrywanie usług sieci Web ...................................................................................540
Tworzenie przykładowej usługi sieci Web .....................................................................542
Tworzenie projektu ...................................................................................................543
Dodanie kodu źródłowego ........................................................................................545
Kompilacja usługi sieci Web ....................................................................................546
Tworzenie klienta usługi sieci Web ................................................................................548
Tworzenie projektu ...................................................................................................549
Dodanie kodu źródłowego ........................................................................................550
Spis treści
13
Bardziej zaawansowana usługa sieci Web ......................................................................553
Tworzenie usługi.......................................................................................................553
Testowanie usługi .....................................................................................................556
Tworzenie klienta......................................................................................................557
Dodanie kodu źródłowego ........................................................................................560
Podsumowanie ................................................................................................................564
Pytania i odpowiedzi .......................................................................................................564
Warsztat...........................................................................................................................565
Quiz...........................................................................................................................565
Ćwiczenia..................................................................................................................565
Dodatek A Odpowiedzi .................................................................................... 567
Odpowiedzi do pytań z rozdziału 1.................................................................................567
Quiz...........................................................................................................................567
Ćwiczenia..................................................................................................................567
Odpowiedzi do pytań z rozdziału 2.................................................................................568
Quiz...........................................................................................................................568
Ćwiczenie..................................................................................................................569
Odpowiedzi do pytań z rozdziału 3.................................................................................569
Quiz...........................................................................................................................569
Ćwiczenia..................................................................................................................569
Odpowiedzi do pytań z rozdziału 4.................................................................................571
Quiz...........................................................................................................................571
Ćwiczenia..................................................................................................................571
Odpowiedzi do pytań z rozdziału 5.................................................................................572
Quiz...........................................................................................................................572
Odpowiedzi do pytań z rozdziału 6.................................................................................573
Quiz...........................................................................................................................573
Ćwiczenia..................................................................................................................573
Odpowiedzi do pytań z rozdziału 7.................................................................................574
Quiz...........................................................................................................................574
Ćwiczenia..................................................................................................................575
Odpowiedzi do pytań z rozdziału 8.................................................................................576
Quiz...........................................................................................................................576
Ćwiczenia..................................................................................................................577
Odpowiedzi do pytań z rozdziału 9.................................................................................578
Quiz...........................................................................................................................578
Ćwiczenia..................................................................................................................579
Odpowiedzi do pytań z rozdziału 10...............................................................................579
Quiz...........................................................................................................................579
Ćwiczenia..................................................................................................................580
Odpowiedzi do pytań z rozdziału 11...............................................................................583
Quiz...........................................................................................................................583
Ćwiczenia..................................................................................................................584
Odpowiedzi do pytań z rozdziału 12...............................................................................586
Quiz...........................................................................................................................586
Ćwiczenia..................................................................................................................586
Odpowiedzi do pytań z rozdziału 13...............................................................................586
Quiz...........................................................................................................................586
Odpowiedzi do pytań z rozdziału 14...............................................................................587
Quiz...........................................................................................................................587
Ćwiczenia..................................................................................................................587
14
Visual Basic .NET dla każdego
Odpowiedzi do pytań z rozdziału 15...............................................................................587
Quiz...........................................................................................................................587
Ćwiczenia..................................................................................................................588
Odpowiedzi do pytań z rozdziału 16...............................................................................589
Quiz...........................................................................................................................589
Ćwiczenia..................................................................................................................589
Odpowiedzi do pytań z rozdziału 17...............................................................................593
Quiz...........................................................................................................................593
Ćwiczenia..................................................................................................................594
Odpowiedzi do pytań z rozdziału 18...............................................................................595
Quiz...........................................................................................................................595
Odpowiedzi do pytań z rozdziału 19...............................................................................595
Quiz...........................................................................................................................595
Ćwiczenia..................................................................................................................596
Odpowiedzi do pytań z rozdziału 20...............................................................................596
Quiz...........................................................................................................................596
Ćwiczenia..................................................................................................................597
Odpowiedzi do pytań z rozdziału 21...............................................................................599
Quiz...........................................................................................................................599
Skorowidz...................................................................................... 601
Rozdział 2.
Praca z Visual Basic .NET
Poprzedni rozdział zawierał podstawowe informacje dotyczące programowania, języ-
ka Visual Basic i platformy .NET. W niniejszym rozdziale stworzymy właściwą apli-
kację działającą w systemie Windows. Omówimy następujące zagadnienia:
Środowisko Visual Studio
Praca z plikami, projektami i rozwiązaniami
Przykładowy projekt dla Windows
Najpierw poznamy zintegrowane środowisko programistyczne Visual Studio (VS).
Środowisko Visual Studio
Zintegrowane środowisko programistyczne (IDE — Integrated Development Envi-
ronment) jest przeznaczone dla programistów tworzących aplikacje. Można, oczywi-
ście, programować bez korzystania ze środowiska programistycznego i wpisywać kod
źródłowy w edytorze tekstowym (np. w Notatniku), a następnie powstałe w edytorze
pliki kompilować z wiersza poleceń. Programowanie w taki sposób jest jednak kło-
potliwe i czasochłonne — niewielu programistów zdecydowałoby się na tworzenie
oprogramowania bez wykorzystania środowiska programistycznego, które zawiera
wiele funkcjonalnych narzędzi wspomagających tworzenie programów. Środowisko
programistyczne pozwala na tworzenie rozbudowanych i funkcjonalnych aplikacji
w bardzo krótkim czasie.
Zanim zaczniemy
Zanim rozpoczniemy pracę w Visual Basicu, musimy się upewnić, że nasze środowi-
sko jest zainstalowane. Jeśli mamy jakiekolwiek wątpliwości związane z procesem
instalacji, wróćmy do poprzedniego rozdziału.
48
Visual Basic .NET dla każdego
Ustawienia parametrów środowiska
Podczas pierwszego uruchomienia Visual Studio .NET pojawia się okno przypomi-
nające swym wyglądem okno przeglądarki internetowej. Jest to Start Page — strona
startowa zintegrowanego środowiska programowego Visual Studio .NET. W tym śro-
dowisku znajdą się wszystkie nasze projekty, począwszy od prostych aplikacji, po
strony WWW.
W lewej części ekranu znajdują się odnośniki do kilku interesujących stron. Domyśl-
nie wybrana jest strona służąca do określenia ustawień profilu użytkownika My Pro-
file. Na tej stronie należy wybrać odpowiednie ustawienia parametrów środowiska
wedle własnego uznania. Każdy użytkownik ma do wyboru kilka konfiguracji środo-
wiska Visual Studio. Aby wybrać odpowiednią dla siebie konfigurację, należy trochę
„poeksperymentować” z różnymi ustawieniami. Na razie pozostawmy ustawienia
domyślne, takie jak na rysunku 2.1.
Rysunek 2.1.
Środowisko
Visual Studio .NET
można ustawić
według własnego
uznania tak,
aby łatwo
przełączać się
pomiędzy
poszczególnymi
narzędziami
programistycznymi,
łącznie ze starszą
wersją Visual Basica
Na razie należy wybrać profil Visual Basic Developer. Aby opuścić stronę My Profi-
le, należy kliknąć odnośnik do strony Get Started. To, co widzimy, jest środowiskiem
programistycznym, w którym możemy korzystać z wielu zawartych w nim narzędzi,
służących do tworzenia oprogramowania. W środowisku umieszczono przeglądarkę
internetową, która pozwala na wyświetlanie witryny startowej środowiska (rysunek 2.2).
Strona Get Started zawiera odnośniki do istniejących, wcześniej utworzonych, pro-
jektów oraz dwa przyciski. Jeden z nich służy do utworzenia nowego projektu New
Project, a drugi — do otwarcia jednego z istniejących projektów Open Project. Ze
strony startowej można, za pomocą odnośników umieszczonych w lewej części ekra-
nu, wybrać jedną z ośmiu stron. Oprócz omówionej strony Get Started można wejść do:
Rozdział 2.
♦ Praca z Visual Basic .NET
49
Rysunek 2.2.
Strona startowa
Visual Studio
zawiera informacje
dotyczące wcześniej
utworzonych
projektów
Online Community. Tu znajdują się odsyłacze do stron i grup dyskusyjnych
poświęconych Visual Studio .NET.
Headlines. Na tej stronie można znaleźć wiadomości dotyczące środowiska
Visual Studio i związanych z nim narzędzi. Aby strona otwierała się poprawnie,
musimy mieć połączenie z Internetem (rysunek 2.3).
Search Online, czyli wyszukiwarka internetowa.
My Profile, strona ustawienia parametrów środowiska.
Rysunek 2.3.
Najnowsze
informacje dotyczące
Visual Basic .NET
można znaleźć na
stronie Headlines,
gdzie są odsyłacze
do stron
umieszczonych
w witrynie
msdn.Microsoft.com
50
Visual Basic .NET dla każdego
Strona startowa Visual Studio .NET została zaprojektowana w taki sposób, by spro-
stać oczekiwaniom większości użytkowników. W razie potrzeby można zmienić za-
wartość strony startowej — kod źródłowy jest dostępny w folderze \Program Files\
Microsoft Visual Studio .NET\HTML. Należy pamiętać, że może zdarzyć się sytuacja
gdy modyfikacja strony startowej doprowadzi do jej uszkodzenia, bez możliwości
odtworzenia. Najlepiej przed przystąpieniem do wprowadzania jakichkolwiek zmian
w folderze HTML utworzyć jego kopię bezpieczeństwa.
Główne okna środowiska Visual Studio
Visual Studio zawiera wiele użytecznych okien. Po wybraniu profilu Visual Basic
Developer, na ekranie komputera powinny znajdować się okna: omówionej wbudo-
wanej przeglądarki, okno Solution Explorer (w którym pokazane są tworzone pro-
jekty i pliki wygenerowane podczas ich tworzenia), okno Properties (właściwości)
i okno narzędzi Toolbox. Istnieją jeszcze inne okna, niewidoczne po pierwszym uru-
chomieniu. Są to między innymi:
Object Browser
Command/Immediate
Task list
Class View
Server Explorer
Te okna zostaną przedstawione w tym rozdziale, a o pozostałych będziemy dowiady-
wać się w kolejnych rozdziałach.
Właściwości okien środowiska
Okna w środowisku Visual Studio są przystosowane do efektywnego wykorzystania
powierzchni ekranu środowiska. Visual Studio .NET zapewnia wiele narzędzi i opcji
służących do efektywnego tworzenia aplikacji przez programistów. Głównym celem
twórców środowiska programistycznego było zapewnienie wielu narzędzi, do których
jest łatwy dostęp. Umieszczenie odnośników do tych narzędzi w jednym oknie jest
niemożliwe (chyba że programista dysponuje monitorem o przekątnej 21'). Aby umoż-
liwić dostęp do narzędzi i ułatwić ich wybór, projektanci środowiska programistycz-
nego podzielili narzędzia na grupy i umieścili każdą grupę w jednym oknie. W ten
sposób powstała pokaźna liczba okien zawierających poszczególne narzędzia. Te
okna nazwano oknami narzędziowymi. Wszystkie okna można wyrównywać do kra-
wędzi ekranu i łączyć, czyli dokować, a także dowolnie zmieniać ich rozmiar.
Dokowanie okien
Po uruchomieniu Visual Studio .NET z wybranym ustawieniem środowiska Visual
Basic Developer pojawia się okno pokazane na rysunku 2.4. Okno to przypomina tro-
chę środowisko programistyczne Visual Basica 6.0. W lewej części ekranu znajduje
się okno narzędziowe Toolbox, a po prawej stronie jest okno Solution Explorer oraz
Rozdział 2.
♦ Praca z Visual Basic .NET
51
okno właściwości Properties. W prawym górnym rogu omawianych okien znajdują
się dwa przyciski. Jeden z nich służy do zamknięcia okna (przycisk z „krzyżykiem”
po prawej stronie), a drugi — do umieszczenia okna na pasku (jest to przycisk z „pi-
nezką”, którą „przypinamy” okno do ekranu). Każde okno narzędziowe można doko-
wać w dowolnym miejscu ekranu.
Rysunek 2.4.
Środowisko Visual
Studio .NET,
uruchomione
w trybie
Visual Basic
przypomina
wyglądem
środowisko znane
z Visual Basica 6.0
Aby zmienić położenie zadokowanego okna, wystarczy kliknąć i przytrzymać lewy
przycisk myszy na pasku tytułu, a następnie przeciągnąć okno w pożądane miejsce.
Podczas przesuwania na ekranie widoczny jest zarys przemieszczanego okna, który
oznacza położenie okna po zwolnieniu lewego przycisku myszy. Aby zadokować
okno, wystarczy nacisnąć i przytrzymać lewy przycisk myszy na pasku tytułu, a na-
stępnie przeciągnąć okno do brzegu ekranu i zwolnić przycisk myszy. Na rysunku 2.5
pokazano przykładowy zarys okna, widoczny podczas przemieszczania.
Gdy podczas przemieszczania zarys nie przylgnie do brzegu ekranu, okno stanie się
obiektem samodzielnym, nie będzie zadokowane (rysunek 2.6).
Dokowanie okna może na początku sprawiać kłopoty. Aby szybko zadokować
okno, wystarczy dwa razy kliknąć myszą w obszarze paska tytułu, co spowoduje
zadokowanie okna do brzegu, z którego okno zostało zdjęte.
Ukrywanie okna
Niektóre okna, zadokowane lub samodzielne, mogą okazać się w danej chwili nie-
przydatne i nie ma potrzeby, by zajmowały miejsce na ekranie. Aby zamknąć zbędne
okno, wystarczy kliknąć myszą przycisk „X” znajdujący się w prawym górnym rogu,
na pasku tytułu (rysunek 2.7).
52
Visual Basic .NET dla każdego
Rysunek 2.5.
Zarys okna,
widoczny
podczas jego
przemieszczania,
wskazuje na nowe
miejsce, w którym
okno znajdzie się
po zwolnieniu
lewego przycisku
myszy
Rysunek 2.6.
Okna można
umieścić
w dowolnym
miejscu ekranu
jako obiekty
samodzielne
Aby odzyskać wcześniej zamknięte okno, należy wybrać je z głównego menu View.
Jeśli potrzebny jest częsty dostęp do narzędzi zawartych w oknie, które chcemy ukryć,
wystarczy włączyć opcję automatycznego ukrywania okna Auto-Hide. Aby włączyć
tę opcję, należy nacisnąć przycisk w kształcie pinezki znajdujący się na pasku tytułu
okna narzędziowego (rysunek 2.8). Po włączeniu opcji Auto-Hide okno narzędziowe
zostaje ukryte, ale na jednym z brzegów ekranu jest widoczna zakładka ukrytego okna.
Za każdym razem, kiedy kursor myszy znajdzie się na obszarze zakładki, okno staje się
widoczne. Okno zostanie ponownie ukryte, gdy przesuniemy kursor myszy poza jego
obszar. W menu Windows znajduje się opcja Auto Hide All, która powoduje, że wszyst-
kie okna na ekranie zostają automatycznie ukryte (rysunek 2.9). Dzięki tej opcji możemy
zwiększyć powierzchnię obszaru edycji kodu źródłowego i okna dialogowego (formy).
Rozdział 2.
♦ Praca z Visual Basic .NET
53
Rysunek 2.7.
Okna można
zamknąć poprzez
naciśnięcie lewym
przyciskiem myszy
przycisku „X”.
Zamknięte okna
można otwierać
(za pomocą poleceń
menu View)
Rysunek 2.8.
Każde okno
narzędziowe
ma przycisk
w kształcie pinezki,
który pozwala
na pozostawienie
okna we właściwym
miejscu ekranu
Zakładki
Aby umieścić kilka okien na pewnym fragmencie ekranu, należy skorzystać z zakła-
dek (rysunek 2.10). Kilka zakładek jest widocznych po uruchomieniu środowiska Vi-
sual Basic (np. okno Solutions Explorer jest wyświetlane w tym samym obszarze, co
okno Class View). Okna narzędziowe możemy łączyć dowolnie, oszczędzając po-
wierzchnię ekranu.
54
Visual Basic .NET dla każdego
Rysunek 2.9.
Można użyć opcji
Auto Hide All,
aby zwiększyć
obszar edycji
Rysunek 2.10.
Korzystając
z zakładek możemy
mieć otwartych
wiele okien
narzędziowych
i przełączać się
pomiędzy nimi
Aby stworzyć kombinację okien, wystarczy przeciągnąć jedno okno i umieścić na
drugim. W ten sposób będzie widoczne tylko jedno okno, a w dolnej części ekranu
znajdą się dwie zakładki. Kliknięcie drugiej zakładki spowoduje przełączenie okien.
W ten sposób można tworzyć kombinację wielu okien. Aby rozdzielić okna, wystar-
czy przycisnąć i przytrzymać lewy przycisk myszy na jednym z okien i przeciągnąć
w inne miejsce ekranu.
Zmiana rozmiarów okna
W środowisku Visual Studio można dowolnie zmieniać rozmiary okna. Wyjątek sta-
nowią okna zadokowane, w których można zmienić tylko szerokość. Aby zmienić
rozmiary okna, należy ustawić wskaźnik myszy na krawędzi okna tak, by zmienił się
Rozdział 2.
♦ Praca z Visual Basic .NET
55
on na wskaźnik zmiany rozmiaru. Następnie trzeba nacisnąć i przytrzymać lewy przy-
cisk myszy i zwiększyć (lub zmniejszyć) rozmiary okna. Gdy przy jednej krawędzi
ekranu są zadokowane dwa okna, próba zmiany rozmiaru jednego z nich wpływa na
zmianę rozmiaru drugiego.
Okno narzędziowe Toolbox
Jednym z najczęściej używanych okien w trakcie projektowania aplikacji jest okno
narzędziowe Toolbox. To okno zawiera wiele obiektów kontrolnych, które można do-
dawać do tworzonego projektu. Wszystkie obiekty kontrolne zostały podzielone na li-
sty. Aby wybrać obiekt z listy, należy kliknąć jej zakładkę i rozwinąć listę. W zależ-
ności od realizowanego projektu dostępne są różne zestawy narzędzi. Na przykład,
gdy jedynym aktywnym oknem jest przeglądarka, w oknie narzędziowym jest dostęp-
ny tylko Wskaźnik (Pointer). Wskaźnik jest zawsze widocznym obiektem w oknie
narzędziowym. Zestaw dostępnych narzędzi zależy od aktywnego okna, na przykład,
gdy tworzona jest strona internetowa w języku HTML, w oknie narzędziowym znaj-
duje się zakładka HTML (rysunek 2.11) z wieloma różnymi elementami przydatnymi
podczas projektowania strony.
Rysunek 2.11.
Podczas tworzenia
strony internetowej
wszystkie potrzebne
elementy znajdują
się w oknie
narzędziowym
Aby dodać element do okna edycji, można:
Kliknąć i przeciągnąć element w odpowiednie miejsce.
Dwukrotnie kliknąć element okna narzędziowego, co spowoduje wygenerowanie
odpowiedniej części kodu w obszarze edycji, w miejscu wskazanym przez
znak kursora.
Aby elementy z okna narzędziowego umieścić w oknie dialogowym (formie), można:
Kliknąć odpowiedni element i przeciągnąć w obszar okna graficznego.
Podczas przeciągania widoczny jest zarys elementu.
56
Visual Basic .NET dla każdego
Kliknąć element okna narzędziowego dwa razy — element pojawi się w lewym
górnym rogu okna graficznego.
Wybrać pożądany element z listy, a następnie kliknąć w obszarze okna
graficznego. Nowy element pojawia się w oknie graficznym w pożądanym
miejscu (rysunek 2.12).
Rysunek 2.12.
Elementy można
wrysować w formę
po zaznaczeniu
określonego
elementu w oknie
narzędziowym
Metody umieszczania elementów okna narzędziowego na ekranie zostały opisane
w sposób bardzo ogólny, co może sugerować, że użycie tych elementów jest kło-
potliwe. Taki ogólny opis jest konieczny ze względu na naturę środowiska Visual
Studio, które jest przeznaczone do projektowania aplikacji w wielu językach pro-
gramowania. Różnorodność środowisk programowania w Visual Studio sprawia,
że wyjaśnienie zasad zachowania się środowiska (np. umieszczania elementów
z okna narzędziowego) jest trudne do opisania. Przedstawione metody umieszcza-
nia elementów okna narzędziowego można stosować w innych środowiskach pro-
gramowania (np. Visual C++ .NET).
Konkretnym przykładem wykorzystania obiektów okna narzędziowego zajmiemy się
w dalszej części rozdziału, podczas projektowania pierwszej aplikacji dla systemu Win-
dows. Okno Toolbox pozwala na zdefiniowanie określonego fragmentu tekstu, który
można wstawić w dowolne miejsce okna edycji. Jest to bardzo przydatna funkcja
(przypominająca Schowek w programie Word), która pozwala na stworzenie bloków
kodu źródłowego (np. rozbudowanych elementów witryny internetowej), gotowych
do wykorzystania w polu edycji.
Aby utworzyć własny blok kodu źródłowego, wystarczy zaznaczyć odpowiedni frag-
ment programu w polu edycji i przeciągnąć do okna narzędziowego. W oknie pojawi
się nowy element gotowy do użycia. Aby umieścić ten fragment kodu w oknie edycji,
należy nacisnąć nad nim lewy przycisk myszy i przytrzymać, następnie przeciągnąć
fragment tekstu w pożądane miejsce i zwolnić przycisk. Przykład takiego elementu
pokazano na rysunku 2.13.
Rozdział 2.
♦ Praca z Visual Basic .NET
57
Rysunek 2.13.
Kod źródłowy,
HTML albo inny
wycinek tekstowy
można umieścić
w oknie
narzędziowym
i korzystać z niego
w taki sam sposób,
w jaki korzysta się
z innych obiektów
kontrolnych
Okno narzędziowe posiada wiele dodatkowych opcji, o których możesz się dowie-
dzieć korzystając z plików pomocy środowiska programistycznego. Te opcje to mię-
dzy innymi tworzenie dodatkowych zakładek wewnątrz okna narzędziowego, zmiana
nazwy zakładek, czy zmiana zawartości list elementów. Dodatkowe opcje są udostęp-
nione poprzez menu kontekstowe, otwierane poprzez kliknięcie prawym przyciskiem
myszy w obszarze okna narzędziowego.
Okno Command/Immediate
Dla wielu użytkowników skorzystanie z odpowiedniej komendy wiersza poleceń jest
sposobem na szybkie wykonanie określonego zadania. Często występują takie sytu-
acje, w których korzystanie z okien dialogowych jest mniej wydajne niż korzystanie
z wiersza poleceń, dlatego też w Visual Studio .NET wbudowano okno przypomina-
jące konsolę, które zawiera wiersz poleceń. W poprzednich wersjach Visual Basica
zadanie konsoli spełniało okno Immediate, a w pakiecie Fox Pro — okno Command.
Okna Immediate i Command dodano do środowiska Visual Studio .NET pod jedną na-
zwą, Command. Aby otworzyć okno Command, należy wybrać polecenie Command
Window z menu View, Other Windows. Powinno pojawić się na ekranie nowe okno,
przypominające swym wyglądem konsolę (znaną ze starszych wersji systemów opera-
cyjnych, np. DOS-u). W oknie znajduje się kursor poprzedzony znakiem zachęty. Znak
zachęty sygnalizuje pracę okna w trybie Command. Za znakiem zachęty można wpi-
sywać różne polecenia, które zostaną wykonane po naciśnięciu klawisza Enter. Aby
przełączyć się do trybu Immediate, należy wpisać komendę
i wcisnąć Enter. Na
pasku tytułu okna pojawia się wówczas napis Command Window — Immediate, co
oznacza, że zmieniono tryb pracy konsoli z Command na Immediate. Aby powrócić
do trybu Command, wystarczy wpisać
i wcisnąć Enter (znak zachęty
należy
wprowadzić samodzielnie, gdyż w trybie Immediate nie pojawia się on automatycznie).
58
Visual Basic .NET dla każdego
Konsola pracująca w trybie Command pozwala na wykonywanie różnych poleceń
dotyczących środowiska programistycznego. Na przykład, gdy w oknie Command
wpiszemy polecenie
, to utworzymy nowy projekt. W środowisku
programistycznym to samo zdarzenie można wykonać poprzez wybranie polecenia
Project z menu File, New. Wiele zadań można wykonać szybciej za pomocą instruk-
cji wpisywanych w konsoli niż poprzez wybieranie odpowiednich polecenień interfej-
su graficznego. Przygotowano wiele komend dostępnych z konsoli, większość z nich
jest repliką zdarzeń generowanych za pomocą poleceń menu środowiska graficznego.
Nazwy instrukcji wprowadzanych w konsoli są związane z nazwami ich odpowiedni-
ków środowiska graficznego. Na przykład, aby wybrać jedno z poleceń menu File,
wprowadzamy za znakiem zachęty instrukcję
, a następnie polecenie tego menu,
poprzedzone kropką (
). Oto lista kilku bardzo użytecznych instrukcji:
Tryb Immediate pozwala na natychmiastowe wykonywanie instrukcji języka progra-
mowania (w naszym przypadku — instrukcji Visual Basica). Można wprowadzić w tym
oknie fragment kodu odpowiedzialny za wykonanie określonego zadania i w ten spo-
sób szybko sprawdzić, czy rezultat jest zgodny z naszymi oczekiwaniami. Właściwo-
ści okna Immediate są wykorzystywane podczas pracy z wykorzystaniem punktów
przerwań programu (punkty przerwań ustawiamy podczas wykrywania błędów — to
zagadnienie opisano dokładniej w rozdziale szóstym, „Wykrywanie błędów w pro-
gramach i zapobieganie ich występowaniu”). Spróbujmy napisać prosty program,
w którym wykorzystamy punkt przerwania.
Aby bliżej poznać sposób korzystania z konsoli, wykonamy nasz prosty przykład
w oknie Command. Należy upewnić się, że okno konsoli jest widoczne i ustawione
w trybie Command (widoczny jest znak zachęty
). Wpiszmy instrukcję
i wciśnijmy klawisz
. Podczas wprowadzania instrukcji pojawia się lista
z dostępnymi instrukcjami, z której, po wprowadzeniu kilku liter, możemy wybrać
odpowiednią komendę. Pojawi się okno dialogowe, w którym wybieramy folder Vi-
sual Basic Projects, a następnie typ tworzonej aplikacji — Windows Application. Aby
zamknąć okno dialogowe, naciskamy przycisk OK, po czym pojawia się okno nowe-
go projektu.
Nowy projekt stanowi pusta forma aplikacji, którą należy teraz oprogramować. Nie-
wielka ilość kodu została wygenerowana przez kreatora projektu, resztę należy wpi-
sać samodzielnie. Aby zobaczyć kod źródłowy aplikacji, należy wybrać polecenie View
Code z menu kontekstowego formy (menu kontekstowe otwiera się poprzez kliknię-
cie prawym przyciskiem myszy w obszarze formy), co powoduje wyświetlenie nowe-
go okna z kodem źródłowym.
Znajdźmy linię
. Teraz ustawimy punkt przerwania, który oznacza
miejsce przerwania wykonywania programu. Są trzy sposoby na ustawienie punktu
przerwania. Jednym z nich jest kliknięcie w obszarze szarego marginesu z lewej stro-
ny okna zawierającego kod źródłowy. Innym sposobem jest kliknięcie prawym przy-
ciskiem myszy odpowiedniej linii i wybranie opcji Insert Breakpoint z menu kontek-
stowego. Punkt przerwania można wstawić również poprzez ustawienie kursora na
Rozdział 2.
♦ Praca z Visual Basic .NET
59
odpowiedniej linii i wciśnięcie klawisza F9. Ustawienie punktu przerwania powoduje
zakreślenie danej linii i umieszczenie charakterystycznego punktu na marginesie okna
z kodem źródłowym.
Uruchomienie programu zostanie przerwane, gdy tylko kompilator natrafi na linię
oznaczoną punktem przerwania. Aby rozpocząć wykonywanie programu, należy wci-
snąć klawisz F5, wybrać opcję Start z menu Debug albo wcisnąć przycisk Start (jego
kształt jest podobny do przycisku „Play” w magnetowidzie), znajdujący się na pasku
narzędzi (rysunek 2.14). Najszybciej wybiera się funkcje za pomocą klawiatury, ale
sposób wybierania opcji zależy tylko od programisty — każdy sposób jest dobry, jeśli
prowadzi do celu.
Rysunek 2.14.
Pasek narzędzi Debug
zawiera przyciski
pozwalające na uruchomienie
i zatrzymanie wykonywania
programu (pasek ten jest
stylizowany na panel
magnetowidu)
Po wciśnięciu klawisza F5 wykonywanie programu zostaje przerwane w miejscu ozna-
czonym punktem przerwania. Aplikacja jest w trybie przerwania, co jest oznaczone
pojawieniem się napisu
na pasku tytułu środowiska programistycznego. W punk-
cie oznaczającym przerwanie pojawia się żółta strzałka, a instrukcja, która została
przerwana, jest zakreślona żółtym kolorem. Teraz należy przejść w konsoli do trybu
Immediate i wypróbować jego możliwości.
Jeśli okno Command jest niewidoczne, należy je otworzyć. Następnie należy wpisać
komendę
, aby przełączyć się w tryb Immediate. Teraz można wprowadzać do-
wolne instrukcje języka Visual Basic, które natychmiast zostaną wykonane. Spróbuj-
my wykonać następujące działania:
W trybie Immediate nie można poruszać się pomiędzy poszczególnymi liniami za
pomocą klawiszy strzałek. Strzałki (góra/dół) służą do przewijania wcześniej wpi-
sanych instrukcji. Aby skorzystać z tekstu wygenerowanego w oknie Immediate,
należy zaznaczyć odpowiedni blok, skopiować (CTRL + C) i przenieść w odpowied-
nie miejsce (np. do dokumentu w edytorze Word). Można ustawić kursor (za po-
mocą myszy) na odpowiedniej linii i nacisnąć Enter, wówczas ta konkretna linia
zostanie wypisana jako ostatnia wprowadzona instrukcja w konsoli. Po ponownym
wciśnięciu klawisza Enter ta instrukcja zostanie wykonana.
60
Visual Basic .NET dla każdego
Należy zauważyć, że znak zapytania
jest skrótem dobrze znanej z języka Basic in-
strukcji
(wypisz na ekranie). Gdy nie napiszemy tej instrukcji przed naszym
wyrażeniem (np.
!"#
), nie zostanie ono wykonane (pojawi się błąd składni — Syntax
Error). Błąd nie wystąpi, gdy napiszemy np.
$%$%&'
, bo jest to pra-
widłowa instrukcja Visual Basica (nie zobaczymy efektu zadziałania tej instrukcji).
Gdy teraz naciśniemy F5, program zostanie wykonany do końca, a na ekranie pojawi
się okno dialogowe. To okno ma teraz taką szerokość, jaką zadeklarowano instrukcją
$%
(w naszym przypadku
$% '
). Łatwo więc zauważyć, że można
modyfikować aplikację za pomocą okna Command/Immediate.
Pomoc kontekstowa
System pomocy znajduje się w zakładce okna właściwości (Properties). W oknie po-
mocy mamy możliwość uzyskania informacji dotyczącej każdej instrukcji Visual Ba-
sica i sposobu jej wykorzystania oraz innych informacji dotyczących programowania
w tym języku. Okno pomocy pojawia się po naciśnięciu klawisza F1 albo po wybra-
niu tematu pomocy z menu Help. Okno pomocy zawiera odnośniki do tematów po-
wiązanych z zawartością aktywnego okna środowiska programistycznego, w którym
znajduje się kursor. W oknie pomocy (rysunek 2.15) znajdują się również odnośniki
do dokumentacji platformy .NET. W oknie pomocy można wpisać w odpowiednim
polu hasło i znaleźć informacje na temat instrukcji języka Visual Basic albo technik
programowania. W dokumentacji znajduje się cały rozdział poświęcony programo-
waniu, są tam nawet przykładowe aplikacje.
Rysunek 2.15.
W oknie pomocy
można uzyskać
informacje
dotyczące
aktualnie
wykonywanego
zadania
Okno Server Explorer
W oknie Server Explorer znajduje się lista serwerów i baz danych (rysunek 2.16). Li-
sta baz danych zawiera zbiór wszystkich połączeń tworzonego projektu z serwerami
Rozdział 2.
♦ Praca z Visual Basic .NET
61
baz danych. Poprzez to okno można uzyskać dokładne informacje dotyczące baz da-
nych. Można np. przeglądać informacje wpisane w tabelach, procedury zapamiętane
i inne użyteczne dane dotyczące dostępnych baz danych.
Rysunek 2.16.
Okno Server
Explorer zawiera
informacje
dotyczące
zasobów serwerów
lokalnych i innych
komputerów
Lista serwerów zawiera informacje dotyczące dostępnych komputerów, z którymi
można się połączyć. Ponadto, za pomocą okna Server Explorer można w prosty spo-
sób udostępnić zasoby tych komputerów tworzonej aplikacji (są to np. liczniki wy-
dajności, rejestry, informacje o kolejkach, itp.).
W rozdziale trzynastym „Server Explorer” szczegółowo opisano to narzędzie.
Okno Properties
Okno właściwości (Properties) zawiera informacje na temat każdego obiektu w pro-
jekcie. W Visual Studio każdy element (projekt, rozwiązanie, forma, klasa, i inne) po-
siada zestaw definiowanych właściwości, które go opisują. Przykładem właściwości
jest nazwa projektu. W trakcie projektowania aplikacji środowisko automatycznie
ustawia właściwości domyślne każdego elementu. Aby przejrzeć właściwości obiektu
i dokonać ewentualnych zmian (np. zmienić nazwę projektu), należy skorzystać z okna
Properties (rysunek 2. 17). Niektóre pola w oknie właściwości nie mogą zostać zmie-
nione. Te pola pełnią rolę zakładek, dwukrotne ich kliknięcie powoduje rozwinięcie
listy właściwości znajdujących się w zakładce.
Solution Explorer
W tym oknie znajduje się wykaz aktualnie otwartych projektów. Okno to przypomina
trochę Eksplorator Windows, znajdujący się w systemie operacyjnym Windows. So-
lution Explorer służy do zarządzania projektami i plikami wchodzącymi w skład każ-
dego z projektów. Podczas tworzenia aplikacji programista może wybrać jedną z trzech
62
Visual Basic .NET dla każdego
Rysunek 2.17.
W oknie
Właściwości
są pokazane
wszystkie atrybuty
zaznaczonego
obiektu.
Na rysunku
zaznaczonym
obiektem
jest pole tekstowe,
którego atrybuty
pokazuje okno
Właściwości
metod zarządzania plikami należącymi do projektu. W środowisku Visual Studio .NET
tworzony program można umieszczać w rozwiązaniu (Solution), projekcie (Project)
lub pojedynczym pliku. Rozwiązanie jest zbiorem projektów, a w projektach umiesz-
czone są pliki. Projekty pełnią rolę tworzonych aplikacji zawierających poszczególne
pliki, klasy, komponenty. Okno Eksploratora pozwala na wyświetlenie wszystkich
rozwiązań, projektów i plików pod warunkiem, że są one otwarte. Za pomocą Eksplo-
ratora można wykonać wiele użytecznych funkcji, na przykład:
dodać nowe pliki do projektu (należy kliknąć prawym przyciskiem myszy
i z menu kontekstowego wybrać polecenie Add);
usunąć pliki z projektu (należy kliknąć prawym przyciskiem myszy i z menu
kontekstowego wybrać polecenie Remove);
dodać lub usunąć projekty zawarte w grupie rozwiązań (należy kliknąć
prawym przyciskiem myszy rozwiązanie, aby dodać projekt, albo kliknąć
prawym przyciskiem myszy projekt, by go usunąć z rozwiązania).
Class View
W oknie Class View są umieszczone wszystkie klasy, funkcje i zmienne należące do
tworzonego projektu. Class View (rysunek 2.18) pokazuje hierarchiczną strukturę
projektu, czyli uporządkowany wykaz wszystkich klas, funkcji i zmiennych. W tym
oknie łatwo sprawdzić, które funkcje i zmienne należą do określonej klasy, a także
które klasy są pochodnymi danej klasy.
Aby sprawdzić, w jaki sposób zbudowany jest projekt, wystarczy po kolei klikać na-
zwy poszczególnych klas. Spowoduje to rozwinięcie listy z funkcjami i zmiennymi
należącymi do tych klas oraz nazwami klas potomnych. Aby wyświetlić okno z ko-
dem źródłowym któregokolwiek z obiektów znajdujących się w Class View, wystar-
czy dwukrotnie kliknąć nazwę określonego obiektu. Widok klas pozwala na szybkie
Rozdział 2.
♦ Praca z Visual Basic .NET
63
Rysunek 2.18.
Okno widoku klas
przedstawia
hierarchiczną
strukturę projektu
i zapewnia dostęp
do kodu źródłowego
każdego z obiektów
zorientowanie się w budowie aplikacji, a także na szybki dostęp do odpowiednich klas,
funkcji i zmiennych. Za pomocą widoku klas można szybko sprawdzić, gdzie znaj-
duje się definicja (lub deklaracja) określonego obiektu. Często za pomocą widoku
klas programista jest przełączany do okna Object Browser, opisanego w następnym
podpunkcie. To okno jest niezwykle pomocne podczas projektowania aplikacji w Vi-
sual Basic .NET.
Object Browser
Programowanie w środowisku .NET opiera się na wykorzystywaniu obiektów (obiek-
tów tworzonych przez programistę, obiektów .NET Framework, itp.). Każdy z obiek-
tów zawiera określone metody i posiada swoje właściwości. Aby sprawdzić, jakie
funkcje są dostępne w obiekcie i jakie właściwości posiada, projektanci środowiska
Visual Studio .NET stworzyli Object Browser (przeglądarkę obiektów). Przeglądarka
pokazuje nie tylko obiekty należące do określonego projektu, ale także pozwala na
wyświetlenie właściwości obiektów nie należących do tworzonej aplikacji. Object
Browser jest bardzo przydatnym narzędziem do wyświetlania informacji dotyczących
obiektów .NET Framework (np. właściwości lub funkcji) lub innych bibliotek klas.
Na rysunku 2.19 przedstawiono przykład wykorzystania przeglądarki obiektów, która
wyświetla zawartość biblioteki
()*+
z informacjami dotyczącymi wykorzy-
stania jej elementów.
Task List
Podczas projektowania różnego rodzaju aplikacji istnieje wiele zadań do wykonania.
Poszczególne funkcje programu wykonujące określone zadania mogą korzystać z in-
nych funkcji. Aby zachować porządek pisanego programu, programiści używają ko-
mentarzy, w których opisują zadanie wykonywane w danej części kodu źródłowego.
W komentarzach często używa się charakterystycznych słów (np.
,+,
lub
-./
), które
64
Visual Basic .NET dla każdego
Rysunek 2.19.
Przeglądarka
obiektów
udostępnia
informacje
dotyczące
klas .NET
Framework
lub innych
bibliotek klas
ułatwiają dojście do odpowiednich bloków kodu. W środowisku Visual Studio .NET
wprowadzono standardową listę słów kluczowych zadań, które powinny znajdować
się w komentarzu. Gdy dodajemy jakiś obiekt automatycznie do formy, środowisko
programistyczne generuje odpowiedni kod źródłowy danego obiektu wraz z komenta-
rzem zawierającym słowa kluczowe standardowej listy zadań. Każdy komentarz za-
wierający słowo kluczowe jest wyświetlany w oknie Task List (lista zadań). Przykład
listy zadań pokazano na rysunku 2.20.
Rysunek 2.20.
Każdy komentarz,
poprzedzony
odpowiednim
słowem kluczowym,
zostanie rozpoznany
i dołączony
do listy zadań
Rozdział 2.
♦ Praca z Visual Basic .NET
65
Oprócz standardowych, można używać własnych słów kluczowych. Aby zdefiniować
własne słowa kluczowe, należy użyć z głównego menu opcji Tools, Options, Task
List. W lewej części ekranu znajduje się lista z istniejącymi słowami kluczowymi,
do której można dopisać własne, a następnie kliknąć przycisk Add. Po tej prostej
operacji można pisać komentarze zawierające nowe słowa kluczowe, które zosta-
ną rozpoznane i wpisane w oknie Task List.
Dwukrotne kliknięcie jednego z zadań znajdującego się na liście powoduje wyświe-
tlenie okna z kodem źródłowym i ustawienie kursora w miejscu komentarza. Jest to
dobry sposób na szybkie przemieszczanie się pomiędzy poszczególnymi funkcjami
podczas sprawdzania poprawności składni kodu. Do listy zadań można dodać linie nie
zawierające komentarza (tak zwane skróty).
Aby dodać do listy zadań skrót, należy przesunąć wskaźnik myszy na odpowiednią linię,
nacisnąć prawy przycisk i wybrać polecenie Add Task List Shortcut. Odpowiednia li-
nia zostanie wówczas dodana do listy zadań, a na marginesie okna z kodem źródło-
wym pojawi się symbol niebieskiej strzałki. Podobny symbol (ale w czarnym kolorze)
pojawi się na liście zadań, przy dodanej linii. Po dodaniu linii do listy zadań, można
się do niej szybko odwołać poprzez dwukrotne kliknięcie. Aby usunąć linię z listy za-
dań, należy kliknąć ją prawym przyciskiem myszy, a następnie z menu kontekstowe-
go wybrać opcję Delete.
Okno listy zadań umożliwia dodawanie tak zwanych zadań definiowanych przez użyt-
kownika. Są to zadania, które nie mają nic wspólnego z kodem źródłowym i stanowią
swego rodzaju notatkę dla programisty. Te zadania pełnią tylko funkcję informacyjną,
podobnie jak zadania definiowane w programie Microsoft Outlook. W zadaniach de-
finiowanych przez użytkownika można wykorzystać tylko pola opisu (Description)
i priorytetu zadania (Priority). Mamy do wyboru priorytet niski, normalny i wysoki
(Low, Normal, High).
Rozwiązania i projekty
Podczas tworzenia oprogramowania można skorzystać z kilku poziomów grupowania
poszczególnych składników aplikacji. Najwyższym poziomem jest rozwiązanie (So-
lution), które zawiera składniki tworzonej aplikacji, czyli projekty. Przed rozpoczę-
ciem programowania w środowisku Visual Studio, należy umieścić wewnątrz rozwią-
zania co najmniej jeden projekt. Niniejszy podpunkt poprowadzi nas przez proces
tworzenia nowych projektów, wpisywania kodu źródłowego i korzystania z istnieją-
cych projektów i plików.
Tworzenie nowego projektu
Istnieje kilka sposobów tworzenia nowego projektu. Najczęściej korzysta się z pole-
cenia menu (File, New Project). Wybranie tego polecenia powoduje wyświetlenie
okna dialogowego (rysunek 2.21), w którym mamy do wyboru kilka typów projektów.
Ponieważ Visual Studio umożliwia tworzenie aplikacji w wielu językach, w oknie
dialogowym znajdują się opcje dotyczące wszystkich zainstalowanych języków pro-
gramowania. My będziemy tworzyć aplikację korzystając z opcji zawartych w folde-
rze Visual Basic Projects.
66
Visual Basic .NET dla każdego
Rysunek 2.21.
Okno dialogowe
New Project
pozwala na wybór
typu tworzonego
projektu wraz
z opcjami
językowymi
Aby utworzyć aplikację, którą będzie można uruchomić na lokalnym komputerze w sys-
temie Windows (za pomocą graficznego interfejsu użytkownika, okien dialogowych
i innych elementów), należy z dostępnych typów projektów wybrać ikonę aplikacji
dla Windows (Windows Application). Ponadto trzeba wpisać nazwę tworzonej aplika-
cji i w razie potrzeby zmienić ścieżkę dostępu do folderu wykorzystywanego przez
projekt. Po naciśnięciu przycisku OK kreator aplikacji środowiska Visual Studio
utworzy nowy projekt. Dobrym nawykiem jest stosowanie poprawnego nazewnictwa
tworzonych aplikacji — posiadanie w komputerze projektów o nazwach WindowsAp-
plication1, WindowsApplication2..., może przysporzyć trudności w odnalezieniu wła-
ściwego projektu.
Otwieranie istniejącego projektu
Podczas zamykania środowiska Visual Studio pojawia się okno dialogowe z zapyta-
niem, czy zapisać zmiany w projekcie, a następnie środowisko zamyka się automa-
tycznie. Chcąc otworzyć wcześniej utworzony projekt, powinniśmy zacząć od otwarcia
samego środowiska, a następnie skorzystać z jednej z kilku możliwości oferowanych
przez Visual Studio. Jedną z nich jest otwarcie projektu poprzez opcję głównego me-
nu (File, Open, Project albo przez opcję Recent Files w dolnej części menu Files).
Innym sposobem jest otwarcie projektu ze strony Get Started, gdzie znajdują się od-
nośniki do istniejących projektów wraz z datami ich powstania. Otwarcie nowego
projektu powoduje automatyczne zamknięcie wcześniej tworzonych projektów, chyba
że otworzymy go za pomocą opcji File, Add Project, która powoduje dodanie pro-
jektu do otwartego rozwiązania (grupy projektów).
Pliki
Koncepcję istnienia rozwiązań i projektów stworzono ze względów organizacyjnych
— właściwy kod aplikacji jest rozbity pomiędzy wiele plików, którymi trzeba zarzą-
dzać. Podczas tworzenia nowego projektu niektóre pliki są tworzone automatycznie,
np. plik nowej formy (
0
), gdy jest tworzona aplikacja pod Windows, albo pliki
nowego modułu (
10
), gdy jest tworzona aplikacja uruchamiana z konsoli.
Rozdział 2.
♦ Praca z Visual Basic .NET
67
Te pliki istnieją niezależnie od projektów i mogą być współdzielone przez kilka apli-
kacji, gdy zaistnieje taka potrzeba.
Dodawanie nowych plików do projektu
Oprócz plików generowanych przez środowisko Visual Studio, można dołączać do
projektu własne moduły, klasy, biblioteki, formy i inne pliki z kodem źródłowym.
Własne pliki można dołączać albo przez menu Project, albo za pomocą menu kontek-
stowego w oknie Eksploratora rozwiązań (należy ustawić wskaźnik myszy na nazwie
projektu i kliknąć prawym przyciskiem, a następnie wybrać odpowiednią opcję menu
Add). W zależności od typu pliku, jaki chcemy dołączyć, wybieramy odpowiednią
opcję menu Project lub kontekstowego menu Add. Wybranie opcji Add New Item po-
woduje wyświetlenie okna dialogowego (rysunek 2.22) z typami plików, które można
dodać do projektu.
Rysunek 2.22.
Okno Add New
Item posiada
kilka typów plików,
które można
umieścić
w projekcie.
Wyglądem
przypomina
okno New Project
Zapisywanie zmian
Istnienie wielu grup elementów aplikacji (rozwiązań, projektów, plików) może sta-
nowić pewien problem podczas zamykania środowiska. Należy wiedzieć, w jaki spo-
sób zapisywać zmiany projektów, które mogą zawierać wiele plików. Visual Studio
posiada dwie opcje zapisu zmian: Zapisz (Save) i Zapisz wszystko (Save All). Te opcje
znajdują się w głównym menu File. Opcja Zapisz umożliwia zapisanie zmian pliku
zaznaczonego w Eksploratorze rozwiązań, a opcja Zapisz wszystko powoduje zapisa-
nie zmian we wszystkich plikach należących do aplikacji.
Jeśli chcemy mieć pewność, że wszystkie zmiany w tworzonych projektach będą za-
pisane, możemy w oknie Options wybrać folder Environment i zakładkę Project and
Solutions (rysunek 2.23), a następnie wybrać jedną z trzech opcji Build and Run. Wy-
branie opcji Save changes to open documents spowoduje zapisywanie wszystkich zmian
przed uruchomieniem aplikacji. Ustawienie tej opcji jest bardzo ważne, bo w razie
zawieszenia się środowiska podczas kompilacji lub testowania programu nie stracimy
zmian dokonanych przed próbą uruchomienia projektu.
68
Visual Basic .NET dla każdego
Rysunek 2.23.
Należy zawsze
sprawdzić
ustawienie
opcji Save,
aby zapewnić
zachowanie
wszystkich
dokonanych
w projekcie zmian
na wypadek
zawieszenia się
systemu
Tworzenie pierwszej aplikacji
dla systemu Windows
Po wprowadzeniu do środowiska programistycznego Visual Basic, czas na stworzenie
pierwszej aplikacji. Ten przykład ma na celu pokazanie możliwości środowiska pro-
gramistycznego, dlatego utworzymy bardzo prostą aplikację. Nasza aplikacja będzie
uruchamiana w systemie Windows i umożliwi wprowadzenie przez użytkownika kil-
ku liczb, które zostaną do siebie dodane, a na ekranie pojawi się wynik tej operacji.
Tworzenie projektu
Najpierw należy utworzyć nowy projekt za pomocą opcji Project z menu File, New.
W oknie dialogowym New Project zaznaczamy ikonę Windows Application i wpisu-
jemy nazwę projektu
2
. Nowy projekt zawiera formę, a Visual Studio automa-
tycznie utworzy folder Solution o nazwie Adder. Po wprowadzeniu odpowiednich da-
nych należy nacisnąć OK.
Interfejs użytkownika
W projekcie należy utworzyć graficzny interfejs użytkownika w postaci okna dialo-
gowego, w którym będą trzy pola tekstowe i jeden przycisk (rysunek 2.24). Aby zo-
baczyć obszar tworzonego okna dialogowego (czyli formy), należy dwa razy kliknąć
ikonę Form1.vb w oknie Solution Explorer. Z okna narzędziowego (Toolbox) będzie-
my wybierać potrzebne elementy i umieszczać w formie. Potrzebne elementy to pole
tekstowe TextBox i przycisk Button. Aby je umieścić w formie, należy ustawić wskaź-
nik myszy na pożądanym obiekcie w oknie narzędziowym, przeciągnąć obiekt w ob-
szar formy i zwolnić przycisk. W ten sposób umieścimy wszystkie elementy w oknie
dialogowym (jak pokazano na rysunku 2.24). Po umieszczeniu elementów w obszarze
Rozdział 2.
♦ Praca z Visual Basic .NET
69
formy, należy odpowiednio zmienić ich rozmiary. Aby nabrać wprawy w ustawianiu
elementów i doborze ich rozmiarów, można poświęcić chwilę na ustawianie elemen-
tów w różnej konfiguracji. Gdy wszystkie potrzebne elementy są już w obszarze for-
my, można ustawić ich właściwości.
Rysunek 2.24.
Widok gotowego
interfejsu
użytkownika,
który składa się
z trzech pól
tekstowych
i jednego
przycisku
Zaznaczmy pole tekstowe (pierwsze od góry) i otwórzmy okno właściwości (Proper-
ties) za pomocą klawisza F4 lub przez opcję menu (View, Properties Window). Okno
zawiera listę ustawień zaznaczonego pola tekstowego, ale nas interesują tylko dwie
właściwości:
Text (w zakładce Appearance) reprezentuje zawartość pola tekstowego,
która pojawia się w trakcie uruchomienia aplikacji. Zawartość tego pola
należy usunąć, aby po uruchomieniu aplikacji pole tekstowe było puste.
(Name) (w zakładce Design). W tym polu wpisujemy nazwę pola tekstowego.
Ta nazwa jest identyfikatorem pola. Za każdym razem, kiedy chcemy odwołać
się do pola tekstowego w kodzie źródłowym (np. pobrać liczbę wpisywaną
w pole przez użytkownika), posługujemy się właśnie tą nazwą. Wpiszmy
jakąś konkretną nazwę, np.
*31
.
Powyższe ustawienia należy zmienić w pozostałych dwóch polach tekstowych po-
przez usunięcie tekstu z właściwości Text i zmianę nazwy pól odpowiednio na
(
31
i
4*1
.
Teraz należy zaznaczyć przycisk i zmienić jego właściwości. W polu Text należy wpi-
sać
+
(ten napis pojawi się na przycisku i będzie widoczny podczas pracy aplika-
cji), a w polu (Name) —
2
. Tak jak w przypadku pól tekstowych, nazwa przyci-
sku wpisana w pole (Name)okna właściwości stanowi identyfikator tego obiektu.
70
Visual Basic .NET dla każdego
Ostatnią zmianą, jakiej dokonamy w naszym pierwszym projekcie, jest zmiana nazwy
formy. Należy kliknąć formę tak, aby nie zaznaczyć żadnego z jej obiektów — wów-
czas pojawi się ramka wokół projektowanego okna dialogowego. Następnie należy
znaleźć w oknie właściwości pole Text, które znajduje się w zakładce Appearance.
Tekst wpisany w to pole będzie widoczny na pasku tytułowym tworzonego okna dia-
logowego. W naszej aplikacji wpiszemy nazwę Sumator.
Uruchomienie aplikacji
Do tej pory nie wpisaliśmy ani jednej linijki kodu, ale możemy uruchomić naszą apli-
kację. Środowisko Visual Studio umożliwia uruchomienie aplikacji wewnątrz środo-
wiska, bez tworzenia plików wykonywalnych (np. plików z rozszerzeniem .exe). Można
w szybki sposób uruchamiać tworzony projekt i kontrolować jego zachowanie za po-
mocą wielu narzędzi diagnostycznych, które zostaną szczegółowo omówione w roz-
dziale szóstym. Należy podkreślić różnicę pomiędzy uruchamianiem aplikacji wewnątrz
środowiska a tworzeniem plików wykonywalnych, które mogą być uruchamiane w sys-
temie Windows. W następnym rozdziale nauczymy się tworzyć aplikacje uruchamia-
ne bezpośrednio w systemie operacyjnym.
Aby uruchomić aplikację, należy wcisnąć klawisz F5 albo wybrać polecenie Debug,
Start z głównego menu. Można również wcisnąć przycisk umieszczony w pasku na-
rzędzi, przypominający swym kształtem klawisz „Start” w magnetowidzie. W oknie
środowiska pojawi się okno dialogowe naszej aplikacji, które można przemieszczać,
zmieniać jego rozmiar, wpisywać tekst w pola tekstowe. Pomimo to, że nie wpisali-
śmy ani jednej linijki kodu, nasza aplikacja może być uruchamiana, a w dodatku mo-
żemy wykonać kilka czynności związanych z oknem dialogowym. Tę funkcjonalność
umożliwia .NET Framework i środowisko programowe, które pozwala na tworzenie
interfejsu użytkownika w sposób graficzny i generuje samoczynnie odpowiedni kod
obsługujący okno dialogowe wraz z umieszczonymi w nim elementami. Aby umożli-
wić uruchomienie aplikacji bez udziału środowiska programistycznego, należy „zbu-
dować” (Build) aplikację, czyli stworzyć plik wykonywalny.
Tworzenie pliku wykonywalnego
Operacja tworzenia pliku wykonywalnego dla środowiska Windows sprowadza się do
skompilowania projektu, co spowoduje wygenerowanie pliku wykonywalnego (z roz-
szerzeniem .exe). Plik wykonywalny tworzymy po to, aby można było uruchomić na-
szą aplikację na jakimkolwiek komputerze z zainstalowanym systemem operacyjnym
Windows.
Ustawienia w projekcie
Aby utworzyć plik wykonywalny naszego projektu, należy wybrać polecenie Build
z menu Build. Wykonanie tego polecenia spowoduje utworzenie pliku wykonywalnego
(w naszym przypadku będzie to plik o nazwie Sumator.exe), który zostanie umiesz-
czony w katalogu My Documents\Visual Studio Projects\Sumator\bin\Adder.exe, pod-
czas gdy projekt znajduje się w katalogu My Documents\Visual Studio Projects\Adder.
Rozdział 2.
♦ Praca z Visual Basic .NET
71
Polecenie Build ma pewne właściwości, które można zmienić w zależności od po-
trzeb. Aby zobaczyć domyślne ustawienia tej komendy, należy kliknąć prawym przy-
ciskiem myszy nazwę projektu w oknie Eksploratora rozwiązań i wybrać z menu kon-
tekstowego opcję Properties. Otworzy się okno z właściwościami naszego projektu,
podzielonymi na kilka grup. W grupie Common Properties/General znajdują się pola:
Assembly name. W tym polu umieszczona jest nazwa, jaką będzie miał utworzony
plik wykonywalny po kompilacji. W naszym przypadku to pole zawiera nazwę
Adder. Jeśli zmienimy tę nazwę na np. MyAdder, to po kompilacji zostanie
utworzony plik o takiej nazwie.
Output type. Jest to lista typów plików możliwych do otrzymania w trakcie
kompilacji. Gdy wybierzemy Windows Application lub Console Application,
otrzymamy plik wykonywalny (z rozszerzeniem .exe). Jeśli zostanie wybrana
opcja Library, to w wyniku kompilacji uzyskamy plik biblioteczny
(z rozszerzeniem .dll).
Startup object. Jest to lista wyboru zawierająca wszystkie części projektu,
umożliwiająca okreslenie, która z nich ma być uruchomiona w pierwszej
kolejności po uruchomieniu programu. W naszym przypadku jest to
(1
. Należy zauważyć, że jeśli zmienimy opcję Windows Application
na liście Output type na inną, to może to spowodować zmianę na liście
Startup object. Ponowne ustawienie opcji Windows Application na liście
Output type nie przywróci poprzedniej opcji na liście Startup object; trzeba
ją ustawić samodzielnie.
Jeśli w oknie Properties naszego projektu dokonamy zmian, które mogą być niepra-
widłowe, możemy anulować je za pomocą przycisku Cancel.
Wszystkie ustawienia w zakładce Common Properties/Version są przechowywane
w plikach tworzonych podczas kompilacji. Te informacje są widoczne, gdy w systemie
Windows klikniemy prawym przyciskiem myszy plik i wybierzemy z menu kontek-
stowego zakładkę Właściwości/Wersja (rysunek 2.25). Informacje, które pojawią się
w tej zakładce mogą być ważne dla użytkowników naszych aplikacji. Szczególnie ważne
jest wpisanie szczegółowych informacji dotyczących tworzonych plików bibliotecznych.
W zakładce Common Properties/Build można wybrać ikonę tworzonego pliku wyko-
nywalnego. Z listy rozwijanej Application Icon możemy wybrać ikonę naszego pliku
wykonywalnego. Zamiast domyślnej (Default icon), możemy wybrać dowolną ikonę
umieszczoną w pliku z rozszerzeniem .ico.
W pozostałych zakładkach omawianego okna znajdują się inne informacje i ustawie-
nia dotyczące tworzonej aplikacji.
Ustawienia konfiguracji kompilatora
W górnej części okna właściwości projektu znajduje się lista Configuration. Domyśl-
nie na liście Configuration mamy do wyboru dwa ustawienia: Debug i Release, które
służą do testowania aplikacji (Debug) lub tworzenia wersji dostarczanej użytkownikom
72
Visual Basic .NET dla każdego
Rysunek 2.25.
Informacje
dotyczące
wersji aplikacji
zostały dodane
jeszcze przed
kompilacją
(Release). Środowisko Visual Studio pozwala na utworzenie wielu grup ustawień kon-
figuracji dla jednego projektu. Konfiguracje rozwiązań (Solution Configurations) słu-
żą do wyboru odpowiedniego schematu tworzenia aplikacji.
Za pomocą menedżera konfiguracji (Configuration Manager) można stworzyć własne
grupy konfiguracji, a nawet usunąć istniejące. Okno menedżera konfiguracji pokaza-
no na rysunku 2.26. Na razie wystarczy wiedzieć, że opcja Release służy do utworzenia
plików aplikacji, a opcja Debug jest przeznaczona do testowania tworzonego projektu.
Rysunek 2.26.
Okno Configuration
Manager pozwala
na utworzenie
różnych
konfiguracji
do wykonania
różnych zadań
(testowania,
tworzenia pliku
wykonywalnego, itp.)
Tworzenie pliku wykonywalnego
Najlepszym sposobem na poznanie środowiska programistycznego i jego możliwości
jest wykonanie prostej aplikacji i utworzenie pliku wykonywalnego. Wystarczy wybrać
polecenie Build z menu Build, a kompilator utworzy nam plik wykonywalny. W trak-
cie kompilacji w dolnej części ekranu pojawia się okno Output, w którym wyświetla-
ne są informacje na temat przebiegu kompilacji i ewentualnych błędów powstałych
podczas kompilacji. Jeśli kompilacja przebiegła prawidłowo, możemy zminimalizować
okno środowiska Visual Studio i spróbować uruchomić utworzony plik. Nasza aplika-
cja powinna znajdować się w katalogu My Documents\Visual Studio Projects\ Sumator\
bin\Adder.exe. Jeśli jej tam nie ma, można wykorzystać Eksplorator Windows, aby ją
znaleźć. Po dwukrotnym kliknięciu ikony naszej aplikacji pojawia się zaprojektowane
Rozdział 2.
♦ Praca z Visual Basic .NET
73
przez nas okno dialogowe, co oznacza, że program działa. Plik wykonywalny utwo-
rzony przez kompilator można uruchomić na każdym komputerze wyposażonym w sys-
tem operacyjny Windows.
Wpisywanie kodu źródłowego
Nasz program wprawdzie się uruchomił, ale nie wykonuje postawionego mu zadania.
Na razie mogliśmy się przekonać, w jaki sposób tworzy się podstawową formę apli-
kacji i w jaki sposób umieszcza się elementy w oknie dialogowym. W oknie naszej
aplikacji będziemy do dwóch pól tekstowych wpisywać dwie liczby, a w trzecim polu
pojawi się wynik dodawania dwóch wprowadzonych składników. Aby to zadanie zo-
stało wykonane, należy oprogramować przycisk Dodaj naszej aplikacji.
Wpisywanie kodu źródłowego odpowiedzialnego za wykonanie odpowiedniego zada-
nia po naciśnięciu przycisku jest bardzo proste. Najpierw w oknie Solution Explorer
należy kliknąć dwukrotnie naszą formę. Następnie trzeba dwukrotnie kliknąć przycisk
Dodaj, pokaże się okno z kodem źródłowym, zawierające procedurę obsługującą zda-
rzenie związane z tym przyciskiem. Każdy obiekt kontrolny umieszczany w oknie dia-
logowym może reagować na określone zdarzenia (np. kliknięcie, dwukrotne kliknięcie,
zaznaczenie, usunięcie zaznaczenia, itp.) generowane przez użytkownika programu.
Aby umożliwić reagowanie na zdarzenia, środowisko generuje procedury odpowie-
dzialne za wykonanie funkcji w nich zawartych. Gdy dwukrotnie klikniemy przycisk
Dodaj, który ma identyfikator
2
, środowisko utworzy nam procedurę, która bę-
dzie wykonywana za każdym razem, gdy użytkownik naszego programu naciśnie ten
przycisk. Nazwa tej procedury jest domyślnie tworzona od identyfikatora obiektu,
którego dotyczy i zdarzenia, które spowoduje jej wykonanie. Po dwukrotnym naciśnię-
ciu przycisku Dodaj w naszej formie zostanie utworzona procedura
25 6
.
Aby sprawdzić, jak zdarzenia wpływają na wykonanie procedury związanej ze zda-
rzeniem, można posłużyć się obiektem klasy
**7-
należącym do .NET Frame-
work. Za pomocą klas z grupy, do której należy klasa
**7-
tworzone są formy,
przyciski, pola tekstowe i inne elementy interfejsu użytkownika. Klasa
**7-
po-
zwala na wyświetlenie okna dialogowego z informacją, np. funkcja:
!"#$%&'(()*+ ,(-%.
spowoduje wyświetlenie okna dialogowego przedstawionego na rysunku 2.27. Spróbujmy
wpisać powyższy kod do procedury związanej z naszym przyciskiem. Po uruchomie-
niu programu, za każdym razem, gdy naciśniemy przycisk, pojawi się okno dialogowe
z odpowiednią informacją. To oznacza, że za każdym razem, gdy generujemy zdarze-
nie „kliknięcie przycisku”, wykonywana jest procedura związana z tym zdarzeniem.
Wróćmy do procedury związanej z naszym przyciskiem i usuńmy jej zawartość. W jej
miejsce wstawimy kod źródłowy, którego zadaniem będzie dodanie dwóch liczb i wy-
świetlenie wyniku tej operacji. Najpierw należy dokonać konwersji łańcucha znaków
pól tekstowych, w których wpisywane są liczby, na wartości liczbowe, a następnie
należy dodać dwie liczby do siebie i wyświetlić wynik. Wszystkie te zadania wyko-
namy za pomocą jednej linijki kodu:
#/ 0#(($12$# 30#.4
((((12$#30#..0!
74
Visual Basic .NET dla każdego
Rysunek 2.27.
Funkcje klasy
MessageBox pozwalają
na korzystanie
z okien dialogowych
do wyświetlania
informacji.
Takie okna
często wykorzystuje się
podczas testowania
aplikacji
W powyższym wyrażeniu najpierw dokonywana jest konwersja łańcuchów tekstowych
pierwszego i drugiego składnika na wartości całkowite, następnie te dwie liczby są
dodawane do siebie, a wynik operacji jest wyświetlany w trzecim polu tekstowym, po
zamianie na łańcuch tekstowy. Sposób programowania w Visual Basicu jest dokładniej
opisany w rozdziale trzecim, „Wprowadzenie do programowania w Visual Basic .NET”.
Podsumowanie
Środowisko programistyczne wymyślono po to, by ułatwić pracę programistom i umoż-
liwić pisanie, edycję, sprawdzanie poprawności i kompilację programów. Visual Stu-
dio zapewnia wiele możliwości, których nie sposób opisać w jednym rozdziale. W ni-
niejszym rozdziale przedstawiono główne okna i narzędzia Visual Studio, a także
pokazano sposób tworzenia aplikacji. W kolejnych rozdziałach nie zawsze będziemy
korzystać ze środowiska graficznego, ale w trakcie samodzielnych prób tworzenia
aplikacji możemy się coraz bardziej z nim „zaprzyjaźnić”.
Pytania i odpowiedzi
P: Czy możemy tworzyć aplikacje korzystając z edytora tekstowego i konsoli,
bez udziału środowiska programistycznego?
O: W środowisku Visual Basic .NET można programować w dwojaki sposób. Może-
my pisać kod źródłowy w edytorze tekstowym i kompilować go z wiersza poleceń
konsoli albo tworzyć aplikacje w sposób wizualny, korzystając z możliwości oferowa-
nych przez środowisko programistyczne. W środowisku programuje się jednak o wiele
łatwiej, bo oferuje ono wiele narzędzi ułatwiających tworzenie aplikacji.
P: Czy można zdefiniować własne funkcje dostępne w środowisku programi-
stycznym?
O: Oczywiście! Środowisko programistyczne umożliwia dostosowanie go do potrzeb
użytkownika za pomocą kilku metod (np. można tworzyć własne makra i dodatki).
W tej książce nie zostanie opisany sposób dostosowywania środowiska do własnych
potrzeb, ale można przejrzeć przykłady zawarte w Tools, Macros, Macros IDE.
Rozdział 2.
♦ Praca z Visual Basic .NET
75
Warsztat
W warsztacie znajduje się prosty quiz, który pozwoli na ugruntowanie wiedzy zdo-
bytej w tym rozdziale, i ćwiczenia, które pomogą nabrać doświadczenia w wykorzy-
staniu tej wiedzy. Odpowiedzi na pytania i wskazówki do ćwiczeń znajdują się w do-
datku A, „Odpowiedzi”.
Quiz
1.
W którym oknie środowiska programistycznego można wyświetlić wszystkie
pliki należące do tworzonego projektu?
2.
W którym folderze domyślnie są umieszczane nowe projekty?
3.
W jaki sposób można wybrać ikonę, która będzie przedstawiać plik
wykonywalny tworzonej aplikacji?
4.
Jeśli okno Command jest w trybie Immediate, to w jaki sposób można przejść
w tryb Command?
Ćwiczenie
Spróbujmy poeksperymentować z funkcjami klasy
**7-
i wyświetlić okno dia-
logowe z informacją, gdy użytkownik wykona konkretne zdarzenie. W obszarze okna
edycji kodu źródłowego wybierzmy zmienną
4*1
w prawej liście rozwijanej
i zdarzenie
6%7
w lewej liście rozwijanej, a następnie napiszmy funkcję wy-
świetlającą okno dialogowe, gdy użytkownik spróbuje zmienić zawartość pola tek-
stowego, do którego przypisano zmienną
4*1
.
Wyszukiwarka
Podobne podstrony:
Visual Basic NET dla kazdego vbnetd
Programowanie obiektowe w Visual Basic NET dla kazdego povbnd
Programowanie obiektowe w Visual Basic NET dla kazdego 2
Visual Basic NET dla kazdego 2
Programowanie obiektowe w Visual Basic NET dla kazdego 2
Programowanie obiektowe w Visual Basic NET dla kazdego 2
Programowanie obiektowe w Visual Basic NET dla kazdego povbnd
Visual Basic NET dla kazdego vbnetd
Programowanie obiektowe w Visual Basic NET dla kazdego povbnd
Visual Basic NET dla kazdego vbnetd
Programowanie obiektowe w Visual Basic NET dla kazdego povbnd
Visual Basic NET dla kazdego vbnetd
Programowanie obiektowe w Visual Basic NET dla każdego
Visual Basic NET dla kazdego(1)
Mastering Visual Basic NET Database Programming
Visual Basic NET
praktyczny kurs visual basic net XPYVI3QBP3MCXRIFJRISPLODUH6ANI5R5DTEUTQ
Leksykon VISUAL BASIC, Uwagi dla RR, Rozdział X
więcej podobnych podstron