Przedmowa (17)

Wstęp (19)

Podziękowania (21)

O książce (23)

Część I Przygotowanie do wyprawy (31)

1. Nieustająca metamorfoza C# (33)

• 1.1. Na początek prosty typ danych (34)
  
  • 1.1.1. Typ Product w C# 1 (35)
  • 1.1.2. Kolekcje o mocnym typie w C# 2 (36)
  • 1.1.3. Właściwości implementowane automatycznie w C# 3 (37)
  • 1.1.4. Argumenty nazwane w C# 4 (38)
• 1.2. Sortowanie i filtrowanie (39)
  
  • 1.2.1. Sortowanie produktów po nazwie (40)
  • 1.2.2. Wyszukiwanie elementów w kolekcjach (43)
• 1.3. Obsługa braku danych (44)
  
  • 1.3.1. Reprezentacja nieznanej ceny (45)
  • 1.3.2. Parametry opcjonalne i wartości domyślne (46)
• 1.4. Wprowadzenie do LINQ (46)
  
  • 1.4.1. Wyrażenia kwerendowe i zapytania wewnątrzprocesowe (47)
  • 1.4.2. Wykonywanie zapytań na XML-u (48)
  • 1.4.3. LINQ dla SQL-a (49)
• 1.5. COM i typy dynamiczne (50)
  
  • 1.5.1. Uproszczenie współpracy z COM (50)
  • 1.5.2. Współpraca z językiem dynamicznym (51)
• 1.6. Analiza zawartości środowiska .NET (52)
  
  • 1.6.1. Język C# (53)
  • 1.6.2. Środowisko wykonania (53)
  • 1.6.3. Biblioteki środowiska (54)
• 1.7. Jak zmienić Twój kod w kod doskonały? (54)
  
  • 1.7.1. Prezentacja pełnych programów w formie fragmentów kodu (55)
  • 1.7.2. Kod dydaktyczny nie jest kodem produkcyjnym (56)
  • 1.7.3. Twój nowy najlepszy przyjaciel - specyfikacja języka (56)
• 1.8. Podsumowanie (57)

2. Rdzeń systemu - C# 1 (59)

• 2.1. Delegaty (60)
  
  • 2.1.1. Przepis na prosty delegat (61)
  • 2.1.2. Łączenie i usuwanie delegatów (66)
  • 2.1.3. Dygresja na temat zdarzeń (67)
  • 2.1.4. Podsumowanie delegatów (68)
• 2.2. Charakterystyka systemu typów (69)
  
  • 2.2.1. Miejsce C# w świecie systemów typów (69)
  • 2.2.2. Kiedy system typów C# 1 jest niedostatecznie bogaty? (73)
  • 2.2.3. Podsumowanie charakterystyki systemu typów (75)
• 2.3. Typy wartościowe i referencyjne (76)
  
  • 2.3.1. Wartości i referencje w rzeczywistym świecie (76)
  • 2.3.2. Podstawy typów referencyjnych i wartościowych (77)
  • 2.3.3. Obalanie mitów (79)
  • 2.3.4. Opakowywanie i odpakowywanie (81)
  • 2.3.5. Podsumowanie typów wartościowych i referencyjnych (82)
• 2.4. Więcej niż C# 1 - nowe cechy na solidnym fundamencie (83)
  
  • 2.4.1. Cechy związane z delegatami (83)
  • 2.4.2. Cechy związane z systemem typów (85)
  • 2.4.3. Cechy związane z typami wartościowymi (87)
• 2.5. Podsumowanie (88)

Część II C# 2 - rozwiązanie problemów C# 1 (89)

3. Parametryzowanie typów i metod (91)

• 3.1. Czemu potrzebne są typy generyczne? (92)
  
• 3.2. Proste typy generyczne do codziennego użycia (94)
  
  • 3.2.1. Nauka przez przykład - słownik typu generycznego (94)
  • 3.2.2. Typy generyczne i parametry typów (96)
  • 3.2.3. Metody generyczne i czytanie deklaracji generycznych (100)
