.:$$:.

• Elementy języka i podstawowe koncepcje programistyczne
• Techniki tworzenia najwyższej klasy aplikacji dla platformy .NET
• Metody poprawy bezpieczeństwa i wydajności aplikacji

Język C#, pomimo stosunkowo krótkiej obecności na rynku, zyskał ogromną popularność i jest wykorzystywany przez wielu programistów. Trudno się temu dziwić -- ten łączący w sobie najlepsze cechy Javy i C++ obiektowy język programowania jest niezwykle uniwersalny. Można wykorzystać go w niemal każdym projekcie -- programów dla systemu Windows, dynamicznych witryn internetowych w technologii ASP.NET oraz aplikacji mobilnych dla platformy PocketPC. Prosta składnia, rozbudowane mechanizmy obsługi wyjątków i dostęp do ogromnej biblioteki klas .NET sprawiają, że C# jest doskonałym narzędziem.

Książka "C# 2005. Warsztat programisty" to połączenie kursu i podręcznika programowania w tym języku. Czytając ją, opanujesz zarówno podstawy C#, jak i zaawansowane zagadnienia związane z tworzeniem bezpiecznych i wydajnych aplikacji. Poznasz typy danych, zasady stosowania zmiennych oraz składnię instrukcji i wyrażeń. Przeczytasz o programowaniu obiektowym, typach generycznych, obsłudze wyjątków i technikach programowania w C#. Znajdziesz tu również omówienie gramatyki języka C#, konwencji nazewniczych i zasad umieszczania komentarzy w dokumentacji XML.

• Narzędzia programistyczne
• Struktura języka C#
• Typy danych
• Wyrażenia i instrukcje
• Przestrzenie nazw
• Klasy i obiekty
• Typy wyliczeniowe
• Obsługa wyjątków
• Typy generyczne

O autorach (15)
Wprowadzenie (17)
Rozdział 1. Czym jest C#? (23)

• Nazwa (23)
• Ogólny rzut oka na C# (23)
• Historia (24)
• C# i CLR (24)
• Wzmianka o .NET (25)
• Standardy (25)
• Inne implementacje (25)
• Przykładowy kod C# (26)
• Korzyści z nauki programowania w C# (28)
• Podsumowanie (28)

Rozdział 2. Początki pracy z C# (29)

• Początki pracy z C# są tańsze, niż mogłoby się wydawać! (29)
• Tanie opcje (29)
• Jak pisać kod C#, stosując bezpłatne narzędzia (32)
• Tanie narzędzie, które ułatwia życie! (35)
• Alternatywne edytory tekstowe i narzędzia C# (37)
• Narzędzia komercyjne: Visual Studio i Visual C# (37)
• Podsumowanie (38)

Rozdział 3. Ogólny rzut oka na C# (39)

• C# (39)
• Podstawy C# (39)
• Czytanie źródłowego kodu C# (40)
• Typy (41)
• Typy wartości (41)
• Typy referencyjne (41)
• Typy predefiniowane (42)
• Przeciążanie (44)
• Przekształcenia (44)
• Typy tablicowe (45)
• Zmienne i parametry (45)
• Wyrażenia (47)
• Instrukcje (48)
• Klasy (49)
• Stałe (50)
• Pola (50)
• Metody (50)
• Właściwości (51)
• Zdarzenia (51)
• Operatory (51)
• Indeksatory (51)
• Konstruktory instancji (51)
• Destruktory (52)
• Konstruktory statyczne (52)
• Dziedziczenie (52)
• Klasy statyczne (52)
• Struktury (53)
• Interfejsy (53)
• Delegacje (53)
• Typy wyliczeniowe (54)
• Typy generyczne (54)
• Iteratory (54)
• Typy dopuszczające wartość pustą (55)
• Podsumowanie (55)

Rozdział 4. Struktura języka C# (57)

• Programy C# (57)
• Gramatyka (59)
• Dwuznaczności gramatyczne (59)
• Analiza leksykalna (61)
• Podsumowanie (77)

Rozdział 5. Koncepcje języka C# (79)

