Wstęp (13)

1. Prezentacja C# (19)

• Dlaczego C#? Dlaczego .NET? (19)
• Biblioteka klas platformy .NET (20)
• Styl języka (21)
  • Łatwość konstruowania oprogramowania (22)
  • Kod zarządzany (23)
  • Ciągłość i "ekosystem" Windows (24)
• C# 4.0, .NET 4.0 oraz Visual Studio 2010 (25)
• Podsumowanie (27)

2. Podstawowe techniki programowania (29)

• Początki (29)
• Przestrzenie nazw i typy (32)
• Projekty i solucje (37)
• Komentarze, regiony oraz czytelność (42)
  • Nieprawidłowe komentarze (43)
  • Komentarze dokumentujące XML (44)
• Zmienne (45)
  • Typy zmiennych (46)
• Wyrażenia i instrukcje (52)
  • Instrukcje przypisania (55)
  • Operatory inkrementacji i dekrementacji (55)
• Instrukcje sterowania przepływem i wyboru (56)
  • Instrukcje if (58)
  • Instrukcje switch oraz case (62)
• Instrukcje iteracji (64)
  • Instrukcje foreach (65)
  • Instrukcje for (67)
  • Instrukcje while oraz do (69)
  • Przerywanie wykonywania pętli (70)
• Metody (71)
• Podsumowanie (74)

3. Wyodrębnianie idei przy wykorzystaniu klas i struktur (77)

• Dziel i rządź (77)
  • Wyodrębnianie idei w formie metod (77)
  • Wyodrębnianie idei przy użyciu obiektów i klas (80)
• Definiowanie klas (81)
  • Reprezentowanie stanu przy użyciu właściwości (82)
  • Poziomy ochrony (84)
  • Inicjalizacja przy użyciu konstruktora (86)
  • Pola: miejsca do zapisywania danych (90)
  • Pola mogą się zmieniać, lecz stałe nie (92)
  • Pola i właściwości tylko do odczytu (93)
• Typ enum - powiązane ze sobą stałe (96)
• Typy wartościowe i referencyjne (100)
• Zbyt wiele konstruktorów, Panie Mozart (105)
• Przeciążanie (105)
  • Metody przeciążone oraz domyślne parametry nazwane (106)
• Inicjalizatory obiektów (108)
• Definiowanie metod (112)
  • Deklarowanie metod statycznych (115)
• Pola i właściwości statyczne (116)
  • Konstruktory statyczne (117)
• Podsumowanie (119)

4. Rozszerzalność i polimorfizm (121)

• Tworzenie asocjacji poprzez kompozycję i agregację (122)
• Dziedziczenie i polimorfizm (124)
• Zastępowanie metod w klasach pochodnych (126)
  • Ukrywanie składowych klasy bazowej przy użyciu new (127)
  • Zastępowanie metod przy użyciu modyfikatorów virtual i override (129)
• Dziedziczenie i ochrona (132)
• Wywoływanie metod klasy bazowej (134)
• Dotąd i ani kroku dalej: modyfikator sealed (136)
• Wymuszanie przesłaniania - metody abstrakcyjne (138)
• Wszystkie typy dziedziczą po klasie Object (144)
  • Pakowanie i rozpakowywanie typów wartościowych (144)
• C# nie obsługuje wielokrotnego dziedziczenia implementacji (149)
• C# obsługuje wielokrotne dziedziczenie interfejsów (149)
• Tworzenie jednych interfejsów na bazie innych (152)
  • Jawna implementacja interfejsów (153)
• Ostateczne rozwiązanie: sprawdzanie typów podczas wykonywania programu (157)
• Podsumowanie (158)

5. Delegacje - łatwość komponowania i rozszerzalność (159)

• Kompozycja funkcyjna wykorzystująca delegacje (166)
• Typ Action - akcje ogólne (172)
• Predicate - predykaty ogólne (175)
• Stosowanie metod anonimowych (177)
• Tworzenie delegacji przy użyciu wyrażeń lambda (178)
• Delegacje we właściwościach (180)
• Ogólne delegacje do funkcji (182)
• Informowanie klientów za pomocą zdarzeń (186)
  • Udostępnianie dużej liczby zdarzeń (194)
• Podsumowanie (197)

6. Obsługa błędów (199)

• Kiedy i jak uznać niepowodzenie (204)
• Zwracanie kodu błędu (207)
  • Debugowanie wartości zwracanych (213)
• Wyjątki (214)
  • Obsługa wyjątków (219)
  • Kiedy są wykonywane bloki finally? (226)
  • Określanie, jakie wyjątki będą przechwytywane (227)
  • Wyjątki niestandardowe (230)
• Podsumowanie (232)

7. Tablice i listy (233)

• Tablice (233)
  • Tworzenie i inicjalizacja (234)
  • Własne typy w tablicach (237)
  • Składowe tablic (242)
  • Wielkość tablic (247)
• List (254)
  
   
  • Niestandardowe indeksatory (257)
  • Wyszukiwanie i sortowanie (264)
• Kolekcje i polimorfizm (264)
  • Tworzenie własnych implementacji IEnumerable (268)
• Podsumowanie (274)

8. LINQ (275)

• Wyrażenia zapytań (275)
  • Wyrażenia zapytań a wywołania metod (277)
  • Metody rozszerzeń a LINQ (278)
  • Klauzule let (280)
• Koncepcje i techniki LINQ (281)
  • Delegacje i wyrażenia lambda (281)
  • Styl funkcyjny i kompozycja (283)
  • Wykonywanie opóźnione (284)
• Operatory LINQ (285)
  • Filtrowanie (285)
  • Porządkowanie (286)
  • Konkatenacja (289)
  • Grupowanie (289)
  • Projekcje (291)
  • Spinanie (298)
  • Robimy się wybredni (299)
  • Testowanie całej kolekcji (300)
  • Agregacja (302)
  • Operacje na zbiorach (304)
  • Łączenie (304)
  • Konwersje (305)
• Podsumowanie (306)

9. Klasy kolekcji (307)

• Słowniki (307)
  • Popularne zastosowania słowników (309)
  • IDictionary (315)
  • Słowniki i LINQ (317)
• HashSet oraz SortedSet (318)
• Kolejki (319)
• Listy połączone (320)
• Stosy (321)
• Podsumowanie (322)

10. Łańcuchy znaków (323)

• Czym są łańcuchy znaków? (324)
• Typy String i Char (325)
• Literały łańcuchowe i znakowe (326)
  • Oznaczanie znaków specjalnych (327)
• Formatowanie wyświetlanych danych (330)
  • Standardowe łańcuchy formatowania liczb (331)
  • Niestandardowe łańcuchy formatujące (337)
  • Daty i godziny (340)
  • W drugą stronę - konwersja łańcuchów na dane innych typów (343)
  • Złożone formatowanie przy użyciu metody String.Format (345)
• Wrażliwość na ustawienia kulturowe (346)
  • Poznawanie reguł formatowania (348)
• Uzyskiwanie dostępu do znaków na podstawie indeksów (349)
• Łańcuchy znaków są niezmienne (349)
• Pobieranie ciągu znaków (351)
• Składanie łańcuchów znaków (352)
  • Ponowne dzielenie łańcuchów (354)
  • Wielkie i małe litery (355)
• Operacje na tekście (356)
  • StringBuilder - modyfikowalne łańcuchy znaków (357)
• Odnajdywanie i zastępowanie łańcuchów (361)
• Wszelkiego typu "puste" łańcuchy znaków (362)
• Usuwanie białych znaków (365)
• Sprawdzanie typu znaków (368)
• Kodowanie znaków (368)
  • Dlaczego kodowanie ma znaczenie (370)
  • Kodowanie i dekodowanie (371)
  • Po co reprezentować łańcuchy w formie sekwencji bajtów? (378)
• Podsumowanie (378)

11. Pliki i strumienie (379)

• Sprawdzanie katalogów i plików (379)
• Badanie katalogów (382)
• Operacje na ścieżkach (383)
  • Ścieżka i aktualny katalog roboczy (384)
• Zdobywanie informacji o pliku (385)
• Tworzenie plików tymczasowych (388)
• Usuwanie plików (389)
• Powszechnie znane katalogi (390)
• Bezpieczne łączenie elementów ścieżek (393)
• Tworzenie i zabezpieczanie hierarchii katalogów (394)
• Usuwanie katalogu (401)
• Zapis plików tekstowych (402)
  • Zapis całego pliku tekstowego w jednym wywołaniu (402)
  • Zapis tekstu przy użyciu klasy StreamWriter (403)
• Gdy pliki schodzą na złą drogę: obsługa wyjątków (406)
  • Określanie i modyfikacja uprawnień (410)
• Wczytywanie plików do pamięci (414)
• Strumienie (418)
  • Poruszanie się wewnątrz strumienia (424)
  • Zapis danych przy użyciu strumieni (425)
• Odczyt, zapis i blokowanie plików (426)
• Konstruktory klasy FileStream (428)
  • Bufory strumieni (428)
  • Określanie uprawnień podczas tworzenia strumieni (429)
  • Opcje zaawansowane (429)
• Asynchroniczne operacje na plikach (430)
• Mechanizm Isolated Storage (433)
  • Magazyny (434)
  • Zapis i odczyt tekstu (435)
  • Definicja izolowania (436)
  • Zarządzanie magazynami użytkownika przy użyciu limitów (440)
  • Zarządzanie magazynami (441)
• Strumienie, które nie są plikami (444)
  • Strumień adaptujący - CryptoStream (447)
  • Wszystko w pamięci - MemoryStream (448)
  • Reprezentowanie danych binarnych jako tekstu przy użyciu kodowania Base64 (449)
• Podsumowanie (452)

12. XML (453)

• Podstawy XML (krótki przegląd) (453)
  • Elementy (453)
  • XHTML (455)
• Litera "X" oznacza "rozszerzalny" (eXtensible) (456)
• Tworzenie dokumentów XML (456)
  • Elementy XML (459)
  • Atrybuty XML (460)
  • Umieszczanie kodu LINQ w LINQ to XML (463)
• Przeszukiwanie kodu XML za pomocą LINQ (464)
  • Wyszukiwanie pojedynczego węzła (467)
  • Osie wyszukiwania (468)
  • Klauzule where (469)
• Serializacja XML (469)
  • Dostosowywanie serializacji XML za pomocą atrybutów (472)
• Podsumowanie (473)

13. Sieci (475)

• Wybór technologii sieciowej (475)
  • Aplikacja WWW z kodem klienta (476)
  • Klient .NET i serwer .NET (480)
  • Klient .NET i usługa WWW pochodząca z zewnątrz (482)
  • Klient zewnętrzny i usługa WWW .NET (483)
• Platforma WCF (483)
  • Tworzenie projektu WCF (483)
  • Kontrakty WCF (484)
  • Testowy host i klient WCF (486)
  • Udostępnianie usługi WCF (489)
  • Pisanie klienta WCF (496)
  • Dwukierunkowa komunikacja z dwustronnymi kontraktami (504)
• Protokół HTTP (513)
  • Klient WWW (514)
  • Klasy WebRequest i WebResponse (518)
• Gniazda (525)
  • Protokoły IP, IPv6 oraz TCP (526)
  • Łączenie się z usługami za pomocą klasy Socket (531)
  • Implementowanie usług za pomocą klasy Socket (535)
• Inne możliwości związane z siecią (540)
• Podsumowanie (540)

14. Bazy danych (541)

• Krajobraz możliwości dostępu do danych w ramach platformy .NET (541)
  • Klasyczny mechanizm ADO.NET (542)
  • LINQ i bazy danych (546)
  • Technologie dostępu do danych nieopracowane przez firmę Microsoft (548)
  • WCF Data Services (548)
  • Technologia Silverlight i dostęp do danych (549)
  • Bazy danych (550)
• Model encji danych (551)
  • Wygenerowany kod (555)
  • Zmiana odwzorowywania (557)
  • Związki (558)
  • Dziedziczenie (565)
• Zapytania (566)
  • LINQ to Entities (566)
  • Entity SQL (570)
  • Mieszanie języków ESQL oraz LINQ (573)
  • Dostawca ADO.NET EntityClient (574)
• Kontekst obiektu (574)
  • Obsługa połączenia (574)
  • Tworzenie, aktualizowanie i usuwanie (577)
  • Transakcje (579)
  • Optymistyczna współbieżność (584)
  • Czas życia kontekstu i encji (586)
• WCF Data Services (587)
• Podsumowanie (591)

15. Podzespoły (593)

• Komponenty .NET - podzespoły (593)
  • Odwołania (594)
  • Pisanie bibliotek (597)
  • Ochrona (599)
• Nazwy (602)
  • Podpisywanie i silne nazwy (603)
• Ładowanie (605)
  • Ładowanie z folderu aplikacji (606)
  • Ładowanie z bufora GAC (606)
  • Ładowanie z pliku Silverlight o rozszerzeniu xap (607)
  • Jawne ładowanie (607)
• Podsumowanie (609)

16. Wątki i kod asynchroniczny (611)

• Wątki (613)
  • Wątki i systemowy mechanizm szeregujący (615)
  • Stos (617)
  • Pula wątków (624)
  • Powinowactwo oraz kontekst wątków (625)
  • Popularne błędne opinie dotyczące wątków (627)
  • Tworzenie kodu wielowątkowego jest trudne (634)
  • Strategie tworzenia kodu wielowątkowego (637)
• Podstawowe narzędzia synchronizacji (638)
  • Monitor (639)
  • Inne typy blokad (649)
  • Inne mechanizmy synchronizacji (653)
  • Zdarzenia (653)
  • Odliczanie (654)
• Programowanie asynchroniczne (655)
  • Model programowania asynchronicznego (656)
  • Programowanie asynchroniczne bazujące na zdarzeniach (659)
  • Doraźne operacje asynchroniczne (660)
• Task Parallel Library (661)
  • Zadania (661)
  • Obsługa anulowania (668)
  • Obsługa błędów (669)
• Równoległość danych (671)
  • Metody Parallel.For oraz Parallel.ForEach (671)
  • PLINQ - równoległe LINQ (673)
• Podsumowanie (674)

17. Atrybuty i odzwierciedlanie (675)

• Atrybuty (675)
  • Typy atrybutów (676)
  • Własne atrybuty (677)
• Odzwierciedlanie (681)
  • Badanie metadanych (681)
  • Odkrywanie typów (683)
  • Odzwierciedlanie na rzecz określonego typu (684)
  • Późne wiązanie (686)
• Podsumowanie (689)

18. Typ dynamic (691)

• Styl statyczny kontra styl dynamiczny (691)
  • Styl dynamiczny i automatyzacja COM (693)
• Typ dynamic (694)
  • Typy obiektów i słowo dynamic (697)
• Typ dynamic w zastosowaniach niezwiązanych z interoperacyjnością? (707)
• Podsumowanie (710)

19. Współdziałanie z COM i Win32 (711)

• Importowanie kontrolek ActiveX (711)
  • Importowanie kontrolek do projektów .NET (712)
• Podzespoły współdziałania (714)
  • Bez PIA (716)
• 64 czy 32 bity? (717)
• Mechanizm P/Invoke (720)
• Wskaźniki (724)
• Rozszerzenia składni C# 4.0 (729)
  • Właściwości indeksowane (729)
  • Opcjonalny modyfikator ref (730)
• Podsumowanie (731)

20. WPF i Silverlight (733)

• XAML i kod ukryty (735)
  • XAML i obiekty (739)
• Elementy i kontrolki (742)
  • Panele układów (743)
  • Elementy graficzne (752)
  • Kontrolki (759)
  • Kontrolki użytkownika (763)
• Szablony kontrolek (765)
  • Style (767)
  • Menedżer stanu wizualnego (769)
• Wiązanie danych (771)
  • Szablony danych (773)
• Podsumowanie (776)

21. Tworzenie aplikacji w ASP.NET (777)

• Podstawy technologii Web Forms (777)
  • Zdarzenia formularzy sieciowych (779)
  • Cykl życia stron w technologii Web Forms (780)
• Tworzenie aplikacji internetowych (781)
  • Pliki kodu ukrytego (782)
  • Dodawanie kontrolek (783)
  • Kontrolki serwerowe (785)
• Wiązanie danych (786)
  • Sprawdzanie kodu (789)
  • Dodawanie kontrolek i formularzy (792)
• Podsumowanie (796)

22. Windows Forms (797)

• Tworzenie aplikacji (798)
  • Dodawanie źródła wiązania (799)
• Kontrolki (801)
  • Dokowanie i kotwiczenie (806)
• Wiązanie danych (808)
• Obsługa zdarzeń (813)
• Podsumowanie (814)

Skorowidz (817)

• Titel: C#. Programowanie. Wydanie VI
• Autor: Ian Griffiths, Matthew Adams, Jesse Liberty
• Originaler Titel: Programming C# 4.0: Building Windows, Web, and RIA Applications for the .NET 4.0 Framework
• Übersetzung: Piotr Rajca, Łukasz Suma
• ISBN: 978-83-246-5694-3, 9788324656943
• Veröffentlichungsdatum: 2012-10-22
• Format: E-book
• Artikelkennung: cshpr6
• Verleger: Helion