Visual Basic 2005. Wprowadzenie do programowania w .NET - Helion

Autor: Matthew MacDonald
Tytuł oryginału: The Book of Visual Basic 2005: .NET Insight for Classic VB Developers
Tłumaczenie: Adam Majczak, Tomasz Walczak
ISBN: 978-83-246-0696-2
stron: 592, Format: B5, okładka: miękka
Data wydania: 2007-07-16
Księgarnia: Helion

Cena książki: 77,00 zł

Pobierz fragment książki » Osoby, które kupiły tę książkę, wybierały także »

Tagi: .NET - Programowanie | Visual Basic - Programowanie

Wszechstronny przewodnik po świecie programowania w .NET
dla programistów języka Visual Basic

Jakie nowe funkcje oferuje Visual Basic 2005?
Jak wykorzystać najnowsze właściwości języka Visual Basic 2005 do przyspieszenia i ułatwienia programowania?
Jak zwiększyć produktywność, wykorzystując możliwości platformy .NET?

Wciąż zastanawiasz się nad przejściem z Visual Basic 6 na wersję pracującą w środowisku .NET? Najwyższa pora! Visual Basic 2005 to język, na który wielu programistów czekało od lat. Jest w pełni obiektowy, ma usprawnioną obsługę błędów, nowy model obsługi zdarzeń oraz udostępnia wiele innych funkcji, które znacznie zwiększają produktywność. Integracja z .NET pozwala korzystać w języku Visual Basic z wszystkich możliwości tej platformy, pracować we wspólnym środowisku uruchomieniowym (CLR) i używać rozbudowanej biblioteki klas .NET.

"Visual Basic 2005. Wprowadzenie do programowania w .NET" to wszechstronny przewodnik po świecie programowania w najnowszej wersji języka Visual Basic. Czytając tę książkę, dowiesz się, jakie zmiany zostały wprowadzone w wersjach języka Visual Basic zgodnych z platformą .NET. Nauczysz się wykorzystywać je do przyspieszenia i ułatwienia programowania. Poznasz udogodnienia dostępne w środowisku Visual Studio, techniki wygodnej obsługi baz danych przy użyciu ADO.NET, udoskonalone narzędzia diagnostyczne i wiele innych funkcji, które ułatwią Ci tworzenie programów wysokiej jakości.

Możliwości platformy .NET
Praca w Visual Studio
Programowanie obiektowe w Visual Basic 2005
Tworzenie interfejsów użytkownika przy użyciu formularzy Windows
Podzespoły i komponenty
Diagnozowanie programów w Visual Studio
Praca z bazami danych przy użyciu ADO.NET
Programowanie wielowątkowe
Tworzenie aplikacji i usług sieciowych
Instalowanie programów napisanych w Visual Basic 2005

Poznaj Visual Basic 2005 i dołącz do społeczności programistów .NET.

Osoby które kupowały "Visual Basic 2005. Wprowadzenie do programowania w .NET", wybierały także:

ASP .NET Core. Kurs video. Rozwijanie dodatkowych funkcjonalności Web API 89,00 zł, (26,70 zł -70%)
ASP.NET Core. Kurs video. Tworzenie REST Web API 49,00 zł, (14,70 zł -70%)
Gray Hat C#. Język C# w kontroli i łamaniu zabezpieczeń 57,74 zł, (17,90 zł -69%)
ASP.NET Core 6. Kurs video. Rozwijaj aplikacje webowe z Entity Framework Core 178,97 zł, (62,64 zł -65%)
PowerShell. Kurs video. Zarz 164,31 zł, (59,15 zł -64%)

Spis treści

Visual Basic 2005. Wprowadzenie do programowania w .NET -- spis treści

Wprowadzenie (17)

1. Rewolucja .NET (23)

