Wstęp (11)

1. Wprowadzenie do C# i .NET Framework (17)

• Obiektowość (17)
• Bezpieczeństwo typów (18)
• Zarządzanie pamięcią (19)
• Platformy (19)
• Powiązania C# z CLR (19)
• CLR i .NET Framework (20)
• C# i środowisko wykonawcze systemu Windows (21)
• Co nowego w C# 6.0 (22)
• Co było nowego w C# 5.0 (24)
• Co było nowego w C# 4.0 (24)
• Co było nowego w C# 3.0 (25)

2. Podstawy języka C# (27)

• Pierwszy program w języku C# (27)
• Składnia (30)
• Podstawy typów (33)
• Typy liczbowe (42)
• Typ logiczny i operatory (49)
• Łańcuchy znaków i pojedyncze znaki (51)
• Tablice (53)
• Zmienne i parametry (57)
• Wyrażenia i operatory (65)
• Operatory null (70)
• Instrukcje (71)
• Przestrzenie nazw (79)

3. Tworzenie typów w języku C# (87)

• Klasy (87)
• Dziedziczenie (101)
• Typ object (109)
• Struktury (113)
• Modyfikatory dostępu (114)
• Interfejsy (116)
• Wyliczenia (121)
• Typy zagnieżdżone (124)
• Typy generyczne (125)

4. Zaawansowane elementy języka C# (139)

• Delegaty (139)
• Zdarzenia (147)
• Wyrażenia lambda (153)
• Metody anonimowe (157)
• Instrukcje try i wyjątki (158)
• Wyliczanie i iteratory (166)
• Typy wartościowe dopuszczające wartość null (171)
• Przeciążanie operatorów (177)
• Metody rozszerzające (180)
• Typy anonimowe (182)
• Wiązanie dynamiczne (183)
• Atrybuty (191)
• Atrybuty informacji wywołującego (193)
• Niebezpieczny kod i wskaźniki (194)
• Dyrektywy preprocesora (198)
• Dokumentacja XML (200)

5. Ogólny zarys platformy (205)

• CLR i rdzeń platformy (207)
• Technologie praktyczne (212)

6. Podstawowe wiadomości o platformie (219)

• Obsługa łańcuchów i tekstu (219)
• Data i godzina (232)
• Daty i strefy czasowe (239)
• Formatowanie i parsowanie (244)
• Standardowe łańcuchy formatu i flagi parsowania (250)
• Inne mechanizmy konwersji (257)
• Globalizacja (261)
• Praca z liczbami (262)
• Wyliczenia (266)
• Krotki (269)
• Struktura Guid (271)
• Sprawdzanie równości (271)
• Określanie kolejności (281)
• Klasy pomocnicze (284)

7. Kolekcje (289)

• Przeliczalność (289)
• Interfejsy ICollection i IList (296)
• Klasa Array (300)
• Listy, kolejki, stosy i zbiory (308)
• Słowniki (316)
• Kolekcje i pośredniki z możliwością dostosowywania (322)
• Dołączanie protokołów równości i porządkowania (328)

8. Zapytania LINQ (335)

• Podstawy (335)
• Składnia płynna (337)
• Wyrażenia zapytań (343)
• Wykonywanie opóźnione (347)
• Podzapytania (353)
• Tworzenie zapytań złożonych (356)
• Strategie projekcji (360)
• Zapytania interpretowane (362)
• LINQ to SQL i Entity Framework (368)
• Budowanie wyrażeń zapytań (381)

9. Operatory LINQ (387)

• Informacje ogólne (388)
• Filtrowanie (391)
• Projekcja (394)
• Łączenie (406)
• Porządkowanie (413)
• Grupowanie (416)
• Operatory zbiorów (419)
• Metody konwersji (420)
• Operatory elementów (423)
• Metody agregacyjne (425)
• Kwantyfikatory (429)
• Metody generujące (430)

10. LINQ to XML (433)

