• Poznaj elementy języka i zasady programowania obiektowego.
• Wykorzystaj możliwości platformy .NET.
• Napisz i uruchom własne aplikacje.

C# to jeden z języków programowania wchodzących w skład platformy .NET. Według założeń producenta -- firmy Microsoft -- ma stanowić podstawowe narzędzie programistyczne dla tej platformy. C#, łączący w sobie najlepsze cechy języków Visual Basic, C++ i Java, jest łatwy do opanowania, a daje ogromne możliwości. Oparty na komponentach i obiektach doskonale nadaje się zarówno do tworzenia aplikacji dla komputerów osobistych, jak i dla urządzeń typu PocketPC. Twórcy aplikacji w C# mogą wybierać między doskonałym środowiskiem Visual Studio .NET a kilkoma narzędziami dostępnymi na licencji open-source.

Książka "Język C#. Szkoła programowania" to podręcznik, który wprowadzi Cię w arkana sztuki pisania programów w tym języku. Poznasz elementy języka C# i dowiesz się, na czym polega programowanie obiektowe. Nauczysz się korzystać z zaawansowanych możliwości oferowanych przez technologię obiektową, takich jak polimorfizm, interfejsy i struktury. Przeczytasz tu także o obsłudze wyjątków, tworzeniu dokumentacji w formacie XML w oparciu o komentarze w kodzie oraz o operacjach wejścia i wyjścia na plikach.

• Kompilowanie i uruchamianie programów w C#
• Typy i operatory
• Instrukcje warunkowe i pętle
• Tablice
• Klasy i obiekty
• Dziedziczenie
• Obsługa zdarzeń
• Rekurencja

Spis treści:

Rozdział 1. Komputery i ich programowanie - podstawowe pojęcia (29)

• C# - obiektowy język programowania (31)
  • Organizacja komputera (32)
• Sprzęt (32)
  • Właściwości pamięci operacyjnej (34)
  • Systemy liczbowe (36)
  • Bajty (37)
  • Pliki (38)
• Oprogramowanie (38)
  • Ogólny proces wykonywania programu C# (38)
  • System operacyjny (39)
  • Języki programowania i kompilatory (40)
  • Wprowadzenie do .NET (41)
  • Kompilacja kodu źródłowego C# w .NET (42)
• Podsumowanie (45)
• Pytania kontrolne (46)

Rozdział 2. Twój pierwszy program C# (47)

• Rozwój oprogramowania (48)
• Proces tworzenia oprogramowania (48)
• Algorytmy i pseudokod (50)
• Trzy rodzaje błędów (53)
• Programowanie obiektowe - pierwsze spotkanie (54)
  • Programowanie procesowe i jego wrodzone problemy (55)
  • Programowanie obiektowe i jego zalety (55)
• Ponowne wykorzystanie oprogramowania (60)
• Zestaw, podstawowa jednostka ponownego wykorzystania kodu w .NET (62)
  • Punkt widzenia programisty (63)
  • Punkt widzenia użytkownika (64)
• Biblioteka klas środowiska .NET Framework (66)
• C# - historia i cele projektowania (67)
• Pochodzenie C# (67)
• Cele utworzenia C# (70)
• Jakiego rodzaju programy można pisać za pomocą C#? (71)
• Mechanizmy tworzenia programu C# (73)
• Przed rozpoczęciem (74)
• Wybór edytora tekstu (75)
• Siedem kroków do napisania prostego programu C# (75)
  • Otwieranie i używanie konsoli poleceń (krok 1.) (76)
  • Wpisywanie i zapisywanie kodu źródłowego C# (krok 2.) (77)
  • Przekształcanie kodu źródłowego w plik PE (.exe) (krok 3.) (80)
  • Jeżeli kompilator wykryje błędy składniowe (krok 4.) (80)
  • Uruchamianie programu (krok 5.) (81)
  • Sprawdzanie wyników (krok 6.) (82)
  • Czas na świętowanie (krok 7.) (82)
• Krótka analiza kodu źródłowego (82)
• Uwaga o błędach składniowych i kompilatorach (83)
• Podsumowanie (84)
• Pytania kontrolne (85)
• Ćwiczenia z programowania (86)

Rozdział 3. C# - wycieczka z przewodnikiem, część I (87)

• Wstęp (88)
• Abstrakcja i hermetyzacja (88)
  • Abstrakcja (88)
  • Hermetyzacja (90)
  • Uwaga o uczeniu się programowania obiektowego (96)
