Zostań profesjonalnym programistą C#
C# jest uważany przez wielu programistów za najlepszy język stosowany do tworzenia aplikacji dla platformy .NET. Język ten, opracowany w firmie Microsoft, łączy w sobie najbardziej wartościowe cechy C++ i Javy, ścisłą integrację z komponentami .NET, wysoki poziom bezpieczeństwa i ogromne możliwości. Świetnie nadaje się do tworzenia aplikacji sieciowych i bazodanowych przeznaczonych zarówno dla systemu Windows, jak i dla urządzeń przenośnych, takich jak PocketPC. Popularność C# stale rośnie, a nieodpłatne udostępnienie przez firmę Microsoft środowiska programistycznego Visual C# Express Edition sprawiło, że coraz więcej twórców oprogramowania wykorzystuje je w swojej pracy.

Książka "Wstęp do programowania w języku C#" to podręcznik przeznaczony dla tych, którzy chcą poznać ten język od podstaw. Czytając ją, poznasz możliwości C# i platformy .NET. Nauczysz się tworzyć własne aplikacje, korzystając ze środowiska Visual C# Express Edition. W książce znajdziesz omówienie składni i elementów języka C#, wyjaśnienie zasad programowania obiektowego i sposobów realizacji różnych zadań programistycznych. Napiszesz aplikacje dla Windows wykorzystujące biblioteki klas .NET i obsługujące pliki w formacie XML.

• Konstrukcja platformy .NET
• Składnia C#
• Elementy języka
• Programowanie obiektowe
• Obsługa zdarzeń
• Korzystanie z tablic i kolekcji
• Obsługa wyjątków
• Biblioteka Windows Forms
• Stosowanie komponentów .NET
• Operacje na plikach i strumieniach
• Obsługa formatu XML

Spis treści:

Przedmowa (11)

Rozdział 1. Wprowadzenie (13)

• Czym jest programowanie (13)
  
  • Mnogość języków programowania (14)
  • Edytory kodu (15)
  • Kompilatory (15)
  • Mity związane z programowaniem (16)
• Języki programowania (17)
  
  • Asembler (18)
  • Fortran (19)
  • C (19)
  • C++ (19)
  • Perl (20)
  • PHP (20)
  • Turbo Pascal (20)
  • Java (21)
• Język maszynowy (21)
  
• Działanie kompilatorów (22)
  
  • Tworzenie kodu źródłowego (22)
  • Prekompilacja (23)
  • Kompilacja do kodu Asemblera (23)
  • Optymalizacja kodu (23)
  • Asemblacja (23)
  • Konsolidacja (24)
• Języki interpretowane (24)
  
• Język C# (24)
  
• Instalacja środowiska (24)
  
• Jak się uczyć (25)
  
  • Nie ucz się na pamięć! (25)
  • Początkowe trudności (25)
  • Pomoc systemowa (25)
  • Praktyka (26)
• Pierwsza aplikacja (26)
  
  • Kompilacja i uruchamianie (26)
  • Komponenty (28)
  • Piszemy kod (29)
  • Zapisywanie projektu (29)
• Podsumowanie (30)

Rozdział 2. Podstawy platformy .NET (31)

• Interfejs programistyczny (32)
  
  • API systemu Windows (32)
• Wizja .NET (33)
  
  • Składniki platformy .NET (34)
  • Konkluzja (37)
• C# a .NET (37)
  
• Rodzaje aplikacji (38)
  
  • Aplikacje konsolowe (38)
  • Windows Forms (38)
  • Formularze Web Forms (38)
• Składniki .NET Framework (39)
  
• Usługi sieciowe (39)
  
  • Niezależność (40)
  • Uniwersalność (40)
• Podsumowanie (41)

Rozdział 3. Podstawy języka C# (43)

• Podstawowa składnia (43)
  
  • Najprostszy program (45)
  • Jak kompilatory czytają kod (45)
  • Wielkość znaków (45)
  • Program musi posiadać metodę Main (46)
  • Średnik kończy instrukcję (46)
  • Program musi posiadać klasę (47)
  • Wcięcia, odstępy (47)
  • Słowa kluczowe (47)
  • Symbole (47)
