Język C# i Platforma .NET

Opis

C# jest językiem programowania platformy .NET, nowego produktu Microsoftu. Andrew Troelsen uczy, jak wykorzystać C# do stworzenia prawie każdego rodzaju aplikacji .NET, począwszy od aplikacji systemu Windows a skończywszy na aplikacjach sieci WWW. Dokładnie omawia każdy aspekt pisania programów .NET i podaje dobrze dobrane przykłady.

Bezkompromisowo praktyczna i kompletna, książka ta zaczyna się krótkim omówieniem podstaw języka C#, po czym szybko przechodzi do głównych zagadnień technicznych i kluczowych elementów architektury tej platformy. Autor nie tylko szeroko omawia podstawowe narzędzia, ale także zajmuje się tak istotnymi, a jednocześnie subtelnymi sprawami jak właściwe użycie wątków. Czytelnik dowie się z książki, jak użyć C# do tworzenia aplikacji z graficznym interfejsu użytkownika, przy czym wyczerpująco zostały omówione Windows Forms i GDI+. Równie przydatne informacje dotyczą zastosowania C# i platformy .NET do budowania aplikacji WWW, usług WWW i dostępu do danych za pomocą ADO.NET. Ponieważ tradycyjne aplikacje COM będą nam towarzyszyć przez długi jeszcze czas, autor dokładnie przedstawił zagadnienia współpracy środowisk .NET i COM.

Spis treści

Uwagi dotyczące książki (str.17)

Wprowadzenie (str.19)

Podziękowania (str.25)

Rozdział 1. Filozofia .NET (str.27)

Jak się dzisiaj sprawy mają (str.27)

1. Wyobraź sobie, że jesteś programistą C w Win32 (str.28)
2. Wyobraź sobie, że jesteś programistą C++ w MFC (str.28)
3. Wyobraź sobie, że programujesz w Visual Basicu (str.28)
4. Wyobraź sobie, że programujesz w Javie (str.29)
5. Wyobraź sobie, że programujesz w COM (str.29)
6. Wyobraź sobie, że programujesz w Windows DNA (str.30)
7. Rozwiązania .NET (str.31)
8. Bloki tworzące platformę .NET (CLR, CTS i CLS) (str.32)
9. Biblioteki klas podstawowych .NET (str.32)
10. Co C# wnosi nowego do tabel (str.33)
11. Języki programowania współpracujące na platformie .NET (str.34)
12. Przegląd pakietów (ang. assemblies), czyli binariów .NET (str.35)
13. Pakiety zawierające jeden lub wiele plików (str.36)
14. Rola języka pośredniego MSIL (str.36)
15. Zalety języka pośredniego IL (str.39)
16. Rola metadanych (str.39)
17. Krótki przykład metadanych (str.40)
18. Kompilowanie IL do postaci charakterystycznej dla danej platformy (str.41)
19. Typy oraz przestrzenie nazw .NET (str.41)
20. Wspólne środowisko uruchomieniowe – CLR (str.42)
21. Wspólny system plików – CTS (str.43)
22. Typy klasowe CTS (str.44)
23. Typy strukturalne CTS (str.45)
24. Typy interfejsowe CTS (str.46)
25. Składowe typów CTS (str.46)
26. Wyliczeniowe typy CTS (str.46)
27. Typy delegowane CTS (str.46)
28. Wewnętrzne typy danych CTS (str.47)
29. Specyfikacja wspólnego języka – CLS (str.48)
30. Praca z przestrzeniami nazw (str.49)
31. Podróż po przestrzeniach nazw .NET (str.50)
32. Dostęp do przestrzeni nazw w programach (str.52)
33. Odwołania do pakietów zewnętrznych (str.53)
34. Analizowanie przestrzeni nazw (str.54)
35. Wykorzystanie ILDasm.exe (str.55)
36. Sieciowa aplikacja CLassViewer (str.59)
37. Aplikacja pulpitu WinCV (str.59)
38. Budowanie aplikacji C# wykorzystującej kompilator wiersza poleceń (str.60)
39. Odwoływanie się do pakietów zewnętrznych (str.62)
40. Kompilowanie wielu plików źródłowych (str.63)
41. Budowanie aplikacji C# w IDE Visual Studio.NET (str.65)
42. Tworzenie rozwiązań w VS.NET (str.65)
43. Okno Solution Explorer (str.65)
44. Okno Properties (str.67)
45. Szkic kodu (str.68)
46. Odwołania do zewnętrznych pakietów (str.69)
47. Debugowanie w środowisku IDE Visual Studio.NET (str.70)
48. Opis okna Server Explorer (str.71)
49. Narzędzia edycyjne związane z XML-em (str.72)
50. Obsługa diagramów UML (str.72)
51. Narzędzie Object Browser (str.72)
52. Narzędzia do manipulowania bazami danych (str.74)
53. Zintegrowany system pomocy (str.74)
54. Podsumowanie (str.76)

