C#

Praktyczny kurs

• Zanim zaczniesz programować, czyli podstawowe koncepcje i uruchomienie programu

• Elementy języka, czyli od typów danych do zmiennych, operatorów i instrukcji

• Programowanie obiektowe, czyli obiekty, klasy, dziedziczenie i cała reszta

C# należy do rodziny obiektowych języków programowania. Co to oznacza? Otóż znajduje się on w doborowym towarzystwie Javy, C++ i wielu innych języków, za pomocą których można tworzyć wspaniałe aplikacje, ale jednocześnie jest od nich odrobinę łatwiejszy. Jeśli dopiero zaczynasz przygodę z programowaniem, szybciej uda Ci się go opanować, a jeśli jest to dla Ciebie któryś kolejny język, zrozumienie jego składni i reguł nie powinno sprawić Ci większych trudności — szczególnie jeśli do nauki wykorzystasz tę książkę.

Ten znakomity praktyczny podręcznik pozwoli Ci przećwiczyć używanie i sposób działania wszystkich elementów C# — różnych typów danych, zmiennych i operatorów, instrukcji i tablic. Zobaczysz, jak korzystać z pętli i jak zachowują się obiekty. Poznasz najróżniejsze rodzaje klas, opanujesz wygodne korzystanie z dziedziczenia i nauczysz się obsługiwać błędy. W dalszej części książki znajdziesz zaawansowane zagadnienia programowania obiektowego i odkryjesz, jak projektować aplikacje z interfejsem graficznym. Krótko mówiąc, po starannym wykonaniu ćwiczeń będziesz w stanie zaprojektować i zbudować własną aplikację z użyciem języka C#!

• Typy danych, zmienne i instrukcje sterujące

• Tablice i pętle

• Klasy i obiekty

• Dziedziczenie

• Obsługa błędów i wyjątków

• System wejścia-wyjścia

• Polimorfizm i interfejsy

• Klasy zagnieżdżone i typy uogólnione

• Aplikacje z interfejsem graficznym

Wstęp (9)

• Czym jest C#? (9)
• Dla kogo jest ta książka? (9)
• Standardy C# (10)

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 (16)
  • .NET Framework (16)
  • Visual Studio (19)
  • Mono (22)
  • MonoDevelop (Xamarin Studio) (23)
  • Struktura kodu (26)
• Lekcja 3. Komentarze (27)
  • Komentarz blokowy (27)
  • Komentarz liniowy (28)
  • Komentarz XML (29)
  • Ćwiczenia do samodzielnego wykonania (30)

Rozdział 2. Elementy języka (31)

• Typy danych (31)
• Lekcja 4. Typy danych w C# (32)
  • Typy danych w C# (32)
  • Zapis wartości (literały) (36)
• Zmienne (39)
• Lekcja 5. Deklaracje i przypisania (39)
  • Proste deklaracje (39)
  • Deklaracje wielu zmiennych (41)
  • Nazwy zmiennych (42)
  • Zmienne typów odnośnikowych (42)
  • Ćwiczenia do samodzielnego wykonania (43)
• Lekcja 6. Wyprowadzanie danych na ekran (43)
  • Wyświetlanie wartości zmiennych (43)
  • Wyświetlanie znaków specjalnych (46)
  • Instrukcja Console.Write (48)
  • Ćwiczenia do samodzielnego wykonania (49)
• Lekcja 7. Operacje na zmiennych (49)
  • Operacje arytmetyczne (50)
  • Operacje bitowe (57)
  • Operacje logiczne (61)
  • Operatory przypisania (63)
  • Operatory porównywania (relacyjne) (64)
  • Pozostałe operatory (65)
  • Priorytety operatorów (65)
  • Ćwiczenia do samodzielnego wykonania (66)
• Instrukcje sterujące (67)
• Lekcja 8. Instrukcja warunkowa if...else (67)
  • Podstawowa postać instrukcji if...else (67)
  • Zagnieżdżanie instrukcji if...else (69)
  • Instrukcja if...else if (72)
  • Ćwiczenia do samodzielnego wykonania (75)
• Lekcja 9. Instrukcja switch i operator warunkowy (76)
  • Instrukcja switch (76)
  • Przerywanie instrukcji switch (79)
  • Operator warunkowy (81)
  • Ćwiczenia do samodzielnego wykonania (82)