• Program interakcyjny Hello World! (97)
  • Treść Hello.cs (97)
  • Podstawowe elementy Hello.cs (100)
  • Kilka podstawowych spostrzeżeń (113)
• Podsumowanie (118)
• Pytania kontrolne (119)
• Ćwiczenia z programowania (120)

Rozdział 4. C# - wycieczka z przewodnikiem, część II (123)

• Wstęp (123)
• Zasadnicze elementy SimpleCalculator.cs (124)
  • Prezentacja SimpleCalculator.cs (124)
  • Bliższe spojrzenie na SimpleCalculator.cs (126)
• Upraszczanie kodu za pomocą metod (139)
• Metody jako budowanie bloków - hermetyzacja metod pomocniczych za pomocą słowa kluczowego private (140)
• Podsumowanie (142)
• Pytania kontrolne (143)
• Ćwiczenia z programowania (144)

Rozdział 5. Twój pierwszy program obiektowy w C# (145)

• Wstęp (146)
• Struktura leksykalna (146)
  • Identyfikatory i style stosowania wielkich liter (146)
  • Literały (147)
  • Komentarze i dokumentacja kodu źródłowego (148)
  • Separatory (148)
  • Operatory (149)
  • Słowa kluczowe (150)
• Pewne przemyślenia na temat symulacji windy (150)
• Pojęcia, cele i rozwiązania w programie symulacji windy - zbieranie cennych danych statystycznych do oceny systemu wind (150)
  
• Programowanie obiektowe - przykład praktyczny (152)
  • Prezentacja SimpleElevatorSimulation.cs (153)
  • Ogólna struktura programu (156)
  • Głębsza analiza SimpleElevatorSimulation.cs (159)
  • Związki klas i UML (170)
• Podsumowanie (174)
• Pytania kontrolne (175)
• Ćwiczenia z programowania (175)

Rozdział 6. Typy, część I - typy proste (177)

• Wstęp (178)
• Typy w C# - przegląd (178)
  • Co to jest typ? (179)
  • Język z silną kontrolą typów (179)
  • Zalety typów (182)
  • Typy w C# (183)
• Typy proste (189)
  • Przegląd typów prostych (191)
  • Typy liczb całkowitych (196)
• Zegar Blipos (212)
  • Typy zmiennoprzecinkowe (222)
  • Typ decimal (229)
  • Zgodność wartości zmiennoprzecinkowych, decimal i całkowitoliczbowych (231)
  • Jawne konwersje typów (231)
  • Stałe - nazwy symboliczne dla literałów (233)
  • Formatowanie wartości liczbowych (237)
  • Typ bool - krótkie omówienie (240)
• Podsumowanie (241)
• Pytania kontrolne (243)
• Ćwiczenia z programowania (244)

Rozdział 7. Typy, część II - operatory, wyliczenia i łańcuchy znakowe (245)

• Wstęp (246)
• Operatory arytmetyczne i wyrażenia arytmetyczne (246)
  • Operatory dwuargumentowe (247)
• Asocjacyjność (251)
• Nawiasy i pierwszeństwo (252)
• Operator modulo (%) (254)
• Operatory jednoargumentowe (259)
  • Jednoargumentowy plus i jednoargumentowy minus (260)
  • Operatory inkrementacji i dekrementacji (261)
• Określanie typu wyrażenia (265)
  • Konwersje i operatory jednoargumentowe plus lub minus (266)
• Łączenie różnych typów w jednym wyrażeniu (268)
• Dostęp do metadanych komponentu - krótkie wprowadzenie (272)
• Stałe wyliczeniowe (277)
• Operatory dla zmiennych wyliczanych (281)
• Konwersje (282)
• Metody typu System.Enum (282)
• Znaki i tekst (283)
• Typ char (283)
  • Podwójne życie char (286)
• Typ string (287)
  • Literały i obiekty typu string (288)
  • Łańcuchy dosłowne (289)
  • Praca z łańcuchami (289)
  • Wstawianie sformatowanych liczb do łańcucha (294)
  • Praca z łańcuchami (298)
• Podsumowanie (316)
• Pytania kontrolne (317)
• Ćwiczenia z programowania (318)

Rozdział 8. Sterowanie, część I - instrukcje warunkowe i pojęcia pokrewne (321)

