Wstęp

• Dla kogo jest ta książka? (32)
• Wiemy, o czym myślisz (33)
• Metapoznanie: myślenie o myśleniu (35)
• Zmuś swój mózg do posłuszeństwa (37)
• Czego potrzebujesz do tej książki? (38)
• Przeczytaj to (39)
• Grupa korektorów technicznych (40)
• Podziękowania (41)

Rozdział 1. Napisz coś fajnego, i to szybko!

• Dlaczego powinieneś uczyć się C# (44)
• C# oraz Visual Studio ułatwiają wiele czynności (45)
• Co robić w Visual Studio... (46)
• Co Visual Studio robi w naszym imieniu... (46)
• Obcy atakują! (50)
• Tylko Ty możesz uratować Ziemię (51)
• Oto co masz zamiar napisać (52)
• Zacznij od pustej aplikacji (54)
• Określ wymiary siatki na stronie (60)
• Dodaj kontrolki do siatki (62)
• Używaj właściwości, by zmieniać wygląd kontrolek (64)
• To kontrolki sprawiają, że gra działa (66)
• Stworzyłeś scenę, na której będzie prowadzona gra (71)
• Czym zajmiesz się teraz? (72)
• Dodaj metody, które coś zrobią (73)
• Podaj kod metody (74)
• Dokończ metodę i uruchom program (76)
• Oto co zrobiłeś do tej pory (78)
• Dodaj liczniki czasu zarządzające rozgrywką (80)
• Popraw działanie przycisku Start (82)
• Uruchom program, by zobaczyć postępy w pracy (83)
• Dodaj kod obsługujący interakcję użytkownika z kontrolkami (84)
• Dotknięcie człowiekiem wroga kończy grę (86)
• Teraz już można bawić się grą (87)
• Zadbaj, by wrogowie wyglądali jak obcy (88)
• Dodaj ekran startowy i tytuł (89)
• Opublikuj swoją aplikację (90)
• Użyj programu Remote Debugger, by uruchomić aplikację na innym komputerze (91)
• Rozpocznij zdalne debugowanie (92)

Rozdział 2. Pod maską

• Kiedy robisz to... (96)
• ...IDE robi to (97)
• Skąd się biorą programy (98)
• IDE pomaga Ci kodować (100)
• Anatomia programu (102)
• W tej samej przestrzeni nazw mogą być dwie klasy (107)
• Twoje programy używają zmiennych do pracy z danymi (108)
• C# używa znanych symboli matematycznych (110)
• Użyj debuggera, by zobaczyć, jak zmieniają się wartości zmiennych (111)
• Pętle wykonują czynność wielokrotnie (113)
• Instrukcje if/else podejmują decyzje (114)
• Utwórz aplikację od samego początku (115)
• Niech przycisk coś zrobi (117)
• Ustal warunki i sprawdź, czy są prawdziwe (118)
• Tworzenie klasycznych aplikacji Windows jest łatwe (129)
• Przepisz program jako klasyczną aplikację Windows (130)
• Twój program wie, gdzie zacząć (134)
• Możesz zmienić punkt wejścia programu (136)
• Kiedy zmieniasz coś w IDE, zmieniasz także swój kod (138)

Rozdział 3. Tworzenie kodu ma sens

• W jaki sposób Maciek myśli o swoich problemach (144)
• W jaki sposób system nawigacyjny w samochodzie Maćka rozwiązuje jego problemy (145)
• Klasa Navigator napisana przez Maćka posiada metody do ustalania i modyfikacji tras (146)
• Wykorzystaj to, czego się nauczyłeś, do napisania prostego programu używającego klas (147)
• Maciek ma pewien pomysł (149)
• Maciek może użyć obiektów do rozwiązania swojego problemu (150)
• Używasz klasy do utworzenia obiektu (151)
• Kiedy tworzysz obiekt na podstawie klasy, to taki obiekt nazywamy instancją klasy (152)
• Lepsze rozwiązanie... uzyskane dzięki obiektom! (153)
• Instancja używa pól do przechowywania informacji (158)
• Stwórzmy kilka instancji! (159)
• Dzięki za pamięć (160)
• Co Twój program ma na myśli (161)
• Możesz używać nazw klas i metod w celu uczynienia kodu bardziej intuicyjnym (162)
• Nadaj swojej klasie naturalną strukturę (164)
• Diagramy klas pozwalają w sensowny sposób zorganizować klasy (166)
• Utwórz klasę do pracy z kilkoma facetami (170)
• Utwórz projekt dla facetów (171)
• Utwórz formularz do interakcji z facetami (172)
• Jest jeszcze prostszy sposób inicjalizacji obiektów (175)

