Poznaj .NET Framework - siłę platformy .NET

Niniejsza książka stanowi wprowadzenie do .NET Framework, złożonego i bardzo bogatego zestawu narzędzi służących do tworzenia aplikacji dla platformy .NET. Lektura tej książki sprawi, że poznasz główne elementy .NET Framework i nauczysz się tworzyć programy dla platformy .NET. Duża liczba przykładów - od tworzenia grafiki do obsługi baz danych - zilustrowanych wieloma linijkami kodu, ułatwi Ci tworzenie zaawansowanych aplikacji w pełni korzystających z nowych cech platformy .NET. Dołączony CD-ROM zawiera wiele gotowych do użycia narzędzi, które ułatwią Ci pracę.

Dzięki tej książce:

• Zrozumiesz architekturę .NET
• Dowiesz się, czym jest i co zawiera .NET Framework
• Poznasz główne przestrzenie nazw .NET
• Nauczysz się tworzyć aplikacje z graficznym interfejsem użytkownika dla platformy .NET korzystające z biblioteki Windows Forms
• Dowiesz się, jak programować usługi XML Web Services za pomocą biblioteki ASP.NET,
• Nauczysz się obsługiwać bazy danych za pomocą biblioteki ADO.NET
• Dowiesz się jak korzystać z obiektów COM i API systemu Windows
• Zrozumiesz mechanizm bezpieczeństwa platformy .NET
• Nauczysz się korzystać z SOAP i XML
• Poznasz technologię Remoting
• Dowiesz się jak korzystać z formularzy i kontrolek WWW
• Nauczysz się posługiwać piórami, pędzlami, kolorami i innymi składowymi przestrzeni nazw Drawing

Książka przeznaczona jest dla programistów Visual Basica, C++, C# i Javy tworzących aplikacje dla Windows.

Osoby które kupowały "Visual Studio .NET: .NET Framework. Czarna księga", wybierały także:

• Gray Hat C#. Język C# w kontroli i łamaniu zabezpieczeń 57,74 zł, (17,90 zł -69%)
• ASP.NET Core 6. Kurs video. Rozwijaj aplikacje webowe z Entity Framework Core 179,00 zł, (71,60 zł -60%)
• Testowanie automatyczne w .NET. Kurs video. Zastosowania frameworka nUnit 169,00 zł, (76,05 zł -55%)
• Programowanie asynchroniczne i równoległe w C#. Kurs video. Poziom podstawowy 69,00 zł, (31,05 zł -55%)
• Technologia LINQ. Kurs video. Warsztat pracy z danymi z różnych źródeł 59,00 zł, (26,55 zł -55%)

Spis treści

Visual Studio .NET: .NET Framework. Czarna księga -- spis treści

O Autorach (17)

Wstęp (19)

Rozdział 1. Wprowadzenie do .NET (23)

• Co to jest .NET? (23)
  
• Wstęp do kluczowych technologii (25)
  
  • IL i specyfikacja CLS (26)
  • Środowisko CLR (27)
  • Biblioteka klas bazowych (27)
  • ASP.NET (29)
  • Windows Forms (30)
  • XML (31)
  • C# (32)
• Jak działa .NET? (34)
  
  • IL i metadane (34)
  • Kompilacja JIT (35)
  • Kod nadzorowany a automatyczne zwalnianie pamięci (36)
  • Przestrzenie nazw (36)
  • Podzespoły (37)
  • Dziedziny aplikacyjne (40)
• Wpływ .NET na Visual C++ i Visual Basica (41)
  
  • Visual C++ (41)
  • Visual Basic (43)
• Oto C# (44)
  
• Co się stało z COM? (46)

Rozdział 2. Model programowania w środowisku .NET (49)

• Teoria (49)
  
  • Programowanie obiektowe z lotu ptaka (49)
    • Co to jest obiekt? (50)
    • Zapis klas i obiektów w kodzie (52)
    • Dziedziczenie i polimorfizm (54)
    • Mała dygresja na temat UML (57)
    • Interfejsy (58)
  • Klasy (59)
    • Części składowe klasy (59)
    • Modyfikatory klas (60)
  • Typy referencyjne i bezpośrednie (61)
  • Struktury (63)
  • Dziedziczenie (65)
  • Interfejsy (65)
  • Delegacje (66)
  • Zdarzenia (67)
  • Metadane i atrybuty (68)
  • Wyjątki (69)
  • Refleksja i klasa Type (72)