• Komentarze (48)
  
• Podzespoły, metody, klasy (49)
  
  • Funkcje (49)
  • Metody (50)
  • Klasy (50)
  • Przestrzenie nazw (51)
  • Operator kropki (51)
  • Słowo kluczowe using (52)
• Zmienne (53)
  
  • Deklarowanie zmiennych (53)
  • Przydział danych (54)
  • Typy danych (55)
  • Restrykcje w nazewnictwie (55)
• Stałe (56)
  
• Operacje na konsoli (57)
  
  • Metody klasy Console (58)
  • Właściwości klasy Console (58)
• Operatory (59)
  
  • Operatory porównania (60)
  • Operatory arytmetyczne (60)
  • Operator inkrementacji oraz dekrementacji (61)
  • Operatory logiczne (62)
  • Operatory bitowe (62)
  • Operatory przypisania (63)
  • Inne operatory (63)
• Instrukcje warunkowe (63)
  
  • Instrukcja if (64)
  • Słowo kluczowe else (68)
  • Instrukcja else if (69)
  • Instrukcja switch (70)
• Pętle (73)
  
  • Pętla while (73)
  • Pętla do-while (75)
  • Pętla for (76)
  • Instrukcja break (77)
  • Instrukcja continue (78)
  • Operator warunkowy (79)
• Konwersja danych (80)
  
• Rzutowanie (81)
  
• Przykładowa aplikacja (81)
  
• Dyrektywy preprocesora (83)
  
  • Deklarowanie symboli (84)
  • Instrukcje warunkowe (84)
  • Błędy i ostrzeżenia (85)
• Podsumowanie (86)

Rozdział 4. Przegląd .NET Framework (87)

• Środowisko CLR (87)
  
  • Kod pośredni IL (88)
  • Kod zarządzany i niezarządzany (89)
  • Moduł zarządzany (89)
  • Podzespoły (90)
  • Działanie CLR (90)
• System CTS (91)
  
• Specyfikacja CLS (92)
  
• Biblioteka klas (93)
  
• Moduły, przestrzenie nazw (93)
  
  • Wieloznaczność (95)
  • Główne przestrzenie nazw (96)
• Podsumowanie (97)

Rozdział 5. Programowanie obiektowe (99)

• Na czym polega programowanie obiektowe (99)
  
• Podstawowy kod formularza WinForms (101)
  
  • Moduł Form1.Designer.cs (103)
  • Generowanie kodu (104)
  • Ukrywanie kodu (105)
• Programowanie zdarzeniowe (106)
  
  • Generowanie zdarzeń (106)
  • Obsługa zdarzeń (110)
• Klasy (110)
  
  • Składnia klasy (110)
  • Do czego służą klasy (111)
  • Instancja klasy (112)
  • Klasy zagnieżdżone (114)
• Pola (114)
  
• Metody (115)
  
  • Zwracana wartość (116)
  • Parametry metod (116)
  • Przeciążanie metod (118)
  • Przekazywanie parametrów (119)
• Dziedziczenie (122)
  
  • Klasa domyślna (123)
• Hermetyzacja (123)
  
• Modyfikatory dostępu (123)
  
  • Sekcja private (124)
  • Sekcja public (125)
  • Sekcja protected (126)
  • Sekcja internal (127)
• Konstruktor (127)
  
  • Pola tylko do odczytu (128)
• Destruktor (129)
  
• Właściwości (129)
  
  • Modyfikatory dostępu (132)
• Elementy statyczne (132)
  
  • Metody statyczne (133)
  • Klasy statyczne (134)
• Polimorfizm (135)
  
  • Ukrywanie elementów klas (135)
  • Słowo kluczowe base (137)
  • Metody wirtualne (139)
  • Przedefiniowanie metod (140)
  • Elementy abstrakcyjne (141)
  • Elementy zaplombowane (142)