Rozdział 4. Jest 10:00. Czy wiesz, gdzie są Twoje dane?

• Typ zmiennej określa rodzaj danych, jakie zmienna może przechowywać (182)
• Zmienna jest jak kubek z danymi (184)
• 10 kilogramów danych w pięciokilogramowej torebce (185)
• Nawet wtedy, gdy liczba ma prawidłowy rozmiar, nie możesz przypisać jej do każdej zmiennej (186)
• Kiedy rzutujesz wartość, która jest zbyt duża, C# dopasowuje ją automatycznie (187)
• C# przeprowadza niektóre rzutowania automatycznie (188)
• Kiedy wywołujesz metodę, zmienne muszą pasować do typów parametrów (189)
• Przetestuj kalkulator zwrotu kosztów (193)
• Połączenie = z operatorem (194)
• Także obiekty używają zmiennych (195)
• Korzystaj ze swoich obiektów za pomocą zmiennych referencyjnych (196)
• Referencje są jak etykiety do Twoich obiektów (197)
• Jeżeli nie ma już żadnej referencji, Twoje obiekty są usuwane z pamięci (198)
• Referencje wielokrotne i ich efekty uboczne (199)
• Dwie referencje oznaczają DWA sposoby na zmianę danych obiektu (204)
• Specjalny przypadek: tablice (205)
• Tablice mogą także zawierać grupę zmiennych referencyjnych (206)
• Witamy w barze Niechlujny Janek - najtańsze kanapki w mieście! (207)
• Obiekty używają referencji do komunikacji między sobą (209)
• Tam, gdzie obiektów jeszcze nie było (210)
• Napisz grę w literki (215)
• Kontrolki to też obiekty, podobne do innych (219)

Laboratorium C# numer 1. Dzień na wyścigach

• Specyfikacja: stwórz symulator wyścigów (226)
• Końcowy produkt (234)

Rozdział 5. Co ma być ukryte... niech będzie ukryte

• Krystyna planuje przyjęcia (236)
• Co powinien robić program szacujący? (237)
• Napiszesz program dla Krystyny (238)
• Jazda próbna Krystyny (244)
• Każda opcja powinna być obliczana osobno (246)
• Bardzo łatwo przez przypadek źle skorzystać z obiektów (248)
• Hermetyzacja oznacza, że niektóre dane w klasie są prywatne (249)
• Użyj hermetyzacji w celu kontroli dostępu do metod i pól Twojej klasy (250)
• Ale czy jego prawdziwa tożsamość jest NAPRAWDĘ chroniona? (251)
• Dostęp do prywatnych pól i metod można uzyskać tylko z wnętrza klasy (252)
• Hermetyzacja utrzymuje Twoje dane w nieskazitelnym stanie (260)
• Właściwości sprawią, że hermetyzacja będzie łatwiejsza (261)
• Utwórz aplikację do przetestowania klasy Farmer (262)
• Użyj automatycznych właściwości do ukończenia klasy (263)
• Co wtedy, gdy chcemy zmienić pole mnożnika wyżywienia? (264)
• Użyj konstruktora do inicjalizacji pól prywatnych (265)

Rozdział 6. Drzewo genealogiczne Twoich obiektów