• 3.3. Wkraczamy głębiej (103)
  
  • 3.3.1. Ograniczenia typów (104)
  • 3.3.2. Interfejs argumentów typu dla metod generycznych (109)
  • 3.3.3. Implementowanie typów generycznych (110)
• 3.4. Zaawansowane elementy typów generycznych (116)
  
  • 3.4.1. Pola i konstruktory statyczne (117)
  • 3.4.2. Jak kompilator JIT traktuje typy generyczne (119)
  • 3.4.3. Iteracja przy użyciu typów generycznych (121)
  • 3.4.4. Refleksja i typy generyczne (123)
• 3.5. Ograniczenia typów generycznych C# i innych języków (128)
  
  • 3.5.1. Brak wariancji typów generycznych (128)
  • 3.5.2. Brak ograniczeń operatorów lub ograniczeń "numerycznych" (133)
  • 3.5.3. Brak generycznych właściwości, indekserów i innych elementów typu (135)
  • 3.5.4. Porównanie z C++ (136)
  • 3.5.5. Porównanie z typami generycznymi Javy (137)
• 3.6. Podsumowanie (139)

4. Wyrażanie "niczego" przy użyciu typów nullowalnych (141)

• 4.1. Co robisz, kiedy zwyczajnie nie masz wartości? (142)
  
  • 4.1.1. Czemu zmienne typu wartościowego nie mogą zawierać null? (142)
  • 4.1.2. Metody reprezentacji wartości null w C# 1 (143)
• 4.2. System.Nullable<T> i System.Nullable (145)
  
  • 4.2.1. Wprowadzenie Nullable<T> (146)
  • 4.2.2. Opakowywanie i odpakowywanie Nullable<T> (149)
  • 4.2.3. Równość instancji Nullable<T> (150)
  • 4.2.4. Wsparcie ze strony niegenerycznej klasy Nullable (151)
• 4.3. Składnia C# 2 dla typów nullowalnych (152)
  
  • 4.3.1. Modyfikator ? (152)
  • 4.3.2. Przypisania i porównania z null (154)
  • 4.3.3. Konwersje i operatory nullowalne (156)
  • 4.3.4. Logika typów nullowalnych (159)
  • 4.3.5. Stosowanie operatora as z typami nullowalnymi (161)
  • 4.3.6. Nullowy operator koalescencyjny (161)
• 4.4. Nowatorskie zastosowania typów nullowalnych (164)
  
  • 4.4.1. Testowanie operacji bez parametrów zwrotnych (165)
  • 4.4.2. Bezbolesne porównania przy użyciu nullowalnego operatora koalescencyjnego (167)
• 4.5. Podsumowanie (169)

5. Przyspieszone delegaty (171)

• 5.1. Pożegnanie z dziwaczną składnią delegatów (173)
  
• 5.2. Konwersja grupy metod (174)
  
• 5.3. Kowariancja i kontrawariancja (176)
  
  • 5.3.1. Kontrawariancja parametrów delegatów (176)
  • 5.3.2. Kowariancja typu zwracanego delegata (178)
  • 5.3.3. Małe ryzyko niekompatybilności (179)
• 5.4. Akcje delegatów tworzone w miejscu przy użyciu metod anonimowych (180)
  
  • 5.4.1. Rozpoczynamy prosto - operując na parametrach (181)
  • 5.4.2. Zwracanie wartości z metod anonimowych (183)
  • 5.4.3. Ignorowanie parametrów typu (185)
• 5.5. Przechwytywanie zmiennych w metodach anonimowych (186)
  
  • 5.5.1. Definicja domknięcia i różnych typów zmiennych (187)
  • 5.5.2. Analiza zachowania zmiennych przechwyconych (188)
  • 5.5.3. Jaki cel mają zmienne przechwycone? (189)
  • 5.5.4. Przedłużone życie zmiennych przechwyconych (190)
  • 5.5.5. Instancje zmiennej lokalnej (192)
  • 5.5.6. Mieszanka zmiennych współdzielonych i odrębnych (194)
  • 5.5.7. Wskazówki odnośnie do zmiennych przechwyconych i podsumowanie (196)
