Visual Basic 2005. Wprowadzenie do programowania w .NET Matthew MacDonald

Dostępność produktu

Produkt nie został jeszcze oceniony pod kątem ułatwień dostępu lub nie podano żadnych informacji o ułatwieniach dostępu lub są one niewystarczające. Prawdopodobnie Wydawca/Dostawca jeszcze nie umożliwił dokonania walidacji produktu lub nie przekazał odpowiednich informacji na temat jego dostępności.

Spis treści książki

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)

pokaż cały spis treści

ukryj recenzje