• Przegląd architektury (433)
• Informacje ogólne o X-DOM (434)
• Tworzenie drzewa X-DOM (437)
• Nawigowanie i wysyłanie zapytań (440)
• Modyfikowanie drzewa X-DOM (444)
• Praca z wartościami (447)
• Dokumenty i deklaracje (450)
• Nazwy i przestrzenie nazw (453)
• Adnotacje (458)
• Projekcja do X-DOM (459)

11. Inne technologie XML (465)

• Klasa XmlReader (465)
• Klasa XmlWriter (474)
• Typowe zastosowania klas XmlReader i XmlWriter (476)
• XSD i sprawdzanie poprawności schematów (480)
• XSLT (483)

12. Zwalnianie zasobów i mechanizm usuwania nieużytków (485)

• IDisposable, Dispose i Close (485)
• Automatyczne usuwanie nieużytków (491)
• Finalizatory (493)
• Jak działa mechanizm usuwania nieużytków? (498)
• Wycieki pamięci zarządzanej (503)
• Słabe odwołania (507)

13. Diagnostyka i kontrakty kodu (511)

• Kompilacja warunkowa (511)
• Debugowanie i klasy monitorowania (515)
• Ogólne omówienie kontraktów kodu (518)
• Warunki początkowe (523)
• Warunki końcowe (527)
• Asercje i metody inwariantów obiektu (529)
• Kontrakty w interfejsach i metodach abstrakcyjnych (531)
• Rozwiązywanie problemów z awariami podczas użycia kontraktów (532)
• Selektywne egzekwowanie kontraktów (534)
• Statyczne sprawdzenie kontraktu (536)
• Integracja z debuggerem (538)
• Procesy i wątki procesów (539)
• Klasy StackTrace i StackFrame (540)
• Dziennik zdarzeń Windows (542)
• Liczniki wydajności (544)
• Klasa Stopwatch (549)

14. Współbieżność i asynchroniczność (551)

• Wprowadzenie (551)
• Wątkowanie (552)
• Zadania (569)
• Reguły asynchroniczności (577)
• Funkcje asynchroniczne w języku C# (582)
• Wzorce asynchroniczności (598)
• Wzorce uznane za przestarzałe (606)

15. Strumienie i wejście-wyjście (611)

• Architektura strumienia (611)
• Użycie strumieni (613)
• Adapter strumienia (626)
• Kompresja strumienia (634)
• Praca z plikami w postaci archiwum ZIP (636)
• Operacje na plikach i katalogach (637)
• Plikowe operacje wejścia-wyjścia w środowisku uruchomieniowym Windows (648)
• Mapowanie plików w pamięci (650)
• Odizolowany magazyn danych (653)

16. Sieć (661)

• Architektura sieci (661)
• Adresy i porty (664)
• Adresy URI (665)
• Klasy po stronie klienta (667)
• Praca z HTTP (680)
• Utworzenie serwera HTTP (685)
• Użycie FTP (688)
• Użycie DNS (690)
• Wysyłanie poczty elektronicznej za pomocą SmtpClient (691)
• Użycie TCP (692)
• Otrzymywanie poczty elektronicznej POP3 za pomocą TCP (695)
• TCP w środowisku uruchomieniowym Windows (697)

17. Serializacja (699)

• Koncepcje serializacji (699)
• Serializacja kontraktu danych (703)
• Kontrakty danych i kolekcje (713)
• Rozszerzenie kontraktu danych (715)
• Serializacja binarna (718)
• Atrybuty serializacji binarnej (720)
• Serializacja binarna za pomocą ISerializable (724)
• Serializacja XML (727)

18. Podzespoły (737)

• Co znajduje się w podzespole? (737)
• Silne nazwy i podpisywanie podzespołu (742)
• Nazwy podzespołów (745)
• Technologia Authenticode (748)
• Global Assembly Cache (751)
• Zasoby i podzespoły satelickie (754)
• Wyszukiwanie i wczytywanie podzespołów (762)
• Wdrażanie podzespołów poza katalogiem bazowym (768)
• Umieszczenie w pojedynczym pliku wykonywalnym (769)
• Praca z podzespołami, do których nie ma odwołań (771)

19. Refleksje i metadane (773)