• Gotowe rozwiązania (74)
  
  • Definiowanie klas (74)
  • Przeciążanie i przesłanianie metod (74)
  • Definiowanie pól i metod należących do klasy (75)
  • Definiowanie struktur (75)
  • Konstruktory i destruktory w VB (77)
  • Sprzątanie po obiektach .NET (78)
  • Korzystanie z dziedziczenia (78)
  • Przesłanianie metod (79)
  • Definiowanie klas abstrakcyjnych (80)
  • Definiowanie zapieczętowanych klas i metod (81)
  • Definiowanie właściwości (81)
  • Definiowanie interfejsów (83)
  • Implementowanie interfejsów (83)
  • Korzystanie z obiektu za pośrednictwem interfejsu (84)
  • Definiowanie i używanie delegacji (86)
  • Definiowanie i używanie zdarzeń (90)
  • Jak dołączyć atrybuty do klas i składowych? (96)
  • Jak definiuje się atrybuty użytkownika? (97)
  • Jak odczytać wartość atrybutu? (100)
  • Jak obsłużyć wyjątek? (102)
  • Jak zgłosić wyjątek? (104)
  • Jak otrzymać obiekt klasy Type z informacjami o typie? (104)
  • Jak odczytać informacje o typie? (105)
  • Dynamiczne tworzenie obiektów (107)

Rozdział 3. Przestrzeń nazw System (109)

• Teoria (109)
  
  • Typy podstawowe (109)
    • Typy podstawowe a CLS (110)
    • Typy zmiennopozycyjne (110)
    • Konwersje (111)
    • Interfejsy (112)
  • Klasa Object (113)
    • Równość obiektów (113)
    • Finalizacja (115)
    • Metoda GetHashCode() (116)
    • Metoda GetType() (116)
    • Klonowanie i kopiowanie (116)
    • ToString() (117)
  • Tablice (118)
  • Inne typy (119)
    • String (119)
    • DateTime i TimeSpan (119)
    • TimeZone (119)
    • Decimal (120)
  • Wyliczenia (120)
  • Wyjątki (121)
  • Klasa Console (122)
  • Klasa Math (123)
  • Klasa Type (123)
  • Inne klasy (124)
• Gotowe rozwiązania (124)
  
  • W jaki sposób można skorzystać z klas zdefiniowanych w przestrzeni nazw System? (124)
  • Co łączy typy danego języka programowania z typami przestrzeni System? (125)
  • Jak zdefiniować nowy typ bezpośredni? (126)
  • Jak sprawdzić, czy dwa obiekty są takie same? (130)
    • Typy referencyjne (130)
    • Typy bezpośrednie (131)
  • Jak zrealizować kopiowanie płytkie i głębokie? (131)
  • Jak zdefiniować własną metodę ToString()? (133)
  • Indeksowanie tablic w języku Visual Basic (135)
  • Jak posługiwać się typem Array? (135)
    • Tworzenie tablic (136)
    • Odczyt właściwości tablicy (136)
    • Odczyt elementów tablicy i nadanie im wartości (137)
    • Metody klasy Array (138)
  • Jak posługiwać się typem String? (140)
    • Tworzenie obiektu klasy String (140)
    • Porównywanie napisów (141)
    • Kopiowanie i modyfikacja napisów (142)
    • Przeszukiwanie napisów (143)
    • Konwersja napisów (144)
  • Jak przedstawiać i posługiwać się datami i czasem? (144)
    • Tworzenie obiektu klasy TimeSpan (144)
    • Odczyt wartości obiektów TimeSpan (145)
    • Operacje na obiektach TimeSpan (145)
    • Tworzenie obiektu klasy DateTime (145)
    • Wyprowadzenie daty i czasu (146)
    • Odczyt wartości obiektów DateTime (146)
    • Operacje na obiektach DateTime (147)
  • Jak definiować i posługiwać się typami wyliczeniowymi? (148)
  • Jak dowiedzieć się, jaki wyjątek oraz gdzie wystąpił? (149)
  • Jak korzysta się z wyjątków wewnętrznych? (150)
  • Czym różnią się metody Console.WriteLine() i Console.Out.WriteLine()? (151)
  • Jak formatować wyprowadzane dane? (151)
    • Wykorzystanie szablonów do formatowania (152)
    • Metoda ToString() (153)
  • Jak generuje się liczby losowe? (154)

Rozdział 4. Przestrzeń nazw System.Collections (157)

• Teoria (157)
  
  • Interfejsy zdefiniowane w System.Collections (158)
    • Interfejs IEnumerable (158)
    • Interfejs IEnumerator (159)
    • Interfejs ICollection (159)
    • Interfejs IList (160)
    • Interfejs IComparer (160)
    • Interfejs IDictionary (161)
    • Interfejs IDictionaryEnumerator (162)
    • Interfejs IHashCodeProvider (162)
  • Klasa ArrayList (162)
  • Klasa BitArray (163)
  • Klasa Hashtable (163)
  • Klasa NameValueCollection (165)
  • Klasa Queue (165)
  • Klasa SortedList (166)
  • Klasa Stack (166)
  • Klasy StringCollection i StringDictionary (167)
