Kod: vb40
Tytuł: Przejście do VB.NET
Cena: 55,90   56,40
Realizacja: 1 dzień roboczy [więcej >>>]
Reklama: tania książka = Twoja Książka

Wstęp (str.11)
Kim jesteś? (str.11)
W kwestii Microsoftu (str.12)
Wersje testowe (str.13)
Kod źródłowy (str.14)
Desaware (str.14)
Ważna uwaga dotycząca kodu zamieszczonego w książce (str.15)
Jeszcze jedna ważna uwaga dotycząca kodu zamieszczonego w książce (str.15)
Podziękowania (str.16)

Część I. Strategie (str.19)

Rozdział 1. Gdzie zacząć? (str.21)

Rola kontekstu (perspektywa) (str.22)
.NET - rzeczywistość czy fikcja marketingowa? (str.23)

Rozdział 2. Jak bez strachu stawić czoła VB.NET (str.27)

O Boże, zepsuli VB! (str.27)
Zapomnij o wszystkim, czego się nauczyłeś (str.29)
Inżynieria oprogramowania - aspekty ekonomiczne (str.30)

Rozdział 3. Strategie migracji (str.33)

Ramy czasowe (str.33)
Porting (str.34)
Uwarunkowania procesu migracji (str.35)
Nowe aplikacje po stronie serwera (str.35)
Stare aplikacje po stronie serwera (str.36)
Aplikacje po stronie klienta (str.36)
A co z C#? (str.37)
Alternatywy .NET spoza Microsoftu (str.38)
Co dalej? (str.38)

Część II. Koncepcje (str.39)

Rozdział 4. .NET w szerszej perspektywie (str.41)

Mechanizm wirtualny (str.42)
Umarł COM. Niech żyje CO? (str.43)
COM: pomysł a implementacja (str.44)
Problemy z interfejsami (str.45)
Problemy z rejestrem (str.46)
Problem interfejsu IUnknown (str.46)
Obsługa błędów (str.47)
COM+ (str.47)
COM+2.0 (str.48)
Biblioteka CLR (str.48)
Manifesty (str.50)
Język pośredni (IL) (str.51)
Problem zapętlonych referencji (str.53)
I wreszcie kod (str.56)
Kontrowersje związane z kodem (str.61)
Podsumowanie: dlaczego .NET? (str.63)

Rozdział 5. Dziedziczenie (str.65)

Mit ponownego wykorzystania kodu (str.65)
Łańcuch wskaźników w VB6 (str.66)
Pojemnikowy łańcuch wskaźników w VB.NET (str.73)
Łańcuch wskaźników korzystający z dziedziczenia w VB.NET (str.81)
Podwójny łańcuch wskaźników (str.82)
Konflikty nazewnicze (str.90)
Dziedziczenie w .NET (str.92)
Wszystko jest obiektem (str.92)
Rzut okiem na formatki (str.94)
Dziedziczenie w VB.NET - odsłona druga (str.97)
Problem ulotnej klasy bazowej (str.101)
Widoczność metod (str.103)
Podsumowanie (str.104)

Rozdział 6. Zarządzanie pamięcią w VB.NET (str.105)

Obiekty mające wartość i obiekty referencyjne (str.105)
Obiekty mające wartość (str.105)
Obiekty referencyjne (str.109)
Czyszczenie pamięci – odsłona druga (str.109)
Finalizatory (str.111)
Wielki spór o finalizację niedeterministyczną (str.113)
Powrót z zaświatów – wskrzeszanie obiektów (str.115)
Podsumowanie (str.118)

Rozdział 7. Wielowątkowość w VB.NET (str.121)

Krótki wstęp do wielowątkowości (str.122)
Niedoszłe zakupy (str.123)
Wielowątkowość: dalsza analiza (str.124)
Projekt: pierwsza linia obrony (str.139)
Synchronizacja: druga linia obrony (str.142)
Pożytki z wielowątkowości (str.157)
Wydajne stany oczekiwania (str.157)
Operacje tła (str.158)
Wydajny dostęp klientów (str.159)
Ocena wydajności programów wielowątkowych (str.160)
Podsumowanie (str.167)

Część III. Kod (str.169)

Rozdział 8. Typy danych i operatory (str.171)