• Uruchamianie aplikacji (79)
• Zamykanie aplikacji (80)
• Deklaracje w C# (80)
• Składowe (83)
• Składowe przestrzeni nazw (83)
• Składowe struktur (83)
• Składowe wyliczeniowe (83)
• Składowe klas (83)
• Składowe interfejsów (84)
• Składowe tablic (85)
• Składowe delegacji (85)
• Dostęp do składowych (85)
• Deklarowana dostępność (85)
• Sygnatury (86)
• Sygnatury indeksatorów (86)
• Sygnatury konstruktorów instancji (86)
• Sygnatury metod (86)
• Sygnatury operatorów (87)
• Sygnatury i przeciążanie (87)
• Zasięg (88)
• Nazwy przestrzeni nazw i typów (89)
• Zarządzanie pamięcią w C# (89)
• Podsumowanie (90)

Rozdział 6. Typy (91)

• Trzy typy typów (91)
• Różnice pomiędzy typami wartościowymi i referencyjnymi (91)
• System typów w C# (92)
• Typy wartościowe (92)
• System.ValueType (94)
• Konstruktory domyślne (94)
• Typy strukturalne (94)
• Typy proste (95)
• Typy całkowitoliczbowe (96)
• Określanie typów (97)
• Typy zmiennoprzecinkowe (98)
• Typy dziesiętne (98)
• Typ bool (99)
• Typy wyliczeniowe (99)
• Typy referencyjne (99)
• Typy klas (100)
• Typ object (101)
• Typ string (101)
• Typy tablicowe (101)
• Typy delegacji (101)
• Typ null (101)
• Pakowanie i odpakowywanie (101)
• Typy nullable (102)
• Podsumowanie (103)

Rozdział 7. Zmienne (105)

• Czym są zmienne? (105)
• Nie wszystkie zmienne tworzy się w ten sam sposób (105)
• Kategorie zmiennych (106)
• Zmienne statyczne (107)
• Elementy tablicy (107)
• Zmienne instancji (108)
• Parametry wartości (109)
• Parametry referencyjne (109)
• Parametry wyjściowe (110)
• Zmienne lokalne (111)
• Wartości domyślne (111)
• Przypisania niewątpliwe (111)
• Zmienne zainicjalizowane (112)
• Zmienne niezainicjalizowane (112)
• Podsumowanie (121)

Rozdział 8. Przekształcenia (123)

• Przekształcenia niejawne (123)
• Przekształcenia tożsamościowe (124)
• Niejawne przekształcenia liczbowe (124)
• Niejawne przekształcenia wyliczeniowe (125)
• Niejawne przekształcenia referencyjne (125)
• Przekształcenia typu opakowywanie (126)
• Niejawne przekształcenia parametrów typów (127)
• Niejawne przekształcenia wyrażeń stałych (127)
• Niejawne przekształcenia definiowane przez użytkownika (127)
• Przekształcenia jawne (128)
• Jawne przekształcenia liczbowe (128)
• Jawne przekształcenia wyliczeniowe (130)
• Jawne przekształcenia referencyjne (131)
• Przekształcenia typu odpakowywanie (132)
• Jawne przekształcenia parametrów typu (132)
• Jawne przekształcenia definiowane przez użytkownika (132)
• Przekształcenia standardowe (132)
• Standardowe przekształcenia niejawne (133)
• Standardowe przekształcenia jawne (133)
• Przekształcenia definiowane przez użytkownika (133)
• Przekształcenia metod anonimowych (134)
• Przekształcenia grup metod (134)
• Przekształcenia typu null (135)
• Przekształcenia dopuszczające wartość pustą (135)
• Podsumowanie (136)

Rozdział 9. Wyrażenia (137)

• Klasyfikacja wyrażeń (137)
• Wyniki wyrażeń (138)
• Wartości wyrażeń (138)
• Wyrażenia i operatory (138)
• Trzy rodzaje operatorów (139)
• Priorytet i łączność operatorów (139)
• Przeciążanie operatorów (141)
• Operatory rozszerzone (144)
• Wyszukiwanie składowej (146)
• Typy bazowe (147)
• Składowe funkcyjne (147)
• Wyrażenia podstawowe (151)
• Literały (152)
• Nazwy proste (152)
• Wyrażenia nawiasowe (152)
• Dostęp do składowej (152)
• Wyrażenia wywołania (153)
• Dostęp do elementu (154)
• Wyrażenie wartości domyślnej (157)
• Metody anonimowe (157)
• Wyrażenia jednoargumentowe (158)
• Wyrażenia rzutowania (158)
• Operatory arytmetyczne (158)
• Operatory przesunięcia (159)
• Operatory relacyjne (159)
• Operatory logiczne (160)
• Logiczne operatory warunkowe (161)
• Operator null coalescing (161)
• Operatory przypisania (162)
• Wyrażenie (163)
• Wyrażenia stałe (163)
• Wyrażenia boolowskie (165)
• Podsumowanie (166)

