.:$$:.

Visual Basic przeszedł generalny remont. Istnieje wiele powodów, dla których programiści Visual Basica 6 powinni przesiąść się na nowy Visual Basic .NET. Należy do nich zaliczyć chociażby formularze Web, możliwość tworzenia aplikacji i usług WWW, strukturalną obsługę wyjątków, prawdziwe programowanie zorientowane obiektowo czy też wielowątkowość.

"Visual Basic .NET. Księga eksperta" zawiera dokładne omówienie nowego języka Visual Basic .NET, zunifikowanego środowiska programowania Visual Studio IDE, programowania formularzy WWW, ADO.NET, usługi WWW, GDI+ i wiele innych.

Visual Studio .NET jest środowiskiem bardzo rozbudowanym i potężnym. Aby w pełni je wykorzystać, poznasz także sposoby tworzenia makr oraz znajdziesz omówienie modelu automatyzacji służącego do indywidualizacji zadań i interfejsu IDE w Visual Studio. Książka zawiera wiele przykładów wziętych z praktyki programistycznej.

Książka omawia:

• Środowisko programistyczne Visual Studio, korzystanie z SourceSafe
• Język Visual Basic .NET, programowanie zorientowane obiektowo w VB .NET
• Rozszerzanie środowiska programistycznego za pomocą makr
• Zaawansowane programowanie w VB .NET: refleksje, przeciążanie, programowane oparte na zdarzeniach, polimorfizm, definiowanie atrybutów
• Tworzenie interfejsu użytkownika (aplikacje konsolowe, aplikacje z interfejsem Windows)
• Pisanie aplikacji wielowątkowych
• Uruchamianie usług WWW (Web Services)

"Visual Basic .NET. Księga eksperta" jest doskonałym podręcznikiem dla wszystkich osób, dla których osiągnięcie wysokiej sprawności w posługiwaniu się językiem Visual Basic stanowi podstawę kariery programistycznej. Niezależnie, od tego, czy używałeś poprzedniej wersji tego języka, czy też nie: jeśli chcesz stać się ekspertem Visual Basica, trzymasz w ręku odpowiednią książkę.
O Autorze (19)
Wstęp (21)
Rozdział 1. Ujednolicone środowisko pracy Visual Studio (29)

• Profile użytkownika (30)
• Tworzenie projektu (31)
• Pliki i katalogi projektu (31)
• Dodawanie projektu do kontroli kodu źródłowego (33)
• Kompilacja projektów (35)
• Korzystanie z menedżera konfiguracji (36)
• Właściwości wspólne (36)
• Opcje konfiguracyjne (38)
• Debug Build (38)
• Release Build (38)
• Kompilacje typu Command-Line oraz korzystanie z Make File (39)
• Organizacja kodu źródłowego formularza (39)
• Przełączanie się pomiędzy widokiem kodu a widokiem obiektów (42)
• Przestrzenie nazw (43)
• Skracanie kodu (44)
• Dyrektywa #Region (45)
• Edytowanie kodu i cechy ułatwiające tworzenie dokumentacji (45)
• Konfiguracja opcji IDE (48)
• Opcje środowiska (49)
• Opcje kontroli kodu źródłowego (49)
• Opcje edytora tekstu (49)
• Opcje projektanta formularzy (Windows Forms Designer) (50)
• Opcje analizatora (50)
• Opcje narzędzi bazy danych (50)
• Opcje debugowania (50)
• Opcje projektanta HTML (51)
• Opcje projektu (51)
• Opcje projektanta XML (51)
• Proces debugowania w nowym IDE (51)
• Podstawowe klawisze skrótów podczas debugowania (52)
• Strukturalna obsługa wyjątków (53)
• Przegląd Szablonów Projektów (53)
• Windows Application (53)
• Class Library (54)
• Windows Control Library (55)
• ASP.NET Web Applications (55)
• ASP.NET Web Service (57)
• Web Control Library (58)
• Empty Project (58)
• Empty Web Project (58)
• New Project in Existing Folder (58)
• Projekty w wersji Enterprise (58)
• Technologia IntelliSense (60)
• Składowe klas (60)
• Informacja o parametrach (60)
• Szybka podpowiedź (60)
• Dokańczanie wyrazów (60)
• Cechy IntelliSense specyficzne dla VB (61)
• Korzystanie z widoków (61)
• Solution Explorer (61)
• Class View (62)
• Server Explorer (62)
• Resource View (63)
• Properties Window (63)
• Toolbox (63)
• Pendind Check-ins (63)
• Web Browser (63)
• Inne okna (64)
• Dokumentacja (67)
• Podsumowanie (67)