• Krystyna organizuje także przyjęcia urodzinowe (276)
• Potrzebujemy klasy BirthdayParty (277)
• Stwórz program Planista przyjęć w wersji 2.0 (278)
• Jeszcze jedna rzecz... Czy możesz dodać opłatę 100 zł za przyjęcia dla ponad 12 osób? (285)
• Kiedy klasy używają dziedziczenia, kod musi być napisany tylko raz (286)
• Zbuduj model klasy, rozpoczynając od rzeczy ogólnych i przechodząc do bardziej konkretnych (287)
• W jaki sposób zaprojektowałbyś symulator zoo? (288)
• Użyj dziedziczenia w celu uniknięcia powielania kodu w klasach potomnych (289)
• Różne zwierzęta wydają różne dźwięki (290)
• Pomyśl, w jaki sposób pogrupować zwierzęta (291)
• Stwórz hierarchię klas (292)
• Każda klasa pochodna rozszerza klasę bazową (293)
• Aby dziedziczyć po klasie bazowej, użyj dwukropka (294)
• Wiemy, że dziedziczenie dodaje pola, właściwości i metody klasy bazowej do klasy potomnej... (297)
• Klasa pochodna może przesłaniać odziedziczone metody w celu ich modyfikacji lub zmiany (298)
• W każdym miejscu, gdzie możesz skorzystać z klasy bazowej, możesz zamiast niej użyć jednej z jej klas pochodnych (299)
• Klasa pochodna może ukrywać metody klasy bazowej (306)
• Używaj override i virtual, by dziedziczyć zachowania (308)
• Klasa potomna może uzyskać dostęp do klasy bazowej, używając słowa kluczowego base (310)
• Jeśli Twoja klasa bazowa posiada konstruktor, klasa pochodna też musi go mieć (311)
• Teraz jesteś już gotowy do dokończenia zadania Krystyny (312)
• Stwórz system zarządzania ulem (317)
• Użyj dziedziczenia, aby rozszerzyć system zarządzania pszczołami (324)

Rozdział 7. Klasy, które dotrzymują swoich obietnic

• Wróćmy do pszczelej korporacji (330)
• Możemy użyć dziedziczenia do utworzenia klas dla różnych typów pszczół (331)
• Interfejs daje klasie do zrozumienia, że musi ona zaimplementować określone metody i właściwości (332)
• Użyj słowa kluczowego interface do zdefiniowania interfejsu (333)
• Teraz możesz utworzyć instancję NectarStinger, która będzie wykonywała dwa rodzaje zadań (334)
• Klasy implementujące interfejsy muszą zawierać WSZYSTKIE ich metody (335)
• Poćwicz trochę z interfejsami (336)
• Nie możesz utworzyć instancji interfejsu, ale możesz uzyskać jego referencję (338)
• Referencje interfejsów działają tak samo jak referencje obiektów (339)
• Za pomocą "is" możesz sprawdzić, czy klasa implementuje określony interfejs (340)
• Interfejsy mogą dziedziczyć po innych interfejsach (341)
• RoboBee 4000 może wykonywać zadania pszczół bez potrzeby spożywania cennego miodu (342)
• Ekspres do kawy także jest urządzeniem (344)
• Rzutowanie w górę działa w odniesieniu do obiektów i interfejsów (345)
• Rzutowanie w dół pozwala zamienić urządzenie z powrotem w ekspres do kawy (346)
• Rzutowanie w górę i w dół działa także w odniesieniu do interfejsów (347)
• Jest coś więcej niż tylko public i private (351)
• Modyfikatory dostępu zmieniają widoczność (352)
• Obiekty niektórych klas nigdy nie powinny być tworzone (355)
• Klasa abstrakcyjna jest jak skrzyżowanie klasy i interfejsu (356)
• Jak wspominaliśmy, obiekty niektórych klas nigdy nie powinny być tworzone (358)
• Metoda abstrakcyjna nie ma ciała (359)
• Piekielny diament śmierci (364)
• Polimorfizm oznacza, że jeden obiekt może przyjmować wiele różnych postaci (367)

Rozdział 8. Przechowywanie dużej ilości danych

