• 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:

• Gray Hat C#. Język C# w kontroli i łamaniu zabezpieczeń 57,74 zł, (17,90 zł -69%)
• Programowanie asynchroniczne i równoległe w C#. Kurs video. Poziom podstawowy 69,00 zł, (31,05 zł -55%)
• Technologia LINQ. Kurs video. Warsztat pracy z danymi z różnych źródeł 59,00 zł, (26,55 zł -55%)
• Język XAML. Kurs video. Poziom pierwszy. Programowanie aplikacji w WPF 59,00 zł, (26,55 zł -55%)
• ASP.NET MVC. Kurs video. Poziom pierwszy. Programowanie aplikacji internetowych 79,00 zł, (35,55 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)