• Gotowe rozwiązania (167)
  
  • Której klasy kolekcji użyć? (167)
  • Które kolekcje są wielobieżne? (168)
  • Jak zbudować iterację dla elementów kolekcji? (169)
  • Jak posługiwać się klasą ArrayList? (170)
    • Tworzenie i wypełnianie obiektu klasy ArrayList (170)
    • Usuwanie elementów (171)
    • Operacje na obiektach ArrayList (172)
    • Korzystanie z metod opakowujących (173)
  • Jak przechowywać dane identyfikowane kluczami? (174)
    • Tworzenie i wypełnianie obiektu klasy Hashtable (174)
    • Wyszukiwanie kluczy i wartości w obiekcie klasy Hashtable (175)
    • Usuwanie elementów z obiektu klasy Hashtable (176)
    • Korzystanie z metod opakowujących obiekt klasy Hashtable (176)
    • Korzystanie z klasy SortedList (177)
    • Tworzenie i wypełnianie obiektu klasy SortedList (177)
    • Pobieranie elementów w obiekcie klasy SortedList (179)
    • Modyfikacja elementów w obiekcie klasy SortedList (179)
    • Usuwanie elementów w obiekcie klasy SortedList (179)
    • Korzystanie z obiektów SortedList przez wiele wątków (180)
  • Przechowywanie listy elementów w obiekcie klasy Queue (180)
  • Jak posługiwać się klasą Stack? (181)
  • Jak przechowywać znaczniki w obiekcie klasy BitArray? (182)
  • Przechowywanie napisów w obiekcie klasy StringCollection (183)
  • Przechowywanie napisów w obiekcie klasy NameValueCollection (184)
    • Wyszukiwanie i pobieranie elementów (185)
    • Usuwanie elementów (186)
  • Jak określić własną kolejność sortowania? (186)
  • Jak zdefiniować własną kolekcję? (188)

Rozdział 5. Przestrzenie nazw XML (191)

• Teoria (191)
  
  • XML z lotu ptaka (191)
    • Co to jest XML? (192)
    • Budowa dokumentu XML (193)
    • Atrybuty (195)
    • Poprawność dokumentu XML (195)
    • Przestrzenie nazw (196)
    • Przetwarzanie dokumentów XML (197)
    • Wykorzystanie arkuszy stylów XSL do przekształceń dokumentów XML (198)
  • Przestrzeń nazw System.Xml (200)
  • Klasa XmlTextReader (200)
  • Klasa XmlValidatingReader (202)
  • Klasa XmlTextWriter (203)
  • Klasa XmlDocument (203)
    • Klasa XmlNode (205)
    • Klasa XmlElement (205)
    • Składowe klasy XmlDocument (206)
  • XSL i XPath (207)
  • Klasa XPathNavigator (208)
• Gotowe rozwiązania (209)
  
  • Której klasy należy użyć do obsługi XML? (209)
  • Przetwarzanie dokumentu XML za pomocą klasy XmlTextReader (211)
    • Tworzenie obiektu klasy XmlTextReader (212)
    • Odczyt elementów (212)
    • Korzystanie z atrybutów (214)
    • Obsługa przestrzeni nazw (215)
  • Przetwarzanie dokumentu ze sprawdzaniem poprawności (215)
  • Zapis dokumentu XML za pomocą klasy XmlTextWriter (218)
    • Wyprowadzanie instrukcji przetwarzania i komentarzy (220)
    • Obsługa przestrzeni nazw (221)
  • Korzystanie z klasy XPathNavigator (221)
    • Tworzenie obiektu (221)
    • Poruszanie się po drzewie (222)
    • Nawigacja wśród atrybutów (224)
  • Obsługa drzewa DOM za pomocą klasy XmlDocument (225)
    • Ładowanie dokumentu XML (225)
    • Nawigacja (226)
    • Przetwarzanie węzłów potomnych (226)
    • Tworzenie i modyfikacja węzłów (229)
  • Korzystanie z klasy XPath (231)
    • Kompilacja wyrażeń XPath (232)
  • Przekształcanie dokumentu XML za pomocą klasy XslTransform (233)

Rozdział 6. Przestrzenie nazw klas wejścia-wyjścia i sieciowych (235)