• Refleksje i aktywacja typów (774)
• Refleksje i wywoływanie składowych (780)
• Refleksje dla podzespołów (792)
• Praca z atrybutami (793)
• Generowanie dynamicznego kodu (799)
• Emitowanie podzespołów i typów (805)
• Emitowanie składowych typów (809)
• Emitowanie generycznych typów i klas (814)
• Kłopotliwe cele emisji (816)
• Parsowanie IL (819)

20. Programowanie dynamiczne (825)

• Dynamiczny system wykonawczy języka (825)
• Unifikacja typów liczbowych (827)
• Dynamiczne wybieranie przeciążonych składowych (828)
• Implementowanie obiektów dynamicznych (833)
• Współpraca z językami dynamicznymi (836)

21. Bezpieczeństwo (839)

• Uprawnienia (839)
• Zabezpieczenia dostępu kodu (843)
• Dopuszczanie częściowo zaufanych wywołujących (846)
• Model transparentności (848)
• Ograniczanie innego zestawu (856)
• Zabezpieczenia systemu operacyjnego (860)
• Tożsamości i role (862)
• Kryptografia (864)
• Windows Data Protection (864)
• Obliczanie skrótów (865)
• Szyfrowanie symetryczne (867)
• Szyfrowanie kluczem publicznym i podpisywanie (871)

22. Zaawansowane techniki wielowątkowości (877)

• Przegląd technik synchronizacji (878)
• Blokowanie wykluczające (878)
• Blokady i bezpieczeństwo ze względu na wątki (886)
• Blokowanie bez wykluczania (892)
• Sygnalizacja przy użyciu uchwytów zdarzeń oczekiwania (897)
• Klasa Barrier (905)
• Leniwa inicjalizacja (906)
• Pamięć lokalna wątku (909)
• Metody Interrupt i Abort (911)
• Metody Suspend i Resume (912)
• Zegary (913)

23. Programowanie równoległe (917)

• Dlaczego PFX? (917)
• PLINQ (920)
• Klasa Parallel (933)
• Równoległe wykonywanie zadań (939)
• Klasa AggregateException (948)
• Kolekcje współbieżne (951)
• Klasa BlockingCollection (954)

24. Domeny aplikacji (959)

• Architektura domeny aplikacji (959)
• Tworzenie i likwidowanie domen aplikacji (961)
• Posługiwanie się wieloma domenami aplikacji (962)
• Metoda DoCallBack (964)
• Monitorowanie domen aplikacji (965)
• Domeny i wątki (965)
• Dzielenie danych między domenami (967)

25. Współpraca (973)

• Odwołania do natywnych bibliotek DLL (973)
• Szeregowanie (974)
• Wywołania zwrotne z kodu niezarządzanego (977)
• Symulowanie unii C (977)
• Pamięć współdzielona (978)
• Mapowanie struktury na pamięć niezarządzaną (981)
• Współpraca COM (985)
• Wywołanie komponentu COM z C# (986)
• Osadzanie typów współpracujących (990)
• Główne moduły współpracujące (990)
• Udostępnianie obiektów C# dla COM (991)

26. Wyrażenia regularne (993)

• Podstawy wyrażeń regularnych (994)
• Kwantyfikatory (998)
• Asercje o zerowej wielkości (999)
• Grupy (1002)
• Zastępowanie i dzielenie tekstu (1003)
• Receptury wyrażeń regularnych (1005)
• Leksykon języka wyrażeń regularnych (1008)

27. Kompilator Roslyn (1013)

• Architektura Roslyn (1014)
• Drzewa składni (1015)
• Kompilacja i model semantyczny (1030)

Skorowidz (1041)

• Titel: C# 6.0 w pigułce. Wydanie VI
• Autor: Joseph Albahari, Ben Albahari
• Originaler Titel: C# 6.0 in a Nutshell: The Definitive Reference, 6th Edition
• Übersetzung: Robert Górczyński, Jakub Hubisz, Łukasz Piwko
• ISBN: 978-83-283-2424-4, 9788328324244
• Veröffentlichungsdatum: 2016-10-10
• Format: E-book
• Artikelkennung: c6pig6
• Verleger: Helion