Typy liczbowe (str.171)
String*1 a Char (str.172)
Typy boole'wskie (str.172)
Typy walutowe i dziesiętne (str.174)
Liczby całkowite (str.174)
Typy bez znaku (str.175)
CLR (str.175)
Typy pozaliczbowe (str.176)
Pożegnanie z wariantami (str.176)
Łańcuchy tekstowe (str.178)
Tablice (str.179)
Daty (str.181)
Typy wyliczeniowe (str.181)
Deklaracje (str.183)
Konwersje i typizacja (str.184)
Konwersje klas (str.186)
Konwersje struktur (str.187)
Operatory (str.188)
Operatory AndAlso oraz OrElse (str.188)
Operatory łańcuchowe (str.189)
Operatory konkatenacji (str.190)
Eqv i Imp (str.191)
Podsumowanie (str.191)

Rozdział 9. Składnia języka (str.193)

Wywołania funkcji i parametry (str.193)
Racjonalny mechanizm wywołań (str.193)
Zwracanie wartości (str.194)
Domyślna opcja ByVal (str.194)
Konwencja ByVal – ostrzeżenie (str.194)
Zakres zmiennych (str.206)
Zmienne statyczne (str.209)
Obsługa błędów (str.210)
Stara metoda (str.211)
Obsługa błędów w VB6 (str.212)
Strukturalna obsługa wyjątków (str.213)
Inne zmiany (str.222)
Zmiany w przepływie kontroli (str.222)
Brak dwupostaciowych funkcji łańcuchowych (str.222)
Pozostałe drobne zmiany (str.223)
Polecenia, które zniknęły (str.223)
Usunięte polecenia graficzne (str.223)
Usunięte polecenia wariantowe (str.224)
Usunięte polecenia matematyczne (str.224)
Pozostałe polecenia, które usunięto (str.225)
Przestrzenie nazw Microsoft.VisualBasic i Compatibility (str.226)
Kreatory (str.227)
Decyzje kompatybilnościowe (str.228)
Łańcuchy a kompatybilność (str.230)
Kompatybilność operacji na plikach (str.231)
Podsumowanie (str.232)

Rozdział 10. Szczegółowo o obiektach (str.233)

Części składowe aplikacji .NET (str.233)
Domeny aplikacji (str.233)
Złożenia (str.236)
Ustawianie zakresu w VB.NET (str.238)
Przestrzenie nazw (str.238)
Ustawianie zakresu - poziom przestrzeni nazw (str.243)
Ustawianie zakresu - poziom klasy (str.246)
Klasy - dalsze informacje (str.248)
Elementy współdzielone (str.248)
MyBase oraz MyClass (str.249)
Zagnieżdżanie klas (str.252)
Metody i właściwości (str.252)
Przeładowywanie funkcji (str.252)
Użycie konstruktorów (str.255)
Metody czy właściwości (str.258)
Procedury właściwości (str.260)
Zdarzenia i delegacje (str.266)
Zdarzenia, wywołania zwrotne oraz COM (str.267)
Delegacje (str.268)
Zdarzenia (str.275)
Podsumowanie (str.282)

Rozdział 11. Atrybuty oraz mechanizm reflection (str.283)

O kompilatorach i interpreterach (str.283)
Stopniowa kompilacja (str.285)
Czas kompilacji a czas wykonania programu (str.286)
Atrybuty (str.287)
Refleksja (str.287)
Struktura manifestu (str.288)
Definiowanie dodatkowych atrybutów (str.291)
Wiązanie (str.295)
Wczesne wiązanie a problem "piekła DLL -i" (str.296)
Późne wiązanie (str.296)
Poprawne użycie późnego wiązania (str.299)
Dynamiczne ładowanie (str.301)
Podsumowanie (str.302)
Interludium (str.303)

Część IV. Wspaniały świat .NET (str.305)

Rozdział 12. Przewodnik po przestrzeniach nazw .NET (str.307)

O czym trzeba pamiętać, korzystając z przestrzeni nazw .NET (str.307)
Wszystko opiera się na hierarchii klas .NET Framework (str.307)
Platforma .NET powstała z myślą o programistach VB.NET (str.308)
Pierwsze kroki w świecie przestrzeni nazw (str.309)
Korzystanie z mapy przestrzeni nazw (str.310)
Wszystko zawiera się w przestrzeni nazw System (str.314)
Prawdziwie bazowe klasy (str.314)
Podstawowe klasy obsługi języków (str.315)
Klasy obsługujące kategorię czasu (str.317)
Klasy przestrzeni nazw System ogólnego przeznaczenia (str.317)
Wyjątki (str.319)
Atrybuty (str.320)
Interfejsy (str.321)
Inne ciekawe klasy przestrzeni nazw System (str.323)
Kolekcje (str.323)
System.CollectionBase oraz tworzenie własnych kolekcji (str.324)
Dodatkowe możliwości kolekcji (str.327)
Inne kolekcje (str.328)
Generowanie grafiki (str.330)
Dla programistów korzystających z metod obsługi grafiki dostępnych w VB6 (str.330)
Dla programistów korzystających z wywołań operacji graficznych Win32 API (str.331)
Żegnaj GDI, witaj GDI+ (str.331)
Bitmapy (str.333)
Strategie poznawania GDI+ (str.335)
Drukowanie (str.336)
I/O (str.340)
Inne klasy przestrzeni nazw System.IO (str.343)
Serializacja i zarządzanie danymi (str.344)
Serializacja (str.344)
ADO.NET a XML (str.347)
Podsumowanie (str.351)

