.NET CLR. Księga eksperta - Helion

Autor: Kevin Burton
Tytuł oryginału: .NET Common Language Runtime Unleashed
Tłumaczenie: Marcin Jędrysiak
ISBN: 83-7197-780-8
stron: 872, Format: B5, okładka: miękka
Data wydania: 2002-02-04
Księgarnia: Helion

Cena książki: 125,00 zł

Pobierz fragment książki » Osoby, które kupiły tę książkę, wybierały także »

Tagi: .NET - Programowanie | C# - Programowanie | C++ - Programowanie | Visual Basic - Programowanie

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.

Osoby które kupowały ".NET CLR. Księga eksperta", wybierały także:

Domain-Driven Design dla .NET Core. Jak rozwiązywać złożone problemy podczas projektowania architektury aplikacji 96,45 zł, (29,90 zł -69%)
Gray Hat C#. Język C# w kontroli i łamaniu zabezpieczeń 57,74 zł, (17,90 zł -69%)
PowerShell. Kurs video. Zarz 169,00 zł, (67,60 zł -60%)
ASP .NET Core. Kurs video. Rozwijanie dodatkowych funkcjonalności Web API 89,00 zł, (40,05 zł -55%)
Programowanie asynchroniczne i równoległe w C#. Kurs video. Poziom podstawowy 69,00 zł, (31,05 zł -55%)

Spis treści

.NET CLR. Księga eksperta -- spis treści

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)