Rozdział 2. Czas na zmiany... (69)

• Rozszerzenia plików (69)
• Grupy Visual Basic jako rozwiązania (69)
• Nowe rozszerzenia plików źródłowych (69)
• Przestrzenie nazw (71)
• Referencje (72)
• Dyrektywy Option (72)
• Option Explicit (72)
• Option Compare (74)
• Option Strict (74)
• Moduł Option Private (75)
• Option Base (76)
• Typy danych (76)
• Typy Object (77)
• Typy całkowite (80)
• Typy niecałkowite (81)
• Typ Char (85)
• Typ String (86)
• Typ Boolean (89)
• Typ DateTime (91)
• Deklaracje zmiennych (94)
• Deklarowanie i inicjowanie pojedynczej zmiennej (95)
• Deklaracje wielu zmiennych jednocześnie (96)
• Inicjowanie wielu zmiennych jednocześnie (97)
• Definiowanie stałych (98)
• Tworzenie egzemplarzy obiektów (98)
• Listy inicjujące zmienne (99)
• Operatory (99)
• Funkcje konwersji typów (101)
• Zmiany zasięgu zmiennych w VB .NET (103)
• Instrukcje sterowania pracą programu (103)
• Tablice i kolekcje (104)
• Tablice o określonych granicach (105)
• Tablice N-wymiarowe (105)
• Modyfikacja rozmiarów tablic (106)
• Zwracanie tablic przez funkcje (106)
• Tablice jako podklasy System.Array (107)
• Abstrakcyjne typy danych (107)
• Strukturalna obsługa wyjątków (109)
• Korzystanie ze słów zastrzeżonych w Visual Basic .NET (110)
• Kompatybilność pomiędzy aplikacjami VB6 a VB .NET (110)
• Microsoft.VisualBasic (110)
• Elementy programowania VB6 zmienione w Visual Basic .NET (111)
• Podsumowanie (111)

Rozdział 3. Podstawy programowania w Visual Basic .NET (113)

• Deklarowanie i inicjowanie zmiennych (113)
• Inicjowanie zmiennych (114)
• Deklarowanie i inicjowanie zmiennych w pojedynczej instrukcji (116)
• Deklarowanie zmiennych tuż przed ich pierwszym użyciem (116)
• Deklarowanie zmiennych o jak najmniejszym zasięgu (116)
• Korzystanie z refaktoringu: zamiana zmiennych tymczasowych na kwerendy (117)
• Praca z zasięgiem blokowym (119)
• Zmienne statyczne (120)
• Używanie zmiennych statycznych (120)
• Zmienne statyczne a pamięć (121)
• Korzystanie z tablic (121)
• Tablice są instancjami klasy System.Array (121)
• Deklarowanie tablic (122)
• Korzystanie z metod tablicowych (122)
• Tablice wielowymiarowe (123)
• Praca z abstrakcyjnymi typami danych (125)
• Składowe klasy ArrayList (126)
• Używanie ArrayList (127)
• HashTable (128)
• SortedList (129)
• Queue (130)
• Podsumowanie Abstrakcyjnych Typów Danych (130)
• Przesłanianie zmiennych (131)
• Funkcje i podprogramy (132)
• Definiowanie struktur (132)
• Używanie obiektów (132)
• Co to jest konstruktor? (133)
• Konstruktory sparametryzowane (134)
• Destruktory (134)
• Obsługa wyjątków (135)
• Try...Catch (135)
• Try...Finally (139)
• Podsumowanie (140)

Rozdział 4. Makra i rozszerzenia Visual Studio (141)