Krótka historia języka Visual Basic (23)
- Wejście w .NET (24)
Ograniczenia "klasycznego" Visual Basic (25)
- Dziwaczna mieszanina Visual Basic (25)
- Odrębne języki (25)
- Bóle głowy przy rozwoju projektu (25)
- Piekło DLL (26)
- Niepełne wsparcie dla programowania obiektowego (26)
Wizja .NET (26)
- Składniki .NET (27)
- Common Language Runtime (CLR) (27)
- Klasy .NET (28)
- Mówienie w tym samym języku (29)
- Dogłębna integracja języków (30)
- Przygotowana infrastruktura (30)
- Usługi sieciowe i internet kolejnej generacji (31)
- Otwarte standardy: XML, SOAP, WSDL oraz pozostałe litery alfabetu (31)
- Metadane. Czy to koniec piekła DLL? (32)
Czy VB 2005 to jeszcze wciąż VB? (33)
- Udoskonalenia, bez których nie da się żyć (33)
- A teraz zmiany, które mogą frustrować (34)
- Ciemne strony .NET (34)
- A co z COM? (35)
I co dalej? (35)

2. Środowisko programowania (37)

Nowości w .NET (38)
Rozpoczynanie pracy w IDE (39)
- Strona początkowa (40)
- Zmiana zachowania przy uruchamianiu (41)
- Tworzenie projektu (42)
- Dokumenty z zakładkami (44)
- Dokowane i zgrupowane okna (45)
Zwiedzanie Visual Studio (45)
- Wyszukiwarka rozwiązań Solution Explorer (46)
- Przybornik: Toolbox (47)
- Okno właściwości: Properties (49)
- Wyświetlanie kodu (50)
- Dzielenie okien (52)
- Lista zadań Task List (53)
Strzępki kodu: Code Snippets (55)
- Wstawianie strzępków (55)
- Zarządzanie strzępkami (56)
Makra (57)
- Makro IDE (58)
- Tymczasowa makroinstrukcja - Temporary Macro (59)
- Makra z inteligencją (59)
- Makroinstrukcje a zdarzenia (60)
Najprostszy możliwy program w środowisku .NET (62)
- Pliki tworzące projekt aplikacji MyFirstConsoleApplication (63)
- Foldery projektu aplikacji MyFirstConsoleApplication (64)
- Własności projektu - Project Properties (65)
I co dalej? (67)

3. Podstawy VB 2005 (69)

Nowości w .NET (70)
Wprowadzenie do biblioteki klas (72)
- Namespace (72)
- Assembly - skompilowany kod namespace (75)
- Typy danych (75)
Stosowanie biblioteki klas (77)
- Dodanie referencji do pliku assembly (78)
- Jak importować namespace? (80)
- Wykorzystanie przestrzeni namespace z biblioteki klas (82)
- Szczególny obiekt - My (85)
Pliki kodu (88)
- Bloki klas i modułów (89)
- Bloki namespace (90)
- Dodanie plików kodu (91)
Typy danych (91)
- Typy danych w namespace System (92)
- Wspólna deklaracja wielu zmiennych (92)
- Inicjator VB - Initializer (93)
- Typy danych jako obiekty (93)
- Typ String (94)
- Bardziej efektywne obiekty klasy String (97)
- Czas i data (98)
- Macierze (98)
- Macierze i interfejs IEnumerable (99)
- Wbudowane cechy macierzy (100)
- Macierze jako typy referencyjne (101)
Zmiany w działaniu operatorów (102)
- Skrócony zapis operatorów przypisania (102)
- Konwersja typu zmiennej (103)
- Math, czyli nieco matematyki (104)
- Random numbers - liczby pseudolosowe (104)
- Pewne nowe reguły dostępności - Scope (104)
- Logika na skróty (105)
- Szybkie pomijanie iteracji w pętli (107)
Rozszerzone procedury (107)
- Wywołanie metody (108)
- Poprzez wartość lub poprzez referencję: ByVal, ByRef (108)
- Słowo kluczowe Return (109)
- Opcjonalne parametry (110)
- Wartości domyślne (111)
- Przeciążenie metod (111)
- Delegaty (113)
I co dalej? (116)

