Visual Basic 2005. Wprowadzenie do programowania w .NET

Autor: Matthew MacDonald

Szczegóły książki w Helionie
Tytuł oryginału: The Book of Visual Basic 2005: .NET Insight for Classic VB Developers
ISBN: 978-83-246-0696-2
Cena: 77 zł
Oprawa: miękka
Format: B5
Data wydania: 2007.07.16
Liczba stron: 592
Przykładowy rozdział: ftp://ftp.helion.pl/online/vb25pn/vb25pn-7.pdf
Kategoria: Visual Basic

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.

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)

©2007 Włodzimierz Gajda | prace magisterskie | Dubai | Korekta prac magisterskich , Ebooki programowanie androida, Pozycjonowanie stron Poznań