• Teoria (235)
  
  • Strumienie (235)
    • Klasa Stream (235)
    • Klasa FileStream (237)
    • Klasa MemoryStream (239)
    • Inne klasy do obsługi strumieni (239)
  • Tekstowe operacje wejścia-wyjścia (240)
    • Podklasy TextWriter (241)
    • Podklasy TextReader (243)
  • Pliki i katalogi (244)
    • Klasa FileSystemInfo (244)
    • Klasa File (245)
    • Klasa FileInfo (247)
    • Klasa Directory (248)
    • Klasa DirectoryInfo (249)
    • Klasa Path (249)
    • Klasa FileSystemWatcher (250)
  • Przestrzeń nazw System.Net (251)
    • Klasy: IPAddress, IPEndPoint i Dns (252)
    • Podklasy WebRequest i WebResponse (252)
  • Przestrzeń nazw System.Net.Sockets (253)
    • Czym są gniazda? (253)
    • Jak korzystać z gniazd? (254)
• Gotowe rozwiązania (256)
  
  • Binarne operacje wejścia-wyjścia z użyciem strumieni (256)
  • Odczyt i zapis w plikach tekstowych (258)
    • Zapis w pliku (259)
    • Odczyt z pliku (261)
  • Przetwarzanie plików i katalogów (262)
    • Założenie projektu (263)
    • Odczyt listy napędów (263)
    • Obsługa wyboru innego napędu (264)
    • Przetworzenie katalogu (265)
    • Wyświetlenie informacji o plikach i katalogach (266)
    • Zmiana katalogu (268)
    • Przejście do góry (269)
  • Śledzenie zmian plików i katalogów (269)
    • Założenie projektu (270)
    • Zdefiniowanie interfejsu użytkownika (270)
  • Korzystanie z gniazd (273)
    • Program klienta (274)
    • Podłączenie do gniazda (275)
    • Pobranie strumienia (275)
    • Wysłanie danych do gniazda (275)
    • Program serwera (276)

Rozdział 7. Bezpieczeństwo w .NET (279)

• Teoria (279)
  
  • Model bezpieczeństwa w .NET (280)
    • Współpraca mechanizmów bezpieczeństwa .NET i systemu Windows (280)
    • Uprawnienia dostępu do kodu (281)
    • Uprawnienia związane z tożsamością (281)
    • Uprawnienia związane z rolami (283)
  • Zasady bezpieczeństwa (283)
    • Definiowanie zasad bezpieczeństwa (285)
  • Kodowanie operacji na uprawnieniach (289)
  • Klasa CodeAccessPermission (289)
    • Sprawdzanie uprawnień (291)
    • Ograniczanie uprawnień (293)
    • Gwarantowanie uprawnień (294)
• Gotowe rozwiązania (295)
  
  • Nadawanie podzespołom nazw silnych (295)
    • Nadanie nazwy silnej za pomocą Visual Studio .NET (296)
    • Nadanie nazwy silnej za pomocą programu al.exe (296)
  • Żądanie dostępu do zasobów (297)
  • Ograniczanie dostępu do plików i katalogów (298)
  • Umożliwienie wykonywania metody tylko wskazanym użytkownikom (300)
    • Sprawdzenie bezpośrednie (300)
    • Użycie atrybutów określających tożsamość (301)
    • Użycie klas WindowsIdentity i WindowsPrincipal (302)

Rozdział 8. Przestrzeń nazw System.Web (305)

• Teoria (305)
  
  • Wprowadzenie do ASP.NET (305)
    • Od ASP do ASP.NET (306)
    • Jak działa sieć WWW? (307)
    • Stosowanie technologii ASP.NET w aplikacjach (310)
  • Formularze WWW (311)
    • Jak działają formularze WWW? (312)
    • Kod schowany (313)
    • Zdarzenia ASP.NET (314)
    • Formularze WWW w projekcie aplikacji (316)
  • Kontrolki WWW (316)
    • Kontrolki HTML (316)
    • Kontrolki WWW (317)
    • Zdarzenia zgłaszane przez kontrolki (318)
  • Usługi XML Web Services (319)
    • Wstęp do usług XML Web Services (320)
    • Przykłady usług XML Web Services (321)
    • Jak działają usługi XML Web Services? (323)
    • Zmiana paradygmatów projektowych (324)
    • Usługi XML Web Services w projekcie aplikacji (325)
    • Tworzenie usług XML Web Services (327)
    • Wywoływanie usług XML Web Services (327)