• 5.6. Podsumowanie (197)

6. Implementowanie iteratorów w prosty sposób (199)

• 6.1. C# 1 - udręka ręcznego pisania iteratorów (201)
  
• 6.2. C# 2 - proste iteratory z wyrażeniami yield (204)
  
  • 6.2.1. Wprowadzenie do uproszczeń iteratorów i wyrażenia yield return (204)
  • 6.2.2. Wizualizacja toku wykonania iteratora (206)
  • 6.2.3. Zaawansowany tok wykonania iteratora (208)
  • 6.2.4. Dziwactwa w implementacji (211)
• 6.3. Przykłady z życia (213)
  
  • 6.3.1. Iterowanie po datach w harmonogramie (213)
  • 6.3.2. Iterowanie po wierszach pliku (214)
  • 6.3.3. Leniwe filtrowanie elementów z użyciem uproszczenia iteratora i predykatu (217)
• 6.4. Pseudosynchroniczny kod z użyciem biblioteki CCR (219)
  
• 6.5. Podsumowanie (222)

7. Pozostałe cechy C# 2 (225)

• 7.1. Typy częściowe (227)
  
  • 7.1.1. Tworzenie typu składającego się z kilku plików (227)
  • 7.1.2. Użycie typów częściowych (229)
  • 7.1.3. Metody częściowe - tylko w C# 3 (231)
• 7.2. Klasy statyczne (233)
  
• 7.3. Niezależny poziom dostępu do getterów i setterów właściwości (235)
  
• 7.4. Aliasy przestrzeni nazw (237)
  
  • 7.4.1. Kwalifikowanie aliasów przestrzeni nazw (238)
  • 7.4.2. Aliasy globalnej przestrzeni nazw (239)
  • 7.4.3. Aliasy zewnętrzne (240)
• 7.5. Dyrektywy pragma (241)
  
  • 7.5.1. Pragmy ostrzeżeń (242)
  • 7.5.2. Pragmy sum kontrolnych (243)
• 7.6. Bufory o stałym rozmiarze w kodzie niezarządzanym (243)
  
• 7.7. Udostępnianie wybranych elementów innym modułom (245)
  
  • 7.7.1. Zaprzyjaźnione moduły w prostym przypadku (246)
  • 7.7.2. Do czego warto używać InternalsVisibleTo? (247)
  • 7.7.3. InternalsVisibleTo i moduły podpisane (247)
• 7.8. Podsumowanie (248)

Część III C# 3 - rewolucja w metodzie programowania (251)

8. Redukcja nadmiarowości przez zmyślny kompilator (253)

• 8.1. Właściwości implementowane automatycznie (255)
  
• 8.2. Zmienne lokalne o typie niejawnym (257)
  
  • 8.2.1. Zastosowanie var do deklarowania zmiennych lokalnych (257)
  • 8.2.2. Ograniczenia w typach niejawnych (259)
  • 8.2.3. Zalety i wady typów niejawnych (260)
  • 8.2.4. Zalecenia (261)
• 8.3. Uproszczona inicjalizacja (262)
  
  • 8.3.1. Definicja prostych typów (262)
  • 8.3.2. Ustawianie prostych właściwości (263)
  • 8.3.3. Ustawianie właściwości obiektów zagnieżdżonych (265)
  • 8.3.4. Inicjalizatory kolekcji (266)
  • 8.3.5. Zastosowanie inicjalizatorów (269)
• 8.4. Tablice o typie niejawnym (270)
  
• 8.5. Typy anonimowe (272)
  
  • 8.5.1. Pierwsze spotkania z gatunkiem anonimowym (272)
  • 8.5.2. Części składowe typów anonimowych (274)
  • 8.5.3. Inicjalizatory odwzorowujące (275)
  • 8.5.4. Jaki to ma sens? (276)
• 8.6. Podsumowanie (277)

9. Wyrażenia lambda i drzewa wyrażeń (279)

