.:$$:.

• 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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