• Wprowadzenie do sterowania przebiegiem (322)
• Rozgałęzianie za pomocą instrukcji if (324)
  • Prosta instrukcja if (324)
  • Instrukcje złożone (327)
  • Opcjonalny warunek else (327)
• Operatory porównania i wyrażenia logiczne (330)
• Zagnieżdżone instrukcje if (334)
• Instrukcje if-else o wielu gałęziach (339)
• Operatory logiczne (344)
  • Operator logiczny AND (I) - && (346)
  • Operator logiczny OR (LUB) - || (350)
  • Skrócone wyznaczanie wartości wyrażeń i operatory na poziomie bitowym, & oraz | (352)
  • Operator na poziomie bitowym Exclusive OR (alternatywa wykluczająca) - ^ (354)
  • Operator logiczny NOT (NIE) - ! (355)
• Zakres zmiennych (358)
  • Zakres i czas życia zmiennych (361)
• Instrukcja goto (362)
• Instrukcja switch (364)
  • Zasada 1. (369)
  • Zasada 2. (370)
  • Zasada 3. (373)
  • Zasada 4. (376)
  • Praca z instrukcjami switch (376)
• Operator warunkowy (378)
• Podsumowanie (379)
• Pytania kontrolne (380)
• Ćwiczenia z programowania (382)

Rozdział 9. Sterowanie, część II - instrukcje iteracyjne (383)

• Przeglądanie, analiza i generowanie sekwencji danych (385)
• Instrukcja sterująca (pętla) while (386)
• Instrukcja pętli do-while (390)
• Instrukcja pętli for (394)
• Instrukcje sterujące break i continue (402)
  • Instrukcja break (402)
  • Instrukcja continue (404)
• Programowanie strukturalne i konstrukcje strukturalne (405)
• Operatory połączonego przypisania (409)
• Zagnieżdżone instrukcje iteracyjne (410)
• Ćwiczenia z programowania (418)
• Podsumowanie (420)
• Pytania kontrolne (421)
• Ćwiczenia z programowania (423)

Rozdział 10. Tablice, część I - podstawy (425)

• Deklarowanie i definiowanie tablicy (427)
• Uzyskiwanie dostępu do poszczególnych elementów tablicy (432)
• Przekroczony zakres indeksu (438)
• Wprowadzanie poprawki na indeks tabeli zaczynający się od zera (442)
• Inicjowanie tablicy (443)
• Przemierzanie całej tablicy za pomocą instrukcji foreach (445)
• System.Array jest typem referencyjnym (447)
• Tablice i równość (450)
• Tablice i metody (453)
  • Elementy tablic jako argumenty metod (453)
  • Referencje do tablic jako argumenty metod (455)
  • Klonowanie obiektu tablicy (458)
• Metoda wykonywania porównania tablic w sensie równości wartości (463)
• Argumenty wiersza poleceń (465)
• Używanie tablic jako wartości zwracanych przez metody (467)
  • Tablice i klasy (472)
• Elementy tablicy odnoszące się do obiektów (472)
• Tablice jako zmienne instancji w klasach (476)
  • Studium - program symulacji banku (478)
• Podsumowanie (486)
• Pytania kontrolne (488)
• Ćwiczenia z programowania (490)

Rozdział 11. Tablice, część II - tablice wielowymiarowe, przeszukiwanie i sortowanie tablic (491)

• Tablice wielowymiarowe (492)
  • Tablice dwuwymiarowe (493)
  • Tablice wyszczerbione (514)
• Tablice z więcej niż dwoma wymiarami (518)
  • Uzyskiwanie dostępu do tablicy wielowymiarowej w pętli foreach (521)
• Metody wbudowane w klasę System.Array (522)
• Techniki rozwiązywania problemów tablicowych (525)
  • Sortowanie (525)
• Przeszukiwanie (535)
  • Przeszukiwanie sekwencyjne (536)
  • Przeszukiwanie binarne (538)
  • Przeszukiwanie za pomocą metody IndexOf() klasy System.Array (544)
• Podsumowanie (546)
• Pytania kontrolne (547)
• Ćwiczenia z programowania (548)

Rozdział 12. Anatomia klasy, część I - doświadczenia ze statycznymi składowymi klas i metodami (551)

• Podstawy anatomii klasy (552)
• Składowe danych (555)
  • Zmienne instancji (555)
  • Zmienne statyczne (557)
  • Składowe stałe (565)
  • Składowe tylko do odczytu (566)
  • Deklarowanie danych składowych (566)