• Automatyzacja zadań powtarzających się (142)
• Przykład: nagrywanie makra (142)
• Podgląd zarejestrowanego makra (143)
• Edycja makra tymczasowego (144)
• Uruchamianie makra (148)
• Przypisywanie klawiszy skrótu do makra (149)
• Dodawanie klawisza makra do paska narzędziowego (149)
• Korzystanie z Eksploratora Makr (151)
• Eksport makra (151)
• Makra włączające i wyłączające pułapki (151)
• Wysyłanie informacji do okna wyjściowego Output (153)
• Eksportowanie modułów makra (155)
• Importowanie modułów makra (155)
• Korzystanie z Macros IDE (155)
• Bezpieczeństwo makr (156)
• Współdzielenie makr (156)
• Tworzenie projektu makra (156)
• Obsługa Visual Studio poprzez okno Command (158)
• Odpowiadanie na zdarzenia IDE (158)
• Dostosowanie Visual Studio do własnych wymagań (160)
• Ogólny opis Extensibility Object Model (161)
• Ogólny opis Project-Neutral Extensibility Object Model (165)
• Tworzenie przystawek (167)
• Tworzenie projektu przystawki (168)
• Rejestracja przystawek (172)
• Dodawanie zachowań do przystawki (173)
• Tworzenie kreatorów (174)
• Tworzenie pliku uruchomieniowego kreatora (176)
• Rejestracja biblioteki klas kreatora (176)
• Testowanie kreatora (176)
• Program Integracji Visual Studio (177)
• Podsumowanie (178)

Rozdział 5. Procedury, funkcje i struktury (179)

• Pisanie procedur (179)
• Pisanie procedur (180)
• Pisanie funkcji (182)
• Definiowanie argumentów procedury (185)
• Domyślne przekazywanie parametrów (186)
• Korzystanie z parametrów opcjonalnych (190)
• Definiowanie argumentów ParamArray (193)
• Redukowanie liczby parametrów (194)
• Praca z rekurencją (199)
• Definiowanie procedur rekurencyjnych (199)
• Zamiana rekurencji na algorytm nierekurencyjny (199)
• Definiowanie struktur (200)
• Definiowanie pól i właściwości (201)
• Dodawanie metod do struktur (202)
• Implementowanie konstruktorów (203)
• Definiowanie zdarzeń strukturalnych (205)
• Deklarowanie zmiennych w strukturze (207)
• Ukrywanie informacji (208)
• Argumenty struktur i typy zwracane (208)
• Cechy niedostępne dla struktur (208)
• Korzystanie z typów wyliczeniowych (209)
• Podsumowanie (210)

Rozdział 6. Refleksje (213)

• Przestrzeń nazw Reflection (213)
• Pakiety (214)
• Manifest jako źródło informacji o zasobach (216)
• Obiekt modułu (216)
• Obiekt File (219)
• Właściwość Location (221)
• Właściwość EntryPoint (221)
• Właściwość GlobalAssemblyCache (221)
• Type (221)
• Wiązania (222)
• Klasa MethodInfo (227)
• Klasa ParameterInfo (228)
• Klasa FieldInfo (228)
• Klasa PropertyInfo (228)
• Klasa EventInfo (228)
• Tworzenie typów w trakcie działania aplikacji z wykorzystaniem refleksji (229)
• Inne przypadki korzystania z refleksji (232)
• Lokalizacja (233)
• Podsumowanie (233)

Rozdział 7. Tworzenie klas (235)

• Definiowanie klas (235)
• Używanie specyfikatorów dostępu do klas (237)
• Hermetyzacja i ukrywanie informacji (239)
• Specyfikatory dostępu (240)
• Praca z zasięgiem (240)
• Dodawanie pól i właściwości (240)
• Hermetyzacja i właściwości (242)
• Definiowanie właściwości indeksowanych (243)
• Korzystanie z modyfikatorów właściwości (250)
• Definiowanie właściwości współdzielonych (253)
• Dodawanie atrybutów właściwości (253)
• Dodawanie metod do klas (254)
• Implementowanie konstruktorów i destruktorów (256)
• Dodawanie funkcji i procedur do metod (260)
• Korzystanie z modyfikatorów metod (263)
• Korzystanie ze specyfikatorów dostępu (265)
• Dodawanie zdarzeń do klas (266)
• Definiowanie klas zagnieżdżonych (267)
• Zrozumienie celu korzystania z klas zagnieżdżonych (271)
• Definiowanie klasy Signal (272)
• Definiowanie abstrakcyjnej klasy bazowej Light (276)
• Implementowanie świateł sygnalizacji (276)
• Podsumowanie programu TrafficLight (277)
• Tworzenie egzemplarzy klas (277)
• Podsumowanie (278)