• 9.1. Wyrażenia lambda i delegaty (281)
  
  • 9.1.1. Przygotowanie - wprowadzenie delegatów typu Func<...> (281)
  • 9.1.2. Pierwsze przekształcenie na wyrażenie lambda (282)
  • 9.1.3. Używanie pojedynczego wyrażenia jako ciała (283)
  • 9.1.4. Lista parametrów o typie niejawnym (284)
  • 9.1.5. Skrót dla pojedynczego parametru (284)
• 9.2. Proste przykłady użycia List<T> i zdarzeń (286)
  
  • 9.2.1. Filtrowanie, sortowanie i operacje na listach (286)
  • 9.2.2. Logowanie w metodach obsługi zdarzeń (288)
• 9.3. Drzewa wyrażeń (289)
  
  • 9.3.1. Budowanie drzew wyrażeń w sposób programistyczny (289)
  • 9.3.2. Kompilowanie drzew wyrażeń do postaci delegatów (291)
  • 9.3.3. Konwersja wyrażeń lambda C# na drzewa wyrażeń (292)
  • 9.3.4. Drzewa wyrażeń w sercu LINQ (296)
  • 9.3.5. Drzewa wyrażeń poza LINQ (297)
• 9.4. Zmiany we wnioskowaniu typów i rozwiązywaniu przeciążeń (299)
  
  • 9.4.1. Powód do zmiany - usprawnienie wywołań metod generycznych (300)
  • 9.4.2. Wnioskowanie typu zwracanego funkcji anonimowych (301)
  • 9.4.3. Dwufazowe wnioskowanie typu (302)
  • 9.4.4. Wybieranie odpowiedniego przeciążenia metody (306)
  • 9.4.5. Podsumowanie wnioskowania typów i rozwiązywania przeciążeń (308)
• 9.5. Podsumowanie (308)

10. Metody rozszerzające (311)

• 10.1. Życie przed metodami rozszerzającymi (312)
  
• 10.2. Składnia metod rozszerzających (315)
  
  • 10.2.1. Deklarowanie metod rozszerzających (315)
  • 10.2.2. Wywoływanie metod rozszerzających (316)
  • 10.2.3. Wykrywanie metod rozszerzających (318)
  • 10.2.4. Wywołanie metody na pustej referencji (319)
• 10.3. Metody rozszerzające w .NET 3.5 (321)
  
  • 10.3.1. Pierwsze kroki z Enumerable (321)
  • 10.3.2. Filtrowanie z użyciem Where i spinania wywołań metod (323)
  • 10.3.3. Antrakt: czy metody Where nie widzieliśmy już wcześniej? (325)
  • 10.3.4. Projekcja przy użyciu metody Select i typów anonimowych (326)
  • 10.3.5. Sortowanie przy użyciu OrderBy (327)
  • 10.3.6. Przykłady logiki biznesowej z użyciem łańcuchowania (328)
• 10.4. Wskazówki i uwagi odnośnie do użycia (330)
  
  • 10.4.1. "Rozszerzanie świata" i wzbogacanie interfejsów (330)
  • 10.4.2. Płynne interfejsy (331)
  • 10.4.3. Rozważne użycie metod rozszerzających (332)
• 10.5. Podsumowanie (334)

11. Wyrażenia kwerendowe i LINQ dla Obiektów (335)

• 11.1. Wprowadzenie do LINQ (336)
  
  • 11.1.1. Podstawowe koncepcje w LINQ (336)
  • 11.1.2. Definiowanie przykładowego modelu danych (341)
• 11.2. Prosty początek - wybieranie elementów (343)
  
  • 11.2.1. Rozpoczynanie od źródła i kończenie na selekcji (343)
  • 11.2.2. Translacja kompilatora jako podstawa wyrażeń kwerendowych (344)
  • 11.2.3. Zmienne zakresu i projekcje nietrywialne (347)
  • 11.2.4. Cast, OfType i zmienne zakresu o typie jawnym (349)
• 11.3. Filtrowanie i porządkowanie sekwencji (351)
  
  • 11.3.1. Filtrowanie przy użyciu klauzuli where (351)
  • 11.3.2. Zdegenerowane wyrażenia kwerendowe (352)
  • 11.3.3. Porządkowanie przy użyciu klauzuli orderby (353)