• Składowe funkcyjne (567)
  • Metody (567)
  • Metody statyczne (570)
• Podsumowanie (605)
• Pytania kontrolne (606)
• Ćwiczenia z programowania (609)

Rozdział 13. Anatomia klasy, część II - tworzenie obiektu i odzyskiwanie pamięci (611)

• Konstruktory instancji (612)
  • Dlaczego potrzebne są konstruktory instancji? (612)
  • Praca z konstruktorami instancji (616)
  • Przeciążenie konstruktorów instancji (621)
  • Inicjalizator konstruktora (628)
  • Prywatne konstruktory instancji (631)
• Konstruktory statyczne (631)
• Składowe tylko do odczytu (632)
• Zbieranie nieużytków - automatyczne dynamiczne zarządzanie pamięcią (634)
  • Jak sprawić, by obiekty stały się nieosiągalne? (635)
  • Zadania mechanizmu zbierania nieużytków (639)
  • Zwalnianie brakujących zasobów innych niż pamięć (641)
• Podsumowanie (658)
• Pytania kontrolne (660)
• Ćwiczenia z programowania (661)

Rozdział 14. Anatomia klasy, część III - pisanie intuicyjnego kodu (663)

• Właściwości (665)
  • Właściwości a metody dostępowe (665)
  • Właściwości są szybkie (672)
  • Implementacja opóźnionej inicjalizacji i leniwych aktualizacji z właściwościami (674)
• Indeksery - używanie obiektów podobnie jak tablic (679)
  • Wywoływanie indeksera z wnętrza obiektu, w którym rezyduje (683)
  • Przeciążanie indekserów - wielokrotne indeksery w tej samej klasie (684)
  • Unikanie nadużywania indekserów (689)
• Przeciążenie operatora (690)
  • Przeciążenie operatora zdefiniowane przez użytkownika (692)
• Zdefiniowane przez użytkownika konwersje niejawne i jawne (701)
  • Dwa przypadki wymagające konwersji zdefiniowanych przez użytkownika (702)
  • Używanie technik konwersji niezdefiniowanych przez użytkownika (704)
  • Składnia konwersji zdefiniowanych przez użytkownika (704)
  • Łączenie konwersji zdefiniowanej przez użytkownika i niejawnej (711)
• Typy zagnieżdżone (713)
  • Zalety klas zagnieżdżonych (714)
  • Przykład prostej klasy zagnieżdżonej (714)
• Podsumowanie (715)
• Pytania kontrolne (717)
• Ćwiczenia z programowania (719)

Rozdział 15. Przestrzenie nazw, jednostki kompilacji i zestawy (721)

• Definiowanie własnej przestrzeni nazw (722)
• Globalna nienazwana przestrzeń nazw (723)
• Przestrzenie nazw i jednostki kompilacji (723)
• Zagnieżdżone przestrzenie nazw (726)
• Składnia przestrzeni nazw (729)
• Więcej na temat dyrektywy using (731)
  • Aliasy klas i przestrzeni nazw (731)
• Jednostki kompilacji, przestrzenie nazw oraz zestawy (733)
  • Kompilowanie kilku jednostek kompilacji do jednego zestawu (734)
  • Wielokrotne wykorzystywanie przestrzeni nazw zawartych w zestawie (738)
  • Dzielenie przestrzeni nazw do kilku zestawów (741)
• Badanie zestawów za pomocą narzędzia Ildasm (744)
• Podsumowanie (746)
• Pytania kontrolne (747)
• Ćwiczenia z programowania (749)

Rozdział 16. Dziedziczenie, część I - podstawowe pojęcia (751)

• Potrzeba dziedziczenia (753)
  • Życie bez dziedziczenia (754)
• Podstawy dziedziczenia (760)
  • Przesłanianie definicji funkcji (765)
• Modyfikatory dostępu a dziedziczenie (771)
  • Modyfikator dostępu protected (771)
  • Accessing private... (771)
  • Modyfikator dostępu internal protected (773)
  • Przegląd modyfikatorów dostępu (774)
• Konstruktory klas wyprowadzonych (774)
• Również indeksery są dziedziczone i mogą być przesłaniane (780)
• Wywoływanie przesłoniętych funkcji klasy bazowej (783)
• Wielokrotne wykorzystanie biblioteki klas .NET Framework za pomocą dziedziczenia (786)
• Wielopoziomowe wyprowadzanie klas (788)
• Przesłanianie metod i przeciążanie to różne mechanizmy (792)
• Podsumowanie (794)
• Pytania kontrolne (796)
• Ćwiczenia z programowania (797)