Rozdział 2. Podstawy języka C# (str.77)

1. Anatomia klasy w języku C# (str.77)
2. Wariacje na temat metody Main() (str.78)
3. Przetwarzanie parametrów wiersza poleceń (str.79)
4. Tworzenie obiektów – konstruktory (str.80)
5. Czyżby dziura w pamięci? (str.82)
6. Budowa aplikacji w języku C# (str.83)
7. Inicjalizacja składowych (str.85)
8. Operacje we/wy z klasą Console (str.85)
9. Wprowadzenie do formatowania tekstu w C# (str.86)
10. Typy będące wartością oraz typy referencyjne (str.89)
11. Bliżej o typach referencyjnych i będących wartościami (str.91)
12. Główny węzeł hierarchii klas – System.Object (str.93)
13. Przesłanianie niektórych domyślnych zachowań klasy System.Object (str.96)
14. Statyczne składowe klasy System.Object (str.100)
15. Typy danych przestrzeni nazw System (i synonimy w języku C#) (str.100)
16. Eksperymenty z typami (str.103)
17. Uwagi dotyczące wyboru typów danych (str.104)
18. Przechodzenie między typami referencyjnymi a wartościami – opakowywanie
19. i odpakowywanie (str.105)
20. Przypisania domyślne oraz zasięg zmiennych (str.106)
21. Definiowanie stałych (str.108)
22. Instrukcje iteracyjne języka C# (str.110)
23. Pętla for (str.110)
24. Pętla foreach in (str.111)
25. Pętle while oraz do while (str.112)
26. Instrukcje warunkowe języka C# (str.113)
27. Pozostałe operatory języka C# (str.116)
28. Definiowanie niestandardowych metod klasowych (str.117)
29. Modyfikatory dostępu do metod (str.117)
30. Metody statyczne i metody instancyjne (str.120)
31. Definiowanie zmiennych statycznych (str.121)
32. Niektóre składowe statyczne klasy Environment (str.123)
33. Modyfikatory parametrów w metodach (str.124)
34. Tablice w języku C# (str.128)
35. Tablice wielowymiarowe (str.129)
36. Klasa podstawowe System.Array (str.131)
37. Operacje na łańcuchach znakowych w języku C# (str.134)
38. Znaki sterujące i napisy dosłowne (str.135)
39. Klasa System.Text.StringBuilder (str.137)
40. Typy wyliczeniowe w języku C# (str.138)
41. Klasa System.Enum (str.140)
42. Struktury w języku C# (str.142)
43. Opakowywania i odpakowywania ciąg dalszy (str.145)
44. Definiowanie niestandardowych przestrzeni nazw (str.146)
45. Rozwiązywanie konfliktów nazw w przestrzeniach nazw (str.147)
46. Synonimy przestrzeni nazw (str.149)
47. Zagnieżdżone przestrzenie nazw (str.149)
48. Podsumowanie (str.150)

Rozdział 3. Programowanie obiektowe w języku C# (str.151)

1. Formalna definicja klasy w C# (str.151)
2. Autoreferencjalność w języku C# (str.153)
3. Definiowanie domyślnego publicznego interfejsu (str.155)
4. Określenie widoczności na poziomie typu – typy publiczne i wewnętrzne (str.155)
5. Filary OOP (str.157)
6. Hermetyzacja (str.158)
7. Dziedziczenie (str.158)
8. Polimorfizm klasyczny i ad hoc (str.160)
9. Filar I – hermetyzacja (str.162)
10. Hermetyzacja realizowana za pomocą tradycyjnych metod dostępu i modyfikacji (str.163)
11. Inna forma hermetyzacji – właściwości klasy (str.164)
12. Wewnętrzna reprezentacja właściwości w języku C# (str.166)
13. Właściwości tylko do odczytu, tylko do zapisu oraz statyczne (str.167)
14. Pseudohermetyzacja – pola tylko do odczytu (str.169)
15. Statyczne pola tylko do odczytu (str.170)
16. Filar II – dziedziczenie (str.171)
17. Kontrola sposobu tworzenia obiektów klasy podstawowej (str.173)
18. Odwołania do kilku klas podstawowych (str.174)
19. Sekrety rodzinne, czyli słowo kluczowe protected (str.175)
20. Zamknięcie ciągu dziedziczenia – klasy zapieczętowane (str.175)
21. Implementacja modelu zawierania i delegacji (str.176)
22. Definicje typów zagnieżdżonych (str.181)
23. Filar III – polimorfizm (str.182)
24. Definiowanie klas abstrakcyjnych (str.185)
25. Wymuszenie polimorfizmu – składowe abstrakcyjne (str.186)
26. Różne wersje składowych klas (str.189)
27. Rzutowanie typów klasowych (str.191)
28. Rzutowanie typów liczbowych (str.192)
29. Obsługa wyjątków (str.192)
30. Wyrzucanie wyjątku (str.193)
31. Łapanie wyjątków (str.195)
32. Budowanie własnych wyjątków, odsłona pierwsza (str.196)
33. Budowanie własnych wyjątków, odsłona druga (str.198)
34. Obsługa wielu wyjątków (str.199)
35. Blok „finally” (str.200)
36. Końcowe uwagi o wyjątkach (str.201)
37. Czas życia obiektu (str.203)
38. Finalizowanie referencji do obiektu (str.204)
39. Kulisy finalizacji (str.205)
40. Budowanie metod destrukcyjnych na poczekaniu (str.206)
41. Interfejs IDisposable (str.207)
42. Współdziałanie z algorytmem czyszczenia pamięci (str.207)
43. Optymalizacja czyszczenia pamięci (str.209)
44. Podsumowanie (str.212)

Rozdział 4. Interfejsy i zbiory (str.213)

1. Programowanie oparte na interfejsach (str.213)
2. Implementowanie interfejsu (str.215)
3. Dostęp do interfejsu (str.217)
4. Interfejsy i parametry (str.219)
5. Jawna implementacja interfejsu (str.221)
6. Budowanie hierarchii interfejsów (str.224)
7. Określanie wielu interfejsów podstawowych (str.226)
8. Budowanie niestandardowych typów wyliczeniowych (IEnumerable oraz IEnumerator) (str.227)
9. Budowanie dokładnych kopii obiektów (ICloneable) (str.230)
10. Budowanie obiektów porównywalnych (IComparable) (str.232)
11. Określanie wielu kryteriów sortowania (IComparer) (str.235)
12. Niestandardowe właściwości i niestandardowe sposoby sortowania (str.237)
13. Przestrzeń nazw System.Collections (str.237)
14. Przestrzeń nazw System.Collections.Specialized (str.239)
15. Wyposażenie klasy samochodów (str.239)
16. Podsumowanie (str.243)
17. Rozdział 5. Zaawansowane techniki budowania klas w C# (str.245)
18. Budowanie niestandardowego indeksatora (str.245)
19. Przeciążanie operatorów (str.248)
20. Przeciążanie operatorów równości (str.252)
21. Przesłanianie operatorów porównania (str.254)
22. Uwagi końcowe o przeciążaniu operatorów (str.256)
23. Delegacje – działanie i wykorzystanie (str.257)
24. Budowanie przykładowej delegacji (str.258)
25. Delegacje jako typy zagnieżdżone (str.259)
26. Składowe klasy System.MulticastDelegate (str.260)
27. Użycie delegacji CarDelegate (str.261)
28. Analiza kodu delegacji (str.263)
29. Delegacje zbiorowe (str.264)
30. Metody instancyjne jako funkcje wywoływane zwrotnie (str.266)
31. Zdarzenia (str.268)
32. Za kulisami zdarzeń (str.270)
33. Odbieranie informacji o zajściu zdarzenia (str.272)
34. Obiekty w roli ujść zdarzeń (str.275)
35. Interfejs zdarzeń (str.276)
36. Dokumentacja wykorzystująca język XML (str.280)
37. Przeglądanie wygenerowanego pliku XML (str.283)
38. Tworzenie dokumentacji w Visual Studio.NET (str.284)
39. Podsumowanie (str.285)

Rozdział 6. Pakiety, wątki oraz AppDomain (str.287)

1. Problemy z klasycznymi binariami COM (str.287)
2. Problemy przy pracy z różnymi wersjami w COM (str.288)
3. Problemy modelu COM związane z instalacją (str.289)
4. Przegląd pakietów .NET (str.290)
5. Pakiety zawierające jeden oraz wiele plików (str.291)
6. Dwa spojrzenia na pakiet – fizyczne oraz logiczne (str.293)
7. Pakiety przyczyniają się do wielokrotnego wykorzystania kodu (str.294)
8. Pakiety ustalają powiązania typów (str.295)
9. Pakiety są jednostkami, które same się opisują i określają wersję (str.295)
10. Pakiety definiują zabezpieczenia (str.296)
11. Pakiety dopuszczają wykonanie równoległe (str.296)
12. Budowanie pojedynczego pliku pakietu testowego (str.296)
13. Aplikacja typu klient w języku C# (str.300)
14. Aplikacja typu klient w języku Visual Basic.NET (str.301)
15. Dziedziczenie między klasami (str.303)
16. Analiza manifestu pakietu CarLibrary (str.305)
17. Analiza typów w bibliotece CarLibrary (str.308)
18. Czym są pakiety prywatne (str.310)
19. Wyszukiwanie pakietu (str.312)
20. Identyfikator pakietu prywatnego (str.312)
21. Prywatne pakiety i pliki konfiguracyjne XML (str.312)
22. Specyfika wiązania prywatnego pakietu (str.314)
23. Czym są pakiety dzielone (str.316)
24. Kłopoty z GAC (str.317)
25. Czym są nazwy dzielone (jednoznaczne) (str.317)
26. Budowanie pakietu dzielonego (str.319)
27. Instalowanie pakietów katalogu GAC (str.321)
28. Wykorzystywanie pakietów dzielonych (str.322)
29. Zasady ustalania wersji w .NET (str.324)
30. Zapisywanie informacji o wersjach (str.325)
31. Zamrażanie aktualnej wersji pakietu dzielonego (str.325)
32. Budowanie wersji 2.0 pakietu dzielonego (str.326)
33. Domyślny algorytm ustalania wersji (str.328)
34. Zasady samodzielnego określania wersji (str.328)
35. Plik konfiguracyjny administratora (str.330)
36. Przegląd tradycyjnego programowania wątków w Win32 (str.330)
37. Problem współbieżności i synchronizacji wątków (str.332)
38. Klasa System.AppDomain (str.332)
39. Eksperyment z AppDomain (str.334)
40. Przestrzeń nazw System.Threading (str.335)
41. Klasa Thread (str.336)
42. Tworzenie wątku drugorzędnego (str.338)
43. Nadawanie wątkom nazw (str.339)
44. Zatkanie wątku podstawowego (str.340)
45. Usypianie wątku (str.342)
46. Współbieżność (str.343)
47. Słowo kluczowe lock (str.346)
48. Użycie System.Threading.Monitor (str.347)
49. Użycie System.Threading.Interlocked (str.347)
50. Podsumowanie (str.349)

Rozdział 7. Refleksja typów i stosowanie atrybutów w programowaniu (str.351)

1. Refleksja (str.351)
2. Klasa Type (str.352)
3. Uzyskiwanie obiektu typu Type (str.353)
4. Eksperymenty w klasie Type (str.353)
5. Przestrzeń nazw System.Reflection (str.357)
6. Ładowanie pakietu (str.358)
7. Wyliczanie typów zawartych w pakiecie (str.360)
8. Wyliczanie składowych klas (str.360)
9. Wyliczanie parametrów metod (str.361)
10. Dynamiczne wywoływanie (późne wiązanie) (str.363)
11. Klasa Activator (str.363)
12. Działanie i tworzenie pakietów dynamicznych (str.366)
13. Przestrzeń nazw System.Reflection.Emit (str.366)
14. Tworzenie pakietu dynamicznego (str.367)
15. Wykorzystywanie dynamicznie generowanych pakietów (str.372)
16. Programowanie wykorzystujące atrybuty (str.374)
17. Praca z istniejącymi atrybutami (str.375)
18. Budowanie niestandardowych atrybutów (str.376)
19. Ograniczenia użycia atrybutów (str.378)
20. Atrybuty działające na poziomie pakietu (i modułu) (str.380)
21. Plik AssemblyInfo.cs w Visual Studio.NET (str.381)
22. Odczytywanie atrybutów podczas działania programu (str.383)
23. Podsumowanie (str.384)

Rozdział 8. Przegląd przestrzeni nazw Windows Forms (str.385)

1. Dwie przestrzenie nazw dla graficznego interfejsu użytkownika (str.385)
2. Przegląd przestrzeni nazw Windows Forms (str.386)
3. Typy Windows Forms (str.387)
4. Obszar roboczy projektu (str.387)
5. Tworzenie okna głównego (ręcznie) (str.389)
6. Klasa System.Windows.Forms.Application (str.395)
7. Przykłady zastosowania klasy Application (str.397)
8. Obsługa zdarzenia ApplicationExit (str.398)
9. Wstępne przetwarzanie komunikatów za pomocą klasy Application (str.399)
10. Anatomia formularza (str.400)
11. Podstawowe czynności formularza (str.401)
12. Klasa Component (str.401)
13. Klasa Control (str.402)
14. Definiowanie stylów formantu (str.404)
15. Zdarzenia klasy Control (str.406)
16. Praca z klasą Control (str.406)
17. Reagowanie na zdarzenia myszy: część pierwsza (str.408)
18. Sprawdzanie, który przycisk myszy został naciśnięty (str.410)
19. Reagowanie na zdarzenia myszy: część druga (str.410)
20. Reagowanie na zdarzenia klawiatury (str.411)
21. Jeszcze raz o klasie Control (str.413)
22. Klasa Control – ciąg dalszy (str.414)
23. Podstawy informacje o malowaniu (str.416)
24. Klasa Scrollable Control (str.416)
25. Klasa ContainerControl (str.417)
26. Klasa Form (str.418)
27. Klasa Form – ciąg dalszy (str.420)
28. Tworzenie menu za pomocą Windows Forms (str.421)
29. Typ Menu$MenuItemCollection (str.422)
30. Tworzenie systemu Menu (str.423)
31. Umieszczenie kolejnego elementu górnego menu (str.425)
32. Tworzenie menu kontekstowego (pop-up) (str.426)
33. Dekorowanie systemu menu (str.429)
34. Tworzenie menu za pomocą Visual Studio.NET (str.432)
35. Paski stanu (str.434)
36. Tworzenie paska stanu (str.435)
37. Typ Timer (str.437)
38. Wyświetlanie podpowiedzi menu (str.438)
39. Tworzenie paska narzędzi (str.439)
40. Dodawanie obrazów do przycisków paska narzędzi (str.442)
41. Tworzenie pasków narzędzi w fazie projektowania (str.443)
42. Dodawanie ImageList w czasie projektowania (str.445)
43. Niewielka, ale kompletna aplikacja wykorzystująca Windows Forms (str.447)
44. Posługiwanie się rejestrem systemowym (str.448)
45. Współpraca z przeglądarką zdarzeń (str.452)
46. Odczytywanie z dziennika zdarzeń (str.455)
47. Podsumowanie (str.456)

Rozdział 9. Ulepszone środowisko graficzne (GDI+) (str.457)

1. Przegląd przestrzeni nazw GDI+ (str.457)
2. Konfigurowanie obszaru roboczego projektu GDI+ (str.458)
3. Przegląd przestrzeni nazw System.Drawing (str.458)
4. Typy pomocnicze przestrzeni System.Drawing (str.461)
5. Typy Point i PointF (str.461)
6. Typy Rectangle i RectangleF (str.463)
7. Typy Size, SizeF i Region (str.464)
8. Klasa Region (str.464)
9. Sesje malowania (str.465)
10. Unieważnianie obszaru programu klienta (str.467)
11. Wizualizacja obiektów GDI+ bez obsługi zdarzenia Paint (str.468)
12. Klasa Graphics (str.469)
13. Domyślny układ współrędnych GDI+ (str.471)
14. Zmiana jednostek miary na osiach współrzędnych (str.472)
15. Określenie innego początku układu współrzędnych (str.473)
16. Określanie koloru aktywnego (str.475)
17. Klasa ColorDialog (str.476)
18. Manipulowanie czcionkami (str.478)
19. Rodziny czcionek (str.479)
20. Rozmiary czcionek (str.481)
21. Budowa aplikacji do manipulacji czcionkami (str.481)
22. Wyliczanie zainstalowanych czcionek (System.Drawing.Text) (str.484)
23. Klasa FontDialog (str.486)
24. Przegląd przestrzeni nazw System.Drawing.Drawing2D (str.488)
25. Jakość obrazu (str.490)
26. Używanie piór (str.491)
27. Praca z typami Pen Caps (str.495)
28. Pędzle malujące jednolitym kolorem (str.497)
29. Praca z pędzlami kreskującymi (str.499)
30. Pędzle teksturowe (str.501)
31. Pędzle gradientowe (str.502)
32. Malowanie obrazów na ekranie (str.504)
33. Przeciąganie, sprawdzanie położenia kursora i PictureBox (str.507)
34. Więcej o sprawdzaniu trafień (str.511)
35. Sprawdzanie trafień obrazów nieprostokątnych (str.513)
36. Format zasobów .NET (str.516)
37. Przestrzeń nazw System.Resources (str.517)
38. Tworzenie pliku *.resx z poziomu programu (str.518)
39. Odczytywanie pliku *.resx z programu (str.520)
40. Tworzenie pliku *.resources (str.521)
41. Wiązanie pliku *.resources do pakietu (str.521)
42. ResourceWriter (str.522)
43. ResourceManager (str.523)
44. Automatyczna konfiguracja zasobów w Visual Studio.NET (str.524)
45. Podsumowanie (str.527)

Rozdział 10. Programowanie z użyciem formantów Windows Forms (str.529)

1. Hierarchia klasy Control (str.529)
2. Dodawanie (ręczne) formantów do formularza (str.530)
3. Typ Control$ControlCollection (str.531)
4. Dodawanie formantów do formularza (łatwiejszy sposób) (str.533)
5. Formant TextBox (str.535)
6. Przykłady wykorzystania pól tekstowych (str.537)
7. Typ Button (i klasa macierzysta ButtonBase) (str.539)
8. Określanie położenia zawartości (str.541)
9. Przykłady różnych przycisków (str.541)
10. Pola wyboru (str.543)
11. Przyciski opcji (RadioButton) i pola grupy (GroupBox) (str.544)
12. Przykłady przycisków opcji (i pól wyboru) (str.545)
13. Formant CheckedListBox (str.547)
14. Formanty ListBox i ComboBox (str.549)
15. ComboBox (str.551)
16. Określanie kolejności przechodzenia klawiszem Tab (str.554)
17. Kreator Tab Order (str.554)
18. Formant TrackBar (str.555)
19. Formant MonthCalendar (str.558)
20. Więcej o typie DateTime (str.561)
21. Pola przewijane: DomainUpDown i NumericUpDown (str.562)
22. Formanty Panel (str.565)
23. Przypisywanie formantom etykiety narzędzia (ToolTip) (str.566)
24. Wstawianie etykiety narzędzia w czasie projektowania (str.568)
25. ErrorProvider (str.568)
26. Zmiana rozmiarów i punkty zaczepienia formantu (str.571)
27. Dokowanie formantu (str.572)
28. Tworzenie niestandardowych okien dialogowych (str.574)
29. Przykładowa aplikacja z oknem dialogowym (str.575)
30. Odczytywanie danych z okna dialogowego (str.579)
31. Dziedziczenie formularzy (str.581)
32. Podsumowanie (str.582)

Rozdział 11. Wejście, wyjście i serializacja obiektów (str.585)

1. Przestrzeń nazw System.IO (str.585)
2. Typy Directory(Info) oraz File(Info) (str.587)
3. Abstrakcyjna klasa podstawowa FileSystemInfo (str.587)
4. Typ DirectoryInfo (str.588)
5. Wyliczenie FileAttributes (str.590)
6. Wyliczanie plików za pomocą typu DirectoryInfo (str.590)
7. Utworzenie podkatalogów za pomocą typu DirectoryInfo (str.592)
8. Statyczne elementy klasy Directory (str.593)
9. Klasa FileInfo (str.594)
10. Metoda FileInfo.Open() (str.596)
11. Elementy FileInfo.OpenRead() i FileInfo.OpenWrite() (str.598)
12. Składowe FileInfo.OpenText(), FileInfo.CreateText() i FileInfo.AppendText() (str.599)
13. Abstrakcyjna klasa Stream (str.599)
14. FileStreams (str.600)
15. MemoryStream (str.602)
16. BufferedStreams (str.603)
17. StreamWriter i StreamReader (str.603)
18. Zapis do pliku tekstowego (str.605)
19. Odczyt z pliku tekstowego (str.606)
20. StringWriter (str.608)
21. StringReader (str.610)
22. Przetwarzanie danych binarnych (BinaryReader i BinaryWriter) (str.611)
23. Ciekawostka (str.613)
24. Trwałość obiektów na platformie .NET (str.615)
25. Rola grafów obiektowych (str.615)
26. Konfiguracja obiektów w celu serializacji (str.616)
27. Wybór formatera (str.619)
28. Rola przestrzeni nazw System.Runtime.Serialization (str.619)
29. Serializacja za pomocą formatera binarnego (str.620)
30. Serializacja za pomocą formatera SOAP (str.622)
31. Serializacja niestandardowa (oraz interfejs ISerializable) (str.623)
32. Prosty przykład (str.624)
33. Aplikacja Windows Forms – ewidencja pojazdów (str.627)
34. Dodawanie danych o kolejnych samochodach (str.630)
35. Zastosowanie serializacji (str.631)
36. Podsumowanie (str.634)
37. Rozdział 12. Praca z kodem niezarządzanym (str.635)
38. Problemy współpracy różnych platform (str.635)
39. Przestrzeń nazw System.Runtime.InteropServices (str.636)
40. Współpraca z bibliotekami DLL w języku C (str.637)
41. Pole ExactSpelling (str.640)
42. Definiowanie zestawu znaków (str.640)
43. CallingConvention i EntryPoint (str.641)
44. Współpraca środowisk .NET i COM (str.642)
45. Typy COM jako równoważne typom .NET (str.643)
46. Zarządzanie zliczaniem referencji ko-klasy (str.643)
47. Ukrywanie interfejsów COM niskiego poziomu (str.644)
48. Bardzo prosty serwer Visual Basic COM (str.645)
49. IDL dla serwera VB COM (str.647)
50. Bardzo prosty klient COM (str.648)
51. Importowanie biblioteki typów (str.650)
52. Referencje do pakietu (str.651)
53. Wczesne wiązanie do klasy COM CoCalc (str.651)
54. Późne wiązanie do klasy CoCalc (str.652)
55. Postać wygenerowanego pakietu (str.655)
56. Budowanie testowego serwera ATL (str.657)
57. Rozbudowa interfejsu [default] COM (str.658)
58. Generowanie zdarzenia COM (str.660)
59. Zgłoszenie błędu COM (str.661)
60. Ujawnianie wewnętrznego podobiektu (i użycie SAFEARRAY) (str.662)
61. Ostatni punkt: konfigurowanie wyliczenia IDL (str.664)
62. Klient próbny w Visual Basicu 6.0 (str.665)
63. Tworzenie pakietu (i sprawdzanie procesu konwersji) (str.667)
64. Konwersja biblioteki typu (str.668)
65. Konwersja interfejsu COM (str.668)
66. Konwersja atrybutu parametru IDL (str.669)
67. Konwersja hierarchii interfejsu (str.670)
68. Konwersje ko-klasy (i właściwości COM) (str.670)
69. Konwersje wyliczeń COM (str.673)
70. COM SAFEARRAY (str.674)
71. Obsługa zdarzeń COM (str.675)
72. Obsługa błędu COM (str.679)
73. Pełny program klienta w C# (str.679)
74. Współdziałanie w kierunku z COM do .NET (str.681)
75. Rola osłony CCW (str.682)
76. Interfejs klasy (str.683)
77. Definiowanie interfejsu klasy (str.684)
78. Tworzenie typu .NET (str.684)
79. Generowanie biblioteki typów i rejestrowanie typów .NET (str.685)
80. Sprawdzanie informacji o typach eksportowanych (str.685)
81. Interfejs _Object (str.686)
82. Wygenerowana instrukcja biblioteki (str.687)
83. Oglądanie typów za pomocą przeglądarki obiektów OLE/COM Object Viewer (str.688)
84. Sprawdzanie zarejestrowanych elementów (str.688)
85. Tworzenie klienta próbnego w Visual Basicu 6.0 (str.690)
86. Problemy mapowania z pakietu .NET na COM (str.692)
87. Informacja o typie BaseClass (str.693)
88. Informacja o typie DerivedClass (str.693)
89. Zarządzanie wygenerowanym kodem IDL (czyli TlbExp.exe) (str.694)
90. Informacja o wygenerowanym typie COM (str.696)
91. Rejestracja pakietu (str.697)
92. Współpraca z usługami COM+ (str.697)
93. Przestrzeń nazw System.EnterpriseServices (str.699)
94. Tworzenie typów dla środowiska COM+ (str.700)
95. Tworzenie typu C# przeznaczonego dla środowiska COM+ (str.701)
96. Dodawanie atrybutów COM+ na poziomie pakietu (str.702)
97. Konfigurowanie pakietu w katalogu COM+ (str.703)
98. Eksplorator usług składowych (str.704)
99. Podsumowanie (str.705)

Rozdział 13. Dostęp do danych za pomocą ADO.NET (str.707)

1. Dlaczego potrzebne jest środowisko ADO.NET (str.707)
2. Przegląd ADO.NET (str.708)
3. Przestrzenie nazw ADO.NET (str.709)
4. Typy przestrzeni System.Data (str.710)
5. Typ DataColumn (str.712)
6. Tworzenie DataColumn (str.713)
7. Wstawianie DataColumn do DataTable (str.715)
8. Przygotowanie DataColumn do pełnienia funkcji klucza głównego (str.715)
9. Włączanie pól z autoinkrementacją (str.715)
10. Reprezentacja XML (str.717)
11. Typ DataRow (str.718)
12. Właściwość DataRow.RowState (str.719)
13. Właściwość ItemArray (str.721)
14. DataTable (str.722)
15. Tworzenie pełnej DataTable (str.724)
16. Manipulowanie DataTable: usuwanie wierszy (str.726)
17. Manipulacja danymi klasy DataTable: filtrowanie i przeszukiwanie (str.727)
18. Manipulowanie danymi w DataTable: uaktualnianie wierszy (str.730)
19. Typ DataView (str.732)
20. Do czego służy DataSet (str.735)
21. Składowe klasy DataSet (str.736)
22. Tworzenie DataSet (str.737)
23. Formułowanie relacji za pomocą typu DataRelation (str.740)
24. Nawigowanie między pokrewnymi tabelami (str.742)
25. Odczytywanie i zapisywanie zbiorów danych zapisanych w formacie XML (str.745)
26. Budowa prostej testowej bazy danych (str.747)
27. Providery danych środowiska ADO.NET (str.748)
28. Zarządzany provider OleDb (str.749)
29. Nawiązywanie połączenia za pomocą typu OleDbConnection (str.750)
30. Tworzenie polecenia SQL (str.752)
31. OleDbDataReader (str.753)
32. Połączenie z bazą danych Access (str.755)
33. Wykonanie procedury zapisanej w bazie (str.755)
34. Typ OleDbDataAdapter (str.758)
35. Zapełnianie DataSet za pomocą typu OleDbDataAdapter (str.760)
36. Zarządzany provider danych SQL (str.762)
37. Przestrzeń nazw System.Data.SqlTypes (str.763)
38. Wstawianie nowych rekordów za pomocą SqlDataAdapter (str.763)
39. Uaktualnianie istniejących rekordów za pomocą SqlDataAdapter (str.766)
40. Polecenia SQL tworzone automatycznie (str.768)
41. Wypełnianie DataSet składającego się z wielu tabel (i dodawanie DataRelation) (str.770)
42. Podsumowanie (str.773)

Rozdział 14. ASP.NET i programowanie dla sieci WWW (str.775)

1. Aplikacje i serwery WWW (str.775)
2. Katalogi wirtualne (str.776)
3. Podstawowa struktura dokumentu HTML (str.778)
4. Podstawowe formatowanie tekstu w HTML (str.780)
5. Formatowanie nagłówków (str.782)
6. Edytory HTML w Visual Studio.NET (str.783)
7. Tworzenie formularzy w HTML (str.784)
8. Tworzenie interfejsu użytkownika (str.786)
9. Wstawianie obrazu (str.788)
10. Rola skryptów po stronie klienta (str.789)
11. Przykład skryptów po stronie klienta (str.790)
12. Weryfikacja poprawności strony HTML default.htm (str.792)
13. Przekazywanie danych z formularza (metody GET i POST) (str.794)
14. Przetwarzanie zapytania (str.795)
15. Tworzenie strony klasycznego serwera Active (str.795)
16. Odpowiedź na dane przesłane metodą POST (str.798)
17. Pierwsza aplikacja ASP.NET (str.799)
18. Niektóre problemy dotyczące klasycznego ASP (str.800)
19. Korzyści płynące z ASP.NET (str.801)
20. Przestrzenie nazw ASP.NET (str.801)
21. Podstawowe typy przestrzeni System.Web (str.801)
22. Na czym polega różnica między aplikacją a sesją (str.803)
23. Prosta aplikacja WWW w języku C# (str.804)
24. Początkowa postać pliku *.aspx (str.806)
25. Plik web.config (str.807)
26. Plik global.asax (str.808)
27. Dodawanie prostej logiki w języku C# (str.808)
28. Architektura aplikacji WWW w pakiecie ASP.NET (str.809)
29. Typ System.Web.UI.Page (str.810)
30. Codebehind i *.aspx (str.812)
31. Właściwość Page.Request (str.813)
32. Właściwość Page.Response (str.814)
33. Właściwość Page.Application (str.816)
34. Właściwość Page.Session (str.817)
35. Usuwanie błędów i śledzenie przebiegu aplikacji ASP.NET (str.817)
36. Korzyści płynące z zastosowania formantów WebForm (str.820)
37. Formanty WebForm (str.821)
38. Wyprowadzenie formantów WebForm (str.823)
39. Kategorie formantów WebForm (str.825)
40. Wbudowane formanty WebForm (str.825)
41. Formanty wzbogacone (str.828)
42. Formanty związane z przetwarzaniem danych (str.832)
43. Formanty do sprawdzania poprawności danych (str.835)
44. Obsługa zdarzeń związanych z formantami WebForm (str.838)
45. Podsumowanie (str.840)

Rozdział 15. Tworzenie usług WWW (str.841)

1. Rola usług WWW (str.841)
2. Anatomia usługi WWW (str.842)
3. Protokół wire (str.842)
4. Usługi opisu serwisu WWW (str.843)
5. Usługi wykrywania (str.843)
6. Przestrzenie nazw serwisu WWW (str.843)
7. Przestrzeń nazw System.Web.Services (str.844)
8. Budowa prostego serwisu WWW (str.844)
9. Plik Codebehind (*.asmx.cs) (str.846)
10. Dodawanie prostych funkcji (str.847)
11. Testowanie serwisu WWW (str.848)
12. Typ WebMethodAttribute (str.850)
13. Klasa bazowa System.Web.Services.WebService (str.853)
14. Język WSDL (Web Service Description Language) (str.854)
15. Protokoły komunikacji serwisu WWW (str.857)
16. Transmisja danych za pomocą HTTP GET i POST (str.857)
17. Transmisja danych za pomocą SOAP (str.859)
18. Konwersja z WSDL do C# (tworzenie proxy) (str.861)
19. Tworzenie proxy za pomocą wsdl.exe (str.862)
20. Tworzenie pakietu (str.864)
21. Budowanie klienta (str.864)
22. Tworzenie proxy za pomocą VS.NET (str.866)
23. Bardziej interesujący serwis WWW (i klient WWW) (str.868)
24. Serializowanie typów niestandardowych (str.869)
25. Rozbudowa klienta Windows Forms (str.870)
26. Tworzenie typów serializowanych (dalsze szczegóły) (str.872)
27. Protokół Discovery (str.873)
28. Dodawanie nowej usługi (str.874)
29. Podsumowanie (str.876)

Skorowidz (str.877)