• Lekcja 10. Pętle (82)
  • Pętla for (83)
  • Pętla while (86)
  • Pętla do...while (88)
  • Pętla foreach (89)
  • Ćwiczenia do samodzielnego wykonania (90)
• Lekcja 11. Instrukcje break i continue (91)
  • Instrukcja break (91)
  • Instrukcja continue (95)
  • Ćwiczenia do samodzielnego wykonania (96)
• Tablice (97)
• Lekcja 12. Podstawowe operacje na tablicach (98)
  • Tworzenie tablic (98)
  • Inicjalizacja tablic (101)
  • Właściwość Length (102)
  • Ćwiczenia do samodzielnego wykonania (103)
• Lekcja 13. Tablice wielowymiarowe (104)
  • Tablice dwuwymiarowe (104)
  • Tablice tablic (107)
  • Tablice dwuwymiarowe i właściwość Length (109)
  • Tablice nieregularne (111)
  • Ćwiczenia do samodzielnego wykonania (115)

Rozdział 3. Programowanie obiektowe (117)

• Podstawy (117)
• Lekcja 14. Klasy i obiekty (118)
  • Podstawy obiektowości (118)
  • Pierwsza klasa (119)
  • Jak użyć klasy? (121)
  • Metody klas (122)
  • Jednostki kompilacji, przestrzenie nazw i zestawy (126)
  • Ćwiczenia do samodzielnego wykonania (130)
• Lekcja 15. Argumenty i przeciążanie metod (131)
  • Argumenty metod (131)
  • Obiekt jako argument (134)
  • Przeciążanie metod (138)
  • Argumenty metody Main (139)
  • Sposoby przekazywania argumentów (140)
  • Definicje metod za pomocą wyrażeń lambda (143)
  • Ćwiczenia do samodzielnego wykonania (144)
• Lekcja 16. Konstruktory i destruktory (145)
  • Czym jest konstruktor? (145)
  • Argumenty konstruktorów (148)
  • Przeciążanie konstruktorów (149)
  • Słowo kluczowe this (151)
  • Niszczenie obiektu (154)
  • Ćwiczenia do samodzielnego wykonania (155)
• Dziedziczenie (156)
• Lekcja 17. Klasy potomne (156)
  • Dziedziczenie (156)
  • Konstruktory klasy bazowej i potomnej (160)
  • Ćwiczenia do samodzielnego wykonania (164)
• Lekcja 18. Modyfikatory dostępu (164)
  • Określanie reguł dostępu (165)
  • Dlaczego ukrywamy wnętrze klasy? (170)
  • Jak zabronić dziedziczenia? (174)
  • Tylko do odczytu (175)
  • Ćwiczenia do samodzielnego wykonania (178)
• Lekcja 19. Przesłanianie metod i składowe statyczne (179)
  • Przesłanianie metod (179)
  • Przesłanianie pól (182)
  • Składowe statyczne (183)
  • Ćwiczenia do samodzielnego wykonania (186)
• Lekcja 20. Właściwości i struktury (186)
  • Właściwości (187)
  • Struktury (196)
  • Ćwiczenia do samodzielnego wykonania (200)

Rozdział 4. Wyjątki i obsługa błędów (203)

• Lekcja 21. Blok try...catch (203)
  • Badanie poprawności danych (203)
  • Wyjątki w C# (207)
  • Ćwiczenia do samodzielnego wykonania (211)
• Lekcja 22. Wyjątki to obiekty (212)
  • Dzielenie przez zero (212)
  • Wyjątek jest obiektem (213)
  • Hierarchia wyjątków (214)
  • Przechwytywanie wielu wyjątków (215)
  • Zagnieżdżanie bloków try...catch (218)
  • Ćwiczenia do samodzielnego wykonania (220)
• Lekcja 23. Własne wyjątki (220)
  • Zgłaszanie wyjątków (221)
  • Ponowne zgłoszenie przechwyconego wyjątku (223)
  • Tworzenie własnych wyjątków (225)
  • Wyjątki warunkowe (226)
  • Sekcja finally (228)
  • Ćwiczenia do samodzielnego wykonania (231)

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

• Lekcja 24. Ciągi znaków (233)
  • Znaki i łańcuchy znakowe (233)
  • Znaki specjalne (237)
  • Zamiana ciągów na wartości (238)
  • Formatowanie danych (240)
  • Przetwarzanie ciągów (242)
  • Ćwiczenia do samodzielnego wykonania (247)