Rozdział 17. Dziedziczenie, część II - funkcje abstrakcyjne, polimorfizm oraz interfejsy (801)

• Abstrakcyjne metody, właściwości, indeksery oraz klasy (802)
• Polimorfizm (807)
  • Obiekt klasy potomnej ma więcej niż jeden typ (807)
  • Wiązanie dynamiczne metod wirtualnych oraz akcesorów (get, set) (808)
  • Studium - prosty program do rysowania (810)
• Tracenie i odzyskiwanie informacji o typie (818)
  • Operator is (819)
  • Rzutowanie obiektów (820)
  • Operator as (823)
• System.Object - elementarna klasa bazowa (823)
• Ukrywanie metod (830)
• Tworzenie wersji poprzez użycie słów kluczowych new i override (832)
• Dziedziczenie wielokrotne (836)
• Interfejsy (837)
  • Definiowanie interfejsu (840)
  • Implementacja interfejsu (841)
  • O programowaniu z interfejsami (845)
  • Budowanie hierarchii interfejsów (850)
  • Konwersje interfejsów (850)
  • Przeciążanie wirtualnych implementacji interfejsów (851)
  • Jawna implementacja funkcji interfejsu (852)
• Podsumowanie (855)
• Pytania kontrolne (857)
• Ćwiczenia z programowania (858)

Rozdział 18. Struktury (861)

• Definiowanie struktur (862)
• Pakowanie i odpakowywanie (865)
• Tworzenie struktur ze słowem kluczowym new oraz bez niego (866)
• Typy wartościowe a typy referencyjne (867)
• Podsumowanie (869)
• Pytania kontrolne (869)
• Ćwiczenia z programowania (870)

Rozdział 19. Obsługa wyjątków (871)

• Obsługa wyjątków - krótki przegląd (872)
• Rzeczywistość bez try-catch-finally (873)
• Bloki try oraz catch (875)
• Przechwytywanie obiektów wyjątków w wyższych ogniwach łańcucha wywołań (878)
• Wieloskładnikowe bloki catch (880)
• Blok finally (881)
• Zagnieżdżone bloki try (884)
• throw - jawne wyrzucanie wyjątków (886)
• Pisanie własnych wyjątków (889)
• Podsumowanie (892)
• Pytania kontrolne (892)
• Ćwiczenia z programowania (893)

Rozdział 20. Delegaty i zdarzenia (895)

• Delegaty (896)
  • Tablice delegatów oraz delegaty przekazywane jako argument wywołań metod (900)
  • Delegaty grupowe (905)
• Zdarzenie (908)
  • Pisanie programów działających w oparciu o zdarzenia (909)
• Podsumowanie (917)
• Pytania kontrolne (917)
• Ćwiczenia z programowania (918)

Rozdział 21. Przetwarzanie wstępne, dokumentacja XML oraz atrybuty (919)

• Dyrektywy preprocesora (920)
  • Wyłączanie i dołączanie kodu za pomocą #define, #if oraz #endif (920)
  • #undef - usuwanie definicji identyfikatorów (923)
  • #elif oraz #else (923)
  • #error oraz #warning (924)
  • #region oraz #endregion (924)
  • #line (924)
• Dokumentacja XML (924)
  • Prosty przykład dokumentacji XML (925)
• Atrybuty (927)
  • Prosty przykład oznaczania atrybutami (930)
• Podsumowanie (933)
• Pytania kontrolne (934)
• Ćwiczenia z programowania (936)

Rozdział 22. Wejście i wyjście z wykorzystaniem plików (939)

• Wejście/wyjście z wykorzystaniem plików i podstawy strumieni (940)
  • Pliki tekstowe i pliki binarne (940)
• Przegląd klas wejścia/wyjścia z wykorzystaniem plików (941)
• Klasa FileInfo (942)
• Realizacja wejścia do plików tekstowych i wyjścia z nich poprzez StreamReader oraz StreamWriter (946)
• Realizacja binarnego wejścia i wyjścia za pomocą klasy FileStream (951)
• Podsumowanie (955)
• Pytania kontrolne (955)
• Ćwiczenia z programowania (956)

Rozdział 23. Podstawy rekurencji (959)