• Gotowe rozwiązania (331)
  
  • Utworzenie formularza WWW (331)
  • Dodanie kontrolek WWW do formularza WWW (333)
    • Sposoby rozmieszczania kontrolek na formularzu WWW (333)
    • Dodanie kontrolek i wybór sposobu ich rozmieszczania (333)
  • Dodanie kodu obsługującego zdarzenia zgłaszane przez kontrolki WWW (334)
  • Wykrycie przesłania zwrotnego w obsłudze zdarzenia Page_Load (335)
  • Opóźniona obsługa zdarzeń (337)
  • Korzystanie z kontrolki WWW DataGrid (340)
  • Korzystanie z kontrolek sprawdzających (343)
  • Przechowywanie danych w obiekcie sesji serwera WWW (344)
  • Testowanie i debugging formularzy WWW (345)
    • Punkty kontrolne i inne narzędzia (345)
    • Właściwość Trace formularzy WWW (347)
  • Utworzenie usługi XML Web Service (347)
    • Usługa BookService (348)
    • Zamiana biblioteki klas na usługę XML Web Service (350)
  • Wykrywanie usług XML Web Services i korzystanie z plików WSDL (351)
    • Wykrywanie usług XML Web Services (351)
    • Dokument WSDL (352)
  • Wywołanie usługi XML Web Service z aplikacji (354)
  • Testowanie i debugging usług XML Web Services (355)
    • Debugging usługi XML Web Service w Visual Studio .NET (355)
    • Punkty kontrolne i inne narzędzia (356)
    • Korzystanie ze zdalnych usług XML Web Services (356)

Rozdział 9. Formularze Windows Forms (357)

• Teoria (357)
  
  • Formularze i kontrolki (357)
  • Anatomia aplikacji typu Windows Forms (358)
    • Szkielet aplikacji (358)
    • Kod programu i polecenie wywołujące kompilator (360)
  • Klasa Form (361)
    • Właściwości formularza (361)
    • Związki między formularzami (364)
    • Formularze MDI (366)
    • Okna dialogowe (369)
    • Obsługa zdarzeń (370)
  • Klasa Application (372)
  • Dziedziczenie wizualne (373)
  • Powszechnie stosowane okna dialogowe (375)
• Gotowe rozwiązania (376)
  
  • Jak utworzyć aplikację typu Windows Forms? (376)
  • Jak zdefiniować i wyświetlić nowy formularz? (379)
  • Utworzenie formularza MDI (380)
  • Utworzenie i wyświetlenie okna dialogowego (381)
    • Utworzenie okna dialogowego (381)
    • Wyświetlenie okna dialogowego (382)
  • Wyświetlenie okna komunikatu (383)
  • Jak obsługiwać menu? (384)
    • Obsługa zdarzeń zgłaszanych przez menu (385)
    • Kodowanie operacji na menu (385)
  • Jak dodać do formularza menu kontekstowe? (387)
  • Wyświetlenie okna dialogowego "Otwieranie" (388)
  • Utworzenie formularza pochodzącego od innego formularza (390)
  • Użycie kontrolki Splitter (392)

Rozdział 10. Kontrolki i formularze Windows Forms (393)

• Teoria (393)
  
  • Formularze i kontrolki (393)
  • Klasa Control (394)
    • Styl obiektu klasy Control (396)
    • Odświeżenie kontrolki (396)
  • Zastosowanie kontrolek (398)
    • Kontrolki Label i LinkLabel (398)
    • Przyciski (399)
    • Kontrolki CheckBox i RadioButton (401)
    • Kontrolka ListBox (402)
    • Kontrolka CheckedListBox (405)
    • Kontrolka ComboBox (406)
    • Pola tekstowe (406)
    • Kontrolka DataGrid (411)
    • Kontrolka DateTimePicker (412)
    • Kontrolka MonthCalendar (415)
    • Kontrolki UpDown (416)
    • Kontrolka GroupBox (416)
    • Kontrolka Panel (417)
    • Paski przewijania i kontrolka TrackBar (418)
    • Kontrolka ImageList (419)
    • Kontrolki ListView i TreeView (420)
    • Menu (425)
    • Kontrolka PictureBox (426)
    • Kontrolka ProgressBar (426)
    • Kontrolka StatusBar (427)
    • Kontrolka Toolbar (428)
    • Klasa SystemInformation (429)
    • Kontrolka TabControl (430)
    • Kontrolka Timer (433)
    • Kontrolki dostawcze (433)