• Łańcuchy znaków nie zawsze sprawdzają się przy kategoryzowaniu danych (386)
• Typy wyliczeniowe pozwalają Ci wyliczyć prawidłowe wartości (387)
• Typy wyliczeniowe pozwalają na reprezentowanie liczb za pomocą nazw (388)
• Z tablicami ciężko się pracuje (392)
• Listy ułatwiają przechowywanie kolekcji... czegokolwiek (393)
• Listy są bardziej elastyczne niż tablice (394)
• Listy kurczą się i rosną dynamicznie (397)
• Typy generyczne mogą przechowywać każdy typ (398)
• Inicjalizatory kolekcji działają tak samo jak inicjalizatory obiektu (402)
• Stwórzmy listę kaczek (403)
• Listy są proste, ale SORTOWANIE może być skomplikowane (404)
• IComparable pomoże Ci posortować listę kaczek (405)
• Użyj interfejsu IComparer, aby powiedzieć liście, jak ma sortować (406)
• Utwórz instancję obiektu porównującego (407)
• IComparer może wykonywać złożone porównania (408)
• Przesłonienie metody ToString() pozwala obiektom przedstawiać się (411)
• Zmień pętle foreach tak, by obiekty Duck i Card same się opisywały (412)
• Pisząc pętlę foreach, używasz IEnumerable (413)
• Używając IEnumerable, możesz rzutować całą listę w górę (414)
• Możesz tworzyć własne przeciążone metody (415)
• Użyj słownika do przechowywania kluczy i wartości (421)
• Wybrane funkcjonalności słownika (422)
• Napisz program korzystający ze słownika (423)
• I jeszcze WIĘCEJ typów kolekcji... (435)
• Kolejka działa według reguły: pierwszy przyszedł, pierwszy wyszedł (436)
• Stos działa według reguły: ostatni przyszedł, pierwszy wyszedł (437)

Rozdział 9. Zachowaj te bajty dla mnie!

• C# używa strumieni do zapisu i odczytu danych (442)
• Różne strumienie zapisują i odczytują różne rzeczy (443)
• FileStream odczytuje dane z pliku i zapisuje je w nim (444)
• W jaki sposób zapisać tekst do pliku w trzech prostych krokach (445)
• Kanciarz wymyślił nowy diabelski plan (446)
• Zapis i odczyt wymaga dwóch obiektów (449)
• Dane mogą przechodzić przez więcej niż jeden strumień (450)
• Użyj wbudowanych obiektów do wyświetlenia standardowych okien dialogowych (453)
• Okna dialogowe są kolejnymi kontrolkami .NET (454)
• Okna dialogowe także są obiektami (455)
• Używaj wbudowanych klas File oraz Directory do pracy z plikami i katalogami (456)
• Używaj okien dialogowych do otwierania i zapisywania plików (wszystko za pomocą kilku linijek kodu) (459)
• Dzięki IDisposable obiekty usuwane są prawidłowo (461)
• Unikaj błędów systemu plików, korzystając z instrukcji using (462)
• Zapisywanie danych do plików wymaga wielu decyzji (468)
• Użyj instrukcji switch do wybrania właściwej opcji (469)
• Dodaj przeciążony konstruktor Deck(), który wczytuje karty z pliku (471)
• Kiedy obiekt jest serializowany, serializowane są także wszystkie obiekty z nim powiązane... (475)
• Serializacja pozwala Ci zapisywać lub odczytywać całe grafy obiektów naraz (476)
• .NET automatycznie konwertuje tekst do postaci Unicode (481)
• C# może użyć tablicy bajtów do przesyłania danych (482)
• Do zapisywania danych binarnych używaj klasy BinaryWriter (483)
• Pliki utworzone dzięki serializacji można także zapisywać i odczytywać ręcznie (485)
• Sprawdź, gdzie pliki się różnią, i użyj tej informacji do ich zmiany (486)
• Praca z plikami binarnymi może być skomplikowana (487)
• Użyj strumieni plików do utworzenia widoku w postaci szesnastkowej (488)
• StreamReader i StreamWriter będą do tego odpowiednie (489)

Laboratorium C# numer 2. Wyprawa

• Specyfikacja: utwórz grę przygodową (496)
• Zabawa dopiero się zaczyna! (516)

Rozdział 10. Przenosząc swoje aplikacje na wyższy poziom

