Rozdział 1. Zanim zaczniesz programować (11)

• Lekcja 1. Podstawowe koncepcje C# i .NET (11)
  
  • Jak to działa (11)
  • Narzędzia (12)
  • Instalacja narzędzi (13)
• Lekcja 2. Pierwsza aplikacja, kompilacja i uruchomienie programu (17)
  
  • .NET Framework (17)
  • Visual C# Express (18)
  • Turbo C# Explorer (22)
  • Mono (24)
  • Struktura kodu (25)
• Lekcja 3. Komentarze (26)
  
  • Komentarz blokowy (26)
  • Komentarz liniowy (28)
  • Komentarz XML (28)
  • Ćwiczenia do samodzielnego wykonania (29)

Rozdział 2. Elementy języka (31)

• Typy danych (31)
  
• Lekcja 4. Typy danych w C# (32)
  
  • Typy danych w C# (32)
• Zmienne (36)
  
• Lekcja 5. Deklaracje i przypisania (36)
  
  • Proste deklaracje (36)
  • Deklaracje wielu zmiennych (38)
  • Nazwy zmiennych (39)
  • Zmienne typów odnośnikowych (39)
  • Ćwiczenia do samodzielnego wykonania (40)
• Lekcja 6. Wyprowadzanie danych na ekran (40)
  
  • Wyświetlanie wartości zmiennych (40)
  • Wyświetlanie znaków specjalnych (43)
  • Instrukcja Console.Write (44)
  • Ćwiczenia do samodzielnego wykonania (44)
• Lekcja 7. Operacje na zmiennych (45)
  
  • Operacje arytmetyczne (45)
  • Operacje bitowe (52)
  • Operacje logiczne (56)
  • Przypisania (58)
  • Porównywania (relacyjne) (59)
  • Pozostałe operatory (60)
  • Priorytety operatorów (60)
  • Ćwiczenia do samodzielnego wykonania (60)
• Instrukcje sterujące (62)
  
• Lekcja 8. Instrukcja warunkowa if...else (62)
  
  • Podstawowa postać instrukcji if...else (62)
  • Zagnieżdżanie instrukcji if...else (63)
  • Instrukcja if...else if (66)
  • Ćwiczenia do samodzielnego wykonania (69)
• Lekcja 9. Instrukcja switch i operator warunkowy (69)
  
  • Instrukcja switch (69)
  • Przerywanie instrukcji switch (72)
  • Operator warunkowy (74)
  • Ćwiczenia do samodzielnego wykonania (75)
• Lekcja 10. Pętle (75)
  
  • Pętla for (75)
  • Pętla while (79)
  • Pętla do...while (81)
  • Pętla foreach (82)
  • Ćwiczenia do samodzielnego wykonania (83)
• Lekcja 11. Instrukcje break i continue (84)
  
  • Instrukcja break (84)
  • Instrukcja continue (87)
  • Ćwiczenia do samodzielnego wykonania (88)
• Tablice (89)
  
• Lekcja 12. Podstawowe operacje na tablicach (89)
  
  • Tworzenie tablic (90)
  • Inicjalizacja tablic (92)
  • Właściwość Length (93)
  • Ćwiczenia do samodzielnego wykonania (94)
• Lekcja 13. Tablice wielowymiarowe (95)
  
  • Tablice dwuwymiarowe (95)
  • Tablice tablic (98)
  • Tablice dwuwymiarowe i właściwość Length (100)
  • Tablice nieregularne (102)
  • Ćwiczenia do samodzielnego wykonania (106)

Rozdział 3. Programowanie obiektowe (107)

• Podstawy (107)
  
• Lekcja 14. Klasy i obiekty (108)
  
  • Podstawy obiektowości (108)
  • Pierwsza klasa (109)
  • Jak użyć klasy? (111)
  • Metody klas (112)
  • Jednostki kompilacji, przestrzenie nazw i zestawy (115)
  • Ćwiczenia do samodzielnego wykonania (119)
• Lekcja 15. Argumenty i przeciążanie metod (120)
  
  • Argumenty metod (120)
  • Obiekt jako argument (123)
  • Przeciążanie metod (127)
  • Argumenty metody Main (128)
  • Sposoby przekazywania argumentów (129)
  • Ćwiczenia do samodzielnego wykonania (130)
• Lekcja 16. Konstruktory (130)
  
  • Czym jest konstruktor? (131)
  • Argumenty konstruktorów (133)
  • Przeciążanie konstruktorów (134)
  • Słowo kluczowe this (135)
  • Niszczenie obiektu (138)
  • Ćwiczenia do samodzielnego wykonania (139)
• Dziedziczenie (140)
  
• Lekcja 17. Klasy potomne (140)
  
  • Dziedziczenie (140)
  • Konstruktory klasy bazowej i potomnej (144)
  • Ćwiczenia do samodzielnego wykonania (148)
• Lekcja 18. Modyfikatory dostępu (148)
  
  • Określanie reguł dostępu (149)
  • Czemu ukrywamy wnętrze klasy? (153)
  • Jak zabronić dziedziczenia? (157)
  • Tylko do odczytu (158)
  • Ćwiczenia do samodzielnego wykonania (161)