Rozdział 8. Dodawanie zdarzeń (279)

• Rozumienie zdarzeń i procedur ich obsługi (279)
• Podstawowa delegacja: EventHandler (281)
• Dołączanie wielu zdarzeń do jednej procedury obsługi (288)
• Tworzenie procedur obsługi zdarzeń w edytorze kodu (290)
• Pisanie procedur obsługi zdarzeń w edytorze kodu (293)
• Przypisywanie procedur obsługi zdarzeń w trakcie pracy aplikacji (294)
• Tworzenie procedur obsługi zdarzeń w trakcie pracy aplikacji (294)
• Tworzenie procedur obsługi zdarzeń w WebForms Designer (296)
• Deklarowanie i wywoływanie zdarzeń (296)
• Deklarowanie zdarzeń (298)
• Generowanie zdarzeń (299)
• Implementowanie procedur obsługi zdarzeń klasy (300)
• Implementowanie procedur obsługi zdarzeń współdzielonych (300)
• Implementowanie procedur obsługi zdarzeń modułowych (300)
• Implementowanie procedur obsługi zdarzeń struktury (302)
• Niedostępne właściwości zdarzeń (303)
• Podsumowanie (303)

Rozdział 9. Delegacje (305)

• Używanie delegacji EventHandler (306)
• Korzystanie z argumentów obiektu EventHandler (306)
• Korzystanie z argumentu EventHandler System.EventArgs (315)
• Przegląd składowych delegacji (315)
• Definiowanie delegacji (317)
• Deklarowanie procedur odpowiadających sygnaturom delegacji (317)
• Inicjowanie delegacji (318)
• Cel stosowania delegacji (318)
• Przekazywanie delegacji jako argumentów (319)
• Przegląd algorytmów sortowania i opis działania aplikacji (320)
• Algorytmy sortowania (321)
• Analiza działania aplikacji SortAlgorithms (321)
• Alternatywa dla typów proceduralnych (326)
• Delegacje grupowe (327)
• Metoda Combine (329)
• Korzystanie z delegacji grupowych (329)
• Korzystanie z delegacji poza granicami projektu (330)
• Podsumowanie (333)

Rozdział 10. Dziedziczenie i polimorfizm (335)

• Podstawy dziedziczenia (335)
• Co to jest dziedziczenie? (336)
• Podstawowa składnia dziedziczenia (337)
• Dziedziczenie w przykładach (338)
• Implementowanie właściwości, zdarzeń i metod w edytorze kodu (339)
• Dziedziczenie pojedyncze a dziedziczenie wielokrotne (342)
• Definiowanie klas, które muszą być dziedziczone (342)
• Przykład wirtualnej klasy abstrakcyjnej (343)
• Definiowanie klas, które nie mogą być dziedziczone (345)
• Polimorfizm (346)
• Trzy rodzaje polimorfizmu (348)
• Wywoływanie metod dziedziczonych (350)
• Przesłanianie metody klasy nadrzędnej (350)
• Dynamiczne rzutowanie typów (352)
• Definiowanie interfejsów (354)
• Interfejsy a klasy (354)
• Definiowanie interfejsu (355)
• Podsumowanie (357)

Rozdział 11. Składowe współdzielone (359)

• Deklarowanie pól współdzielonych (359)
• Definiowanie właściwości współdzielonych (360)
• Używanie metod współdzielonych (364)
• Definiowanie konstruktorów współdzielonych (369)
• Konstruktory współdzielone i singletony (369)
• Przykład konstruktora współdzielonego (370)
• Implementowanie metod fabrycznych (375)
• Przeciążanie składowych współdzielonych (378)
• Generowanie zdarzeń współdzielonych (380)
• Podsumowanie (382)

Rozdział 12. Definiowanie atrybutów (383)

