Visual Basic 2005. Wprowadzenie do programowania w .NET - Helion
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ł
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:
- C# 10 and .NET 6 Modern Cross-Platform Development 213,57 zł, (29,90 zł -86%)
- Software Architecture with C# 9 and .NET 5 213,57 zł, (29,90 zł -86%)
- Windows Presentation Foundation Development Cookbook 186,88 zł, (29,90 zł -84%)
- Improving your C# Skills 175,88 zł, (29,90 zł -83%)
- .NET Core 2.0 By Example 157,37 zł, (29,90 zł -81%)
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)