Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00078 006116 13848770 na godz. na dobę w sumie
Visual Basic 2010. Od podstaw - książka
Visual Basic 2010. Od podstaw - książka
Autor: , Liczba stron: 736
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-2827-8 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> visual basic - programowanie
Porównaj ceny (książka, ebook, audiobook).

Zostań specjalistą języka Visual Basic 2010!

Visual Basic 2010 to najnowsza wersja języka programowania Visual Basic .NET, jednego z języków współpracujących ze środowiskiem Visual Studio 2010. Jego największe zalety to łatwość stosowania i szybkość tworzenia szerokiego wachlarza aplikacji, od tych przeznaczonych dla systemu Windows, poprzez aplikacje internetowe, aż po te zaprojektowane dla urządzeń mobilnych. Platforma .NET daje programistom języka Visual Basic 2010 możliwość tworzenia w pełni obiektowych programów, napisanych za pomocą klas bazowych wspólnych dla wszystkich języków obsługiwanych przez Visual Studio 2010.

Dzięki tej książce poznasz zagadnienia potrzebne do tworzenia własnych programów w języku Visual Basic 2010. Naucz się podstaw budowania aplikacji Windows Forms, obsługi błędów oraz debugowania własnego kodu. Poznaj sposoby programowania obiektowego i zastosuj je w swoich aplikacjach. Dowiedz się, jak współpracować z zewnętrznymi bazami danych, tworzyć aplikacje sieciowe oraz używać języka XML w swoich programach. Zdobądź wiedzę niezbędną do tego, aby budować profesjonalne aplikacje, które wykorzystują wszystkie możliwości języka Visual Basic 2010.

Dołącz do grona najlepszych programistów języka Visual Basic 2010!

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

Darmowy fragment publikacji:

Visual Basic 2010. Od podstaw Autorzy: Thearon Willis, Bryan Newsome Tłumaczenie: Tomasz Walczak ISBN: 978-83-246-2827-8 Tytuł oryginału: Beginning Visual Basic 2010 Format: 172×245, stron: 736 Zostań specjalistą języka Visual Basic 2010! • Szczegółowy opis tworzenia aplikacji • Programowanie obiektowe z pomocą języka Visual Basic 2010 • Debugowanie oraz obsługa błędów • Współpraca z bazami danych Visual Basic 2010 to najnowsza wersja języka programowania Visual Basic .NET, jednego z języków współpracujących ze środowiskiem Visual Studio 2010. Jego największe zalety to łatwość stosowania i szybkość tworzenia szerokiego wachlarza aplikacji, od tych przeznaczonych dla systemu Windows, poprzez aplikacje internetowe, aż po te zaprojektowane dla urządzeń mobilnych. Platforma .NET daje programistom języka Visual Basic 2010 możliwość tworzenia w pełni obiektowych programów, napisanych za pomocą klas bazowych wspólnych dla wszystkich języków obsługiwanych przez Visual Studio 2010. Dzięki tej książce poznasz zagadnienia potrzebne do tworzenia własnych programów w języku Visual Basic 2010. Naucz się podstaw budowania aplikacji Windows Forms, obsługi błędów oraz debugowania własnego kodu. Poznaj sposoby programowania obiektowego i zastosuj je w swoich aplikacjach. Dowiedz się, jak współpracować z zewnętrznymi bazami danych, tworzyć aplikacje sieciowe oraz używać języka XML w swoich programach. Zdobądź wiedzę niezbędną do tego, aby budować profesjonalne aplikacje, które wykorzystują wszystkie możliwości języka Visual Basic 2010. • Aplikacje Windows Forms • Podstawowe komendy • Programowanie obiektowe • Platforma .NET • Technologia ASP.NET • Struktury danych • Wykorzystanie języka XML • Wdrażanie aplikacji • Współpraca z bazami danych • Obsługa błędów Dołącz do grona najlepszych programistów języka Visual Basic 2010! Idź do • Spis treści • Przykładowy rozdział Katalog książek • Katalog online • Zamów drukowany katalog Twój koszyk • Dodaj do koszyka Cennik i informacje • Zamów informacje o nowościach • Zamów cennik Czytelnia • Fragmenty książek online Kontakt Helion SA ul. Kościuszki 1c 44-100 Gliwice tel. 32 230 98 63 e-mail: helion@helion.pl © Helion 1991–2010 Spis treści Podziękowania .............................................................................................. 14 O autorach ..................................................................................................... 15 O redaktorze merytorycznym ...................................................................... 17 Wprowadzenie .............................................................................................. 19 Rozdział 1. Wprowadzenie do języka Visual Basic 2010 ............................................... 23 Programowanie oparte na zdarzeniach .....................................................................24 Instalacja Visual Basic 2010 ........................................................................................25 Środowisko programistyczne Visual Basic 2010 ......................................................28 Ustawianie profilu ..................................................................................................29 Menu ........................................................................................................................29 Paski narzędzi .........................................................................................................30 Tworzenie prostej aplikacji .........................................................................................31 Okna środowiska Visual Studio 2010 ..................................................................32 Okno narzędzi .........................................................................................................35 Zmodyfikowana notacja węgierska ......................................................................39 Edytor kodu .............................................................................................................40 Używanie systemu pomocy .........................................................................................43 Podsumowanie ..............................................................................................................43 Rozdział 2. Platforma .NET .............................................................................................. 47 Zależność Microsoftu od systemu Windows ............................................................47 MSN 1.0 ...................................................................................................................48 Wizja .NET ..............................................................................................................49 Czy nie przypomina to Javy? .................................................................................50 Co dalej? ...................................................................................................................51 Pisanie oprogramowania dla systemu Windows .....................................................51 Klasy platformy .NET ............................................................................................52 Wykonywanie kodu ...............................................................................................53 Wspólne środowisko uruchomieniowe .....................................................................54 Ładowanie i wykonywanie kodu ..........................................................................55 Izolacja aplikacji .....................................................................................................55 Bezpieczeństwo .......................................................................................................55 Współdziałanie .......................................................................................................56 Obsługa wyjątków ..................................................................................................56 Wspólny system typów i specyfikacja wspólnego języka ........................................57 Podsumowanie ..............................................................................................................57 6 µ VISUAL BASIC 2010. OD PODSTAW Rozdział 3. Pisanie programów ....................................................................................... 61 Informacje i dane ..........................................................................................................61 Algorytmy ................................................................................................................62 Czym jest język programowania? .........................................................................63 Zmienne .........................................................................................................................63 Komentarze i odstępy ..................................................................................................66 Komentarze .............................................................................................................66 Odstępy ....................................................................................................................68 Typy danych ..................................................................................................................68 Używanie liczb ........................................................................................................68 Podstawowe operacje matematyczne na liczbach całkowitych ........................69 Skrócone operatory matematyczne ......................................................................71 Arytmetyka na liczbach zmiennoprzecinkowych ..............................................73 Używanie ciągów znaków .....................................................................................76 Używanie dat ...........................................................................................................84 Zmienne logiczne ...................................................................................................90 Przechowywanie zmiennych .......................................................................................90 System dwójkowy ...................................................................................................91 Bity i bajty ................................................................................................................91 Reprezentowanie wartości .....................................................................................92 Przekształcanie wartości ........................................................................................93 Metody ...........................................................................................................................95 Dlaczego warto używać metod? ............................................................................95 Metody z tego rozdziału ........................................................................................96 Tworzenie metod ....................................................................................................99 Nazwy metod ........................................................................................................102 Zasięg .....................................................................................................................103 Podsumowanie ............................................................................................................105 Rozdział 4. Sterowanie przebiegiem programu ..........................................................109 Podejmowanie decyzji ................................................................................................109 Instrukcja If .................................................................................................................110 Instrukcja Else .......................................................................................................112 Obsługa wielu alternatyw za pomocą instrukcji ElseIf ....................................113 Zagnieżdżone instrukcje If ..................................................................................114 Jednowierszowe instrukcje If ..............................................................................114 Operatory porównania ........................................................................................114 Porównywanie ciągów znaków ...........................................................................124 Wyrażenie Select Case ................................................................................................125 Używanie wyrażenia Select Case bez uwzględniania wielkości liter .............129 Warunki z wieloma wartościami ........................................................................132 Wyrażenie Case Else ............................................................................................133 Używanie różnych typów danych w wyrażeniach Select Case .......................134 Pętle ..............................................................................................................................134 Pętle For … Next ..................................................................................................134 Pętle Do … Loop ..................................................................................................140 Spis treści µ 7 Pętle zagnieżdżone ...............................................................................................145 Wczesne wychodzenie z pętli ..............................................................................147 Pętle nieskończone ...............................................................................................149 Podsumowanie ............................................................................................................150 Rozdział 5. Struktury danych ........................................................................................153 Wprowadzenie do korzystania z tablic ....................................................................153 Definiowanie i używanie tablic ...........................................................................153 Używanie pętli For Each … Next .......................................................................156 Przekazywanie tablic jako parametrów .............................................................159 Sortowanie tablic ..................................................................................................161 Przechodzenie w odwrotnym kierunku ............................................................162 Inicjowanie tablicy ...............................................................................................163 Wyliczenia ...................................................................................................................165 Używanie wyliczeń ...............................................................................................165 Określanie stanu ...................................................................................................168 Ustawianie niepoprawnych wartości .................................................................170 Stałe ...............................................................................................................................171 Używanie stałych ..................................................................................................171 Stałe różnych typów .............................................................................................173 Struktury ......................................................................................................................174 Tworzenie struktur ...............................................................................................174 Dodawanie właściwości do struktur ..................................................................177 Tablice ArrayList ........................................................................................................178 Używanie klasy ArrayList ....................................................................................178 Usuwanie elementów z listy ArrayList ..............................................................182 Wyświetlanie elementów tablic ArrayList ........................................................185 Używanie kolekcji .......................................................................................................186 Tworzenie kolekcji CustomerCollection ...........................................................187 Dodawanie właściwości Item ..............................................................................188 Wyszukiwanie elementów za pomocą kolekcji Hashtable ....................................190 Używanie kolekcji Hashtable ..............................................................................190 Usuwanie elementów — metody Remove, RemoveAt i Clear .......................193 Wrażliwość na wielkość znaków ........................................................................195 Zaawansowane techniki manipulacji tablicami ......................................................197 Tablice dynamiczne ..............................................................................................197 Słowo kluczowe Preserve .....................................................................................199 Podsumowanie ............................................................................................................200 Język XAML ..................................................................................................203 Czym jest XAML? .......................................................................................................203 Składnia języka XAML ...............................................................................................205 Technologia WPF .......................................................................................................208 Tworzenie bogatych interfejsów użytkownika w aplikacjach WPF ......................208 Używanie standardowych kontrolek technologii WPF ..................................214 Podłączanie zdarzeń .............................................................................................218 Podsumowanie ............................................................................................................222 Rozdział 6. 8 µ VISUAL BASIC 2010. OD PODSTAW Rozdział 7. Tworzenie aplikacji dla systemu Windows ...............................................225 Reagowanie na zdarzenia ...........................................................................................225 Ustawianie zdarzeń przycisku ............................................................................226 Tworzenie prostych aplikacji ....................................................................................233 Tworzenie formularza ..........................................................................................233 Zliczanie liter ...............................................................................................................236 Zliczanie słów ..............................................................................................................239 Bardziej złożone aplikacje .........................................................................................244 Aplikacja do edycji tekstu ....................................................................................245 Tworzenie paska narzędzi .........................................................................................246 Tworzenie paska stanu ...............................................................................................250 Tworzenie pola edycji ................................................................................................252 Usuwanie zawartości pola edycji ..............................................................................254 Obsługa działania przycisków paska narzędzi ........................................................256 Używanie wielu formularzy ......................................................................................262 Okno z informacjami o programie ....................................................................262 Podsumowanie ............................................................................................................265 Rozdział 8. Okna dialogowe ..........................................................................................269 Okno komunikatu ......................................................................................................269 Ikony okna komunikatu ......................................................................................270 Przyciski okna komunikatu ................................................................................271 Ustawianie przycisku domyślnego .....................................................................271 Inne opcje ..............................................................................................................271 Składnia metody Show .........................................................................................271 Przykładowe okna komunikatu ..........................................................................273 Kontrolka OpenFileDialog ........................................................................................276 Kontrolka OpenFileDialog ..................................................................................277 Właściwości kontrolki OpenFileDialog ............................................................277 Metody kontrolki OpenFileDialog .....................................................................279 Używanie kontrolki OpenFileDialog .................................................................279 Kontrolka SaveFileDialog ..........................................................................................283 Właściwości kontrolki SaveFileDialog ..............................................................284 Metody kontrolki SaveFileDialog .......................................................................285 Używanie kontrolki SaveFileDialog ...................................................................285 Kontrolka FontDialog ................................................................................................288 Właściwości kontrolki FontDialog ....................................................................288 Metody kontrolki FontDialog .............................................................................288 Używanie kontrolki FontDialog .........................................................................288 Kontrolka ColorDialog ..............................................................................................291 Właściwości kontrolki ColorDialog ...................................................................292 Używanie kontrolki ColorDialog .......................................................................293 Kontrolka PrintDialog ...............................................................................................294 Właściwości kontrolki PrintDialog ....................................................................295 Używanie kontrolki PrintDialog ........................................................................296 Spis treści µ 9 Klasa PrintDocument ..........................................................................................296 Drukowanie dokumentu .....................................................................................296 Kontrolka FolderBrowserDialog ..............................................................................303 Właściwości kontrolki FolderBrowserDialog ...................................................303 Używanie kontrolki FolderBrowserDialog .......................................................304 Podsumowanie ............................................................................................................306 Rozdział 9. Tworzenie menu ..........................................................................................309 Właściwości menu ......................................................................................................309 Rysunki ..................................................................................................................310 Klawisze dostępu ..................................................................................................310 Klawisze skrótu .....................................................................................................310 Znacznik wyboru ..................................................................................................310 Okno właściwości .................................................................................................311 Tworzenie menu .........................................................................................................312 Projektowanie menu ............................................................................................312 Dodawanie pasków narzędzi i kontrolek ..........................................................314 Kod obsługujący menu ........................................................................................316 Dodawanie kodu obsługującego menu Widok oraz paski narzędzi .............320 Testowanie kodu ...................................................................................................321 Menu kontekstowe .....................................................................................................324 Tworzenie menu kontekstowego .......................................................................324 Włączanie i wyłączanie opcji menu oraz przycisków paska narzędzi ...........327 Podsumowanie ............................................................................................................331 Rozdział 10. Debugowanie i obsługa błędów ................................................................333 Główne rodzaje błędów .............................................................................................334 Błędy składni .........................................................................................................334 Błędy wykonania ...................................................................................................337 Błędy logiczne .......................................................................................................338 Debugowanie ...............................................................................................................339 Tworzenie przykładowego programu ................................................................339 Ustawianie punktów przerwania ........................................................................355 Debugowanie za pomocą okien Watch i QuickWatch ...................................362 Używanie okna Autos ..........................................................................................364 Używanie okna Locals .........................................................................................364 Obsługa błędów ..........................................................................................................366 Używanie ustrukturalizowanej obsługi błędów ...............................................367 Podsumowanie ............................................................................................................369 Rozdział 11. Tworzenie obiektów ...................................................................................373 Wprowadzenie do podejścia obiektowego ..............................................................373 Hermetyzacja ........................................................................................................375 Metody i właściwości ...........................................................................................375 Zdarzenia ...............................................................................................................375 Widoczność ...........................................................................................................376 Czym jest klasa? ....................................................................................................377 10 µ VISUAL BASIC 2010. OD PODSTAW Tworzenie klas ............................................................................................................377 Powtórne wykorzystanie kodu .................................................................................378 Projektowanie klasy ....................................................................................................379 Stan .........................................................................................................................380 Działanie ................................................................................................................380 Zapisywanie stanu ................................................................................................381 Prawdziwe właściwości ........................................................................................383 Właściwości do odczytu i zapisu ........................................................................386 Metoda IsMoving .................................................................................................389 Konstruktory ...............................................................................................................391 Dziedziczenie ...............................................................................................................393 Dodawanie nowych metod i właściwości ..........................................................394 Dodawanie metody GetPowerToWeightRatio ................................................397 Zmiana ustawień domyślnych ............................................................................398 Polimorfizm — trudne słowo, łatwe pojęcie ....................................................400 Przesłanianie innych metod ................................................................................401 Dziedziczenie po klasie Object ...........................................................................403 Obiekty i struktury .....................................................................................................403 Klasy platformy .NET ................................................................................................404 Przestrzenie nazw .................................................................................................404 Instrukcja Imports ................................................................................................406 Tworzenie własnych przestrzeni nazw ..............................................................407 Dziedziczenie na platformie .NET .....................................................................410 Podsumowanie ............................................................................................................411 Rozdział 12. Zaawansowane techniki programowania obiektowego ........................413 Tworzenie przeglądarki ulubionych stron internetowych ....................................413 Skróty internetowe i adresy ulubionych stron .................................................414 Używanie klas .......................................................................................................416 Przeglądanie skrótów do ulubionych stron ......................................................422 Otwieranie stron ...................................................................................................429 Inna wersja przeglądarki ulubionych .......................................................................431 Dostęp do ulubionych stron za pomocą zasobnika .........................................431 Wyświetlanie listy ulubionych stron ..................................................................433 Używanie współdzielonych właściwości i metod ...................................................436 Używanie procedur współdzielonych ................................................................437 Używanie metod współdzielonych ....................................................................441 Programowanie obiektowe i zarządzanie pamięcią ...............................................442 Przywracanie pamięci ..........................................................................................444 Zwalnianie zasobów .............................................................................................444 Defragmentacja i kompaktowanie .....................................................................445 Podsumowanie ............................................................................................................446 Rozdział 13. Tworzenie bibliotek klas ............................................................................449 Biblioteki klas ..............................................................................................................450 Tworzenie biblioteki klas .....................................................................................450 Tworzenie biblioteki klas dla projektu Favorites Viewer ...............................452 Spis treści µ 11 Aplikacje wielowarstwowe ..................................................................................455 Używanie silnych nazw ..............................................................................................456 Podpisywanie podzespołów ................................................................................457 Wersje podzespołu ...............................................................................................459 Rejestrowanie podzespołów ......................................................................................460 Narzędzie Gacutil .................................................................................................460 Dlaczego utworzonego podzespołu nie widać w oknie dialogowym References? ..................................................461 Projektowanie bibliotek klas .....................................................................................461 Używanie gotowych bibliotek klas ...........................................................................462 Podglądanie klas za pomocą przeglądarki obiektów .............................................463 Podsumowanie ............................................................................................................464 Rozdział 14. Tworzenie własnych kontrolek formularzy Windows .............................467 Kontrolki formularzy Windows ...............................................................................468 Tworzenie i testowanie kontrolek użytkownika .....................................................468 Udostępnianie właściwości kontrolek użytkownika ..............................................472 Dodawanie właściwości .......................................................................................472 Udostępnianie metod kontrolki użytkownika ..................................................474 Udostępnianie zdarzeń kontrolki użytkownika ...............................................475 Etap projektowania a czas wykonywania programu .............................................479 Tworzenie kontrolki CommandLink .......................................................................481 Tworzenie kontrolki CommandLink ................................................................482 Używanie kontrolki CommandLink ..................................................................490 Podsumowanie ............................................................................................................493 Rozdział 15. Dostęp do baz danych ................................................................................495 Czym są bazy danych? ................................................................................................496 Obiekty bazodanowe Microsoft Access .............................................................496 Tabele .....................................................................................................................496 Kwerendy ...............................................................................................................497 Instrukcja SELECT języka SQL ................................................................................497 Kwerendy w bazie danych Access ............................................................................499 Komponenty dostępu do danych .............................................................................503 DataSet ...................................................................................................................503 DataGridView .......................................................................................................504 BindingSource .......................................................................................................504 BindingNavigator .................................................................................................504 TableAdapter .........................................................................................................504 Wiązanie danych .........................................................................................................505 Podsumowanie ............................................................................................................511 Rozdział 16. Programowanie baz danych przy użyciu SQL Server i ADO.NET ............515 ADO.NET ....................................................................................................................517 Przestrzenie nazw ADO.NET .............................................................................517 Klasa SqlConnection ............................................................................................518 Klasa SqlCommand ..............................................................................................520 12 µ VISUAL BASIC 2010. OD PODSTAW Klasa SqlDataAdapter ..........................................................................................522 Klasa DataSet .........................................................................................................526 Klasa DataView .....................................................................................................527 Klasy ADO.NET w praktyce .....................................................................................529 Przykład zastosowania obiektu DataSet ............................................................530 Wiązanie danych .........................................................................................................538 Obiekty BindingContext i CurrencyManager ..................................................538 Wiązanie kontrolek ..............................................................................................539 Podsumowanie ............................................................................................................567 Rozdział 17. Witryny w technologii Dynamic Data .........................................................571 Tworzenie witryny typu Dynamic Data Linq to SQL ............................................571 Zmienianie projektu witryn typu Dynamic Data ............................................577 Podsumowanie ............................................................................................................583 Rozdział 18. ASP.NET .......................................................................................................585 Architektura typu uproszczony klient .....................................................................586 Formularze WWW a formularze Windows ...........................................................587 Zalety formularzy Windows ...............................................................................587 Zalety formularzy WWW ...................................................................................587 Aplikacje sieciowe — podstawowe elementy ..........................................................588 Serwery WWW .....................................................................................................588 Przeglądarki ...........................................................................................................588 Hipertekstowy język znaczników .......................................................................588 Język JavaScript .....................................................................................................589 Kaskadowe arkusze stylów (CSS) .......................................................................589 Technologia Active Server Pages ..............................................................................589 Zalety ......................................................................................................................590 Specjalne pliki witryn internetowych ................................................................590 Tworzenie aplikacji ..............................................................................................590 Kontrolki — okno narzędzi ................................................................................591 Tworzenie witryn ........................................................................................................591 Tworzenie formularzy WWW oraz przetwarzanie po stronie klienta i po stronie serwera ............................................................591 Lokalizacje witryn internetowych w środowisku Visual Studio 2010 ...........597 Przekazywanie danych i sprawdzanie ich poprawności ..................................599 Projektowanie wyglądu i stylu witryny .............................................................604 Używanie kontrolki GridView do tworzenia formularzy WWW sterowanych danymi ...............................609 Podsumowanie ............................................................................................................614 Rozdział 19. Visual Basic 2010 i XML ..............................................................................619 Wprowadzenie do XML ............................................................................................619 Jak wygląda język XML? ......................................................................................620 XML dla osób poznających Visual Basic ...........................................................622 Reguły .....................................................................................................................623 Spis treści µ 13 Książka adresowa ........................................................................................................623 Tworzenie projektu ..............................................................................................623 Klasa SerializableData ..........................................................................................624 Wczytywanie plików XML ..................................................................................630 Modyfikowanie danych .......................................................................................633 Wysyłanie poczty elektronicznej ........................................................................634 Tworzenie listy adresów ......................................................................................635 Pomijanie wybranych składowych .....................................................................639 Wczytywanie danych adresowych .....................................................................641 Dodawanie nowych adresów ..............................................................................642 Poruszanie się po danych ....................................................................................644 Usuwanie adresów ................................................................................................646 Integracja z książką adresową ...................................................................................648 Zasady integracji ...................................................................................................648 Wczytywanie książki adresowej w innej aplikacji ............................................650 Podsumowanie ............................................................................................................655 Rozdział 20. Wdrażanie aplikacji .....................................................................................657 Czym jest wdrażanie? .................................................................................................657 Wdrażanie typu ClickOnce .................................................................................658 Wdrażanie typu XCOPY ......................................................................................663 Tworzenie aplikacji instalacyjnych przy użyciu Visual Studio 2010 ...................663 Edytor interfejsu użytkownika ..................................................................................667 Wdrażanie innych rozwiązań ...................................................................................670 Podzespoły prywatne ...........................................................................................671 Podzespoły współdzielone ...................................................................................671 Wdrażanie aplikacji dla komputerów stacjonarnych ......................................672 Wdrażanie aplikacji sieciowych ..........................................................................672 Wdrażanie usług WWW ......................................................................................673 Przydatne narzędzia..............................................................................................673 Podsumowanie ...................................................................................................................674 Dodatek A Rozwiązania ćwiczeń...................................................................................677 Dodatek B Co dalej? .......................................................................................................691 Skorowidz ....................................................................................................697 3 Pisanie programów CZEGO NAUCZYSZ SIĘ W TYM ROZDZIALE? „ Działania algorytmów. „ Stosowania zmiennych. „ Działania różnych typów danych, w tym liczb całkowitych, liczb zmiennoprzecinkowych, ciągów znaków i dat. „ Określania zasięgu kodu. „ Usuwania błędów z aplikacji. „ Przechowywania danych w pamięci komputera. Po zainstalowaniu i uruchomieniu środowiska Visual Basic 2010, a nawet po napisaniu prostego, ale działającego programu, pora przyjrzeć się podstawowym informacjom dotyczącym pisania pro- gramów. Dzięki temu będziesz mógł samodzielnie zacząć tworzyć bardziej rozbudowane aplikacje. Informacje i dane Informacje opisują fakty i można je przedstawiać oraz wyszukiwać w dowolnym formacie, niezależ- nie od tego, czy dany format bardziej nadaje się dla ludzi, czy dla komputerów. Na przykład, jeśli cztery osoby będą miały za zadanie mierzyć natężenie ruchu na czterech różnych skrzyżowaniach, po zakończeniu pracy przedstawią cztery ręcznie zapisane listy z liczbą samochodów, które przeje- chały w danym okresie (może to być jedna lista na każdą godzinę). Pojęcie dane służy do opisu informacji, które zostały zestawione, uporządkowane i sformatowane w taki sposób, aby możliwe było ich bezpośrednie wykorzystanie przez program komputerowy. Komputer nie może bezpośrednio użyć informacji zebranych przez osoby mierzące natężenie ruchu w postaci zestawu kartek pełnych odręcznych zapisków. Ktoś musi najpierw przekształcić te zapiski na dane. Na przykład można przepisać liczby do arkusza programu Excel, który można następnie bezpośrednio wykorzystać w programie zaprojektowanym do analizy wyników. 62 µ ROZDZIAŁ 3. PISANIE PROGRAMÓW Algorytmy Zmiany w przemyśle komputerowym zachodzą z niesamowitą szybkością. Większość profesjonal- nych programistów musi cały czas uczyć się czegoś nowego, aby ich umiejętności były aktualne. Jednak niektóre aspekty tworzenia programów nie zmieniły się od czasu ich wymyślenia i prawdo- podobnie nie zmienią się w najbliższym czasie. Dobrym przykładem aspektu technologii kompute- rowej, którego istota nie zmieniła się od początku, jest proces i dyscyplina tworzenia oprogramowania. Aby program działał, musi mieć dane, na których może pracować. Następnie program bierze takie dane i przekształca je na inną postać. Na przykład aplikacja może pobierać bazę z danymi klientów zapisaną w pamięci komputera jako zestaw jedynek i zer, a następnie przekształcać ją na postać możliwą do odczytania na ekranie monitora. Komputer pokładowy w samochodzie nieustannie analizuje informacje dotyczące środowiska oraz stanu pojazdu i przystosowuje mieszankę paliwa tak, aby zapewnić jak najwydajniejszą pracę silnika. Dostawca usług telekomunikacyjnych zapisuje wykonane telefony i na podstawie tych informacji generuje rachunki. Wspólną podstawą tych programów są algorytmy. Przed napisaniem programu rozwiązującego dany problem, trzeba rozbić go na pojedyncze kroki opisujące rozwiązanie problemu. Algorytm jest nie- zależny od języka programowania, dlatego możesz zapisać go zarówno za pomocą języka naturalnego, jak i diagramów lub w inny sposób ułatwiający wizualizację problemu. Wyobraź sobie, że pracujesz dla firmy telekomunikacyjnej i masz za zadanie wygenerować rachunki na podstawie telefonów wykonanych przez klientów. Poniższy algorytm opisuje jedno z możliwych rozwiązań: 1. Pierwszego dnia miesiąca musisz utworzyć rachunki dla wszystkich klientów. 2. Z każdym klientem powiązana jest lista połączeń wykonanych w ubiegłym miesiącu. 3. Znasz długość każdej rozmowy, a także porę jej przeprowadzenia. Na podstawie tych informacji możesz obliczyć koszt każdego połączenia. 4. Każdy rachunek to łączna suma wszystkich połączeń. 5. Jeśli klient rozmawiał dłużej, niż wynosi ustalony limit, musi zapłacić określoną kwotę za każdą dodatkową minutę. 6. Do każdego rachunku dodajesz podatek. 7. Po przygotowaniu rachunku trzeba go wydrukować i wysłać pocztą. Tych siedem punktów opisuje — dość wyczerpująco — algorytm programu generującego rachunki za połączenia wychodzące w systemie operatora telefonii komórkowej. Nie jest istotne, czy gotowe rozwiązanie napisane będzie w języku C++, Visual Basic 2010, C#, Java, czy w innym — podstawo- wy algorytm programu nie zmieni się. Warto jednak pamiętać, że poszczególne punkty powyższego algorytmu można rozbić na mniejsze, bardziej szczegółowe algorytmy. Dobrą wiadomością dla osób uczących się programować jest to, że zwykle utworzenie takiego algo- rytmu jest dość proste. Bardzo łatwo zrozumieć działanie powyższego algorytmu. Algorytmy zawsze tworzy się, wykorzystując zdrowy rozsądek, choć może się okazać, że trzeba napisać kod dla algo- rytmu zawierającego skomplikowane rozumowanie matematyczne lub naukowe. Możliwe, że nie uznasz tego za algorytm zdroworozsądkowy, jednak będzie on taki dla jego autora. Zła wiadomość jest taka, że proces przekształcania algorytmu na kod może być trudny. Dla programisty nauczenie się tworzenia algorytmów to kluczowa umiejętność. Wszyscy dobrzy programiści uwzględniają to, że wybór języka programowania nie jest zbyt istotny. Różne języki są dobre do wykonywania odmiennych zadań. Język C++ daje programistom dużą kontrolę nad działaniem programów, jednak pisanie aplikacji w tym języku jest trudniejsze niż na przykład w Visual Basic 2010, podobnie jak tworzenie interfejsu użytkownika. Niektóre z problemów związanych z językiem C++ rozwiązuje jego zarządzana wersja udostępniana przez platformę .NET, Zmienne µ 63 dlatego powyższe stwierdzenia są mniej prawdziwe dziś niż jeszcze kilka lat temu. Jako programista musisz nauczyć się wykorzystywać różne języki do rozwiązywania różnych problemów w jak najwydajniejszy sposób. Choć na początku większość programistów koncentruje się na jednym języku, warto pamiętać, że różne języki pozwalają tworzyć najlepsze rozwiązania dla odmiennych problemów. W pewnym momencie do napisania programu w nowym języku może okazać się ko- nieczne użycie podstawowych umiejętności związanych z projektowaniem algorytmów i kodowaniem. Czym jest język programowania? W pewnym sensie możesz postrzegać jako język programowania cokolwiek, co potrafi podejmować decyzje w środowisku komputera. Komputery potrafią doskonale podejmować decyzje, te jednak muszą być stosunkowo proste, na przykład „czy dana liczba jest większa od trzech?” lub „czy ten samochód jest niebieski?”. Jeśli chcesz podjąć skomplikowaną decyzję, proces jej podejmowania należy rozbić na mniejsze elementy zrozumiałe dla komputera. Do rozbijania złożonych decyzji na proste służą algorytmy. Dobrym przykładem problemu, z którym komputery radzą sobie niezbyt dobrze, jest rozpoznawanie ludzkich twarzy. Nie można po prostu zadać komputerowi pytania „czy to zdjęcie Kasi?”. W zamian trzeba rozbić pytanie na serię prostszych pytań zrozumiałych dla komputera. Decyzja podejmowana przez komputer to jedna z dwóch możliwych odpowiedzi: tak lub nie. Te możliwości określa się także jako prawdę i fałsz lub 1 i 0. Używając pojęć obecnych w programie, nie można kazać komputerowi podjąć decyzji na podstawie pytania „o ile większa jest liczba 10 w porównaniu z liczbą 4?”. Poprawnie zadane pytanie brzmi: „czy liczba 10 jest większa od 4?”. Różnica nie jest duża, ale istotna — pierwsze pytanie nie pozwala udzielić odpowiedzi tak lub nie, pod- czas gdy drugie to umożliwia. Komputer oczywiście potrafi udzielić odpowiedzi na pierwsze z tych pytań, ale wymaga to wykonania pewnych operacji. Mówiąc inaczej, aby odpowiedzieć na pierwsze pytanie, należy odjąć 4 od 10 i użyć wyniku tego działania w odpowiednim miejscu algorytmu. Wymóg stawiania pytań pozwalających na udzielenie odpowiedzi tak lub nie może Ci się wydawać pewnym ograniczeniem, jednak nie należy tak go traktować. Decyzje podejmowane w życiu co- dziennym wyglądają tak samo. Kiedy podejmujesz jakąś decyzję, możesz coś zaakceptować (tak, prawda, 1) lub odrzucić (nie, fałsz, 0). Ta książka opisuje język Visual Basic 2010, ale istotne aspekty programowania są w dużym stopniu niezależne od języka. Kluczowe jest zrozumienie, że każdy program, niezależnie od naszpikowania nowinkami i języka, w którym został napisany, składa się z metod (funkcji i procedur, które są wier- szami kodu służącymi do implementacji algorytmu) oraz zmiennych (miejsc przechowywania danych, którymi manipulują metody). Zmienne Zmienna to coś, w czym przechowywana jest wartość używana w algorytmie. Na podstawie tych wartości można podejmować decyzje (na przykład „czy dana zmienna równa się 7?” lub „czy dana zmienna jest większa od 4?”), można też wykonywać na nich operacje i przekształcać je na inne wartości (na przykład „dodaj 2 do tej zmiennej” lub „pomnóż daną zmienną przez 6” i tak dalej). Przed napisaniem kodu przyjrzyj się kolejnemu algorytmowi: 1. Utwórz zmienną o nazwie intNumber i przypisz do niej liczbę 27. 2. Dodaj 1 do wartości zmiennej o nazwie intNumber i zapisz nową wartość w tej samej zmiennej. 3. Wyświetl zmienną intNumber użytkownikowi aplikacji. 64 µ ROZDZIAŁ 3. PISANIE PROGRAMÓW W tym algorytmie tworzysz zmienną o nazwie intNumber i przypisujesz do niej liczbę 27. Oznacza to, że program używa fragmentu pamięci komputera do przechowywania wartości 27. Ten frag- ment pamięci przechowuje tę wartość do czasu jej zmiany lub poinformowania programu, że wartość nie jest już potrzebna. Drugi krok polega na wykonaniu dodawania. Do wartości zmiennej intNumber zostaje dodana liczba 1. Po wykonaniu tej operacji fragment pamięci przechowujący zmienną intNumber zawiera wartość 28. Na koniec program ma wyświetlić użytkownikowi wartość zmiennej intNumber. Należy wczytać tę wartość z pamięci i wyświetlić ją na ekranie. Także ten algorytm jest prosty i zrozumiały. Opiera się jedynie na zdrowym rozsądku. Jednak kod tego algorytmu w języku Visual Basic 2010 jest nieco bardziej tajemniczy. SPRÓBUJ SAM Używanie zmiennych Plik z kodem projektu Variables można pobrać z witryny helion.pl. W tym ćwiczeniu „Spróbuj sam” nauczysz się, jak używać zmiennych. 1. Utwórz nowy projekt w środowisku Visual Studio 2010, wybierając z menu opcję File/New/Project. W oknie dialogowym New Project wybierz aplikację typu Windows Forms Application z panelu znajdującego się po prawej stronie, wpisz nazwę projektu, Variables, a następnie kliknij przycisk OK (rysunek 3.1). Rysunek 3.1. Tworzenie projektu Variables 2. Zmniejsz nieco formularz Form1 i dodaj do niego przycisk z okna narzędzi. Ustaw właściwość Text przycisku na Dodaj 1 do intNumber, a właściwość Name — na btnAdd. Formularz powinien wyglądać tak jak na rysunku 3.2. Zmienne µ 65 Rysunek 3.2. Główny formularz projektu Variables 3. Kliknij dwukrotnie przycisk, aby otworzyć metodę obsługi zdarzenia btnAdd_Click. Dodaj do tej metody kod wyróżniony pogrubieniem: Private Sub btnAdd_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles btnAdd.Click Dim intNumber As Integer intNumber = 27 intNumber = intNumber + 1 MessageBox.Show( WartoĂÊ zmiennej intNumber + 1 = intNumber.ToString, _ Zmienne ) End Sub 4. Kliknij przycisk Save All na pasku narzędzi, aby zapisać projekt. 5. Uruchom projekt i kliknij przycisk Dodaj 1 do intNumber. Pojawi się okno komunikatu przedstawione na rysunku 3.3. Rysunek 3.3. Wynik dodawania Jak to działa? Po kliknięciu przycisku przez użytkownika program wywołuje metodę obsługi zdarzenia btnAdd_ ´Click, rozpoczyna działanie od góry kodu i wykonuje kolejne wiersze. Pierwszy wiersz definiuje nową zmienną o nazwie intNumber: Dim intNumber As Integer Dim to słowo kluczowe. Jak opisano to w rozdziale 1., słowa kluczowe mają w języku Visual Basic 2010 specjalne znaczenie i służą między innymi do wydawania poleceń. Słowo Dim informuje język, że dalej znajduje się definicja zmiennej. Ta dziwna nazwa pochodzi z pierwszych wersji języka BASIC. Język BASIC musiał mieć informacje opisujące ilość miejsca rezerwowanego dla tablic (opisanych w rozdziale 5.), dlatego znajdowało się w nim polecenie informujące o „wymiarach” (ang. dimensions) tablicy, które w skrócie nazwano Dim. W języku Visual Basic rozszerzono to polecenie na inne rodzaje zmiennych i obecnie oznacza ono mniej więcej „przygotuj miejsce na…”. 66 µ ROZDZIAŁ 3. PISANIE PROGRAMÓW Następnie pojawia się nazwa zmiennej — intNumber. Zauważ, że zmienna nazwana jest zgodnie ze zmodyfikowaną notacją węgierską opisaną w rozdziale 1. W tym przypadku przedrostek int to skrót od Integer. Integer to typ danych reprezentujący zmienną intNumber, co opisuje następny akapit. Po przedrostku znajduje się nazwa zmiennej — w tym przypadku jest to Number. Jeśli w ko- dzie natrafisz na taką zmienną, wiesz, że jest to zmienna reprezentująca liczbę typu Integer. Nazwa Integer informuje język Visual Basic 2010 o rodzaju wartości przechowywanej przez zmien- ną. Rodzaj wartości to typ danych. Na razie wystarczy zapamiętać, że ta instrukcja informuje język, iż zmienna ma przechowywać wartości typu Integer (liczby całkowite). Kolejny wiersz przypisuje wartość do zmiennej intNumber: intNumber = 27 Oznacza to, że powyższa instrukcja zapisuje w zmiennej intNumber liczbę 27. Kolejna instrukcja dodaje do zmiennej intNumber liczbę 1: intNumber = intNumber + 1 Powyższy wiersz oznacza: „pobierz aktualną wartość zmiennej intNumber i dodaj do niej 1”. Ostatni wiersz powoduje wyświetlenie okna dialogowego z tekstem WartoĂÊ zmiennej intNumber + 1 = oraz aktualną wartością tej zmiennej. Ta sama instrukcja ustawia także nagłówek okna dialogowego na Zmienne, aby odzwierciedlał przeznaczenie projektu. Przy korzystaniu z warto- ści liczbowych w tekście warto zastosować metodę ToString do zrzutowania liczby na ciąg znaków. Ułatwia to czytanie i rozumienie kodu, ponieważ wiadomo, że użyto w nim ciągu znaków: MessageBox.Show( WartoĂÊ zmiennej intNumber + 1 = intNumber.ToString, _ Zmienne ) Komentarze i odstępy Kiedy piszesz kod programu, zawsze pamiętaj, że w przyszłości ktoś inny może musieć wprowadzać w nim zmiany. Dlatego powinieneś starać się jak najbardziej ułatwić innym programistom odczytanie kodu. Komentarze i odstępy to dwa podstawowe środki do poprawiania czytelności kodu. Komentarze Komentarze to elementy programu ignorowane przez kompilator języka Visual Basic 2010, co ozna- cza, że możesz w nich zapisać dowolne informacje w dowolnym języku — po polsku, w C#, w Perl, w FORTRAN czy po chińsku. Te komentarze mają pomóc programistom czytającym kod w zrozu- mieniu działania danego fragmentu. Wszystkie języki programowania umożliwiają dodawanie komentarzy. Nie jest to cecha dostępna wyłącznie w języku Visual Basic 2010. Jeśli na przykład przyjrzysz się kodowi w języku C#, zauwa- żysz, że komentarze rozpoczynają się w nim od podwójnego ukośnika (//). Kiedy wiadomo, że warto dodać komentarz? Zależy to od sytuacji, ale dobrą praktyczną wskazówką jest zastanowienie się nad algorytmem. Program z poprzedniego ćwiczenia „Spróbuj sam” działa według następującego algorytmu: 1. Zdefiniuj wartość zmiennej intNumber. 2. Dodaj 1 do wartości zmiennej intNumber. 3. Wyświetl nową wartość zmiennej intNumber użytkownikowi. Komentarze i odstępy µ 67 Możesz dodać do przykładowego kodu komentarze opisujące wszystkie kroki algorytmu: Definicja zmiennej intNumber. Dim intNumber As Integer Ustawianie początkowej wartości. intNumber = 27 Dodanie 1 do wartości zmiennej intNumber. intNumber = intNumber + 1 Wyświetlenie nowej wartości zmiennej intNumber. MessageBox.Show( WartoĂÊ zmiennej intNumber + 1 = intNumber.ToString, _ Zmienne ) W języku Visual Basic 2010 komentarze rozpoczynają się od apostrofu ( ). Tekst znajdujący się w wierszu poprzedzonym apostrofem to komentarz. Można także dodawać komentarze w tym samym wierszu, w którym znajduje się kod, na przykład: intNumber = intNumber + 1 Dodanie 1 do wartości zmiennej intNumber. Takie rozwiązanie jest poprawne, ponieważ po apostrofie znajduje się jedynie komentarz, a nie kod. Zauważ, że komentarze w powyższym kodzie mniej więcej opisują działanie algorytmu. Dobrą praktyką związaną z komentowaniem kodu jest dodawanie krótkiego opisu tego etapu algorytmu, który jest wykonywany przez dany fragment kodu. Środowisko Visual Studio 2010 udostępnia także komentarze XML, które pozwalają utworzyć bloki komentarzy stanowiące dokumentację metod. Aby użyć tej właściwości, umieść kursor w pustym wierszu powyżej definicji metody i wpisz trzy następujące po sobie apostrofy. Środowisko automa- tycznie doda wtedy blok komentarza widoczny w poniższym fragmencie kodu: summary /summary param name= sender /param param name= e /param remarks /remarks Private Sub btnAdd_Click(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles btnAdd.Click Najciekawszą właściwością komentarzy XML jest to, że środowisko Visual Studio 2010 automatycz- nie uzupełnia nazwy parametrów w bloku komentarzy na podstawie parametrów zdefiniowanych w metodzie. Jeśli dana metoda nie przyjmuje żadnych parametrów, środowisko nie dodaje elementu param do bloku komentarzy. Po wstawieniu bloku komentarzy możesz dodać krótki opis działania metody oraz dodatkowe uwagi, które należy uwzględnić, wywołując tę metodę, a także specjalne wymagania stawiane przez metodę. Jeśli metoda zwraca wartość, środowisko dodaje do bloku komentarzy element returns , a pro- gramista może podać zwracaną wartość oraz jej opis. Komentarze mają przede wszystkim ułatwić zrozumienie kodu, zarówno programistom, którzy stykają się z nim po raz pierwszy, jak i autorowi, który wraca do niego po dłuższej przerwie. Ko- mentarze mają wskazywać coś, co może nie być oczywiste na pierwszy rzut oka, lub stanowić krótki opis działania fragmentu kodu, dzięki czemu programista nie musi analizować działania każde- go wiersza, aby zrozumieć jego zastosowanie. 68 µ ROZDZIAŁ 3. PISANIE PROGRAMÓW Programiści mają pewne zasady pisania komentarzy. Jeśli pracujesz dla dużej firmy programi- stycznej lub Twój przełożony albo nauczyciel zwraca dużą uwagę na standardy kodowania, na pew- no dowiesz się, w jakiej postaci powinieneś dodawać komentarze, a także kiedy powinieneś je umieszczać. Odstępy Kolejny istotny aspekt pisania czytelnego kodu to dodawanie wielu odstępów. Odstępy, czyli miejsca na ekranie lub na stronie pozbawione znaków, poprawiają czytelność kodu, podobnie jak odstępy w zwykłym tekście napisanym po polsku. W ostatnim przykładzie przed każdym komentarzem występuje pusty wiersz. Dzięki temu osoba czytająca kod wie, że każdy wyróżniony w ten sposób blok kodu stanowi całość. Więcej o odstępach dowiesz się w następnym rozdziale, gdzie opisane jest sterowanie przepływem programu za pomocą specjalnych bloków kodu. Jednak w praktyce zauważysz, że różni pr
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Visual Basic 2010. Od podstaw
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: