.:$$:.

• Poznaj działanie Common Language Runtime -- podstawowego składnika platformy .NET
• Wykorzystując CLR pisz aplikacje .NET szybciej i wdrażaj je łatwiej
• Poznaj i wykorzystaj wewnętrzne mechanizmy działania platformy .NET
• Skorzystaj z zaawansowanych technik wykrywania i usuwania usterek w aplikacjach

".NET CLR. Księga eksperta" to całościowe opracowanie poświęcone głównemu składnikowi platformy .NET Microsoftu, jakim jest Common Language Runtime. CLR pozwala na korzystanie z dowolnych języków programowania zgodnych z .NET udostępniając im wspólne usługi. Niezależnie od tego, czy uruchamiasz kod napisany w VB, C#, zarządzanym C++, JScripcie czy też w dowolnym innym obsługiwanym przez platformę .NET języku -- wykorzystywane są funkcje i usługi CLR.

Tematy poruszone w książce obejmują m.in.:

• Typy .NET i Common Type System (CTS)
• Strukturę i układ metadanych podzespołu .NET
• Współpracę COM i COM+ z komponentami .NET
• Integrację z bibliotekami Win32 DLL poprzez P/Invoke
• Zarządzanie pamięcią i zasobami w CLR
• Zarządzanie i użycie wątków w środowisku .NET
• Tworzenie wydajnych aplikacji do obsługi sieci równorzędnych
• Tworzenie rozproszonych aplikacji
• Interakcje aplikacji poprzez zdarzenia i delegaty
• Obsługę błędów w .NET przy użyciu wyjątków
• Tworzenie i obsługę bezpiecznych aplikacji dzięki zabezpieczeniom .NET
• Dynamiczne uzyskiwanie informacji o typach poprzez refleksję
• Użycie narzędzi do globalizacji i lokalizacji
• Usuwanie błędów aplikacji .NET
• Profilowanie aplikacji .NET
• Omówienie składni C# i najważniejszych kwestii związanych z tym językiem
• Przegląd bibliotek struktury .NET
• Tworzenie własnego hosta CLR
• Porównanie CLR i JVM

Jeżeli chcesz zajmować się pisaniem aplikacji opartych na .NET, ".NET CLR. Księga eksperta" stanowić będzie cenne uzupełnienie Twojej wiedzy i pozwoli na lepsze zrozumienie zasad, na których oparta jest ta platforma.

O Autorze (15)
Przedmowa (17)
Wstęp (21)
Część I Struktura .NET i podstawy CLR-a (27)
Rozdział 1. Wprowadzenie do zarządzanego środowiska (29)

• Krótka historia CLR (30)
• Omówienie zarządzanego środowiska wykonawczego (30)
• Bezpieczeństwo typów (32)
• Pełne bezpieczeństwo (34)
• Obsługa wielu języków (35)
• Wydajność i skalowalność (36)
• Wdrażanie (37)
• Metadane i samoopisujący kod (38)
• Oczyszczanie pamięci i zarządzanie zasobami (39)
• Ewolucja COM (39)
• Obsługa wątków (40)
• Obsługa sieci (40)
• Zdarzenia (40)
• Konsekwentna obsługa błędów (40)
• Uzyskiwanie informacji o typie w czasie pracy aplikacji (41)
• Globalizacja (41)
• Usuwanie błędów i profilowanie (41)
• Podsumowanie (41)

Rozdział 2. Common Language Runtime - język i system typów (43)

• Common Type System (CTS) (43)
• Typy wartości (44)
• Typy odwołań (48)
• Cechy Common Language Specification (56)
• Nazewnictwo (56)
• Elementy składowe typu (61)
• Właściwości (64)
• Zdarzenia (67)
• Tablice (68)
• Wyliczenia (68)
• Wyjątki (69)
• Własne atrybuty (70)
• Podsumowanie (72)

Rozdział 3. Common Language Runtime - omówienie środowiska wykonawczego (73)

• Wprowadzenie do środowiska wykonawczego (74)
• Uruchamianie metody (75)
• Typy obsługiwane przez IL (76)
• Wykonawczy wątek kontroli (79)
• Sterowanie działaniem metody (80)
• Podsumowanie (89)

Część II Komponenty CLR (91)
Rozdział 4. Podzespół (93)

• Przedstawienie podzespołu .NET (94)
• Niezależność od języka programowania (95)
• Metadane - podstawa dla równoległego wdrażania i obsługi wielu wersji (96)
• Metadane a dokładniejsze zabezpieczenia (96)
• Większa produktywność programisty (97)
• Bezproblemowa interakcja z niezarządzanymi interfejsami API (97)
• Praca zdalna (97)
• Tworzenie międzynarodowych wersji aplikacji (97)
• Koszt metadanych (98)
• Ogólna struktura podzespołu (98)
• Szczegółowe omówienie struktury podzespołu (103)
• Niezarządzany interfejs API i dostęp do metadanych podzespołu (111)
• Fizyczna struktura podzespołu (115)
• Tablica Module (0x00) (119)
• Tablica TypeRef (0x01) (121)
• Tablica TypeDef (0x02) (123)
• Tablica MethodDef (0x06) (125)
• Tablica MemberRef (0x0A) (130)
• Tablica CustomAttribute (0x0C) (130)
• Tablica Assembly (0x20) (131)
• Tablica AssemblyRef (0x23) (131)
• Podsumowanie (132)

Rozdział 5. Podstawy języka Intermediate Language (133)

• Miejsce IL w procesie programowania (133)
• Podręcznik ILDASM (134)
• Podstawy języka IL (135)
• Najczęściej używane polecenia IL (139)
• Polecenia IL do ładowania wartości (139)
• Polecenia IL do składowania (142)
• Polecenia IL do sterowania działaniem kodu (143)
• Polecenia operacji IL (147)
• Polecenia modelu obiektów IL (148)
• Podsumowanie (149)

Rozdział 6. Publikowanie aplikacji (151)

• Problemy z instalacją klienta Windows (151)
• Wdrażanie i publikowanie aplikacji .NET (153)
• Identyfikacja kodu poprzez silną nazwę (153)
• Wdrażanie prywatnego podzespołu (157)
• Instalacja współdzielonego kodu (159)
• Wyszukiwanie podzespołów (162)
• Badanie plików zasad (163)
• Sprawdzenie wcześniejszych odwołań do podzespołu (165)
• Sprawdzenie GAC (165)
• Wyszukiwanie podzespołu (165)
• Administracja zasadami (166)
• Domyślna zasada wiązania (166)
• Zmiana zasady wiązania poprzez plik zasad aplikacji (166)
• Zmiana zasady wiązania poprzez plik zasad wydawcy (168)
• Zmiana zasady wiązania poprzez plik zasad komputera (169)
• Podsumowanie (170)

Część III Usługi wykonawcze zapewniane przez CLR (171)
Rozdział 7. Wykorzystywanie istniejącego kodu poprzez P/Invoke (173)

• Omówienie P/Invoke (173)
• Dlaczego współpraca z klasycznym kodem? (175)
• Niektóre inne metody współpracy z klasycznym kodem (176)
• Użycie P/Invoke (177)
• Deklaracja funkcji - atrybut DLLImport (177)
• Szeregowanie (180)
• Użycie zarządzanych rozszerzeń VC++ (190)
• Wpływ P/Invoke na wydajność aplikacji (194)
• Podsumowanie (194)

Rozdział 8. Użycie COM i COM+ w zarządzanym kodzie (195)

• Runtime Callable Wrapper (196)
• Przykładowa aplikacja demonstrująca użycie RCW (198)
• Programowe generowanie podzespołu współpracy (204)
• Późne wiązanie z komponentem COM (206)
• Współpraca z elementami sterującymi ActiveX (207)
• Współpraca z SOAP (211)
• Podsumowanie (212)

Rozdział 9. Użycie zarządzanego kodu jako komponentu COM i COM+ (215)

• Dlaczego warto tworzyć komponent .NET zachowujący się jak składnik COM? (215)
• Podstawy współpracy niezarządzanego i zarządzanego kodu (216)
• Eksportowanie metadanych do biblioteki typów (217)
• Rejestracja informacji w bibliotece typów (230)
• Demonstracja współpracy COM z klasą Arithmetic (232)
• Demonstracja współpracy COM z Excelem (232)
• Zaawansowane funkcje współpracy COM (235)
• Podsumowanie (240)

Rozdział 10. Zarządzanie pamięcią i zasobami (243)

• Omówienie sposobu zarządzania zasobami w strukturze .NET (243)
• Porównanie alokacji w strukturze .NET i C-Runtime (247)
• Optymalizacja oczyszczania pamięci poprzez generacje (250)
• Finalizacja (250)
• Zarządzanie zasobami poprzez obiekt Disposable (256)
• Duże obiekty (261)
• WeakReference lub wyścig z mechanizmem oczyszczania pamięci (262)
• Podsumowanie (264)

Rozdział 11. Obsługa wątków (265)

• Prezentacja wątków (266)
• Tworzenie i uruchamianie wątków (266)
• Witaj świecie (268)
• Wielozakresowy delegat wątku (268)
• Przekazywanie informacji do wątku (270)
• Inne operacje wykonywane na wątkach (273)
• AppDomain (275)
• Synchronizacja (278)
• Monitor i Lock (280)
• Zsynchronizowane zbiory (282)
• Klasy synchronizacji wątków (282)
• Oczekiwanie poprzez WaitHandle (282)
• Klasa Interlocked (283)
• Słowo kluczowe volatile (283)
• Metoda Join (283)
• Invoke, BeginInvoke oraz EndInvoke (283)
• Pierwszy przykład synchronizacji - obiad filozofów (284)
• Drugi przykład synchronizacji - koszyk z kolorowymi piłkami (285)
• Pula wątków (286)
• QueueUserWorkItem (286)
• RegisterWaitForSingleObject (289)
• Podsumowanie (291)

Rozdział 12. Obsługa sieci (293)

• Krótka historia rozproszonych aplikacji (293)
• Tradycyjne gniazda (294)
• WinSock (295)
• Klasy sieciowe .NET (295)
• Produktywne tworzenie oprogramowania sieciowego (296)
• Warstwowy stos sieci (296)
• Scenariusze dla aplikacji serwerowych i klienckich (296)
• Elastyczność (296)
• Zgodność ze standardami (296)
• Gniazdo w .NET (297)
• Gniazdo UDP (297)
• Gniazdo TCP (306)
• Opcje Socket (311)
• Użycie IOControl (316)
• Asynchroniczne operacje na gniazdach (317)
• Klasy transportowe .NET (323)
• Klasa UDP (324)
• Klasa TCP (326)
• Klasy protokołów .NET (333)
• Obsługa HTTP, HTTPS i FILE (334)
• Programowanie asynchroniczne (336)
• Proste metody pobierania i przekazywania danych (340)
• Aplikacje Windows (341)
• Zarządzanie połączeniem (344)
• ServicePoint i ServicePointManager (346)
• Zarządzanie połączeniem i wydajność (346)
• Bezpieczeństwo sieciowe (350)
• Uwierzytelnianie (351)
• Zabezpieczenia dostępu do kodu (352)
• Dostęp do HTTP (352)
• Dostęp do gniazda (352)
• Rozwiązywanie nazw DNS (353)
• Podsumowanie (353)

Rozdział 13. Tworzenie rozproszonych aplikacji przy użyciu .NET Remoting (355)

• Aplikacje rozproszone (356)
• Użycie .NET do rozpraszania aplikacji (356)
• Architektura Remoting (365)
• Zdalne obiekty (367)
• Prosty serwer czasu korzystający z .NET Remoting (369)
• Serwer czasu korzystający z hosta IIS (375)
• Tworzenie egzemplarza zdalnego obiektu przy użyciu Activator.GetObject (376)
• Tworzenie egzemplarza zdalnego obiektu przy użyciu RemotingServices.Connect (377)
• Tworzenie egzemplarza zdalnego obiektu przy użyciu RegisterWellKnownClientType (377)
• Użycie obiektu Client-Activated (377)
• Asynchroniczne wywołania do zdalnego obiektu (378)
• Generowanie i użycie opisu WSDL zdalnego obiektu (380)
• Użycie usługi WWW poprzez Remoting (383)
• Użycie usługi WWW poprzez interfejsy API Remoting (384)
• Użycie wywołań SOAP z poziomu COM (384)
• Konwersja komponentu COM+ do usługi WWW poprzez funkcje Remoting (387)
• Zaawansowane kwestie związane ze zdalną pracą (388)
• Implementacja własnego ujścia kanału do blokowania określonych adresów IP (388)
• Implementacja własnego ujścia kanału dziennika (393)
• Przedłużanie i kontrolowanie cyklu życia zdalnego obiektu (397)
• Wybranie najlepszej kombinacji kanału i formatera (398)
• Usuwanie błędów zdalnych aplikacji (401)
• Podsumowanie (402)

Rozdział 14. Delegaty i zdarzenia (403)

• Dlaczego delegaty? (403)
• Podstawy używania delegatów (405)
• Porównywanie delegatów (409)
• Usuwanie delegatów (410)
• Klonowanie delegatów (412)
• Serializacja delegatów (413)
• Delegaty asynchroniczne (416)
• Rozwiązanie problemu obiadu filozofów przy wykorzystaniu delegatów (416)
• Zdarzenia i praca z delegatami (421)
• Podstawy użycia zdarzeń (421)
• Zdarzenia Microsoftu (424)
• Podsumowanie (427)

Rozdział 15. Użycie zarządzanych wyjątków do skutecznej obsługi błędów (429)

• Obsługa błędów przy użyciu wyjątków (429)
• Trudności związane z unikaniem wyjątków (430)
• Właściwy sposób obsługi błędów (430)
• Omówienie wyjątków (430)
• Wyjątki C# (436)
• Wyjątki VC++ (443)
• Wyjątki VB (447)
• Podstawowe wyjątki VB (447)
• Zaawansowane wyjątki VB (449)
• Obsługa wyjątków w wielu językach (451)
• Wyjątki P/Invoke (453)
• Wyjątki COM (454)
• Zdalne wyjątki (455)
• Wyjątki wątku i asynchronicznego wywołania zwrotnego (457)
• Wyjątki asynchronicznego wywołania zwrotnego (458)
• Wyjątki wątków (459)
• Podsumowanie (460)

Rozdział 16. Bezpieczeństwo .NET (465)

• Dwa różne, choć podobne, modele zabezpieczeń (465)
• Uprawnienia (466)
• Bezpieczeństwo typologiczne (468)
• Zasady zabezpieczeń (470)
• Główny obiekt (484)
• Uwierzytelnianie (484)
• Autoryzacja (484)
• Zabezpieczenia oparte na rolach (484)
• Zabezpieczenia dostępu kodu (491)
• Izolowane magazynowanie (499)
• Kryptografia w .NET (501)
• Podsumowanie (507)

Rozdział 17. Refleksja (509)

• Użycie refleksji do uzyskania informacji o typie (510)
• Uzyskanie z podzespołu informacji o typie przy użyciu refleksji (510)
• Użycie klasy typu (518)
• Uzyskanie i wykorzystanie atrybutów przy użyciu refleksji (527)
• Dopasowanie metadanych przy użyciu własnych atrybutów (529)
• Użycie refleksji do serializacji typów (534)
• Serializacja używana do pracy zdalnej (535)
• Serializacja XML (540)
• Użycie refleksji do późnego wiązania obiektu (544)
• Dynamiczne generowanie kodu (545)
• Model Code Document Object (CodeDom) (545)
• Kompilacja kodu dla wielu języków (548)
• Mnożenie macierzy (550)
• Bezpośrednie generowanie kodu IL (Reflect.Emit) (558)
• Podsumowanie (559)

Rozdział 18. Globalizacja i lokalizacja (561)

• Podstawy lokalizacji aplikacji (561)
• Droga do międzynarodowej aplikacji (564)
• Użycie klasy CultureInfo (566)
• Użycie klasy RegionInfo (572)
• Użycie zasobów w aplikacji (572)
• Dostęp do zasobów .NET (576)
• Wykorzystanie podzespołów satelitarnych (577)
• Przykład ręcznie tworzonej aplikacji (580)
• Przykład z użyciem Visual Studio .NET (582)
• Edytory IME (583)
• Podsumowanie (585)

Rozdział 19. Usuwanie błędów aplikacji .NET (587)

• Dostarczenie informacji użytkownikowi (588)
• Polecenia Trace i Debug (589)
• Polecenie Assert (598)
• Dzienniki zdarzeń (598)
• Zapewnienie informacji poprzez stronę ASP.NET (602)
• Użycie klasy ErrorProvider (606)
• Weryfikacja wprowadzanych danych przy użyciu klasy ErrorProvider (606)
• Użycie ErrorProvider do weryfikacji danych wprowadzanych do bazy danych (607)
• Użycie debuggera (609)
• Ustawianie punktów kontrolnych (609)
• Krokowe uruchomienie kodu (610)
• Informacje o statusie (610)
• Przyłączanie do działającego procesu (612)
• Zdalne usuwanie błędów (614)
• Błędy ładowania podzespołów (616)
• Tworzenie własnego debuggera (617)
• Faza uruchomieniowa debuggera Cordbg (624)
• Podsumowanie (625)

Rozdział 20. Profilowanie aplikacji .NET (627)

• Tradycyjne narzędzia do profilowania aplikacji .NET (627)
• Stworzenie obrazu użycia pamięci przy użyciu memsnap (628)
• Uzyskanie informacji o wykorzystaniu procesora przy użyciu pstat (629)
• Profilowanie wykorzystania pamięci przy użyciu vadump (630)
• Szczegółowy profil uruchomienia aplikacji .NET dostępny poprzez profile (633)
• Monitorowanie błędów stron przy użyciu pfmon (634)
• Monitorowanie synchronizacji procesów, pamięci i licznika wątków przy użyciu pview (635)
• Menedżer zadań (636)
• Monitorowanie ogólnosystemowych informacji przy użyciu perfmtr (637)
• Profilowanie przy użyciu exctrlst (638)
• Użycie Monitora wydajności i PerformanceCounters do profilowania aplikacji .NET (639)
• Programowy dostęp do liczników wydajności (652)
• Dodanie własnej kategorii liczników przy użyciu Server Explorera (657)
• Tworzenie usługi zapisującej we własnym liczniku PerformanceCounter (659)
• Monitorowanie własnego licznika wydajności (661)
• Dodanie licznika w sposób programowy (663)
• Użycie własnych interfejsów API do profilowania (663)
• General Code Profiler (664)
• Użycie Hot Spots Trackera do odnalezienia często wykorzystywanego kodu (671)
• Podsumowanie (676)

Dodatki (677)
Dodatek A Podstawy C# (679)

• Tworzenie programu w C# (679)
• Programowanie obiektowe w C# (682)
• Obiekty C# (683)
• Obiekty wartości (683)
• Obiekty typów odniesień (692)
• Typ wskaźnika (702)
• Podstawowe elementy programowania w C# (704)
• abstract (704)
• as (707)
• base (708)
• break (708)
• case (709)
• catch (709)
• const (710)
• continue (711)
• default (711)
• delegate (711)
• do (711)
• else (712)
• event (712)
• explicit (712)
• extern (713)
• finally (713)
• fixed (714)
• for (714)
• foreach (714)
• goto (717)
• if (717)
• implicit (717)
• in (717)
• interface (717)
• internal (719)
• is (720)
• lock (720)
• namespace (720)
• new (720)
• operator (720)
• out (721)
• override (721)
• params (721)
• private (722)
• protected (722)
• public (722)
• readonly (723)
• ref (723)
• return (724)
• sealed (724)
• stackalloc (724)
• static (725)
• switch (725)
• throw (726)
• try (726)
• typeof (726)
• unchecked (727)
• unsafe (727)
• using (727)
• virtual (728)
• volatile (729)
• while (729)

Dodatek B Biblioteki klas struktury .NET (731)

• System.BitConverter (731)
• System.Buffer (732)
• System.Console (732)
• System.Convert (733)
• System.DateTime (734)
• System.Environment (735)
• System.Guid (737)
• System.IFormatProvider (737)
• System.Math (739)
• System.OperatingSystem (740)
• System.Random (740)
• System.TimeSpan (741)
• System.TimeZone (741)
• System.Version (742)
• System.Collections (742)
• System.Collections.ArrayList (742)
• System.Collections.BitArray (743)
• System.Collections.Hashtable (745)
• System.Collection.ICollection (745)
• System.Collections.IDictionary (746)
• System.Collections.Ienumerable (747)
• System.Collections.Ilist (747)
• System.Collections.Queue (748)
• System.Collections.ReadOnlyCollectionBase (749)
• System.Collections.SortedList (749)
• System.Collections.Stack (750)
• System.ComponentModel (755)
• System.ComponentModel.License (756)
• System.ComponentModel.TypeDescriptor (760)
• System.Configuration (761)
• System.Data (762)
• System.Diagnostics (762)
• System.Drawing (762)
• System.Drawing.Drawing2D (763)
• System.IO (765)
• System.Messaging (767)
• System.Text (769)
• System.Text.RegularExpression (770)
• System.Timers (771)
• System.Web (772)
• System.Windows.Forms (773)
• System.Xml (777)
• System.Xml.Xsl (779)

Dodatek C Obsługa hostów Common Language Runtime (781)

• Dodanie własnego hosta do CLR (781)

Dodatek D Porównanie Common Language Runtime i Java Virtual Machine (787)

• Historyczne tło wojny o zarządzanie kodem (787)
• Java kontra języki .NET (789)
• Java kontra C# (792)
• Typy zdefiniowane przez użytkownika (793)
• Wyjątki (797)
• Właściwości (799)
• Zdarzenia (801)
• Dostęp do bazy danych (803)
• Polimorfizm (806)
• Współpraca z klasycznym kodem (811)
• Atrybuty (816)
• Serializacja (817)
• Obsługa wersji (820)
• Uzyskanie informacji o typie w czasie pracy aplikacji (821)
• Analiza XML (823)
• Inne różnice między językami (824)
• Dostęp do Internetu (824)
• Graficzny interfejs użytkownika (825)
• Rozważania na temat firmy i pracowników (825)

Dodatek E Bibliografia (827)

• Rozdział 2 (827)
• Rozdział 3 (827)
• Rozdział 4 (828)
• Rozdział 5 (828)
• Rozdział 6 (829)
• Rozdział 7 (829)
• Rozdział 8 (829)
• Rozdział 9 (830)
• Rozdział 10 (830)
• Rozdział 11 (831)
• Rozdział 12 (832)
• Ogólne koncepcje sieci (832)
• Przykłady i porady dotyczące System.Net (832)
• Rozdział 13 (833)
• Rozdział 14 (834)
• Rozdział 16 (835)
• Dodatek A (837)
• Dodatek B (837)
• Dodatek D (838)

Skorowidz (841)