4. Formularze Windows (117)

Nowości w .NET (118)
Rozpoczęcie pracy (119)
- Zasobnik komponentów: Component Tray (120)
- Zindywidualizowane kreatory: Custom Designers (120)
- Blokowanie obiektów sterujących (121)
Układ graficzny obiektów sterujących (122)
- Kotwiczenie (122)
- Dokowanie (124)
- Maksymalny i minimalny rozmiar okna (126)
- Automatyczne przewijanie (127)
- Podzielone okna (127)
- Obiekty sterujące będące pojemnikami (130)
Obiekty sterujące i zdarzenia (131)
- Obsługiwanie więcej niż jednego zdarzenia (133)
- Przyciski Accept i Cancel (134)
Badanie formularzy .NET (135)
- Dwa sposoby na pokazanie formularza (136)
- Formularze i obiekt My (138)
- Formularze modalne (139)
- Formularz startowy i tryb wyłączenia (140)
- Zdarzenia aplikacji (140)
- Osobliwości formularzy (142)
Wewnętrzne działanie formularzy (144)
- Formularze "pod kapeluszem" Visual Basic 6 (144)
- Formularze "pod kapeluszem" w Visual Basic 2005 (146)
- Przechodzenie przez "bagno i breję" (147)
- A co z informacjami binarnymi? (149)
Dynamiczne dodawanie obiektów sterujących (149)
- Dynamiczne podłączenie obsługi zdarzenia (151)
Interakcja pomiędzy formularzami (153)
- Problem z interakcją przykładowego formularza (153)
- Okna dialogowe (155)
- Formularze przyporządkowane (156)
- Interfejsy MDI (157)
Więcej obiektów sterujących w .NET (159)
- Paski i menu (160)
- Ikony powiadamiające (164)
- Nowy rodzaj komponentów - Provider (167)
I co dalej? (168)

5. Programowanie obiektowe (169)

Nowości w .NET (170)
Wprowadzenie do programowania obiektowego (171)
- Co to jest programowanie obiektowe? (172)
- Problemy z tradycyjnym programowaniem strukturalnym (172)
Najpierw były sobie struktury... (173)
- Bardzo prosta struktura danych personalnych (174)
- Jak do struktury wbudować inteligencję? (175)
- Utworzenie instancji obiektu danej klasy (177)
- Obiekty - rzut oka na zaplecze (178)
- Klasy w kawałkach (181)
Rozbudowa klasy poprzez dodanie własności (182)
- Własności tylko do odczytu (185)
Rozbudowa klasy poprzez dodanie konstruktora (186)
- Konstruktory pobierające argumenty (187)
- Klasy z wieloma konstruktorami (188)
- Konstruktor domyślny (190)
- Destruktory (191)
- Mechanizm "Garbage Collection" w Visual Studio (191)
Rozbudowa klasy poprzez dodanie zdarzeń (194)
- Zdarzenie w akcji, czyli jak to działa (195)
- Zdarzenia o różnych sygnaturach (198)
Numeratory (200)
- Jak powstał pomysł na numerację? (202)
- Co się dzieje "pod kapeluszem" w typie wyliczeniowym? (203)
- Stosowanie typu wyliczeniowego w połączeniu ze zdarzeniami (205)
Współużytkowane komponenty klas i obiektów (207)
- Współużytkowane metody (208)
- Współużytkowane własności (210)
- Zaglądamy pod maskę modułu (211)
Ocena klas (212)
- Typy - obraz ogólny (213)
- Inspekcja obiektów w naszej aplikacji (214)
I co dalej? (215)

6. Opanowanie obiektów (217)