• .NET Framework Class Library (142)
  
  • Przestrzenie nazw (143)
  • Klasa System.Object (143)
• Opakowywanie typów (145)
  
• Interfejsy (146)
  
  • Implementacja wielu interfejsów (147)
• Typy wyliczeniowe (148)
  
  • Wartości elementów (149)
• Struktury (150)
  
  • Konstruktory struktur (152)
• Operatory is i as (154)
  
• Przeładowanie operatorów (155)
  
  • Słowo kluczowe operator (156)
• Dzielenie klas (158)
  
• Podsumowanie (158)

Rozdział 6. Delegaty i zdarzenia (159)

• Delegaty (159)
  
  • Tworzenie delegatów (160)
  • Użycie delegatów (161)
  • Funkcje zwrotne (163)
  • Delegaty złożone (165)
  • Metody anonimowe (165)
• Zdarzenia (166)
  
• Podsumowanie (169)

Rozdział 7. Tablice i kolekcje (171)

• Czym są tablice (171)
  
• Deklarowanie tablic (172)
  
  • Indeks (172)
  • Inicjalizacja danych (173)
• Tablice wielowymiarowe (173)
  
• Pętla foreach (174)
  
  • Pętla foreach a tablice wielowymiarowe (176)
• Tablice tablic (177)
  
• Tablice struktur (177)
  
• Parametr args w metodzie Main() (178)
  
• Klasa System.Array (179)
  
  • Metody klasy (180)
  • Słowo kluczowe params (185)
• Przykład - gra kółko i krzyżyk (186)
  
  • Zasady gry (186)
  • Specyfikacja klasy (186)
  • Ustawienie symbolu na planszy (190)
  • Sprawdzenie wygranej (191)
  • Interfejs aplikacji (196)
• Mechanizm indeksowania (201)
  
  • Indeksy łańcuchowe (203)
• Kolekcje (204)
  
  • Interfejsy System.Collections (204)
  • Stosy (206)
  • Kolejki (208)
  • Klasa ArrayList (209)
• Listy (209)
  
  • Typy generyczne (210)
  • Korzystanie z list (212)
• Słowniki (214)
  
  • Przykładowy program (215)
• Podsumowanie (217)

Rozdział 8. Obsługa wyjątków (219)

• Czym są wyjątki (220)
  
• Obsługa wyjątków (220)
  
  • Blok finally (221)
  • Zagnieżdżanie wyjątków (222)
• Klasa System.Exception (223)
  
  • Selektywna obsługa wyjątków (223)
  • Wywoływanie wyjątków (224)
• Własne klasy wyjątków (224)
  
  • Deklarowanie własnej klasy (225)
  • Przykładowa aplikacja (226)
• Przepełnienia zmiennych (229)
  
• Podsumowanie (230)

Rozdział 9. Łańcuchy w C# (231)

• Typ System.String (231)
  
  • Unicode w łańcuchach (232)
  • Niezmienność łańcuchów (232)
  • Konstruktory klasy (233)
  • Operacje na łańcuchach (234)
• Łańcuchy w WinForms (239)
  
• Klasa StringBuilder (241)
  
  • Metody klasy StringBuilder (242)
  • Zastosowanie klasy StringBuilder (242)
• Formatowanie łańcuchów (244)
  
• Specyfikatory formatów (246)
  
  • Własne specyfikatory formatowania (248)
  • Specyfikatory typów wyliczeniowych (249)
• Typ System.Char (250)
  
• Podsumowanie (251)

Rozdział 10. Biblioteka Windows Forms (253)

• Podzespół System.Windows.Forms (253)
  
  • Okno Object Browser (254)
  • Przestrzeń System.Windows.Forms (254)
• Podstawowe klasy (255)
  
  • System.ComponentModel.Component (256)
  • System.Windows.Forms.Control (256)
  • System.Windows.Forms.Application (256)
• Przykład działania (261)
  
  • Przygotowanie klasy (261)
  • Projektowanie interfejsu (261)
  • Rozwiązania programistyczne (262)