• 11.4. Klauzule let i identyfikatory przezroczyste (356)
  
  • 11.4.1. Wprowadzenie do wykonania pośredniego z użyciem let (356)
  • 11.4.2. Identyfikatory przezroczyste (357)
• 11.5. Złączenia (359)
  
  • 11.5.1. Złączenia wewnętrzne korzystające z klauzul join (359)
  • 11.5.2. Złączenia grupowe z użyciem klauzul join ... into (363)
  • 11.5.3. Złączenia krzyżowe i spłaszczanie sekwencji przy użyciu wielokrotnych klauzul from (366)
• 11.6. Grupowania i kontynuacje (369)
  
  • 11.6.1. Grupowanie przy użyciu klauzuli group ... by (369)
  • 11.6.2. Kontynuacje zapytań (373)
• 11.7. Wybór pomiędzy wyrażeniami kwerendowymi a notacją kropkową (375)
  
  • 11.7.1. Operacje wymagające notacji kropkowej (376)
  • 11.7.2. Wyrażenia kwerendowe, dla których prostszym rozwiązaniem może się okazać notacja kropkowa (377)
  • 11.7.3. Gdzie wyrażenia kwerendowe lśnią? (377)
• 11.8. Podsumowanie (379)

12. LINQ - nie tylko kolekcje (381)

• 12.1. Odpytywanie bazy danych przez LINQ dla SQL-a (382)
  
  • 12.1.1. Zaczynamy od bazy danych i modelu (383)
  • 12.1.2. Zapytania wstępne (385)
  • 12.1.3. Zapytania wymagające złączeń (388)
• 12.2. Translacje przy użyciu IQueryable i IQueryProvider (390)
  
  • 12.2.1. Wprowadzenie do IQueryable<T> i związanych z nim interfejsów (391)
  • 12.2.2. Prototyp - implementacja interfejsów wykonująca wpisy w dzienniku (393)
  • 12.2.3. Spajanie wszystkiego razem - metody rozszerzające typu Queryable (395)
  • 12.2.4. Udawany dostawca w działaniu (397)
  • 12.2.5. Podsumowanie IQueryable (398)
• 12.3. Interfejsy zaprzyjaźnione z LINQ i LINQ dla XML-a (399)
  
  • 12.3.1. Rdzenne typy LINQ dla XML-a (399)
  • 12.3.2. Konstrukcja deklaratywna (401)
  • 12.3.3. Zapytania na pojedynczych węzłach (404)
  • 12.3.4. Operatory zapytań spłaszczonych (406)
  • 12.3.5. Praca w harmonii z LINQ (407)
• 12.4. Zastąpienie LINQ dla Obiektów Równoległym LINQ (408)
  
  • 12.4.1. Kreślenie zbioru Mandelbrota przez pojedynczy wątek (409)
  • 12.4.2. Wprowadzenie ParallelEnumerable, ParallelQuery i AsParallel (410)
  • 12.4.3. Podkręcanie zapytań równoległych (411)
• 12.5. Odwrócenie modelu zapytania przy użyciu LINQ dla Rx (413)
  
  • 12.5.1. IObservable<T> i IObserver<T> (414)
  • 12.5.2. Zaczynamy (ponownie) łagodnie (416)
  • 12.5.3. Odpytywanie obiektów obserwowalnych (417)
  • 12.5.4. Jaki to wszystko ma sens? (419)
• 12.6. Rozszerzanie LINQ dla Obiektów (420)
  
  • 12.6.1. Wytyczne odnośnie do projektu i implementacji (421)
  • 12.6.2. Proste rozszerzenie - wybieranie losowego elementu (422)
• 12.7. Podsumowanie (424)

Część IV C# 4 - dobra współpraca z innymi interfejsami (427)

13. Małe zmiany dla uproszczenia kodu (429)

• 13.1. Parametry opcjonalne i argumenty nazwane (430)
  
  • 13.1.1. Parametry opcjonalne (430)
  • 13.1.2. Argumenty nazwane (437)
  • 13.1.3. Złożenie dwóch cech w całość (441)