Nowości w .NET (218)
Filozofia programowania obiektowego (218)
- Idea czarnej skrzynki (219)
- Luźne łączenie (220)
- Spójność (221)
- Co reprezentują klasy? (221)
Dziedziczenie (222)
- Podstawy dziedziczenia (223)
- Konstruktory w klasach potomnych (225)
- Komponenty klas o statusie Protected (227)
- Przysłanianie metod (228)
- Casting (231)
- Klasy abstrakcyjne i słowo kluczowe MustInherit (232)
- Przysłanianie obowiązkowe MustOverride (233)
- Dziedziczenie wielopoziomowe (234)
- Czy dziedziczenie jest dobrym pomysłem? (235)
- Używanie dziedziczenia w celu rozszerzenia klas .NET (236)
Interfejsy (241)
- Używanie interfejsów (243)
- Interfejsy i wsteczna kompatybilność (244)
- Używanie typowych interfejsów .NET (245)
Klasy kolekcji (251)
- Podstawowa kolekcja (252)
- Klasa NuclearFamily (252)
- Kolekcje wyspecjalizowane (255)
- Kolekcje ogólne (255)
I co dalej? (257)

7. Pliki skompilowane i komponenty (259)

Nowości w .NET (260)
Wprowadzenie do plików skompilowanych typu "assembly" (261)
- Pliki skompilowane typu "assembly" kontra komponenty, które używają COM (261)
- Dlaczego nigdy wcześniej nie spotkaliśmy się z tymi cechami? (264)
- Postrzeganie programów jako plików skompilowanych typu "assembly" (265)
- Ustawianie informacji dotyczących pliku skompilowanego typu "assembly" (267)
- Pobieranie informacji o pliku skompilowanym typu "assembly" (270)
Tworzenie komponentu .NET (273)
- Tworzenie projektu biblioteki klas (273)
- Tworzenie klienta (274)
Globalny bufor plików skompilowanych GAC (276)
- GAC "pod maską" (278)
- Tworzenie współdzielonego pliku skompilowanego typu "assembly" (279)
- Pliki strategii (281)
- Tworzenie strategii wersji (282)
Zasoby (284)
- Dodawanie zasobów (284)
- Używanie zasobów (286)
I co dalej? (288)

8. Uodpornianie na błędy (291)

Nowości w .NET (292)
Skąd się biorą błędy? (293)
- Zasady ochrony przed błędami (295)
- Błędy podczas kompilacji (296)
- Zastosowanie opcji Option Explicit i Option Strict (298)
- Numery wierszy kodu (301)
Narzędzia diagnostyczne w Visual Studio (301)
- Podglądamy nasz program w działaniu (302)
- Polecenia dostępne w trybie kroczącym Break Mode (304)
- Okno punktów krytycznych Breakpoints (305)
- Licznik Hit Count (307)
- Okna podglądu: Autos, Locals i Watch (308)
- Okno natychmiastowe Immediate (310)
- Błędy w ruchu - Runtime Errors (310)
Strukturalna obsługa wyjątków (312)
- Mechanizm Error Call Stack (313)
- Ewolucja od mechanizmu On Error Goto (314)
- Wyjątek jako obiekt (315)
- Filtrowanie przy użyciu wyjątku (317)
- Typy wyjątków (318)
- Filtrowanie warunkowe (319)
- Wygenerowanie własnego wyjątku (320)
- Udoskonalenie indywidualnej klasy wyjątków (322)
- Ostatnia linia obrony: zdarzenie UnhandledException (323)
Programowanie defensywne (325)
- Zasady programowania defensywnego (325)
- Testowanie założeń za pomocą Assert() (326)
- Użycie metody Debug.WriteLine() (328)
- Śledzenie za pomocą pliku Log oraz metody Trace (329)
I co dalej? (331)

9. Praca z danymi: pliki, drukowanie i XML (333)