• Technika "przeciągnij i upuść" (266)
  
• Tworzenie menu (270)
  
  • Właściwości menu (271)
  • Ikony dla menu (271)
  • Skróty klawiaturowe (274)
  • Menu podręczne (274)
• Paski narzędziowe (275)
  
• Pasek statusu (276)
  
• Zakładki (276)
  
• Kontrolki tekstowe (277)
  
  • Komponent RichTextBox (280)
• Okna dialogowe (281)
  
  • Właściwości okien dialogowych (282)
  • Aplikacja - edytor tekstów (283)
• Tworzenie nowego formularza (284)
  
• Podsumowanie (285)

Rozdział 11. Podzespoły .NET (287)

• Czym jest COM (287)
  
  • Kontrolka w rozumieniu COM (288)
  • Odrobinę historii (288)
  • ActiveX (288)
  • DCOM (289)
• Podstawowy podzespół (289)
  
  • Deasembler .NET (289)
• Komponenty .NET (291)
  
  • Przygotowanie komponentu w Delphi (291)
  • Przygotowanie komponentu C# (293)
  • Zalety stosowania podzespołów (295)
• Budowa podzespołu (296)
  
• Atrybuty podzespołu (297)
  
• Mechanizm refleksji (298)
  
  • Funkcja GetType (299)
  • Klasa System.Type (300)
  • Ładowanie podzespołu (301)
  • Przykład działania - program Reflection (301)
  • Własne atrybuty (306)
• Aplikacje .NET Framework SDK (311)
  
  • Global Assembly Cache Tool (311)
  • WinCV (313)
  • Narzędzie konfiguracji .NET Framework (313)
  • PEVerify - narzędzie weryfikacji (314)
• .NET a COM (314)
  
• PInvoke (316)
  
  • Użycie funkcji Win32 API (316)
  • Użycie atrybutu DLLImport (318)
• Podsumowanie (319)

Rozdział 12. Pliki i obsługa strumieni (321)

• Czym są strumienie (321)
  
• Klasy przestrzeni System.IO (322)
  
• Operacje na katalogach (322)
  
  • Tworzenie i usuwanie katalogów (322)
  • Kopiowanie i przenoszenie (323)
  • Odczytywanie informacji o katalogu (325)
• Obsługa plików (326)
  
  • Tworzenie i usuwanie plików (327)
  • Kopiowanie i przenoszenie plików (328)
  • Odczytywanie informacji o pliku (328)
• Strumienie (330)
  
  • Obsługa plików tekstowych (330)
  • Operacje na danych binarnych (334)
• Serializacja (335)
  
  • Formaty zapisu danych (335)
  • Przykład serializacji (336)
• Podsumowanie (337)

Rozdział 13. Obsługa formatu XML (339)

• Niezależność XML (340)
  
• XHTML (340)
  
• Budowa dokumentu (340)
  
  • Prolog (341)
  • Znaczniki (341)
  • Atrybuty (343)
  • Podstawowa terminologia (344)
  • Węzeł główny (345)
  • Komentarze (345)
  • Przestrzenie nazw (345)
  • Składnia przestrzeni nazw (346)
  • Przestrzenie nazw i atrybuty (346)
• DTD (347)
  
  • Deklaracja elementu (347)
  • Deklaracja atrybutu (349)
  • DTD w osobnym pliku (350)
• Encje tekstowe (350)
  
• XSD (351)
  
  • Nagłówek XSD (352)
  • Elementy XSD (353)
  • Typy danych (353)
  • Typy proste (353)
• XML a bazy danych (356)
  
• XSL (357)
  
• DOM (357)
  
• SAX (358)
  
• Korzystanie z System.XML (359)
  
  • Ładowanie pliku XML (359)
  • Odczyt dowolnego elementu (360)
  • Odczyt wartości atrybutów (362)
  • Tworzenie pliku XML (364)
• Dokumentacja XML (369)
  
• Podsumowanie (371)

Skorowidz (373)