• Rola atrybutów (384)
• Czym są metadane? (384)
• Nazwy atrybutów (390)
• Elementy opisywane przez atrybuty (391)
• Opisywanie pakietu (391)
• Oznaczanie typów i składowych (393)
• Dodawanie atrybutów typu (393)
• Dodawanie atrybutów metod (396)
• Dodawanie atrybutów pól i własności (399)
• Przeglądanie atrybutów za pomocą deasemblera MSIL (403)
• Pozyskiwanie atrybutów za pomocą refleksji (403)
• Tworzenie atrybutów użytkownika (405)
• Implementacja HelpAttribute (405)
• Deklarowanie klasy atrybutu (405)
• Określanie zasad użycia atrybutu - AttributeUsage (406)
• Dziedziczenie z System.Attribute (407)
• Implementowanie konstruktora (407)
• Dodawanie nazwanych argumentów (408)
• Atrybutu komponentów (408)
• Atrybuty współpracy z COM (409)
• Podsumowanie (409)

Rozdział 13. Aplikacja konsolowa (413)

• Podstawy aplikacji konsolowych (413)
• Procedura Sub Main implementowana w module (414)
• Procedura Sub Main implementowana w klasie (415)
• Pozyskiwanie argumentów wierszy poleceń (416)
• Klasa Console (420)
• Odczyt i zapis w standardowych urządzeniach wejścia-wyjścia (421)
• Zapis do urządzenia informacji o błędach (423)
• Zmiana urządzenia informacji o błędach (424)
• Implementacja programu FileSort (425)
• Stosowanie TextReader (426)
• Stosowanie TextWriter (430)
• Pliki tymczasowe (430)
• Stosowanie interfejsu IEnumerator (431)
• Sortowanie w ArrayList (432)
• Implementowanie interfejsu IComparer (432)
• Przestrzenie nazw aplikacji konsolowych (433)
• Wielowątkowość w aplikacji konsolowej (433)
• Debugowanie aplikacji konsolowych (436)
• Ustalanie argumentów wiersza poleceń za pomocą IDE (436)
• Przyłączanie debugera do uruchomionej aplikacji (436)
• Monitorowanie systemu plików (439)
• Podsumowanie (440)

Rozdział 14. Aplikacje wielowątkowe (441)

• Przetwarzanie asynchroniczne bez udziału wątków (442)
• Stosowanie timera (442)
• Zdarzenie Application.Idle (442)
• Lekkie wątki - pule wątków (444)
• Czym jest pula wątków? (444)
• Jak działa pula wątków? (445)
• Stosowanie puli wątków (445)
• Synchronizacja - WaitHandle (449)
• Synchronizacja z wykorzystaniem klasy Monitor (455)
• Wielowątkowość - waga ciężka (457)
• Tworzenie i korzystanie z wątków (457)
• Przykład wątku (457)
• Dołączanie atrybutu ThreadStatic (459)
• Wielowątkowość a formularze Windows (461)
• Strategie wielowątkowości dla formularzy Windows (462)
• Invoke i wywołania synchroniczne (462)
• Wywołania asynchroniczne - BeginInvoke i EndInvoke (463)
• Podsumowanie (466)

Rozdział 15. Stosowanie formularzy Windows (467)

• Przegląd przestrzeni nazw Forms (467)
• Klasy przestrzeni nazw Forms (468)
• Interfejsy przestrzeni nazw Forms (478)
• Struktury przestrzeni nazw Forms (479)
• Delegacje przestrzeni nazw Forms (480)
• Wyliczenia przestrzeni nazw Forms (481)
• Przegląd przestrzeni nazw System.Drawing (482)
• Klasy przestrzeni nazw System.Drawing (482)
• Struktury przestrzeni nazw System.Drawing (489)
• Klasa Form (489)
• Powoływanie obiektu formularza (490)
• Projektowanie interfejsu użytkownika (491)
• Dynamiczne tworzenie kontrolek (493)
• Procedury obsługi zdarzeń dynamicznie tworzonych kontrolek (494)
• Wyszukiwanie aktywnego formularza (494)
• Dołączanie kodu do formularzy (494)
• Tworzenie formularzy użytkownika za pomocą GDI+ (495)
• Podsumowanie (495)

Rozdział 16. Projektowanie interfejsu użytkownika (497)