Rozdział 10. Instrukcje (167)

• Czym są instrukcje? (167)
• Instrukcje C# (169)
• Punkt końcowy i osiągalność (170)
• Punkt końcowy (170)
• Osiągalność (170)
• Bloki kodu (172)
• Listy instrukcji (172)
• Instrukcje puste (173)
• Instrukcje etykietowane (173)
• Instrukcje deklaracyjne (174)
• Deklaracje zmiennych lokalnych (174)
• Deklaracje stałych lokalnych (175)
• Instrukcje wyrażeniowe (176)
• Instrukcje wyboru (176)
• Instrukcje iteracyjne (182)
• Instrukcje skoku (184)
• Instrukcja using (187)
• Instrukcja yield (188)
• Podsumowanie (189)

Rozdział 11. Przestrzenie nazw (191)

• Czym są przestrzenie nazw? (191)
• Organizowanie klas (191)
• Kontrolowanie zasięgu (192)
• Jednostki kompilacji (192)
• Deklaracje przestrzeni nazw (193)
• Dyrektywy użycia synonimu zewnętrznego (194)
• Dyrektywy użycia (195)
• Składowe przestrzeni nazw (196)
• Deklaracje typów (196)
• Kwalifikowane składowe synonimów (197)
• Podsumowanie (199)

Rozdział 12. Klasy (201)

• Czym są klasy? (201)
• Deklaracje klas (201)
• Modyfikatory klas (202)
• Wskazanie klasy bazowej (203)
• Klasy bazowe (203)
• Implementacje interfejsów (203)
• Ciało klasy (204)
• Deklaracje częściowe (204)
• Składowe klasy (204)
• Dziedziczenie (206)
• Modyfikator new (206)
• Modyfikatory dostępu (206)
• Składowe statyczne i instancji (206)
• Stałe (207)
• Pola (208)
• Pola statyczne i instancji (209)
• Pola readonly (209)
• Metody (210)
• Parametry metody (211)
• Metody statyczne i instancji (212)
• Metody wirtualne (212)
• Metody przesłaniające (213)
• Metody ostateczne (213)
• Metody abstrakcyjne (213)
• Ciało metody (213)
• Właściwości (214)
• Właściwości statyczne i instancji (215)
• Akcesory (215)
• Akcesory wirtualne, ostateczne, przesłaniające i abstrakcyjne (216)
• Zdarzenia (216)
• Zdarzenia jako pola (217)
• Zdarzenia statyczne i instancji (217)
• Akcesory wirtualne, ostateczne, przesłaniające i abstrakcyjne (218)
• Indeksatory (218)
• Operatory (220)
• Operatory jednoargumentowe (221)
• Operatory dwuargumentowe (222)
• Operatory przekształcenia (222)
• Konstruktory instancji (222)
• Konstruktory statyczne (223)
• Destruktory (224)
• Podsumowanie (224)

Rozdział 13. Struktury (225)

• Czym są struktury? (225)
• Deklaracje struktur (226)
• Modyfikatory struktury (227)
• Interfejsy struktury (227)
• Ciało struktury (227)
• Składowe struktury (228)
• Różnice między klasą a strukturą (228)
• Semantyka wartości (229)
• Dziedziczenie (229)
• Przypisania (230)
• Wartości domyślne (230)
• Opakowywanie i rozpakowywanie (230)
• this (231)
• Inicjalizatory pól (231)
• Konstruktory (231)
• Destruktory (231)
• Konstruktory statyczne (232)
• Kiedy korzystać ze struktur (232)
• Podsumowanie (232)

Rozdział 14. Tablice (233)

• Czym jest tablica? (233)
• Typy tablicowe (235)
• Typ System.Array (236)
• Tworzenie tablic (236)
• Dostęp do elementów tablicy (237)
• Składowe tablic (237)
• Kowariancja tablic (237)
• Inicjalizatory tablic (238)
• Podsumowanie (240)

Rozdział 15. Interfejsy (241)

• Czym jest interfejs? (241)
• Definiowanie interfejsu (242)
• Deklaracje interfejsów (242)
• Modyfikatory (243)
• Jawne interfejsy bazowe (243)
• Ciało interfejsu (244)
• Składowe interfejsu (244)
• Metody interfejsu (244)
• Właściwości interfejsu (244)
• Zdarzenia interfejsu (245)
• Podsumowanie (245)

