reklama - zainteresowany?

Visual Studio .NET: .NET Framework. Czarna księga - Helion

Visual Studio .NET: .NET Framework. Czarna księga
Autor: Julian Templeman, David Vitter
Tytuł oryginału: Visual Studio .NET: The .NET Framework. Black Book
Tłumaczenie: Joanna Konopka, Marek Konopka
ISBN: 83-7197-733-6
stron: 736, Format: B5, okładka: miękka
Data wydania: 2003-02-18
Księgarnia: Helion

Cena książki: 125,00 zł

Dodaj do koszyka Visual Studio .NET: .NET Framework. Czarna księga

Tagi: .NET - Programowanie | C# - Programowanie | C++ - Programowanie | Java - Programowanie | programowanie-kupon | Visual Basic - Programowanie

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.

Dodaj do koszyka Visual Studio .NET: .NET Framework. Czarna księga

 

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

  • ASP .NET Core. Kurs video. Rozwijanie dodatkowych funkcjonalności Web API
  • ASP.NET Core. Kurs video. Tworzenie REST Web API
  • Gray Hat C#. Język C# w kontroli i łamaniu zabezpieczeń
  • ASP.NET Core 6. Kurs video. Rozwijaj aplikacje webowe z Entity Framework Core
  • PowerShell. Kurs video. Zarz

Dodaj do koszyka Visual Studio .NET: .NET Framework. Czarna księga

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)

Dodaj do koszyka Visual Studio .NET: .NET Framework. Czarna księga

Code, Publish & WebDesing by CATALIST.com.pl



(c) 2005-2024 CATALIST agencja interaktywna, znaki firmowe należą do wydawnictwa Helion S.A.