• 13.2. Usprawnienia we współpracy z COM (446)
  
  • 13.2.1. Horror automatyzacji Worda przed C# 4 (446)
  • 13.2.2. Zemsta parametrów opcjonalnych i argumentów nazwanych (447)
  • 13.2.3. Kiedy parametr ref nie jest parametrem ref? (448)
  • 13.2.4. Wywoływanie indekserów nazwanych (449)
  • 13.2.5. Łączenie głównych bibliotek COM-owych (451)
• 13.3. Wariancja typów generycznych dla interfejsów i delegatów (453)
  
  • 13.3.1. Typy wariancji: kowariancja i kontrawariancja (454)
  • 13.3.2. Użycie wariancji w interfejsach (455)
  • 13.3.3. Zastosowanie wariancji w delegatach (458)
  • 13.3.4. Złożone sytuacje (459)
  • 13.3.5. Restrykcje i uwagi (461)
• 13.4. Mikroskopijne zmiany w blokadach i zdarzeniach w formie pól (465)
  
  • 13.4.1. Solidne blokowanie (465)
  • 13.4.2. Zmiany w zdarzeniach w formie pól (467)
• 13.5. Podsumowanie (467)

14. Dynamiczne wiązanie w języku statycznym (469)

• 14.1. Co? Kiedy? Dlaczego? Jak? (471)
  
  • 14.1.1. Czym są typy dynamiczne? (471)
  • 14.1.2. Kiedy typy dynamiczne są użyteczne i dlaczego? (472)
  • 14.1.3. W jaki sposób C# zapewnia typy dynamiczne? (474)
• 14.2. Pięciominutowy przewodnik po typie dynamic (474)
  
• 14.3. Przykłady użycia typów dynamicznych (477)
  
  • 14.3.1. COM w ogólności i Microsoft Office w szczególności (477)
  • 14.3.2. Języki dynamiczne, takie jak IronPython (479)
  • 14.3.3. Typy dynamiczne w kodzie całkowicie zarządzanym (484)
• 14.4. Zaglądamy pod maskę (490)
  
  • 14.4.1. Wprowadzenie do DLR (491)
  • 14.4.2. Fundamentalne koncepcje DLR (493)
  • 14.4.3. Jak kompilator C# obsługuje słowo dynamic? (496)
  • 14.4.4. Kompilator C# staje się jeszcze sprytniejszy (500)
  • 14.4.5. Ograniczenia kodu dynamicznego (503)
• 14.5. Implementacja zachowania dynamicznego (506)
  
  • 14.5.1. Użycie klasy ExpandoObject (506)
  • 14.5.2. Użycie klasy DynamicObject (511)
  • 14.5.3. Implementacja IDynamicMetaObjectProvider (518)
• 14.6. Podsumowanie (522)

15. Jaśniejsze wyrażanie kodu przy użyciu kontraktów kodu (523)

• 15.1. Życie przed kontraktami kodu (525)
  
• 15.2. Wprowadzenie do kontraktów kodu (527)
  
  • 15.2.1. Warunki wstępne (529)
  • 15.2.2. Warunki końcowe (530)
  • 15.2.3. Inwarianty (531)
  • 15.2.4. Asercje i założenia (533)
  • 15.2.5. Kontrakty legacyjne (534)
• 15.3. Przepisywanie kodu binarnego przez ccrewrite i ccrefgen (536)
  
  • 15.3.1. Proste przepisywanie (536)
  • 15.3.2. Dziedziczenie kontraktów (538)
  • 15.3.3. Referencyjne moduły kontraktów (541)
  • 15.3.4. Zachowanie w przypadku porażki (543)
• 15.4. Sprawdzanie statyczne (545)
  
  • 15.4.1. Wprowadzenie do analizy statycznej (545)
  • 15.4.2. Zobowiązania niejawne (548)
  • 15.4.3. Selektywne włączanie opcji (551)
• 15.5. Dokumentowanie kodu przy użyciu ccdocgen (554)
  
