Visual Basic NET dla kazdego 2

background image

Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63

e-mail: helion@helion.pl

PRZYK£ADOWY ROZDZIA£

PRZYK£ADOWY ROZDZIA£

IDZ DO

IDZ DO

ZAMÓW DRUKOWANY KATALOG

ZAMÓW DRUKOWANY KATALOG

KATALOG KSI¥¯EK

KATALOG KSI¥¯EK

TWÓJ KOSZYK

TWÓJ KOSZYK

CENNIK I INFORMACJE

CENNIK I INFORMACJE

ZAMÓW INFORMACJE

O NOWOCIACH

ZAMÓW INFORMACJE

O NOWOCIACH

ZAMÓW CENNIK

ZAMÓW CENNIK

CZYTELNIA

CZYTELNIA

FRAGMENTY KSI¥¯EK ONLINE

FRAGMENTY KSI¥¯EK ONLINE

SPIS TRECI

SPIS TRECI

DODAJ DO KOSZYKA

DODAJ DO KOSZYKA

KATALOG ONLINE

KATALOG ONLINE

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

Przyk³ady na ftp: 1889 kB

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.

background image

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

background image

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

background image

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

background image

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

background image

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

background image

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

background image

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

background image

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

background image

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

background image

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

background image

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.

background image

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:

background image

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

background image

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

background image

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).

background image

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).

background image

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.

background image

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ę

background image

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.

background image

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.

background image

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).

background image

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

background image

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.

background image

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

background image

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

background image

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

background image

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

background image

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ń

background image

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.

background image

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.

background image

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.

background image

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

background image

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.

background image

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.

background image

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

background image

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

background image

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!

background image

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.

background image

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
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
Visual Basic NET dla kazdego 2
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