• Damian używa Windows 8 (518)
• Technologia Windows Forms korzysta z grafu obiektów stworzonego przez IDE (524)
• Użyj IDE do przejrzenia grafu obiektów (527)
• Aplikacje dla Sklepu Windows używają XAML do tworzenia obiektów interfejsu użytkownika (528)
• Przeprojektuj formularz Idź na ryby!, zmieniając go w aplikację dla Sklepu Windows (530)
• Określanie postaci strony rozpoczyna się od dodania kontrolek (532)
• Wiersze i kolumny mogą zmieniać wielkość, dostosowując się do rozmiarów strony (534)
• Skorzystaj z systemu siatki, by określić układ stron aplikacji (536)
• Wiązanie danych kojarzy strony XAML z klasami (542)
• Kontrolki XAML mogą zawierać tekst... i nie tylko (544)
• Użyj wiązania danych, by usprawnić aplikację Niechlujnego Janka (546)
• Korzystaj z zasobów statycznych, by deklarować obiekty w kodzie XAML (552)
• Wyświetlaj obiekty, używając szablonów danych (554)
• Interfejs INotifyPropertyChanged pozwala powiązanym obiektom przesyłać aktualizacje (556)
• Zmodyfikuj klasę MenuMaker, by informowała Cię, gdy zmieni się właściwość GeneratedDate (557)

Rozdział 11. Przepraszam, że przerywam

• Damian ma problemy z plikami (566)
• Aplikacje dla Sklepu Windows używają await, by błyskawicznie reagować (568)
• Używaj klasy FileIO do odczytywania i zapisywania plików (570)
• Napisz nieco mniej prosty edytor tekstów (572)
• Kontrakt danych jest abstrakcyjną definicją danych obiektu (577)
• Do odnajdywania i otwierania plików używaj metod asynchronicznych (578)
• Klasa KnownFolders ułatwia dostęp do najczęściej używanych folderów (580)
• W kodzie XML jest serializowany cały graf obiektów (581)
• Prześlij kilka obiektów Guy do lokalnego folderu aplikacji (582)
• Wypróbujmy działanie aplikacji (586)
• Używaj klasy Task, by wywoływać jedną metodę asynchroniczną w innej (587)
• Napisz dla Damiana nową aplikację do zarządzania wymówkami (588)
• Odrębna strona, wymówka i ExcuseManager (589)
• Utwórz stronę główną aplikacji Menedżera wymówek (590)
• Dodaj pasek aplikacji do strony głównej (591)
• Napisz klasę ExcuseManager (592)
• Dodaj kod obsługujący stronę (594)

Rozdział 12. Gaszenie pożarów nie jest już popularne

• Damian potrzebuje swoich wymówek, aby być mobilnym (600)
• Kiedy program zgłasza wyjątek, .NET tworzy obiekt Exception (604)
• Kod Damiana zrobił coś nieoczekiwanego (606)
• Wszystkie obiekty wyjątków dziedziczą po Exception (608)
• Debugger pozwala Ci wyśledzić wyjątki w kodzie i zapobiec im (609)
• Użyj debuggera wbudowanego w IDE, aby znaleźć problem w programie do zarządzania wymówkami (610)
• Oj, oj! - w kodzie dalej są błędy... (613)
• Obsłuż wyjątki za pomocą try i catch (615)
• Co się stanie, jeżeli wywoływana metoda będzie niebezpieczna? (616)
• Użyj debuggera do prześledzenia przepływu w blokach try/catch (618)
• Jeśli posiadasz kod, który ZAWSZE musi zostać wykonany, zastosuj finally (620)
• Użyj obiektu Exception w celu uzyskania informacji o problemie (625)
• Użyj więcej niż jednego bloku catch do wyłapania różnych typów wyjątków (626)
• Jedna klasa zgłasza wyjątek, inna klasa go przechwytuje (627)
• Łatwy sposób na uniknięcie licznych problemów: using umożliwia Ci stosowanie try i finally za darmo (631)
• Unikanie wyjątków: zaimplementuj IDisposable, aby przeprowadzić własne procedury sprzątania (632)
• Najgorszy z możliwych bloków catch: komentarze (634)
• Kilka prostych wskazówek dotyczących obsługi wyjątków (636)