• Gotowe rozwiązania (434)
  
  • Rozmieszczenie kontrolek na formularzu (434)
  • Ustalenie kolejności dostępu do kontrolek (436)
  • Wykorzystanie etykiet do przemieszczania się między kontrolkami (437)
  • Symulacja hiperłączy (437)
  • Jak utworzyć grupę przycisków opcji? (438)
  • Korzystanie z pól tekstowych (439)
    • Odczyt i ustawienie zawartości (439)
    • Pola tekstowe jednowierszowe i wielowierszowe (439)
    • Operacje na zaznaczonym tekście (439)
    • Zmiana wielkości liter (440)
  • Skąd wiadomo, że zmieniła się zawartość pola tekstowego? (440)
  • Zamaskowanie hasła wprowadzanego w polu tekstowym (440)
  • Jak umożliwić użytkownikowi wybór jednego z napisów przechowywanych w tablicy? (440)
  • Jak wyświetlić bieżącą wartość kontrolki TrackBar? (441)
  • Jak używa się kontrolek: ListBox, CheckedListBox i ComboBox? (441)
    • Ustawienie właściwości (442)
    • Dodanie elementów (442)
    • Ustalenie, który element listy jest wybrany (443)
    • Obsługa zdarzenia wyboru elementu (444)
    • Korzystanie z kontrolki CheckedListBox (445)
    • Korzystanie z kontrolki ComboBox (445)
  • Korzystanie z kontrolki StatusBar (446)
    • Tekst i panele (446)
  • Korzystanie z kontrolki ToolBar (447)
    • Zdefiniowanie paska narzędziowego (448)
    • Obsługa zdarzeń zgłaszanych przez przyciski (449)
    • Style przycisków (450)
  • Korzystanie z kontrolki TreeView (450)
    • Utworzenie kontrolki TreeView (450)
    • Tworzenie wierzchołków (450)
    • Właściwości kontrolki TreeView określające jej wygląd (451)
    • Obsługa zdarzeń (452)
  • Korzystanie z kontrolki ListView (452)
    • Utworzenie kontrolki ListView (453)
    • Tworzenie elementów (453)
    • Obsługa zdarzeń (454)
  • Tworzenie formularzy z zakładkami (455)
  • Korzystanie z kontrolki Timer (457)
  • Jak na formularzu umieścić kontrolkę ActiveX? (457)
  • Jak zdefiniować własną kontrolkę? (458)
    • Zdefiniowanie właściwości kontrolki (458)
    • Przesłonięcie metody OnPaint() (459)
    • Obsługa zdarzeń myszy (459)
    • Testowanie kontrolki (460)

Rozdział 11. Przestrzenie nazw Drawing (463)

• Teoria (463)
  
  • Podstawowe funkcje podsystemu GDI+ (463)
    • Klasa Graphics (463)
    • Podstawowe struktury danych (464)
    • Kolory (468)
    • Przybory do rysowania: pióra i pędzle (469)
    • Szczegółowe informacje o klasie Graphics (475)
    • Odświeżenie wyświetlanej grafiki (478)
  • Czcionki (479)
  • Obsługa obrazów (479)
    • Klasa Image (481)
    • Klasa Bitmap (482)
    • Klasy Icon i SystemIcons (482)
  • Drukowanie (484)
    • Klasa PrintDocument (484)
    • Klasy przechowujące ustawienia: PrinterSettings i PageSettings (485)
    • Klasa PrintController (486)
    • Zdarzenie PrintPage (487)
• Gotowe rozwiązania (488)
  
  • Jak narysować coś na formularzu? (488)
    • Korzystanie ze składowych klasy Graphics (489)
  • Korzystanie z kolorów (490)
    • Konwersje kolorów (492)
  • Korzystanie z piór i pędzli (492)
    • Tworzenie i korzystanie z piór (492)
    • Tworzenie i korzystanie z pędzli (494)
  • Korzystanie z przekształceń (496)
    • Reprezentacja przekształceń (498)
  • Jak obsłużyć odświeżanie? (499)
  • Korzystanie z czcionek (500)
    • Tworzenie obiektów klasy Font (500)
    • Rysowanie tekstu (501)
    • Rysowanie konturów napisów (502)
    • Rysowanie obróconego napisu (502)
    • Wykaz dostępnych czcionek (503)
  • Jak wyświetlić obraz na formularzu? (504)
  • Jak zrealizować drukowanie? (506)
    • Wyszukiwanie i wybór drukarki (506)
    • Inicjalizacja obiektu klasy PrintDocument (507)
    • Kontroler wydruku (508)
    • Drukowanie dokumentów wielostronicowych (510)

Rozdział 12. Inne przestrzenie nazw (515)

• Teoria (515)
  
  • Inne przestrzenie nazw .NET (515)
  • Przetwarzanie wielowątkowe (515)
    • Co to jest wątek? (516)
    • Klasa Thread (518)
    • Klasy stosowane do synchronizacji (521)
  • Globalizacja (524)
    • Informacje o kulturze (524)
    • Informacje o kalendarzu (525)
    • Informacje o formatach (527)
  • Usługi systemu Windows (529)
    • Sterowanie usługami (530)
    • Architektura procesu usługi (531)
    • Przestrzeń nazw System.ServiceProcess (532)
  • Przestrzeń nazw System.Diagnostics (537)
    • Zastosowanie asercji do sprawdzenia poprawności działania programu (537)
    • Klasy Trace i Debug (538)
    • Dziennik zdarzeń (539)
    • Korzystanie z "Dziennika zdarzeń" w .NET (541)
  • Przestrzenie nazw Text (541)
    • Klasy reprezentujące sposoby kodowania znaków (542)
    • Klasa StringBuilder (542)
    • Wyrażenia regularne (543)