• Rozmieszczanie kontrolek (497)
• Kotwiczenie kontrolek (498)
• Dokowanie kontrolek (499)
• Zachowanie marginesu kontrolek (499)
• Ustalanie położenia i rozmiaru (499)
• Praca z Menu (500)
• Definiowanie MainMenu i ContextMenu (500)
• Dołączanie kodu menu (501)
• Różnice pomiędzy MainMenu i ContextMenu (503)
• Dynamiczne dodawanie pozycji menu (504)
• Zaawansowane techniki projektowania formularzy (507)
• Własność Form.AutoScale (507)
• Automatyczne przewijanie (507)
• Rozmiar AutoScrollMargin (508)
• Stosowanie obiektu CreateParams (508)
• Czym zajmują się klasy Component i Control (510)
• Klasa Component (510)
• Klasa Control (511)
• Dynamiczne dodawanie kontrolek (512)
• Kontrolki użytkownika - UserControls (513)
• Wprowadzanie kontrolek do kontrolki użytkownika (513)
• Zdarzenia w kontrolkach użytkownika (514)
• Kod w kontrolkach użytkownika (516)
• Umieszczanie kontrolki użytkownika w Visual Studio .NET (516)
• Przypisywanie kontrolce bitmapy pojawiającej się oknie narzędziowym (517)
• Tworzenie własnych kontrolek (517)
• Tworzenie niewidocznych komponentów (518)
• Określanie domyślnego zdarzenia (519)
• Podsumowanie (520)

Rozdział 17. Programowanie z GDI+ (521)

• Podstawy GDI+ (521)
• Stosowanie obiektów Graphics (522)
• Podstawowe klasy związane z rysowaniem (524)
• Proste operacje z wykorzystaniem GDI+ (525)
• Kreślenie figur płaskich i tekstu (526)
• Zaawansowane metody graficzne (530)
• Kreślenie krzywych (530)
• Kreślenie skomplikowanych krzywych - krzywe Bézier (531)
• Ścieżka graficzna - klasa GraphicsPath (532)
• Klasa Region (537)
• Formularze o niestandardowych kształtach (537)
• Klasa Icon (540)
• Przestrzeń nazw Imaging (540)
• Grafika użytkownika w formularzach Windows (541)
• Drukowanie grafiki (542)
• Podsumowanie (543)

Rozdział 18. Stosowanie i implementacja usług WWW (Web Services) (547)

• Przegląd usług Web Services (547)
• Wyszukiwanie usług Web Services za pomocą UDDI (549)
• uddi.microsoft.com (550)
• Lokalne usługi Web Services (550)
• Cztery aspekty pracy z Web Services (551)
• Wywoływanie usług WWW (552)
• Odwołania do WebServices (552)
• Aplikacje formularzy Windows (554)
• Aplikacje formularzy WWW (555)
• Implementowanie usług WWW (556)
• Plik global.asax (556)
• Plik web.config (557)
• Plik disco (559)
• Plik .asmx (560)
• Kiedy usługi Web Servcies mogą okazać się przydatne (561)
• Tworzenie usługi Web Service (562)
• Wybór metody dostępu sieciowego (566)
• Zarządzanie informacjami stanu (567)
• Obsługa i generowanie wyjątków w usługach Web Services (569)
• Debugowanie usług Web Services (570)
• Zintegrowane debugowanie (571)
• Uruchamianie bez debugowania (571)
• Uruchamianie w przeglądarce (571)
• Kompilowanie i rozpowszechnianie projektów sieciowych (572)
• Podsumowanie (573)

Rozdział 19. Programowanie sieciowe z ASP.NET (575)

• Formularze WWW (576)
• Okno projektowania formularzy WWW (576)
• Kod formularzy WWW (578)
• Kompilowanie i uruchamianie aplikacji ASP.NET (580)
• Request i Response (580)
• ASP.NET i ADO.NET (581)
• Baza danych przykładowych programów (582)
• Sortowanie danych w formularzu WWW (584)
• Stronicowanie danych przy użyciu DataGrid (586)
• Buforowanie danych wyjściowych (587)
• Dodawanie i usuwanie elementów bufora (590)
• Deklarowanie terminu ważności elementów pamięci podręcznej (591)
• Względy wydajnościowe (591)
• Przygotowywanie kontrolek do wyświetlenia (592)
• Dynamiczne dodawanie kontrolek do strony (594)
• Programowe dodawanie tekstu statycznego (594)
• Modyfikowanie własności kontrolek przy użyciu kolekcji Attributes (595)
• Programowe dodawanie kontrolek LiteralControl (595)
• Dodawanie kontrolek przy użyciu kontrolki PlaceHolder (596)
• Programowe dodawanie kontrolek prezentacji danych (597)
• Wyposażanie kontrolek dynamicznych w procedury obsługi zdarzeń (598)
• Tworzenie własnych kontrolek WWW (599)
• Zapisywanie strony WWW jako kontrolki serwerowej (600)
• Tworzenie własnej kontrolki użytkownika (606)
• Tworzenie biblioteki kontrolek WWW (607)
• Podsumowanie (609)