Rozdział 13. Kapitan Wspaniały. Śmierć obiektu

• Twoją ostatnią szansą na ZROBIENIE czegoś... jest użycie finalizatora (646)
• Kiedy DOKŁADNIE wywoływany jest finalizator? (647)
• Dispose() działa z using, a finalizatory działają z mechanizmem oczyszczania pamięci (648)
• Finalizatory nie mogą polegać na stabilności (650)
• Spraw, aby obiekt serializował się w Dispose() (651)
• Struktura jest podobna do obiektu... (655)
• ...ale nie jest obiektem (655)
• Wartości są kopiowane, referencje są przypisywane (656)
• Struktury traktowane są jak typy wartościowe, obiekty jak typy referencyjne (657)
• Stos i sterta: więcej na temat pamięci (659)
• Używaj parametrów wyjściowych, by zwracać z metody więcej niż jedną wartość (662)
• Przekazuj referencje, używając modyfikatora ref (663)
• Używaj parametrów opcjonalnych, by określać wartości domyślne (664)
• Jeśli musisz używać wartości pustych, stosuj typy, które je akceptują (665)
• Typy akceptujące wartości puste poprawiają odporność programów (666)
• "Kapitan" Wspaniały... nie tak bardzo (669)
• Metody rozszerzające zwiększają funkcjonalność ISTNIEJĄCYCH klas (670)
• Rozszerzanie podstawowego typu: string (672)

Rozdział 14. Przejmij kontrolę nad danymi

• Janek jest superfanem Kapitana Wspaniałego... (678)
• ...ale jego kolekcja zajmuje każde wolne miejsce (679)
• Dzięki LINQ możesz pobrać dane z różnych źródeł (680)
• Kolekcje .NET są przystosowane do działania z LINQ (681)
• LINQ ułatwia wykonywanie zapytań (682)
• LINQ jest prosty, ale Twoje zapytania wcale takie być nie muszą (683)
• Janek chętnie skorzystałby z pomocy (686)
• Zacznij pisać aplikację dla Janka (688)
• Używaj słowa kluczowego new, by tworzyć typy anonimowe (691)
• LINQ ma wiele zastosowań (694)
• Dodaj nowe zapytania do aplikacji Janka (696)
• LINQ może połączyć Twoje wyniki w grupy (701)
• Połącz wartości Janka w grupy (702)
• Użyj join do połączenia dwóch kolekcji w jedną sekwencję (705)
• Janek zaoszczędził mnóstwo szmalu (706)
• Użyj semantycznego powiększenia, aby przejść do danych (712)
• Dodaj zoom semantyczny do aplikacji Janka (714)
• Zrobiłeś na Janku wielkie wrażenie (719)
• Szablon Split App ułatwia tworzenie aplikacji służących do przeglądania danych (720)

Rozdział 15. Co robi Twój kod, kiedy nie patrzysz

• Czy kiedykolwiek marzyłeś o tym, aby Twoje obiekty potrafiły samodzielnie myśleć? (730)
• Ale skąd obiekt WIE, że ma odpowiedzieć? (730)
• Kiedy wystąpi ZDARZENIE... obiekty nasłuchują (731)
• Jeden obiekt wywołuje zdarzenie, inne nasłuchują... (732)
• Potem inne obiekty obsługują zdarzenie (733)
• Łącząc punkty (734)
• IDE automatycznie tworzy za Ciebie procedury obsługi zdarzeń (738)
• Ogólny typ EventHandler pozwala definiować własne typy zdarzeń (744)
• Formularze używają wielu różnych zdarzeń (745)
• Jedno zdarzenie, wiele procedur obsługi (746)
• Aplikacje dla Sklepu Windows używają zdarzeń do zarządzania cyklem życia procesu (748)
• Dodaj zarządzanie cyklem życia procesu do aplikacji Janka (749)
• Kontrolki XAML korzystają ze zdarzeń trasowanych (752)
• Utwórz aplikację do badania zdarzeń trasowanych (753)
• Połączenie nadawców zdarzenia z jego odbiorcami (758)
• Delegat ZASTĘPUJE właściwą metodę (759)
• Delegat w akcji (760)
• Każdy obiekt może subskrybować publiczne zdarzenie... (763)
• Użyj funkcji zwrotnej, by wiedzieć, kto nasłuchuje (764)
• Funkcje zwrotne są jedynie sposobem używania delegatów (766)
• Możesz używać funkcji zwrotnych w oknach dialogowych MessageDialog (768)
• Użyj delegatów, by skorzystać z panelu Ustawienia (770)

