C# od podszewki. Wydanie II - ebook

Obecnie szczególnie cenione są te języki programowania, które pozwalają na błyskawiczne osiągnięcie oczekiwanych efektów. Dodatkowo absolutnie niezbędne jest zachowanie możliwości uruchamiania raz napisanej aplikacji na różnych platformach bez konieczności jej przepisywania. Nikt nie ma na to czasu! C# to nowoczesny język, który zdobył uznanie programistów na całym świecie, ponieważ spełnia nawet najbardziej wyśrubowane wymagania!

Ten bezcenny podręcznik zaprowadzi Cię w najskrytsze zakątki języka C#. Autorzy założyli, że znasz jego podstawy - to pozwoliło im skupić uwagę na niuansach, ciekawostkach oraz subtelnych szczegółach. W trakcie lektury zrozumiesz, co się dzieje w czeluściach C#, a dzięki temu unikniesz ukrytych pułapek. Książka ta jest obowiązkową pozycją każdego programisty C#. Bez niej najciekawsze funkcje C# wciąż będą Ci obce!

Dowiedz się:

• do czego przydają się typy generyczne
• jak zaimplementować iteratory
• jak zoptymalizować skompilowany kod
• w czym może pomóc język LINQ
• jak testować kod

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&#60T&#62 i System.Nullable (145)
  
  • 4.2.1. Wprowadzenie Nullable&#60T&#62 (146)
  • 4.2.2. Opakowywanie i odpakowywanie Nullable&#60T&#62 (149)
  • 4.2.3. Równość instancji Nullable&#60T&#62 (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&#60...&#62 (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&#60T&#62 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&#60T&#62 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&#60T&#62 i IObserver&#60T&#62 (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&#60T&#62 (590)
  • B.2.2. Tablice (591)
  • B.2.3. LinkedList&#60T&#62 (592)
  • B.2.4. Collection&#60T&#62, BindingList&#60T&#62, ObservableCollection&#60T&#62 i KeyedCollection&#60TKey, TItem&#62 (593)
  • B.2.5. ReadOnlyCollection&#60T&#62 i ReadOnlyObservableCollection&#60T&#62 (594)
• B.3. Słowniki (594)
  
  • B.3.1. Dictionary&#60TKey, TValue&#62 (594)
  • B.3.2. SortedList&#60TKey, TValue&#62 i SortedDictionary&#60TKey, TValue&#62 (595)
• B.4. Zbiory (596)
  
  • B.4.1. HashSet&#60T&#62 (597)
  • B.4.2. SortedSet&#60T&#62 (.NET 4) (597)
• B.5. Queue&#60T&#62 i Stack&#60T&#62 (598)
  
  • B.5.1. Queue&#60T&#62 (598)
  • B.5.2. Stack&#60T&#62 (598)
• B.6. Kolekcje konkurencyjne (.NET 4) (598)
  
  • B.6.1. IProducerConsumerCollection&#60T&#62 i BlockingCollection&#60T&#62 (599)
  • B.6.2. ConcurrentBag&#60T&#62, ConcurrentQueue&#60T&#62, ConcurrentStack&#60T&#62 (600)
  • B.6.3. ConcurrentDictionary&#60TKey, TValue&#62 (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)