• Gotowe rozwiązania (545)
  
  • Programy wielowątkowe (545)
    • Utworzenie aplikacji (545)
    • Inicjalizacja (546)
    • Funkcja wątku (547)
    • Tworzenie nowych wątków (549)
    • Sterowanie pracą wątków (550)
  • Tworzenie usługi systemu Windows (551)
    • Zdefiniowanie usługi (551)
    • Zdefiniowanie funkcji realizującej zadania usługi (553)
    • Utworzenie i wystartowanie wątku (553)
    • Sterowanie pracą wątku (554)
    • Przygotowanie komponentów instalujących usługę (555)
    • Instalacja usługi (556)
  • Korzystanie z asercji (558)
  • Śledzenie działania programu (559)
    • Sterowanie śledzeniem (561)
  • Korzystanie z "Dziennika zdarzeń" (561)
    • Zapis w "Dzienniku zdarzeń" (561)
    • Odczyt z "Dziennika zdarzeń" (563)
  • Korzystanie z klasy StringBuilder (564)
  • Używanie wyrażeń regularnych do wyszukiwania napisów w tekście (567)
    • Bardziej zaawansowany przykład (570)

Rozdział 13. Remoting - zdalne korzystanie z obiektów (573)

• Teoria (573)
  
  • Podstawy technologii Remoting (573)
    • Technologie zdalnego korzystania z obiektów (574)
    • Zdalny klient i serwer (575)
    • Aktywacja i czas życia (576)
    • Porównanie technologii Remoting z DCOM (577)
    • Porównanie technologii Remoting z XML Web Services (578)
    • Zastosowanie technologii Remoting w aplikacjach wielowarstwowych (578)
  • Kanały komunikacyjne (579)
    • Kanał TCP (579)
    • Kanał HTTP (579)
    • Ujścia (580)
    • Porty (580)
    • Rejestracja kanału (581)
  • Komunikacja między obiektami w technologii Remoting (581)
    • Wiadomości (582)
    • Szeregowanie danych (582)
    • Formatowanie wiadomości (583)
    • Obiekty pośredniczące (584)
    • Kontekst wywołania (584)
    • Zastosowanie SOAP w Remoting (585)
  • Zdalne serwery w Remoting (585)
    • Projekt zdalnego serwera (586)
    • Aplikacja macierzysta (586)
    • Konfiguracja zdalnego serwera (587)
    • Określenie konfiguracji w programie (588)
    • Rejestracja obiektu serwerowego (589)
    • Obsługa wersji obiektu serwerowego (590)
  • Zdalne klienty w Remoting (591)
    • Korzystanie z obiektu serwerowego (591)
    • Plik konfiguracyjny obiektu klienckiego (593)
  • Bezpieczeństwo w Remoting (594)
    • Bezpieczeństwo komunikacji (594)
    • Bezpieczeństwo obiektu (595)
• Gotowe rozwiązania (595)
  
  • Utworzenie zdalnego serwera (595)
  • Konfiguracja serwera w kodzie programu (598)
  • Utworzenie aplikacji klienckiej (599)
  • Konfiguracja klienta w kodzie programu (602)
  • Zastosowanie kanału HTTP w komunikacji ze zdalnym obiektem (603)
  • Określenie czasu życia (604)
  • Utworzenie obiektu aktywowanego przez klienta i określenie czasu jego życia (605)
  • Szyfrowanie wiadomości przesyłanych przez zdalne obiekty (606)

Rozdział 14. SOAP i XML (607)

• Teoria (607)
  
  • Zaawansowany XML (607)
    • XML i ADO.NET (607)
    • Zastosowanie XML-a do trwałego przechowywania danych (608)
    • XPath (608)
    • Klasa XmlConvert (609)
  • Schematy XML (609)
    • Budowa schematu XML (610)
    • Schematy wewnętrzne (614)
    • Schematy zewnętrzne (615)
  • Przekształcenia XML (615)
    • Klasa XslTransform (616)
  • Protokół SOAP (616)
    • Koperta SOAP (617)
    • SOAP i usługi XML Web Services (618)
    • SOAP w Visual Studio .NET (618)
    • DCOM a SOAP (619)
• Gotowe rozwiązania (619)
  
  • Tworzenie dokumentu XML w Visual Studio .NET (619)
  • Wyświetlenie konspektu dokumentu XML w Visual Studio .NET (622)
  • Tworzenie schematu XSD w Visual Studio .NET (622)
  • Tworzenie schematu XSD na podstawie istniejącego dokumentu XML (624)
  • Sprawdzenie poprawności dokumentu XML za pomocą schematu XSD (626)
  • Tworzenie pliku z przekształceniami XSLT (627)
  • Przekształcenie dokumentu XML za pomocą XSLT (629)