Rozdział 13. Aplikacje Windows (str.353)

Pakiet nowych formatek (str.354)
Odtwarzalne okna (str.354)
Kontrolki graficzne (str.355)
Zgodność aplikacji-pojemników (str.355)
Wzorce oraz System.Windows.Forms (str.356)
System.ComponentModel.Component (str.356)
System.Windows.Forms.Control (str.357)
System.Windows.Forms.ScrollableControl (str.360)
Pojemniki, kontrolki Forms oraz UserControls (str.362)
Odkrywanie możliwości przestrzeni nazw System.Windows.Forms (str.362)
Dalsza eksploracja (str.365)
AutoRedraw-Plus, Events oraz Overrides (str.365)
Formatki MDI oraz ustawianie zależności pomiędzy formatkami (str.368)
Subclassing oraz obiekt Application (str.369)
Formatki i wątki (str.371)
Podsumowanie (str.373)

Rozdział 14. Aplikacje i usługi internetowe (str.375)

Czym jest Microsoft .NET (str.375)
Programowanie dla Internetu (str.376)
XML (str.377)
Aplikacje rozproszone (str.380)
Zasady projektowania aplikacji w .NET (str.380)
Warstwa bazy danych (str.381)
Tradycyjna aplikacja Windows (str.384)
Rozwiązanie oparte na aplikacji Web (str.385)
Rozwiązanie oparte na usłudze Web (str.394)
Architektura rozproszona (str.396)
Krótka dygresja o Winsock (str.397)
Wpis do księgi gości (str.402)
Podsumowanie (str.403)

Rozdział 15. Mechanizm współpracy z COM oraz dostęp do Win32 API (str.405)

Mechanizm współpracy z COM (COM Interop) (str.406)
Wywoływanie obiektów COM z .NET (str.407)
Obsługa błędów (str.409)
Zwalnianie obiektów (str.409)
Wersjonowanie (str.410)
Późne wiązanie (str.410)
Rozrząd struktur oraz innych typów parametrów (str.410)
Inne zagadnienia (str.410)
Dostęp do obiektów .NET z COM (str.411)
Tworzenie komponentu CalledViaCOM – pierwsza próba (str.413)
Tworzenie komponentu CalledViaCOM – druga próba (str.420)
Dostęp do Win32 API (str.422)
Nowe aspekty użycia instrukcji Declare (str.423)
Trzy najważniejsze rzeczy, o których należy pamiętać, używając wywołań API z VB.NET (str.426)
P-Invoke (str.426)
Wyjaśnienie zawiłości rozrządzania (str.429)
Struktury (str.437)
Zaawanasowane wywołania Win32 API (str.440)
Podsumowanie (str.448)

Rozdział 16. .NET w praktyce (str.449)

Wersjonowanie w .NET (str.449)
Koszmarne scenariusze (str.450)
Scenariusz dla paranoików (str.451)
Wersjonowanie w .NET (str.452)
Mocne nazwy (str.453)
Mocne nazwy i wersjonowanie (str.454)
Wersjonowanie środowiska uruchomieniowego .NET (str.458)
Mocne nazwy a spoofing (str.458)
Konflikty przestrzeni nazw (str.460)
.NET a wykonywanie obok siebie (str.460)
Bezpieczeństwo (str.460)
Koniec wirusów i zawieszających się programów? (str.461)
O szkodliwych programach i wirusach (str.463)
Bezpieczeństwo w .NET - przykłady (str.467)
Techniki ochrony (str.474)
Dodatkowe zagadnienia (str.475)
Deasemblować czy nie deasemblować? (str.475)
Wdrażanie aplikacji (str.478)
Podsumowanie (str.478)
Zakończenie (str.479)
Skorowidz (str.481)