Rozdział 16. Typy wyliczeniowe (247)

• Deklaracje typów wyliczeniowych (248)
• Modyfikatory typów wyliczeniowych (249)
• Składowe typów wyliczeniowych (250)
• Przestroga przed referencjami cyklicznymi (251)
• System.Enum (251)
• Wartości i operacje typów wyliczeniowych (252)
• Podsumowanie (252)

Rozdział 17. Delegacje (253)

• Delegacje w działaniu (253)
• Deklaracje delegacji (254)
• Modyfikatory (254)
• Deklarowanie delegacji (255)
• Lista wywoławcza (255)
• Tworzenie instancji delegacji (256)
• Podsumowanie (257)

Rozdział 18. Wyjątki (259)

• Zgłaszanie wyjątków (259)
• System.Exception (260)
• Typowe klasy wyjątków (260)
• Obsługa wyjątków (261)
• Co się dzieje, gdy klauzula catch nie zostaje odnaleziona? (261)
• Podsumowanie (262)

Rozdział 19. Atrybuty (263)

• Wprowadzenie do atrybutów (263)
• Klasy atrybutów (264)
• Parametry pozycyjne i nazwane (264)
• Użycie atrybutów (264)
• Typy parametrów atrybutu (265)
• Specyfikacja atrybutów (266)
• Instancje atrybutów (269)
• Kompilacja atrybutów (269)
• Odczytywanie instancji atrybutu podczas wykonywania programu (269)
• Atrybuty zastrzeżone (270)
• Atrybut Conditional (270)
• Podsumowanie (272)

Rozdział 20. Typy generyczne (275)

• Typy generyczne w C# i szablony w C++ (275)
• Zalety typów generycznych (276)
• Deklaracje klas generycznych (276)
• Parametry typu (277)
• Różnice parametrów typu (278)
• Typ instancji (279)
• Składowe klas generycznych (279)
• Pola statyczne w klasach generycznych (280)
• Konstruktory statyczne w klasach generycznych (280)
• Dostęp do składowych chronionych (281)
• Przeciążanie w klasach generycznych (281)
• Operatory w klasach generycznych (281)
• Deklaracje struktur generycznych (282)
• Deklaracje interfejsów generycznych (282)
• Jawne implementacje składowych interfejsu (283)
• Deklaracje delegacji generycznych (283)
• Typy konstruowane (283)
• Argumenty typu (284)
• Typy otwarte i zamknięte (284)
• Składowe typów konstruowanych (284)
• Stosowanie dyrektyw użycia synonimów (285)
• Metody generyczne (285)
• Gdzie nie używa się typów generycznych (287)
• Ograniczenia (288)
• Podsumowanie (291)

Rozdział 21. Iteratory (293)

• Blok iteratora (294)
• Bloki iteratora i błędy czasu kompilacji (295)
• Interfejsy enumeratora (295)
• Interfejsy wyliczeniowe (295)
• Typ yield (296)
• This (296)
• Obiekty enumeratora (296)
• Metoda MoveNext (297)
• Przerwanie wykonywania kodu (298)
• Właściwość Current (298)
• Metoda Dispose (299)
• Obiekty przeliczalne (300)
• Metoda GetEnumerator (300)
• Podsumowanie (301)

Rozdział 22. Kod nienadzorowany (303)

• Czym jest kod nienadzorowany? (303)
• Zalety i wady kodu nienadzorowanego (304)
• Zalety kodu nienadzorowanego (304)
• Wady kodu nienadzorowanego (304)
• Konteksty kodu nienadzorowanego (305)
• Podstawowe informacje o wskaźnikach (306)
• Wskaźniki void (307)
• Operatory wskaźnikowe (307)
• Kod nienadzorowany w działaniu (308)
• Stosowanie modyfikatora fixed (309)
• Operator sizeof (310)
• Użycie słowa kluczowego stackalloc (311)
• Kompilowanie kodu nienadzorowanego (312)
• Podsumowanie (312)

Dodatek A Gramatyka języka C# (313)
Dodatek B Konwencje nazewnicze (349)
Dodatek C Biblioteka standardowa (357)
Dodatek D Przenaszalność (371)
Dodatek E Komentarze dokumentacyjne XML (375)
Skorowidz (379)