Wstęp (17)

1. Prezentacja C# (21)

• Dlaczego C#? (21)
• Dlaczego nie C#? (23)
• Najważniejsze cechy C# (25)
  • Kod zarządzany i CLR (27)
  • Ogólność jest ważniejsza od specjalizacji (29)
  • Programowanie asynchroniczne (30)
• Visual Studio (31)
• Anatomia prostego programu (33)
  • Dodawanie projektów do istniejącej solucji (35)
  • Odwołania do innych projektów (35)
  • Pisanie testu jednostkowego (37)
  • Przestrzenie nazw (40)
  • Klasy (44)
  • Punkt wejścia do programu (44)
  • Testy jednostkowe (45)
• Podsumowanie (47)

2. Podstawy stosowania języka C# (49)

• Zmienne lokalne (50)
  • Zakres (55)
• Instrukcje i wyrażenia (58)
  • Instrukcje (59)
  • Wyrażenia (60)
• Komentarze i białe znaki (65)
• Dyrektywy preprocesora (67)
  • Symbole kompilacji (67)
  • Dyrektywy #error oraz #warning (68)
  • Dyrektywa #line (69)
  • Dyrektywa #pragma (69)
  • Dyrektywy #region i #endregion (70)
• Wbudowane typy danych (70)
  • Typy liczbowe (71)
  • Wartości logiczne (80)
  • Znaki i łańcuchy znaków (80)
  • Object (81)
• Operatory (81)
• Sterowanie przepływem (87)
  • Decyzje logiczne przy użyciu instrukcji if (87)
  • Wielokrotny wybór przy użyciu instrukcji switch (89)
  • Pętle: while oraz do (91)
  • Pętle znane z języka C (92)
  • Przeglądanie kolekcji przy użyciu pętli foreach (93)
• Podsumowanie (94)

3. Typy (95)

• Klasy (95)
  • Składowe statyczne (98)
  • Klasy statyczne (100)
  • Typy referencyjne (101)
• Struktury (106)
  • Kiedy tworzyć typy wartościowe? (110)
• Składowe (115)
  • Pola (115)
  • Konstruktory (117)
  • Metody (125)
  • Właściwości (130)
  • Indeksatory (134)
  • Operatory (135)
  • Zdarzenia (138)
  • Typy zagnieżdżone (138)
• Interfejsy (140)
• Typy wyliczeniowe (141)
• Inne typy (144)
  • Typy anonimowe (145)
• Typy i metody częściowe (146)
• Podsumowanie (147)

4. Typy ogólne (149)

• Typy ogólne (150)
• Ograniczenia (152)
  • Ograniczenia typu (153)
  • Ograniczenia typu referencyjnego (155)
  • Ograniczenia typu wartościowego (157)
  • Stosowanie wielu ograniczeń (158)
• Wartości przypominające zero (158)
• Metody ogólne (160)
  • Wnioskowanie typu (160)
• Tajniki typów ogólnych (161)
• Podsumowanie (163)

5. Kolekcje (165)

• Tablice (165)
  • Inicjalizacja tablic (168)
  • Użycie słowa kluczowego params do przekazywania zmiennej liczby argumentów (169)
  • Przeszukiwanie i sortowanie (171)
  • Tablice wielowymiarowe (178)
  • Kopiowanie i zmiana wielkości (181)
• List (182)
• Interfejsy list i sekwencji (185)
• Implementacja list i sekwencji (189)
  • Iteratory (190)
  • Klasa Collection (194)
  • Klasa ReadOnlyCollection (195)
• Słowniki (196)
  • Słowniki posortowane (198)
• Zbiory (200)
• Kolejki i stosy (201)
• Listy połączone (202)
• Kolekcje współbieżne (203)
• Krotki (204)
• Podsumowanie (205)

6. Dziedziczenie (207)

• Dziedziczenie i konwersje (208)
• Dziedziczenie interfejsów (210)
• Typy ogólne (211)
  • Kowariancja i kontrawariancja (212)
• System.Object (217)
  • Wszechobecne metody typu object (217)
• Dostępność i dziedziczenie (218)
• Metody wirtualne (220)
  • Metody abstrakcyjne (222)
• Metody i klasy ostateczne (228)
• Dostęp do składowych klas bazowych (229)
• Dziedziczenie i tworzenie obiektów (230)
• Specjalne typy bazowe (234)
• Podsumowanie (235)

7. Cykl życia obiektów (237)

• Mechanizm odzyskiwania pamięci (238)
  • Określanie osiągalności danych (239)
  • Przypadkowe problemy mechanizmu odzyskiwania pamięci (242)
  • Słabe referencje (244)
  • Odzyskiwanie pamięci (248)
  • Tryby odzyskiwania pamięci (254)
  • Przypadkowe utrudnianie scalania (256)
  • Wymuszanie odzyskiwania pamięci (260)
• Destruktory i finalizacja (261)
  • Finalizatory krytyczne (264)
• Interfejs IDisposable (265)
  • Zwalnianie opcjonalne (271)
• Pakowanie (272)
  • Pakowanie danych typu Nullable (276)
• Podsumowanie (277)

8. Wyjątki (279)

• Źródła wyjątków (281)
  • Wyjątki zgłaszane przez API (282)
  • Wyjątki w naszym kodzie (284)
  • Błędy wykrywane przez środowisko uruchomieniowe (284)
• Obsługa wyjątków (285)
  • Obiekty wyjątków (286)
  • Wiele bloków catch (287)
  • Zagnieżdżone bloki try (289)
  • Bloki finally (290)
• Zgłaszanie wyjątków (292)
  • Powtórne zgłaszanie wyjątków (292)
  • Sposób na szybkie zakończenie aplikacji (295)
• Typy wyjątków (296)
  • Wyjątki niestandardowe (298)
• Wyjątki nieobsługiwane (301)
  • Debugowanie i wyjątki (303)
• Wyjątki asynchroniczne (305)
• Podsumowanie (308)

9. Delegaty, wyrażenia lambda i zdarzenia (309)

• Typy delegatów (310)
  • Tworzenie delegatów (311)
  • MulticastDelegate - delegaty zbiorowe (314)
  • Wywoływanie delegatów (316)
  • Popularne typy delegatów (318)
  • Zgodność typów (319)
  • Więcej niż składnia (323)
• Metody inline (326)
  • Przechwytywane zmienne (328)
  • Wyrażenia lambda oraz drzewa wyrażeń (335)
• Zdarzenia (336)
  • Standardowy wzorzec delegatów zdarzeń (338)
  • Niestandardowe metody dodające i usuwające zdarzenia (339)
  • Zdarzenia i mechanizm odzyskiwania pamięci (342)
  • Zdarzenia a delegaty (344)
• Delegaty a interfejsy (345)
• Podsumowanie (345)

10. LINQ (347)

• Wyrażenia zapytań (348)
  • Jak są rozwijane wyrażenia zapytań (351)
  • Obsługa wyrażeń zapytań (353)
• Przetwarzanie opóźnione (357)
• LINQ, typy ogólne oraz interfejs IQueryable (359)
• Standardowe operatory LINQ (361)
  • Filtrowanie (364)
  • Selekcja (366)
  • Operator SelectMany (369)
  • Określanie porządku (371)
  • Testy zawierania (373)
  • Konkretne elementy i podzakresy (375)
  • Agregacja (379)
  • Operacje na zbiorach (384)
  • Operatory działające na całych sekwencjach z zachowaniem kolejności (384)
  • Grupowanie (386)
  • Złączenia (390)
  • Konwersje (392)
• Generowanie sekwencji (396)
• Inne implementacje LINQ (397)
  • Entity Framework (397)
  • LINQ to SQL (398)
  • Klient WCF Data Services (398)
  • Parallel LINQ (PLINQ) (399)
  • LINQ to XML (399)
  • Reactive Extensions (399)
• Podsumowanie (400)

11. Reactive Extensions (401)

• Rx oraz różne wersje .NET Framework (403)
• Podstawowe interfejsy (405)
  • Interfejs IObserver (406)
  • Interfejs IObservable (407)
• Publikowanie i subskrypcja z wykorzystaniem delegatów (413)
  • Tworzenie źródła przy wykorzystaniu delegatów (413)
  • Subskrybowanie obserwowalnych źródeł przy użyciu delegatów (417)
• Generator sekwencji (418)
  • Empty (418)
  • Never (418)
  • Return (419)
  • Throw (419)
  • Range (419)
  • Repeat (419)
  • Generate (420)
• Zapytania LINQ (421)
  • Operatory grupowania (423)
  • Operatory Join (424)
  • Operator SelectMany (429)
  • Agregacja oraz inne operatory zwracające jedną wartość (430)
  • Operator Concat (431)
• Operatory biblioteki Rx (431)
  • Merge (432)
  • Operatory Buffer i Window (433)
  • Operator Scan (440)
  • Operator Amb (441)
  • DistinctUntilChanged (442)
• Mechanizmy szeregujące (442)
  • Określanie mechanizmów szeregujących (443)
  • Wbudowane mechanizmy szeregujące (445)
• Tematy (447)
  • Subject (447)
  • BehaviorSubject (448)
  • ReplaySubject (449)
  • AsyncSubject (449)
• Dostosowanie (450)
  • IEnumerable (450)
  • Zdarzenia .NET (452)
  • API asynchroniczne (454)
• Operacje z uzależnieniami czasowymi (456)
  • Interval (456)
  • Timer (457)
  • Timestamp (458)
  • TimeInterval (459)
  • Throttle (459)
  • Sample (460)
  • Timeout (460)
  • Operatory okien czasowych (460)
  • Delay (461)
  • DelaySubscription (461)
• Podsumowanie (462)

12. Podzespoły (463)

• Visual Studio i podzespoły (463)
• Anatomia podzespołu (464)
  • Metadane .NET (465)
  • Zasoby (465)
  • Podzespoły składające się z wielu plików (466)
  • Inne możliwości formatu PE (467)
• Tożsamość typu (468)
• Wczytywanie podzespołów (471)
  • Jawne wczytywanie podzespołów (473)
  • Global Assembly Cache (474)
• Nazwy podzespołów (476)
  • Silne nazwy (476)
  • Numer wersji (480)
  • Identyfikator kulturowy (484)
  • Architektura procesora (487)
• Przenośne biblioteki klas (488)
• Wdrażanie pakietów (490)
  • Aplikacje dla systemu Windows 8 (490)
  • ClickOnce oraz XBAP (491)
  • Aplikacje Silverlight oraz Windows Phone (492)
• Zabezpieczenia (493)
• Podsumowanie (494)

13. Odzwierciedlanie (495)

• Typy odzwierciedlania (495)
  • Assembly (498)
  • Module (502)
  • MemberInfo (503)
  • Type oraz TypeInfo (506)
  • MethodBase, ConstructorInfo oraz MethodInfo (510)
  • ParameterInfo (512)
  • FieldInfo (513)
  • PropertyInfo (513)
  • EventInfo (514)
• Konteksty odzwierciedlania (514)
• Podsumowanie (516)

14. Dynamiczne określanie typów (517)

• Typ dynamic (519)
• Słowo kluczowe dynamic i mechanizmy współdziałania (521)
  • Silverlight i obiekty skryptowe (524)
  • Dynamiczne języki .NET (525)
• Tajniki typu dynamic (526)
  • Ograniczenia typu dynamic (526)
  • Niestandardowe obiekty dynamiczne (528)
  • Klasa ExpandoObject (531)
• Ograniczenia typu dynamic (531)
• Podsumowanie (534)

15. Atrybuty (535)

• Stosowanie atrybutów (535)
  • Cele atrybutów (537)
  • Atrybuty obsługiwane przez kompilator (539)
  • Atrybuty obsługiwane przez CLR (543)
• Definiowanie i stosowanie atrybutów niestandardowych (551)
  • Typ atrybutu (551)
  • Pobieranie atrybutów (553)
• Podsumowanie (556)

16. Pliki i strumienie (557)

• Klasa Stream (558)
  • Położenie i poruszanie się w strumieniu (560)
  • Opróżnianie strumienia (561)
  • Kopiowanie (562)
  • Length (562)
  • Zwalnianie strumieni (564)
  • Operacje asynchroniczne (565)
  • Konkretne typy strumieni (565)
• Windows 8 oraz interfejs IRandomAccessStream (566)
• Typy operujące na tekstach (569)
  • TextReader oraz TextWriter (570)
  • Konkretne typy do odczytu i zapisu łańcuchów znaków (572)
  • Kodowanie (574)
• Pliki i katalogi (578)
  • Klasa FileStream (578)
  • Klasa File (581)
  • Klasa Directory (585)
  • Klasa Path (586)
  • Klasy FileInfo, DirectoryInfo oraz FileSystemInfo (588)
  • Znane katalogi (589)
• Serializacja (590)
  • Klasy BinaryReader oraz BinaryWriter (590)
  • Serializacja CLR (591)
  • Serializacja kontraktu danych (594)
  • Klasa XmlSerializer (597)
• Podsumowanie (598)

17. Wielowątkowość (599)

• Wątki (599)
  • Wątki, zmienne i wspólny stan (601)
  • Klasa Thread (607)
  • Pula wątków (609)
  • Powinowactwo do wątku oraz klasa SynchronizationContext (614)
• Synchronizacja (618)
  • Monitory oraz słowo kluczowe lock (619)
  • Klasa SpinLock (625)
  • Blokady odczytu i zapisu (627)
  • Obiekty zdarzeń (628)
  • Klasa Barrier (631)
  • Klasa CountdownEvent (632)
  • Semafory (632)
  • Muteksy (633)
  • Klasa Interlocked (634)
  • Leniwa inicjalizacja (637)
  • Pozostałe klasy obsługujące działania współbieżne (639)
• Zadania (640)
  • Klasy Task oraz Task (640)
  • Kontynuacje (643)
  • Mechanizmy szeregujące (645)
  • Obsługa błędów (647)
  • Niestandardowe zadania bezwątkowe (648)
  • Związki zadanie nadrzędne - zadanie podrzędne (649)
  • Zadania złożone (650)
• Inne wzorce asynchroniczne (651)
• Anulowanie (652)
• Równoległość (653)
  • Klasa Parallel (653)
  • Parallel LINQ (654)
  • TPL Dataflow (654)
• Podsumowanie (655)

18. Asynchroniczne cechy języka (657)

• Nowe słowa kluczowe: async oraz await (658)
  • Konteksty wykonania i synchronizacji (662)
  • Wykonywanie wielu operacji i pętli (663)
  • Zwracanie obiektu Task (666)
  • Stosowanie async w metodach zagnieżdżonych (667)
• Wzorzec słowa kluczowego await (668)
• Obsługa błędów (672)
  • Weryfikacja poprawności argumentów (674)
  • Wyjątki pojedyncze oraz grupy wyjątków (675)
  • Operacje równoległe i nieobsłużone wyjątki (677)
• Podsumowanie (678)

19. XAML (681)

• Platformy XAML (682)
  • WPF (683)
  • Silverlight (684)
  • Windows Phone 7 (686)
  • Windows Runtime oraz aplikacje dostosowane do interfejsu użytkownika Windows 8 (687)
• Podstawy XAML (688)
  • Przestrzenie nazw XAML oraz XML (689)
  • Generowane klasy i kod ukryty (690)
  • Elementy podrzędne (692)
  • Elementy właściwości (692)
  • Obsługa zdarzeń (694)
  • Wykorzystanie wątków (695)
• Układ (696)
  • Właściwości (696)
  • Panele (702)
  • ScrollViewer (712)
  • Zdarzenia związane z układem (712)
• Kontrolki (713)
  • Kontrolki z zawartością (714)
  • Kontrolki Slider oraz ScrollBar (717)
  • Kontrolki postępów (718)
  • Listy (719)
  • Szablony kontrolek (721)
  • Kontrolki użytkownika (724)
• Tekst (725)
  • Wyświetlanie tekstów (725)
  • Edycja tekstów (727)
• Wiązanie danych (729)
  • Szablony danych (732)
• Grafika (735)
  • Kształty (735)
  • Bitmapy (736)
  • Media (737)
• Style (738)
• Podsumowanie (739)

20. ASP.NET (741)

• Razor (742)
  • Wyrażenia (743)
  • Sterowanie przepływem (745)
  • Bloki kodu (746)
  • Jawne wskazywanie treści (747)
  • Klasy i obiekty stron (748)
  • Stosowanie innych komponentów (749)
  • Strony układu (749)
  • Strony początkowe (751)
• Web Forms (752)
  • Kontrolki serwerowe (752)
  • Wyrażenia (758)
  • Bloki kodu (758)
  • Standardowe obiekty stron (759)
  • Klasy i obiekty stron (759)
  • Stosowanie innych komponentów (760)
  • Strony nadrzędne (760)
• MVC (762)
  • Typowy układ projektu MVC (763)
  • Pisanie modeli (769)
  • Pisanie widoków (771)
  • Pisanie kontrolerów (772)
  • Obsługa dodatkowych danych wejściowych (774)
  • Generowanie łączy do akcji (776)
• Trasowanie (777)
• Podsumowanie (781)

21. Współdziałanie (783)

• Wywoływanie kodu rodzimego (783)
  • Szeregowanie (784)
  • Procesy 32- i 64-bitowe (792)
  • Bezpieczne uchwyty (793)
  • Bezpieczeństwo (794)
• Mechanizm Platform Invoke (795)
  • Konwencje wywołań (796)
  • Obsługa łańcuchów znaków (797)
  • Nazwa punktu wejścia (797)
  • Wartości wynikowe technologii COM (798)
  • Obsługa błędów Win32 (802)
• Technologia COM (802)
  • Czas życia obiektów RCW (803)
  • Metadane (805)
  • Skrypty (811)
• Windows Runtime (814)
  • Metadane (815)
  • Typy Windows Runtime (815)
  • Bufory (816)
• Niebezpieczny kod (818)
• C++/CLI i Component Extensions (819)
• Podsumowanie (820)

Skorowidz (821)

• Tytuł: C# 5.0. Programowanie. Tworzenie aplikacji Windows 8, internetowych oraz biurowych w .NET 4.5 Framework
• Autor: Ian Griffiths
• Tytuł oryginału: Programming C# 5.0: Building Windows 8, Web, and Desktop Applications for the .NET 4.5 Framework
• Tłumaczenie: Piotr Rajca
• ISBN: 978-83-246-6987-5, 9788324669875
• Data wydania: 2013-10-08
• Format: Ebook
• Identyfikator pozycji: csh5pr
• Wydawca: Helion