• 15.6. Kontrakty w praktyce (556)
  
  • 15.6.1. Filozofia - czym jest kontrakt? (557)
  • 15.6.2. Jak mam zacząć? (558)
  • 15.6.3. Opcje, wszędzie opcje (559)
• 15.7. Podsumowanie (562)

16. Dokąd teraz? (565)

• 16.1. C# - połączenie tradycji z nowoczesnością (566)
  
• 16.2. Spotkanie .NET z informatyką (567)
  
• 16.3. Świat informatyki (568)
  
• 16.4. Pożegnanie (569)

Dodatki (571)

A Standardowe operatory kwerendowe LINQ (573)

• A.1. Agregacja (574)
  
• A.2. Konkatenacja (575)
  
• A.3. Konwersja (575)
  
• A.4. Operatory jednoelementowe (577)
  
• A.5. Równość (578)
  
• A.6. Generacja (579)
  
• A.7. Grupowanie (580)
  
• A.8. Złączenia (580)
  
• A.9. Partycjonowanie (582)
  
• A.10. Projekcja (582)
  
• A.11. Kwantyfikatory (583)
  
• A.12. Filtrowanie (584)
  
• A.13. Operatory bazujące na zbiorach (584)
  
• A.14. Sortowanie (585)

B Kolekcje generyczne w .NET (587)

• B.1. Interfejsy (588)
  
• B.2. Listy (590)
  
  • B.2.1. List<T> (590)
  • B.2.2. Tablice (591)
  • B.2.3. LinkedList<T> (592)
  • B.2.4. Collection<T>, BindingList<T>, ObservableCollection<T> i KeyedCollection<TKey, TItem> (593)
  • B.2.5. ReadOnlyCollection<T> i ReadOnlyObservableCollection<T> (594)
• B.3. Słowniki (594)
  
  • B.3.1. Dictionary<TKey, TValue> (594)
  • B.3.2. SortedList<TKey, TValue> i SortedDictionary<TKey, TValue> (595)
• B.4. Zbiory (596)
  
  • B.4.1. HashSet<T> (597)
  • B.4.2. SortedSet<T> (.NET 4) (597)
• B.5. Queue<T> i Stack<T> (598)
  
  • B.5.1. Queue<T> (598)
  • B.5.2. Stack<T> (598)
• B.6. Kolekcje konkurencyjne (.NET 4) (598)
  
  • B.6.1. IProducerConsumerCollection<T> i BlockingCollection<T> (599)
  • B.6.2. ConcurrentBag<T>, ConcurrentQueue<T>, ConcurrentStack<T> (600)
  • B.6.3. ConcurrentDictionary<TKey, TValue> (600)
• B.7. Podsumowanie (600)

C Podsumowanie wersji środowisk .NET (603)

• C.1. Główne wersje dystrybucyjne środowiska typu desktop (604)
  
• C.2. Cechy języka C# (605)
  
  • C.2.1. C# 2.0 (605)
  • C.2.2. C# 3 (605)
  • C.2.3. C# 4.0 (606)
• C.3. Biblioteki środowiska (606)
  
  • C.3.1. .NET 2.0 (606)
  • C.3.2. .NET 3.0 (606)
  • C.3.3. .NET 3.5 (607)
  • C.3.4. .NET 4 (607)
• C.4. Cechy środowiska uruchomieniowego (CLR) (608)
  
  • C.4.1. CLR 2.0 (608)
  • C.4.2. CLR 4.0 (609)
• C.5. Inne rodzaje środowiska uruchomieniowego (609)
  
  • C.5.1. Compact Framework (609)
  • C.5.2. Silverlight (610)
  • C.5.3. Micro Framework (611)
• C.6. Podsumowanie (611)

Skorowidz (613)

• Title: C# od podszewki. Wydanie II
• Author: Jon Skeet
• Original title: C# in Depth, Second Edition
• Translation: Janusz Grabis
• ISBN: 978-83-246-6458-0, 9788324664580
• Date of issue: 2012-10-29
• Format: Ebook
• Item ID: cshop2
• Publisher: Helion