• Lekcja 19. Przesłanianie metod i składowe statyczne (162)
  
  • Przesłanianie metod (162)
  • Przesłanianie pól (165)
  • Składowe statyczne (166)
  • Ćwiczenia do samodzielnego wykonania (169)
• Lekcja 20. Właściwości i struktury (169)
  
  • Właściwości (170)
  • Struktury (178)
  • Ćwiczenia do samodzielnego wykonania (182)

Rozdział 4. Obsługa błędów (183)

• Lekcja 21. Blok try...catch (183)
  
  • Sprawdzanie poprawności danych (183)
  • Wyjątki w C# (187)
  • Ćwiczenia do samodzielnego wykonania (191)
• Lekcja 22. Wyjątki to obiekty (192)
  
  • Dzielenie przez zero (192)
  • Wyjątek jest obiektem (193)
  • Hierarchia wyjątków (194)
  • Przechwytywanie wielu wyjątków (195)
  • Zagnieżdżanie bloków try...catch (198)
  • Ćwiczenia do samodzielnego wykonania (199)
• Lekcja 23. Tworzenie klas wyjątków (200)
  
  • Zgłaszanie wyjątków (200)
  • Ponowne zgłoszenie przechwyconego wyjątku (202)
  • Tworzenie własnych wyjątków (205)
  • Sekcja finally (206)
  • Ćwiczenia do samodzielnego wykonania (208)

Rozdział 5. System wejścia-wyjścia (211)

• Lekcja 24. Standardowe wejście i wyjście (211)
  
  • Klasa Console (211)
  • Ćwiczenia do samodzielnego wykonania (221)
• Lekcja 25. Operacje na systemie plików (221)
  
  • Klasa FileSystemInfo (222)
  • Operacje na katalogach (222)
  • Operacje na plikach (229)
  • Ćwiczenia do samodzielnego wykonania (234)
• Lekcja 26. Zapis i odczyt plików (234)
  
  • Klasa FileStream (234)
  • Dostęp swobodny (236)
  • Operacje strumieniowe (241)
  • Ćwiczenia do samodzielnego wykonania (250)

Rozdział 6. Zaawansowane zagadnienia programowania obiektowego (251)

• Polimorfizm (251)
  
• Lekcja 27. Konwersje typów i rzutowanie obiektów (251)
  
  • Konwersje typów prostych (252)
  • Rzutowanie typów obiektowych (253)
  • Rzutowanie na typ Object (257)
  • Typy proste też są obiektowe! (259)
  • Ćwiczenia do samodzielnego wykonania (261)
• Lekcja 28. Późne wiązanie i wywoływanie metod klas pochodnych (261)
  
  • Rzeczywisty typ obiektu (262)
  • Dziedziczenie a wywoływanie metod (264)
  • Dziedziczenie a metody prywatne (269)
  • Ćwiczenia do samodzielnego wykonania (270)
• Lekcja 29. Konstruktory oraz klasy abstrakcyjne (271)
  
  • Klasy i metody abstrakcyjne (271)
  • Wywołania konstruktorów (274)
  • Wywoływanie metod w konstruktorach (278)
  • Ćwiczenia do samodzielnego wykonania (280)
• Interfejsy (281)
  
• Lekcja 30. Tworzenie interfejsów (281)
  
  • Czym są interfejsy? (281)
  • Interfejsy a hierarchia klas (283)
  • Interfejsy i właściwości (286)
  • Ćwiczenia do samodzielnego wykonania (288)
• Lekcja 31. Implementacja kilku interfejsów (288)
  
  • Implementowanie wielu interfejsów (288)
  • Konflikty nazw (290)
  • Dziedziczenie interfejsów (293)
  • Ćwiczenia do samodzielnego wykonania (295)
• Klasy zagnieżdżone (296)
  
• Lekcja 32. Klasa wewnątrz klasy (296)
  
  • Tworzenie klas zagnieżdżonych (296)
  • Kilka klas zagnieżdżonych (298)
  • Składowe klas zagnieżdżonych (299)
  • Obiekty klas zagnieżdżonych (301)
  • Rodzaje klas wewnętrznych (304)
  • Dostęp do składowych klasy zewnętrznej (305)
  • Ćwiczenia do samodzielnego wykonania (307)

Rozdział 7. Aplikacje z interfejsem graficznym (309)

• Lekcja 33. Tworzenie okien (309)
  
  • Pierwsze okno (309)
  • Klasa Form (311)
  • Menu (316)
  • Ćwiczenia do samodzielnego wykonania (320)
• Lekcja 34. Delegacje i zdarzenia (320)
  
  • Koncepcja zdarzeń i delegacji (321)
  • Tworzenie delegacji (321)
  • Delegacja jako funkcja zwrotna (325)
  • Delegacja powiązana z wieloma metodami (329)
  • Zdarzenia (331)
  • Ćwiczenia do samodzielnego wykonania (341)
• Lekcja 35. Komponenty graficzne (342)
  
  • Wyświetlanie komunikatów (342)
  • Obsługa zdarzeń (343)
  • Menu (345)
  • Etykiety (346)
  • Przyciski (348)
  • Pola tekstowe (350)
  • Listy rozwijane (354)
  • Ćwiczenia do samodzielnego wykonania (357)

Zakończenie (359)

Skorowidz (361)