Rozdział 15. ADO.NET (631)

• Teoria (631)
  
  • Wprowadzenie do ADO.NET (631)
    • Porównanie ADO z ADO.NET (632)
    • Warstwy dostępu do danych w ADO.NET (634)
  • Klasa DataSet (636)
    • Klasa DataTable (636)
    • Związki między tabelami w obiekcie DataSet (639)
    • Obiekty DataSet beztypowe i określonego typu (640)
    • Ograniczenia (640)
  • Połączenie ze źródłem danych (641)
    • Obiekt DataAdapter (641)
    • Obiekt Connection (642)
    • Obiekt Command (642)
    • Obiekt DataReader (642)
  • Korzystanie z obiektu DataSet (643)
    • Napełnienie obiektu DataSet danymi (643)
    • Trzy wersje danych (643)
    • Modyfikacja danych przechowywanych w DataSet (644)
    • Właściwość RowState (644)
    • Zatwierdzenie i wycofanie zmian (644)
  • Obsługa XML w ADO.NET (644)
    • Zapis zawartości DataSet w formacie XML (645)
    • Odczyt XML (645)
    • Schematy XML (645)
  • Narzędzia bazodanowe w Visual Studio .NET (646)
    • Korzystanie z komponentów Data (646)
    • Generowanie za pomocą narzędzia Server Explorer kodu korzystającego z danych (647)
    • Projekty typu Database i projektant kwerend (648)
    • Kreator formularza operującego na danych (648)
  • Zaawansowane zagadnienia ADO.NET (649)
    • Zdarzenia w ADO.NET (649)
    • Obsługa błędów w ADO.NET (650)
    • Korzystanie w ADO.NET z procedur przechowywanych (651)
• Gotowe rozwiązania (651)
  
  • Zbudowanie obiektu DataSet w kodzie programu (651)
  • Zdefiniowanie związku między tabelami w obiekcie DataSet (653)
  • Zdefiniowanie połączenia z bazą danych w oknie Server Explorer (654)
  • Szybki dostęp do danych za pomocą komponentów Data (655)
    • Korzystanie z komponentów Data z okna Toolbox (655)
    • Korzystanie z komponentów z okna Server Explorer (657)
  • Napełnienie obiektu DataSet danymi odczytywanymi z bazy danych (658)
  • Modyfikacja danych przechowywanych w obiekcie DataSet (659)
    • Dodanie i usunięcie wierszy (659)
    • Wyszukiwanie danych w obiekcie DataTable (660)
    • Zatwierdzenie i wycofanie zmian (661)
  • Zapisanie w bazie danych zmian wykonanych w obiekcie DataSet (661)
  • Utworzenie obiektu DataSet o określonym typie (662)
    • Zdefiniowanie schematu dla obiektu DataSet (662)
    • Dodanie schematu do obiektu DataSet (664)
  • Utworzenie dokumentu XML za pomocą obiektu DataSet (665)
  • Napełnienie obiektu DataSet zawartością dokumentu XML (666)
  • Odczyt danych za pomocą obiektu DataReader (667)
  • Wykonywanie instrukcji języka SQL (668)
  • Wykonanie procedury przechowywanej (668)
  • Korzystanie ze zdarzeń ADO.NET (670)
  • Wykrywanie błędów w ADO.NET (671)
  • Definiowanie kwerend za pomocą Query Designera (672)

Rozdział 16. Współpraca z obiektami COM i korzystanie z Win32 API (675)

• Teoria (675)
  
  • Współpraca z obiektami COM (676)
    • Co to jest COM? (676)
    • Korzystanie z obiektów COM w kodzie .NET (678)
    • Korzystanie z kontrolek ActiveX w kodzie .NET (679)
    • Korzystanie z obiektów .NET jak z obiektów COM (679)
  • Korzystanie z API systemu Win32 (680)
    • Wybór zbioru znaków (681)
    • Nadanie funkcji z biblioteki DLL innej nazwy (682)
• Gotowe rozwiązania (682)
  
  • Użycie obiektu COM w projekcie .NET (682)
  • Korzystanie z późno wiązanych obiektów COM (684)
  • Korzystanie z obiektów COM w nadzorowanym C++ (687)
  • Użycie kontrolki ActiveX w projekcie .NET (688)
  • Wywołanie nienadzorowanej funkcji z biblioteki DLL za pomocą mechanizmu PInvoke (690)
    • Przykład w Visual Basicu (691)
    • Przykład w języku C# (693)

Skorowidz (695)