• Lekcja 25. Standardowe wejście i wyjście (247)
  • Klasa Console i odczyt znaków (248)
  • Wczytywanie tekstu z klawiatury (255)
  • Wprowadzanie liczb (256)
  • Ćwiczenia do samodzielnego wykonania (257)
• Lekcja 26. Operacje na systemie plików (258)
  • Klasa FileSystemInfo (258)
  • Operacje na katalogach (259)
  • Operacje na plikach (266)
  • Ćwiczenia do samodzielnego wykonania (271)
• Lekcja 27. Zapis i odczyt plików (271)
  • Klasa FileStream (272)
  • Podstawowe operacje odczytu i zapisu (274)
  • Operacje strumieniowe (278)
  • Ćwiczenia do samodzielnego wykonania (287)

Rozdział 6. Zaawansowane zagadnienia programowania obiektowego (289)

• Polimorfizm (289)
• Lekcja 28. Konwersje typów i rzutowanie obiektów (289)
  • Konwersje typów prostych (290)
  • Rzutowanie typów obiektowych (291)
  • Rzutowanie na typ Object (295)
  • Typy proste też są obiektowe! (297)
  • Ćwiczenia do samodzielnego wykonania (299)
• Lekcja 29. Późne wiązanie i wywoływanie metod klas pochodnych (299)
  • Rzeczywisty typ obiektu (300)
  • Dziedziczenie a wywoływanie metod (302)
  • Dziedziczenie a metody prywatne (307)
  • Ćwiczenia do samodzielnego wykonania (308)
• Lekcja 30. Konstruktory oraz klasy abstrakcyjne (309)
  • Klasy i metody abstrakcyjne (309)
  • Wywołania konstruktorów (313)
  • Wywoływanie metod w konstruktorach (316)
  • Ćwiczenia do samodzielnego wykonania (318)
• Interfejsy (319)
• Lekcja 31. Tworzenie interfejsów (319)
  • Czym są interfejsy? (319)
  • Interfejsy a hierarchia klas (322)
  • Interfejsy i właściwości (324)
  • Ćwiczenia do samodzielnego wykonania (326)
• Lekcja 32. Implementacja kilku interfejsów (326)
  • Implementowanie wielu interfejsów (327)
  • Konflikty nazw (328)
  • Dziedziczenie interfejsów (331)
  • Ćwiczenia do samodzielnego wykonania (333)
• Klasy zagnieżdżone (334)
• Lekcja 33. Klasa wewnątrz klasy (334)
  • Tworzenie klas zagnieżdżonych (334)
  • Kilka klas zagnieżdżonych (336)
  • Składowe klas zagnieżdżonych (338)
  • Obiekty klas zagnieżdżonych (339)
  • Rodzaje klas wewnętrznych (342)
  • Dostęp do składowych klasy zewnętrznej (344)
  • Ćwiczenia do samodzielnego wykonania (345)
• Typy uogólnione (346)
• Lekcja 34. Kontrola typów i typy uogólnione (346)
  • Jak zbudować kontener? (346)
  • Przechowywanie dowolnych danych (350)
  • Problem kontroli typów (352)
  • Korzystanie z typów uogólnionych (353)
  • Ćwiczenia do samodzielnego wykonania (356)

Rozdział 7. Aplikacje z interfejsem graficznym (359)

• Lekcja 35. Tworzenie okien (359)
  • Pierwsze okno (359)
  • Klasa Form (361)
  • Tworzenie menu (366)
  • Ćwiczenia do samodzielnego wykonania (370)
• Lekcja 36. Delegacje i zdarzenia (371)
  • Koncepcja zdarzeń i delegacji (371)
  • Tworzenie delegacji (371)
  • Delegacja jako funkcja zwrotna (375)
  • Delegacja powiązana z wieloma metodami (379)
  • Zdarzenia (381)
  • Ćwiczenia do samodzielnego wykonania (391)
• Lekcja 37. Komponenty graficzne (392)
  • Wyświetlanie komunikatów (392)
  • Obsługa zdarzeń (393)
  • Menu (395)
  • Etykiety (397)
  • Przyciski (399)
  • Pola tekstowe (401)
  • Listy rozwijane (404)
  • Ćwiczenia do samodzielnego wykonania (407)

Zakończenie (409)

Skorowidz (410)

416 stron, Format: 16.0x23.5cm, oprawa miękka