Nowości w .NET (334)
Interakcja z plikami (335)
Odczytywanie i zapisywanie plików (336)
- Tworzenie pliku za pomocą obiektu My (336)
- Tworzenie pliku za pomocą klasy FileStream (337)
- Klasy StreamWriter i StreamReader (338)
- Klasy BinaryWriter i BinaryReader (339)
- Dostęp do plików w stylu Visual Basic (343)
- Trochę więcej na temat łańcuchów (343)
- Kompresja plików (345)
Zarządzanie plikami i folderami (347)
- Klasa FileInfo (347)
- Prosta przeglądarka katalogów (351)
- "Przeglądanie" systemu plików (352)
Serializacja obiektu (354)
- Zachowywanie i pobieranie obiektu zdatnego do serializacji (355)
- Precyzyjnie dostrojona serializacja (356)
- Klonowanie obiektów za pomocą serializacji (357)
Drukowanie i podgląd danych (358)
- Drukowanie danych z macierzy (359)
- Drukowanie tekstu z przełamywaniem wierszy (361)
- Drukowanie obrazów (363)
- Ustawienia drukowania (363)
- Podgląd wydruku (365)
Praca z rejestrem (367)
Pliki XML (369)
- Czym tak w ogóle są pliki XML? (370)
- Pisanie prostego dokumentu XML (372)
- Odczytywanie plików XML (373)
- Zaawansowane pliki XML (376)
I co dalej? (376)

10. Bazy danych i ADO.NET (379)

Nowości w .NET (380)
Wprowadzenie do ADO.NET (381)
- Obsługa danych relacyjnych (381)
- Baza danych Northwind (382)
- SQL Server 2005 Express Edition (383)
- Model bazujący na dostawcach (383)
Podstawowe obiekty ADO.NET (385)
Dostęp do przodu w trybie tylko do odczytu (386)
- Obiekty Connection (387)
- Obiekty Command (390)
- Obiekty DataReader (392)
Aktualizowanie danych za pomocą obiektów Command (395)
- Dlaczego warto używać obiektów Command? (396)
- Przykładowa aktualizacja danych (396)
- Wywoływanie procedur składowanych (398)
- Używanie poleceń z parametrami (400)
- Przykład transakcji (402)
Używanie obiektów DataSet (403)
- Kiedy należy używać obiektów DataSet? (404)
- Zapełnianie obiektów DataSet za pomocą obiektów DataAdapter (404)
- Dostęp do informacji zapisanych w obiektach DataSet (405)
- Usuwanie rekordów (406)
- Dodawanie informacji do obiektów DataSet (407)
- Korzystanie z wielu tabel (409)
- Relacje między obiektami DataTable (409)
- Używanie obiektu DataSet do aktualizowania danych (412)
- Aktualizowanie źródła danych (415)
- Ręczne tworzenie obiektów DataSet (418)
Wiązanie danych (421)
I co dalej? (424)

11. Wątki (427)

Nowości w .NET (428)
Wprowadzenie do wątków (428)
- Wątki "pod maską" (429)
- Porównywanie programów jedno- i wielowątkowych (430)
- Skalowalność i prostota (431)
- Zegary a wątki (431)
Używanie komponentu BackgroundWorker do wykonywania podstawowych operacji na wątkach (433)
- Przesyłanie danych do komponentu BackgroundWorker i pobieranie ich z niego (436)
- Śledzenie postępu (439)
- Możliwość anulowania operacji (441)
Zaawansowane operacje na wątkach przy użyciu klasy Thread (442)
- Prosta aplikacja wielowątkowa (443)
- Przekazywanie danych do wątku (445)
- Wielowątkowość i interfejs użytkownika (447)
Podstawy zarządzania wątkami (449)
- Metody klasy Thread (449)
- Priorytety wątków (452)
- Kiedy zbyt wiele to wciąż za mało? (452)
- Program wykorzystujący priorytety wątków (452)
- Diagnozowanie wątków (455)
Synchronizacja wątków (456)
- Potencjalne problemy z wątkami (456)
- Podstawy synchronizacji (456)
- Przykładowy problem z synchronizacją (457)
- Rozwiązanie problemu za pomocą bloku SyncLock (460)
I co dalej? (461)