Rozdział 20. Dziennik zdarzeń (611)

• Źródło zdarzeń (612)
• Tworzenia źródła zdarzeń (612)
• Usuwanie źródła zdarzeń (614)
• Pozyskiwanie tablicy dzienników zdarzeń (614)
• Wyszukiwanie nazwy logu na podstawie nazwy źródła (615)
• Usuwanie dziennika (615)
• Dokonywanie wpisów do istniejącego dziennika (615)
• Własny dziennik zdarzeń (617)
• Pobieranie zawartości dziennika zdarzeń (618)
• Czyszczenie dziennika zdarzeń (620)
• Powiadamianie o zdarzeniu (620)
• Zdalny dziennik zdarzeń (621)
• EventLogTraceListener (621)
• Podsumowanie (622)

Dodatek A Elementy programowania VB6 zmienione w VB.NET (625)

• Elementy usunięte z VB. NET (625)
• Zmiany w deklaracji i składni (627)
• As Any (627)
• Deklarowanie zmiennych (627)
• Numerowanie wierszy (628)
• Zmiany zakresu widoczności zmiennych (629)
• Zmiany w deklaracji procedur (629)
• Brak IsMissing (630)
• Wywoływanie procedur (630)
• Przekazywanie własności przez referencję (631)
• ByVal - domyślny modyfikator argumentu (632)
• Argumenty ParamArray (632)
• Modyfikator Static (633)
• Zmiany we własnościach (633)
• Ujednolicona deklaracja własności w Visual Basic .NET (634)
• Let nie jest już obsługiwane (634)
• Własności domyślne nie mogą być współdzielone lub prywatne (634)
• Własności domyślne muszą pobierać argumenty (634)
• Argumenty własności nie mogą być przekazywane przez referencję (635)
• Zmiany zakresu tablic (636)
• Rozmiar tablicy może się zmienić, ale liczba wymiarów jest stała (636)
• Zmiany w typach danych (637)
• Typ Currency (637)
• Brak DefTyp (637)
• Konstrukcja Type zastąpiona przez Structure (637)
• Visual Basic .NET nie obsługuje ciągów tekstowych o ustalonej długości (638)
• Zmiany w wartościach całkowitoliczbowych (638)
• Zmiany operatorów (639)
• Operatory równoważności i implikacji (639)
• And, Or, Xor i Not (639)
• Szybkie oszacowanie (640)
• Zmiany w sterowaniu przebiegiem programu (640)
• Wywołanie funkcji zamiast GoSub (640)
• Brak On ... GoSub i On ... Goto (642)
• Zmiany w klasach i interfejsach (643)
• Parametryzowane konstruktory (643)
• Brak Option Private Module (643)
• Zmiany w interfejsach (643)
• Zastąpione elementy programowania (644)
• Arcustangens (Atn) (644)
• Circle (645)
• Debug.Print i Debug.Assert (645)
• DoEvents (645)
• IsNull (645)
• IsObject (645)
• Line (646)
• LSet i RSet (646)
• MsgBox (646)
• Wend (646)
• Elementy programowania obsługiwane w inny sposób (647)
• Calendar (647)
• Date (647)
• Empty zastąpiono przez Nothing (648)
• Now (648)
• Rnd i Round (648)
• PSet i Scale nie są obsługiwane w Visual Basic .NET (649)
• Sgn i Sqr (649)
• String (649)
• Time (650)
• VarType (650)
• Typ Variant zastąpiony przez Object (650)

Skorowidz (651)