Rozdział 16. Świetne aplikacje od zewnątrz i od środka

• Liga "Koszykówka. Rusz głową" potrzebuje swojej aplikacji (774)
• Jednak czy wszyscy uzgodnią, jak napisać tę aplikację? (775)
• Czy projektujesz pod kątem wiązania danych, czy łatwości pracy z danymi? (776)
• Wzorzec MVVM pozwala projektować, uwzględniając zarówno wiązanie, jak i dane (777)
• Użyj wzorca MVVM, by rozpocząć tworzenie aplikacji dla ligi koszykówki (778)
• Kontrolki użytkownika pozwalają tworzyć swoje własne kontrolki (781)
• Sędziowie potrzebują stopera (789)
• Wzorzec MVVM oznacza myślenie o stanie aplikacji (790)
• Zacznij tworzenie modelu aplikacji stopera (791)
• Zdarzenia ostrzegają resztę aplikacji o zmianie stanu (792)
• Utwórz widok prostej aplikacji stopera (793)
• Dodaj model widoku aplikacji stopera (794)
• Konwertery automatycznie konwertują wartości na potrzeby powiązań (798)
• Konwertery mogą operować na wielu różnych typach danych (800)
• Stan wizualny sprawia, że kontrolki odpowiadają na zmiany (806)
• Używaj DoubleAnimation, by animować wartości zmiennoprzecinkowe (807)
• Używaj animacji obiektów do animowania wartości obiektów (808)
• Stwórz stoper wskazówkowy, używając tego samego modelu widoku (809)
• Kontrolki interfejsu użytkownika można także tworzyć w kodzie C# (814)
• C# pozwala także na tworzenie "prawdziwych" animacji (816)
• Użyj kontrolki użytkownika, by wyświetlać rysunki tworzące animację (817)
• Niech Twoje pszczoły latają po stronie (818)
• Użyj ItemsPanelTemplate, by powiązać pszczoły z kontrolką Canvas (821)
• Gratulujemy! (Choć jeszcze nie skończyłeś...) (834)

Laboratorium C# numer 3. Invaders

• Dziadek wszystkich gier (836)
• Można zrobić znacznie więcej... (857)

Rozdział 17. Napisz aplikację Windows Phone

• Atak pszczół! (860)
• Zanim zaczniesz... (861)

Dodatek A. 11 najważniejszych rzeczy, które chcieliśmy umieścić w tej książce

• 1. Na temat aplikacji dla Sklepu Windows można dowiedzieć się znacznie więcej (874)
• 2. Podstawy (876)
• 3. Przestrzenie nazw i złożenia (882)
• 4. Użyj BackgroundWorker, by poprawić działanie interfejsu użytkownika (886)
• 5. Klasa Type oraz metoda GetType() (889)
• 6. Równość, IEquatable oraz Equals() (890)
• 7. Stosowanie yield return do tworzenia obiektów umożliwiających iterację (893)
• 8. Refaktoryzacja (896)
• 9. Anonimowe typy i metody oraz wyrażenia lambda (898)
• 10. Zastosowanie LINQ to XML (900)
• 11. Windows Presentation Foundation (902)
• Czy wiesz, że C# i .NET Framework potrafią... (903)

Skorowidz (905)

• Tytuł: C#. Rusz głową! Wydanie III
• Autor: Jennifer Greene, Andrew Stellman
• Tytuł oryginału: Head First C#, 3rd Edition
• Tłumaczenie: Piotr Rajca
• ISBN: 978-83-246-8312-3, 9788324683123
• Data wydania: 2014-08-18
• Format: Ebook
• Identyfikator pozycji: cshru3
• Wydawca: Helion