12. ASP.NET i Formularze sieciowe (463)

Nowości w .NET (464)
Zarys tworzenia aplikacji sieciowych (464)
- Co było nie tak z klasyczną ASP? (465)
Wprowadzenie do aplikacji sieciowych (466)
Tworzenie aplikacji sieciowych (467)
- Składniki projektu ASP.NET (469)
Projektowanie formularzy sieciowych (471)
- Podstawowe kontrolki (471)
- Dodawanie kontrolek do formularzy sieciowych (472)
- Uruchamianie strony internetowej (475)
- Dodawanie metody obsługi zdarzenia (477)
- Jak to działa? (477)
- Właściwość AutoPostback (478)
- Zdarzenia kontrolek sieciowych (478)
- Formularze sieciowe "pod maską" (479)
- Stan widoku (481)
- Cykl przetwarzania stron (482)
- Inne kontrolki (483)
Rozmyślania o stanie (484)
- Budowa żądania (485)
- Wprowadzenie do problemu (485)
- Zapisywanie dodatkowych informacji w stanie widoku (486)
Przesyłanie informacji (488)
- Przekazywanie informacji w łańcuchach znaków zapytania (488)
- Używanie stanu sesji (491)
- Używanie stanu aplikacji (493)
- Podsumowanie różnych technik zarządzania stanem (495)
Wyświetlanie danych za pomocą wiązania (495)
- Podstawy wiązania danych w ASP.NET (496)
- Kontrolki działające jako źródła danych (497)
Instalowanie witryn internetowych (499)
- Instalacja IIS (499)
- Katalogi wirtualne (501)
I co dalej? (504)

13. Usługi sieciowe (505)

Nowości w .NET (506)
Wizja interaktywnej sieci (506)
- Usługi sieciowe - model COM dla internetu? (507)
- Współczesne usługi sieciowe (507)
- Czy usługi sieciowe to obiekty? (508)
Tworzenie pierwszej usługi sieciowej (508)
- Przygotowywanie usługi sieciowej (509)
- Projekt usługi sieciowej (510)
- Klasa usługi sieciowej (512)
- Dostęp do usługi sieciowej (513)
Testowanie usług sieciowych (514)
- Działanie usługi sieciowej (515)
Stosowanie otwartych standardów (517)
- XML i WSDL (517)
- SOAP (518)
Konsumowanie usług sieciowych (520)
- Klasa pośrednicząca (520)
- Tworzenie aplikacji klienckiej (521)
- Dodawanie referencji sieciowej (522)
- Sprawdzanie klasy pośredniczącej (523)
- Używanie klasy pośredniczącej (525)
- Diagnozowanie projektów usług sieciowych (526)
Asynchroniczne wywoływanie usług sieciowych (527)
- Obsługa asynchroniczności w klasie pośredniczącej (528)
- Przykładowy klient asynchroniczny (529)
- Anulowanie asynchronicznych żądań (530)
I co dalej? (531)

14. Instalacja i wdrażanie (533)

Nowości w .NET (534)
Programy instalacyjne (534)
- Wymagania aplikacji .NET (535)
ClickOnce (536)
- Publikowanie w internecie lub w sieci (537)
- Instalowanie aplikacji za pomocą ClickOnce (541)
- Aktualizowanie aplikacji ClickOnce (542)
- Publikowanie na płytach CD (544)
Tworzenie projektu instalacyjnego Visual Studio (545)
Podstawowe opcje projektów instalacyjnych (546)
- Okno File System (547)
- Okno Registry (550)
- Okno File Types (551)
- Interfejs użytkownika (553)
- Niestandardowe operacje (557)
- Warunki uruchamiania (558)
I co dalej? (559)

Skorowidz (561)