• Oczekujące instancje metody w różnych metodach (960)
• Oczekujące instancje metody w ramach tej samej metody (962)
• Działanie rekurencji - obliczenie silni n (965)
• Rekurencja a iteracja (969)
• Przeszukiwanie binarne za pomocą rekurencji (970)
• Podsumowanie (974)
• Pytania kontrolne (974)
• Ćwiczenia z programowania (975)

Dodatek A Odpowiedzi na pytania i rozwiązania ćwiczeń (977)

• Rozdział 1 (977)
  • Odpowiedzi na pytania kontrolne z rozdziału 1 (977)
• Rozdział 2 (978)
  • Odpowiedzi na pytania kontrolne z rozdziału 2 (978)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 2 (980)
• Rozdział 3 (981)
  • Odpowiedzi na pytania kontrolne z rozdziału 3 (981)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 3 (982)
• Rozdział 4 (983)
  • Odpowiedzi na pytania kontrolne z rozdziału 4 (983)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 4 (984)
• Rozdział 5 (987)
  • Odpowiedzi na pytania kontrolne z rozdziału 5 (987)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 5 (988)
• Rozdział 6 (989)
  • Odpowiedzi na pytania kontrolne z rozdziału 6 (989)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 6 (990)
• Rozdział 7 (996)
  • Odpowiedzi na pytania kontrolne z rozdziału 7 (996)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 7 (998)
• Rozdział 8 (1000)
  • Odpowiedzi na pytania kontrolne z rozdziału 8 (1000)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 8 (1002)
• Rozdział 9 (1004)
  • Odpowiedzi na pytania kontrolne z rozdziału 9 (1004)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 9 (1005)
• Rozdział 10 (1007)
  • Odpowiedzi na pytania kontrolne z rozdziału 10 (1007)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 10 (1008)
• Rozdział 11 (1011)
  • Odpowiedzi na pytania kontrolne z rozdziału 11 (1011)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 11 (1012)
• Rozdział 12 (1018)
  • Odpowiedzi na pytania kontrolne z rozdziału 12 (1018)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 12 (1019)
• Rozdział 13 (1022)
  • Odpowiedzi na pytania kontrolne z rozdziału 13 (1022)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 13 (1024)
• Rozdział 14 (1026)
  • Odpowiedzi na pytania kontrolne z rozdziału 14 (1026)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 14 (1027)
• Rozdział 15 (1032)
  • Odpowiedzi na pytania kontrolne z rozdziału 15 (1032)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 15 (1033)
• Rozdział 16 (1036)
  • Odpowiedzi na pytania kontrolne z rozdziału 16 (1036)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 16 (1037)
• Rozdział 17 (1040)
  • Odpowiedzi na pytania kontrolne z rozdziału 17 (1040)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 17 (1042)
• Rozdział 18 (1047)
  • Odpowiedzi na pytania kontrolne z rozdziału 18 (1047)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 18 (1047)
• Rozdział 19 (1049)
  • Odpowiedzi na pytania kontrolne z rozdziału 19 (1049)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 19 (1050)
• Rozdział 20 (1051)
  • Odpowiedzi na pytania kontrolne z rozdziału 20 (1051)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 20 (1052)
• Rozdział 21 (1058)
  • Odpowiedzi na pytania kontrolne z rozdziału 21 (1058)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 21 (1060)
• Rozdział 22 (1063)
  • Odpowiedzi na pytania kontrolne z rozdziału 22 (1063)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 22 (1063)
• Rozdział 23 (1066)
  • Odpowiedzi na pytania kontrolne z rozdziału 23 (1066)
  • Odpowiedzi do ćwiczeń z programowania z rozdziału 23 (1067)

Dodatek B Kolejność operatorów (1069)
Dodatek C Zarezerwowane słowa w C# (1073)
Dodatek D Systemy liczbowe (1075)

• Wprowadzenie (1075)
• System binarny (1076)
• Bity i bajty (1078)
• System ósemkowy (oktalny) (1078)
• System szesnastkowy (heksadecymalny) (1080)
• Praktyczne zastosowanie liczb ósemkowych i szesnastkowych (1082)
• Konwersja z systemu o podstawie 10 na systemy o podstawie 2, 8 i 16 (1084)
  
• Program do rekurencyjnej konwersji pomiędzy systemami liczbowymi (1085)
• Ujemne liczby binarne (1090)

Dodatek E Zestaw znaków Unicode (1093)
Dodatek F Wykorzystanie poleceń systemu DOS w oknie konsoli (1099)