Microsoft Visual Basic .NET 2003. Księga eksperta Heinrich Gantenbein, Greg Dunn, Amit Kalani, Chris Payne, Thiru Thangarathinam

Dostępność produktu

Produkt nie został jeszcze oceniony pod kątem ułatwień dostępu lub nie podano żadnych informacji o ułatwieniach dostępu lub są one niewystarczające. Prawdopodobnie Wydawca/Dostawca jeszcze nie umożliwił dokonania walidacji produktu lub nie przekazał odpowiednich informacji na temat jego dostępności.

Spis treści książki

O autorach (21)


Wstęp (23)


• Historia języka Visual Basic (VB) (23)
  
• Visual Basic .NET (oraz C#) (24)
  
• Visual Basic .NET 2003. Księga eksperta (24)
  
• Sposób organizacji książki (24)
  
  • Część I "Podstawy" (24)
  • Część II "Aplikacje Windows Forms" (25)
  • Część III "Programowanie baz danych" (25)
  • Część IV "Aplikacje Web (ASP.NET)" (25)
  • Część V "Zaawansowane programowanie" (25)
  • Część VI "Zabezpieczanie aplikacji" (25)
  • Część VII "Technologia Remoting" (26)
  • Część VIII "Usługi Web" (26)
  • Część IX "Usługi Enterprise" (26)
  • Jak korzystać z tej książki (26)

Część I Podstawy (27)


Rozdział 1. Wprowadzenie do .NET (29)


• Oprogramowanie jako usługa (29)
  
  • Produkty .NET (30)
  • Usługi .NET (30)
  • .NET Framework (30)
• Zadania .NET Framework (33)
  
• Poznajemy architekturę .NET Framework (34)
  
• Poznajemy zadania .NET Framework (35)
  
• Co to jest MSIL? (36)
  
  • Co to jest plik Portable Executable (PE)? (36)
  • Poznajemy kompilator JIT (37)
• Wspólne środowisko uruchomieniowe (37)
  
  • Składniki CLR (37)
  • Biblioteka klas .NET Framework (38)
  • Zalety CLR (41)
• Co to jest podzespół? (43)
  
  • Struktura podzespołu (44)
  • Wykorzystanie metody XCOPY do bezobsługowej instalacji podzespołów (45)
  • Problemy przy projektowaniu podzespołu (46)
  • Typy podzespołów (46)
  • Metadane (48)
  • System wspólnego języka (CLS) (49)
• Podsumowanie (50)
  
• Propozycje dalszych lektur (50)

Rozdział 2. Podstawy języka (51)


• Deklarowanie zmiennych (51)
  
  • Znaczenie słów kluczowych (52)
  • Poziomy deklaracji (52)
  • Deklaracja typu danych (53)
  • Deklaracja czasu życia (53)
  • Deklaracja zasięgu (53)
  • Deklaracja dostępności (54)
• Zmienne i przypisywanie (54)
  
• Użycie przestrzeni nazw (55)
  
  • Słowo kluczowe Imports (56)
  • Zastosowanie synonimów (58)
• Tworzenie modułów w Visual Basic .NET (58)
  
  • Tworzenie wielu modułów (59)
• Struktury sterujące (60)
  
  • Struktura wyboru If...Then (61)
  • Struktura wyboru If...Then...Else (61)
  • Instrukcja Select...Case (61)
  • Pętla While (62)
  • Pętla DoWhile...Loop (63)
  • Pętla Do...LoopWhile (63)
  • Pętla DoUntil...Loop (64)
  • Pętla Do...LoopUntil (64)
  • Pętla For...Next (64)
  • Pętla ForEach...Next (65)
  • Instrukcja Exit (66)
• Operatory przypisania (67)
  
  • Operatory logiczne (67)
• Instrukcje warunkowe (70)
  
  • Tworzenie wyrażeń warunkowych i ich zastosowanie w instrukcjach warunkowych (70)
• Użycie operatora przypisania (71)
  
• Stałe (71)
  
• Użycie operatorów (72)
  
• Funkcje wbudowane (73)
  
  • Funkcje konwersji (73)
  • Funkcje operujące na ciągach znaków (74)
  • Inne przydatne funkcje (74)
• Tworzenie własnych podprogramów (74)
  
  • Procedury (76)
  • Funkcje (76)
  • Zasięg zmiennych (77)
  • Dlaczego zasięg jest tak ważny? (77)
• Podsumowanie (78)
  
• Propozycje dalszych lektur (78)

Rozdział 3. Podstawy programowania obiektowego (79)


• Mechanizmy obiektowe (79)
  
• Tworzenie klas (80)
  
  • Tworzenie prostych klas (80)
• Obiekty, klasy i instancje (82)
  
  • Tworzenie konstruktorów (83)
  • Składniki obiektu (84)
• Operacje na obiektach (88)
  
  • Deklaracja i tworzenie obiektów (88)
  • Referencje do obiektów (89)
  • Dereferencja obiektów (90)
• Obsługa zdarzeń (90)
  
  • Obsługa pojedynczego zdarzenia (91)
  • Obsługa wielu zdarzeń (91)
  • Słowo kluczowe WithEvents (92)
  • Generowanie zdarzeń (92)
  • Odbieranie zdarzeń (93)
• Dziedziczenie w Visual Basic .NET (96)
  
  • Przesłanianie metod (97)
• Podsumowanie (98)
  
• Propozycje dalszych lektur (99)

Rozdział 4. Typy danych w .NET Framework (101)


• Co to jest wspólny system typów? (102)
  
  • System.Object - od tego się zaczęło (102)
• Typy i synonimy (103)
  
  • Poznajemy typy danych (104)
  • Odzyskiwanie nieużytków (105)
  • Typy wartościowe (106)
  • Typy referencyjne (112)
  • Klasa System.String (113)
• Modyfikowalne ciągi znaków (114)
  
  • Obiekt StringBuilder (114)
• Co to jest GUID? (119)
  
• Pakowanie i rozpakowywanie (120)
  
• Podsumowanie (120)
  
• Propozycje dalszych lektur (121)

Część II Aplikacje Windows Forms (123)


Rozdział 5. Windows Forms (125)


• Tworzenie nowego projektu (125)
  
• Sposób uruchomienia projektu (126)
  
• Wprowadzenie do formularzy (127)
  
  • Klasa Form (127)
• Zmiana właściwości formularza (130)
  
  • Zmiana nazwy formularza (131)
  • Wyświetlanie tekstu w pasku tytułowym formularza (131)
  • Zmiana koloru tła formularza (132)
  • Umieszczanie rysunku jako tła formularza (133)
  • Wyświetlanie ikony w formularzu (133)
  • Określanie początkowego położenia formularza (134)
  • Określanie rozmiaru oraz położenia formularza (134)
  • Obiekt Application (136)
  • Sterowanie wyglądem formularza (136)
• Pokazywanie i usuwanie formularzy (138)
  
  • Pokazywanie formularzy (138)
  • Konfiguracja przycisków sterujących (142)
• Metody formularza (144)
  
  • Obsługa problemów z wyświetlaniem (144)
  • Ponowne inicjowanie właściwości (145)
• Obsługa zdarzeń (145)
  
  • Pętla komunikatów (146)
• Zdarzenia formularza (147)
  
  • Sterowanie działaniem programu (147)
  • Zdarzenia klawiatury i myszy (149)
• Podsumowanie (151)
  
• Propozycje dalszych lektur (152)

Rozdział 6. Formanty (153)


• Wykorzystanie narzędzia Form Designer w Visual Studio .NET (153)
  
  • Okno Toolbox (154)
  • Okno Properties (154)
  • Dodawanie procedur obsługi zdarzeń (155)
  • Operacje na formantach formularza (156)
• Formant TextBox (157)
  
  • Tworzenie pól do wprowadzania hasła (157)
  • Tworzenie pola tekstowego tylko do odczytu (158)
  • Zdarzenia generowane przez formant TextBox (158)
• Formant Button (159)
  
  • Użycie formantu Button (160)
  • Obsługa kliknięcia przycisku (160)
• Formant Label (161)
  
• Formant RadioButton (162)
  
• Formant CheckBox (163)
  
  • Reagowanie na kliknięcie pola wyboru (164)
• Formant ListBox (165)
  
  • Wybieranie elementów formantu ListBox (165)
  • Wyszukiwanie elementów w formancie ListBox (165)
  • Manipulowanie elementami w formancie ListBox (166)
  • Wspólne metody dostępne w formantach list (169)
• Formant ComboBox (169)
  
• Menu (173)
  
  • Budowanie grup menu (173)
  • Dodawanie poziomów menu (174)
  • Programowe tworzenie menu (175)
  • Dodawanie skrótów klawiszowych (177)
  • Dodawanie klawiszy szybkiego dostępu (178)
  • Obsługa zdarzenia Click (179)
  • Zdarzenia sterujące interfejsu użytkownika dla obiektów MenuItems (180)
  • Definiowanie obiektu MenuItem jako separatora (180)
  • Układ elementów menu (181)
  • Menu rozmieszczane od prawej do lewej (182)
  • Menu kontekstowe (182)
• Podsumowanie (183)
  
• Propozycje dalszych lektur (184)

Rozdział 7. Rysowanie (185)


• Interfejs urządzeń graficznych (GDI) (185)
  
• GDI+: API wyższego poziomu (186)
  
  • Własności GDI+ (186)
• Przestrzenie GDI+ w .NET (186)
  
  • Przestrzeń nazw System.Drawing (187)
  • Przestrzeń nazw System.Drawing.Design (187)
  • Przestrzeń nazw System.Drawing.Printing (188)
  • Przestrzeń nazw System.Drawing.Imaging (188)
  • Przestrzeń nazw System.Drawing.Drawing2D (189)
  • Przestrzeń nazw System.Drawing.Text (189)
• Klasa Graphics (189)
  
  • Często używane obiekty graficzne (190)
  • Rysowanie linii (192)
  • Rysowanie prostych figur (195)
  • Wypełnianie figur (198)
  • Zbiory figur (200)
  • Operacje na obrazach (204)
  • Jednostki miary (205)
• Operacje na czcionkach (205)
  
• Podsumowanie (206)
  
• Propozycje dalszych lektur (206)

Rozdział 8. Instalowanie aplikacji (207)


• Wprowadzenie do instalacji (207)
  
  • Planowanie instalacji (208)
• Struktura podzespołu (208)
  
• Opcje instalacji obsługiwane przez .NET (209)
  
  • Zastosowanie XCOPY do instalowania aplikacji (209)
  • Zastosowanie programu Visual Studio .NET Installer (209)
  • Różnice między XCOPY i instalatorem Windows (211)
• Typy szablonów projektów instalacyjnych dostępnych w Visual Studio .NET (212)
  
  • Tworzenie pakietu instalacyjnego (213)
• Konfigurowanie właściwości instalacji (214)
  
• Konfigurowanie właściwości projektu (215)
  
• Typy edytorów instalacji (217)
  
  • Konfiguracja edytora systemu plików (217)
  • Konfigurowanie edytora rejestru (220)
  • Konfiguracja edytora typów plików (220)
  • Konfigurowanie edytora własnych akcji (221)
  • Konfigurowanie edytora warunków uruchomienia (222)
  • Konfigurowanie edytora interfejsu użytkownika (223)
• Generowanie pakietu instalacyjnego (226)
  
  • Instalowanie aplikacji (226)
  • Odinstalowanie aplikacji (227)
• Podsumowanie (228)
  
• Propozycje dalszych lektur (228)

Rozdział 9. Drukowanie (229)


• Drukowanie w .NET (229)
  
• Definiowanie dokumentu (231)
  
  • Zdarzenia obsługiwane przez klasę PrintDocument (232)
  • Metody klasy PrintDocument (233)
  • Drukowanie dokumentu (233)
• Zastosowanie okien dialogowych drukowania (235)
  
  • Zastosowanie formantu PrintPreviewDialog (236)
  • Zastosowanie formantu PrintDialog (238)
  • Użycie formantu PageSetupDialog (240)
  • Zastosowanie formantu PrintPreviewControl (243)
• Obsługa ustawień (244)
  
  • Klasa PrinterSettings (245)
  • Rola klasy PageSettings w drukowaniu (246)
• Podsumowanie (247)
  
• Propozycje dalszych lektur (247)

Rozdział 10. Zaawansowane techniki Windows Forms (249)


• Dynamiczne dodawanie formantów (249)
  
  • Dynamiczne przechwytywanie zdarzeń (251)
• Tworzenie formularzy zależnych (252)
  
• Interfejs MDI (253)
  
• Implementacja dziedziczenia w Visual Studio .NET (254)
  
• Formant NotifyIcon (255)
  
• Zastosowanie dostawców w aplikacjach Windows Forms (257)
  
• Formant HelpProvider (257)
  
  • Dodawanie pomocy do aplikacji Windows Forms (257)
• Wyświetlanie pomocy z użyciem klasy ToolTips (262)
  
• Okna dialogowe (264)
  
• Użycie kursorów w aplikacjach Windows Forms (265)
  
• Zaawansowane formanty interfejsu użytkownika (267)
  
  • Formant TreeView (267)
  • Formant DateTimePicker (272)
  • Formant MonthCalendar (273)
• Podsumowanie (275)
  
• Propozycje dalszych lektur (275)

Część III Programowanie baz danych (277)


Rozdział 11. Klasy ADO.NET (279)


• Dostawcy danych (279)
  
  • Dostawcy SqlClient oraz OleDb (280)
• Obiekt Connection (281)
  
  • Właściwość ConnectionString (281)
  • Metoda Open() (282)
  • Metoda Close() (283)
  • Metoda BeginTransaction() (283)
• Obiekt Command (289)
  
  • Przygotowanie obiektu Command do wykonania instrukcji SQL (289)
  • Przygotowanie obiektu Command do wywołania procedury składowanej (291)
  • Przygotowanie obiektu Command do wywołania TableDirect (293)
  • Metody Execute obiektu Command (293)
• Obiekt DataReader (294)
  
• Obiekt DataSet (297)
  
  • Obiekty DataSet ze ścisłą i luźną kontrolą typów (298)
  • Obiekty podrzędne do DataSet (300)
• Obiekt DataView (311)
  
• Obiekt DataAdapter (312)
  
  • Użycie kreatora DataAdapter do generowania ciągu połączenia (313)
• Problemy z wielodostępem (314)
  
• Przykładowe aplikacje dołączone do książki (315)
  
  • Aplikacja TransactionsAndDataSets (315)
  • Aplikacja TransactionInteractionExplorer (315)
  • Aplikacja ConcurrencyViolator (318)
• Podsumowanie (319)
  
• Propozycje dalszych lektur (320)

Rozdział 12. Tworzenie i obsługa baz danych w Visual Studio (321)


• Tworzenie bazy danych (322)
  
• Tworzenie i modyfikacja komponentów bazy danych (323)
  
• Tworzenie nowej tabeli (323)
  
• Projekt tabeli Instructor (325)
  
  • Definiowanie klucza głównego (326)
  • Rodzaje kluczy głównych (327)
  • Pełny projekt tabeli Instructor (330)
• Zapisywanie tabeli Instructor (332)
  
• Projekt tabeli Student (333)
  
• Projekt tabeli Course (333)
  
• Projekt tabeli Enrollment (334)
  
• Modyfikacja projektu tabeli (334)
  
• Kilka słów o typach danych dla użytkowników Microsoft Access (337)
  
• Pobieranie danych z tabeli (338)
  
• Diagram bazy danych School (338)
  
• Tworzenie nowej relacji (341)
  
• Relacja Course-Instructor (343)
  
• Relacja Enrollment-Course (345)
  
• Relacja Enrollment-Student (345)
  
• Pełny diagram bazy danych (346)
  
• Zapisywanie diagramu bazy danych (346)
  
• Przeglądanie właściwości tabel (347)
  
• Tworzenie nowej perspektywy (349)
  
  • Ukrywanie paneli w oknie projektowania perspektywy (351)
  • Wyświetlanie rekordów z perspektywy (355)
• Zapisywanie perspektywy (355)
  
• Odczyt danych z zamkniętej perspektywy (357)
  
• Uwagi dotyczące uporządkowania perspektyw (358)
  
• Tworzenie procedur składowanych (360)
  
• Edycja procedur składowanych (362)
  
• Tworzenie procedury składowanej z użyciem SqlDataAdapter (364)
  
• Tworzenie funkcji (364)
  
• Operacje na bazie danych, jakich nie da się wykonać w Visual Studio (368)
  
• Podsumowanie (369)
  
• Propozycje dalszych lektur (369)

Rozdział 13. Użycie kreatorów Data Form oraz DataAdapter w aplikacjach Windows (371)


• Opis kreatora (372)
  
• Tworzenie formularza danych (373)
  
  • Obiekty generowane przez kreator (377)
• Analiza wygenerowanego kodu (380)
  
  • Deklaracje zmiennych (380)
  • Tworzenie i inicjalizacja (381)
• Metody tworzone przez kreator Data Form (387)
  
  • Metody wykorzystywane do obsługi zdarzeń (387)
  • Metody niewykorzystywane do obsługi zdarzeń (389)
• Przegląd kodu realizującego różne funkcje (390)
  
  • Ładowanie danych (390)
  • Modyfikacja danych (393)
  • Anulowanie wszystkich zmian (395)
  • Dodawanie rekordów do tabeli Publishers (395)
  • Kasowanie rekordu z tabeli Publishers (395)
  • Anulowanie zmian w rekordzie tabeli Publishers (396)
  • Nawigacja w tabeli Publishers (396)
• Uwalniamy się od kreatora Data Form (397)
  
  • Tworzenie formularza danych SqlClient z wykorzystaniem kreatorów Data Form oraz SqlDataAdapter (397)
• Następne kroki (405)
  
• Podsumowanie (406)
  
• Propozycje dalszych lektur (406)

Rozdział 14. Dołączanie danych w aplikacjach Windows (407)


• Przegląd dołączania danych (408)
  
  • Kategorie łączenia danych: tylko odczyt kontra odczyt-zapis oraz proste kontra złożone (409)
• Potencjalne źródła danych oraz obsługa interfejsu IList (410)
  
  • Klasy .NET implementujące interfejs IList (410)
• BindingContext (410)
  
• Obiekt CurrencyManager (412)
  
• Obiekt PropertyManager (413)
  
• Obiekty dołączane do danych (414)
  
  • Proste dołączanie - formant TextBox (415)
  • Złożone dołączanie - formant ComboBox (415)
  • Formant DataGrid (416)
• Dopasowywanie źródła danych w instrukcjach nawigacyjnych do źródła danych dołączenia (417)
  
• Dołączanie formantów do obiektu DataSet (418)
  
• Dołączanie właściwości obiektu do wartości tabelowych (420)
  
• Ważne metody klas BindingContext i DataSet (423)
  
• Zastosowanie obiektu CurrencyManager do łączenia nietabelowego (427)
  
• Dołączanie wielu formantów formularza do różnych właściwości jednego obiektu (428)
  
• Dołączanie wielu właściwości jednego obiektu do wielu właściwości innego obiektu (430)
  
• Dołączanie formantów formularza do listy ArrayList obiektów (431)
  
  • Ograniczenie aplikacji BindToAnArraylistOfObjects tylko do odczytu (433)
• Dołączanie do odczytu i zapisu (433)
  
  • Implementacja dołączania do odczytu i zapisu we własnej kolekcji obiektów (434)
  • Przykładowa aplikacja: ReadWriteBindableCollection (435)
  • Jak działa aplikacja ReadWriteBindableCollection (436)
  • Klasa Product (439)
  • Klasa Products (443)
  • Dodatkowe operacje pozwalające podłączyć aplikację ReadWriteBindableCollection do bazy danych (450)
• Przykładowe aplikacje dołączone do książki (451)
  
• Podsumowanie (451)
  
• Propozycje dalszych lektur (453)

Rozdział 15. ADO.NET i XML (455)


• Wstęp (455)
  
• Metody związane z XML w klasie DataSet (457)
  
• Odczyt i zapis schematu XML (457)
  
  • Wpływ danych schematu na dane wyświetlane w DataGrid (459)
• Odczyt danych XML (460)
  
  • Aplikacja ReadXmlWorkoutMachine (461)
• Zapis danych XML (463)
  
  • Przykładowe wyniki działania metody WriteXml() (464)
• Tworzenie obiektu XmlReader z wykorzystaniem obiektu Command (467)
  
• Zapis danych schematu do obiektu DataSet za pomocą DataAdapter (469)
  
• Przykładowe aplikacje dołączone do książki (471)
  
• Pozostałe mechanizmy wspierające XML w .NET Framework i Visual Studio (472)
  
• Podsumowanie (472)
  
• Propozycje dalszych lektur (472)

Część IV Aplikacje Web (ASP.NET) (475)


Rozdział 16. Proste aplikacje Web (477)


• Tworzenie prostej aplikacji Web (477)
  
  • Przygotowywanie serwera WWW (478)
  • Konfigurowanie bazy danych (479)
  • Tworzenie strony domowej blogu (480)
• Tworzenie formularzy Web (486)
  
  • Obsługa danych w sieci WWW (486)
  • Użycie formularzy ukrytego kodu (487)
  • Tworzenie interakcyjnych formularzy Web (489)
• Zastosowanie formantów Web na formularzach (495)
  
  • Poznajemy formanty Web (495)
  • Tworzenie rozbudowanego interfejsu użytkownika (498)
• Obsługa zdarzeń Web (502)
  
  • Zdarzenia ASP.NET - powtórka (503)
  • Poznajemy obsługę zdarzeń (505)
• Podsumowanie (511)
  
• Propozycje dalszych lektur (511)

Rozdział 17. Dołączanie danych w aplikacjach Web (513)


• Dołączanie danych do prostych formantów (513)
  
• Zastosowanie formantów szablonowych do wyświetlania danych (517)
  
  • Propagacja zdarzeń (518)
  • Formant Repeater (519)
  • Formant DataList (522)
  • Formant DataGrid (526)
• Tworzenie dołączalnych formantów Web (530)
  
• Przetwarzanie przesyłanych danych formularza (534)
  
  • Model przetwarzania danych formularza (534)
  • Modyfikujemy formant LoginForm (536)
• Podsumowanie (539)
  
• Propozycje dalszych lektur (539)

Rozdział 18. Zarządzanie stanem (541)


• Zapamiętywanie danych na poziomie aplikacji (542)
  
• Zapamiętywanie danych sesji (544)
  
  • Przypomnienie zagadnienia sesji Web (544)
  • Obsługa sesji (545)
• Zapamiętywanie stanu widoku (546)
  
• Zarządzanie mechanizmem cookie (551)
  
  • Przypomnienie na temat cookie (551)
  • Operacje na cookie (552)
• Podsumowanie (556)
  
• Propozycje dalszych lektur (556)

Rozdział 19. Buforowanie (557)


• Buforowanie elementów statycznych (557)
  
• Buforowanie całych stron (561)
  
• Buforowanie formantów (562)
  
  • Buforowanie deklaratywne (562)
  • Buforowanie programowe (564)
• Podsumowanie (565)
  
• Propozycje dalszych lektur (565)

Rozdział 20. Zarządzanie witryną WWW (567)


• Konfigurowanie witryny (567)
  
  • Plik global.asax (568)
  • Plik web.config (570)
• Zastosowanie pamięci podręcznej podzespołów dla plików aplikacji (574)
  
• Śledzenie aplikacji ASP.NET (575)
  
• Podsumowanie (578)
  
• Propozycje dalszych lektur (578)

Rozdział 21. Bezpieczeństwo (579)


• Przegląd zabezpieczeń w ASP.NET (579)
  
• Uwierzytelnianie użytkownika Web (581)
  
  • Uwierzytelnianie Windows (582)
  • Uwierzytelnianie typu Forms (584)
  • Uwierzytelnianie za pomocą usługi Passport (587)
• Autoryzacja użytkowników i ról (588)
  
  • Autoryzacja bazująca na rolach (588)
  • Autoryzacja bazująca na zasobach (592)
• Zapobieganie atakom wstrzyknięcia kodu (593)
  
• Zabezpieczanie ciągów połączenia i innych kluczy (595)
  
• Podsumowanie (596)
  
• Propozycje dalszych lektur (597)

Rozdział 22. Rozszerzanie ASP.NET (599)


• Poznajemy sposób obsługi strumienia HTTP w ASP.NET (599)
  
• Zastosowanie modułów HTTP do modyfikacji danych wyjściowych (602)
  
• Tworzenie własnych obiektów HttpHandler (605)
  
• Podsumowanie (608)
  
• Propozycje dalszych lektur (608)

Część V Zaawansowane programowanie (609)


Rozdział 23. Wersjonowanie i globalna pamięć podręczna podzespołów (611)


• Wprowadzenie do wersjonowania platformy .NET (612)
  
• Podzespoły prywatne (612)
  
• Podzespoły współdzielone (613)
  
  • Przypisywanie silnych nazw (613)
  • Globalna podręczna pamięć podzespołów (613)
• Używanie podzespołów współdzielonych (614)
  
  • Przypisywanie silnej nazwy do podzespołu (614)
  • Dodawanie podzespołu do GAC (616)
  • Opóźnione podpisywanie podzespołów (618)
• Strategie dołączania podzespołów (620)
  
  • Sprawdzanie strategii z poziomu aplikacji (621)
  • Sprawdzanie strategii z poziomu wydawcy (623)
  • Sprawdzanie strategii z poziomu administratora (624)
  • Jak wspólne środowisko uruchomieniowe dołącza podzespół (625)
• Podsumowanie (627)
  
• Propozycje dalszych lektur (627)

Rozdział 24. Operacje wejścia-wyjścia oraz utrwalanie obiektów (629)


• Operacje wejścia-wyjścia na plikach (629)
  
  • Używanie klasy File (630)
  • Używanie klasy FileStream (630)
  • Używanie klas StreamReader oraz StreamWriter (631)
  • Używanie klas BinaryReader oraz BinaryWriter (633)
• Serializacja (634)
  
  • Serializacja XML (636)
  • Serializacja w czasie wykonywania programu (639)
• Podsumowanie (645)
  
• Propozycje dalszych lektur (646)

Rozdział 25. Współpraca z modelem COM (647)


• Wprowadzenie do współdziałania .NET Framework z modelem COM (647)
  
• Jak .NET Framework współdziała z modelem COM? (648)
  
• Używanie komponentów COM w aplikacjach .NET Framework (649)
  
  • Tworzenie i rejestrowanie komponentów COM (649)
  • Tworzenie RCW dla komponentu COM (650)
  • Automatyczne tworzenie opakowania RCW (651)
• Używanie komponentów .NET Framework w aplikacjach COM (652)
  
  • Tworzenie za pomocą Visual Basic .NET klasy dostępnej dla aplikacji COM (652)
  • Tworzenie opakowania wywoływanego z COM (CCW) (654)
  • Używanie komponentów .NET Framework w aplikacji COM (655)
• Podsumowanie (657)
  
• Propozycje dalszych lektur (657)

Rozdział 26. Zdarzenia i delegacje (659)


• Wprowadzenie do zdarzeń (659)
  
  • Definiowanie i zgłaszanie zdarzeń (660)
  • Obsługa zdarzeń (661)
• Wprowadzenie do delegacji (663)
  
  • Definiowanie delegacji (664)
  • Tworzenie instancji delegacji (665)
  • Wywoływanie delegacji (665)
• Delegacje zbiorowe (666)
  
• Zdarzenia i delegacje (667)
  
• Podsumowanie (668)
  
• Propozycje dalszych lektur (668)

Rozdział 27. Wielowątkowość (669)


• Wprowadzenie do wątków (669)
  
  • Zalety wielowątkowości (670)
  • Wady wielowątkowości (670)
• Używanie wątków (671)
  
  • Tworzenie i uruchamianie wątków (671)
  • Właściwości wątków (672)
  • Metody wątków (673)
• Synchronizacja wątków (674)
  
  • Sytuacja wyścigu (674)
  • Zakleszczenie (674)
  • Sposoby synchronizacji (675)
• Programowanie asynchroniczne (678)
  
  • Model programowania asynchronicznego .NET Framework (678)
  • Pobieranie wyników wywołań metod asynchronicznych (679)
  • Asynchroniczne wywołania zwrotne (679)
• Podsumowanie (680)
  
• Propozycje dalszych lektur (681)

Rozdział 28. Rozszerzanie możliwości platformy za pomocą refleksji (683)


• Metadane (683)
  
• Wprowadzenie do mechanizmu refleksji (685)
  
• Stosowanie refleksji do podzespołu (685)
  
• Stosowanie refleksji do typu (686)
  
• Późne dołączanie (689)
  
• Podsumowanie (690)
  
• Propozycje dalszych lektur (690)

Część VI Zabezpieczanie aplikacji (691)


Rozdział 29. Bezpieczeństwo oparte na uprawnieniach kodu (CAS) (693)


• Zarządzanie uprawnieniami kodu (694)
  
  • Sprawdzanie domyślnych zabezpieczeń za pomocą narzędzia konfiguracyjnego .NET Framework (694)
  • Maksymalizacja bezpieczeństwa systemu (696)
  • Łagodzenie systemu bezpieczeństwa w celu tworzenia oprogramowania (704)
  • Instalacja zasad CAS (704)
• Jak środowisko CLR określa zbiór uprawnień nadawanych podzespołowi? (705)
  
  • Określanie uprawnień nadanych podzespołowi przez zasady (705)
  • Stosowanie atrybutów z poziomu podzespołu do zmiany nadawanych uprawnień (707)
• Jak używać żądań zabezpieczeń? (708)
  
  • Proste żądania i analiza stosu (709)
  • Żądania z poziomu dołączania (712)
  • Żądania z poziomu dziedziczenia (713)
• Podpisywanie podzespołów (714)
  
  • Natychmiastowe podpisywanie (715)
  • Opóźnione podpisywanie (715)
• Łączenie różnych technik (717)
  
• Podsumowanie (717)
  
• Propozycje dalszych lektur (717)

Rozdział 30. Uprawnienia oparte na tożsamości i rolach (719)


• Autoryzacja i uwierzytelnianie (719)
  
• Uwierzytelnieni użytkownicy (720)
  
• Bezpieczeństwo oparte na rolach (721)
  
  • Deklaratywne zabezpieczanie oparte na rolach (722)
  • Programowe zabezpieczanie oparte na rolach (723)
• Tworzenie własnych obiektów kontekstu bezpieczeństwa i tożsamości (724)
  
• Podsumowanie (729)
  
• Propozycje dalszych lektur (729)

Część VII Technologia Remoting (731)


Rozdział 31. Technologia Remoting w praktyce (733)


• Wprowadzenie do technologii Remoting (733)
  
  • Procesy systemu Windows a domeny aplikacji .NET Framework (734)
  • Zdalne korzystanie z obiektów i szeregowanie (734)
  • Architektura technologii Remoting (736)
• Proste zdalne korzystanie z obiektów w obrębie procesu (737)
  
• Jawne zdalne korzystanie z obiektów (740)
  
  • Typy aktywacji zdalnych obiektów (740)
  • Zdalne korzystanie z obiektów konfigurowane programowo (741)
  • Deklaratywne konfigurowanie (753)
• Bezpieczeństwo zdalnych wywołań (760)
  
  • Ograniczenia parametrów zdalnych wywołań (760)
• Zarządzanie cyklem życia zdalnych obiektów (762)
  
  • Jak zdalne obiekty kontrolują własną dzierżawę? (764)
  • Jawne odnawianie dzierżawy (764)
  • Odnawianie dzierżawy za pomocą sponsora (765)
  • Zalecane techniki kontroli cyklu życia (771)
• Jednostronne wywołania i zdalne zdarzenia (771)
  
• Konteksty i usługi (772)
  
  • Klasy Object, MarshalByRefObject i ContextBoundObject (773)
  • Usługi (773)
• Podsumowanie (773)
  
• Propozycje dalszych lektur (774)

Część VIII Usługi Web (775)


Rozdział 32. Podstawowe usługi Web (777)


• Protokoły wykorzystywane przez usługi Web (778)
  
• Tworzenie usług Web (778)
  
  • Testowanie usługi (779)
• Wywoływanie usług Web (782)
  
• Tworzenie usług Web używających złożonych parametrów (786)
  
• Importowanie usług Web (789)
  
  • Wykrywanie usług (789)
  • Tworzenie pośrednika usługi (789)
• Dostosowywanie usług Web do własnych potrzeb (790)
  
  • Atrybut WebService (790)
  • Atrybut WebMethod (790)
• Tworzenie własnych nagłówków SOAP (793)
  
• Podsumowanie (796)
  
• Propozycje dalszych lektur (796)

Rozdział 33. Bezpieczeństwo i rozszerzenia usług Web (797)


• Zabezpieczenia z poziomu platformy (797)
  
  • Strategie uwierzytelniania IIS (798)
  • Strategie uwierzytelniania ASP.NET (798)
  • Przekazywanie informacji o uwierzytelnieniu do usług Web (800)
  • Autoryzacja usług Web (800)
• Zabezpieczenia z poziomu komunikatu (802)
  
  • Dodawanie obsługi WSE do aplikacji (802)
  • Uwierzytelnianie za pomocą WSE (803)
  • Żetony zabezpieczeń WSE (806)
  • Autoryzacja za pomocą WSE (806)
  • Zasady bezpieczeństwa WSE (806)
• Podsumowanie (808)
  
• Propozycje dalszych lektur (809)

Część IX Usługi Enterprise (811)


Rozdział 34. Wprowadzenie do usług Enterprise (813)


• Ulepszanie oprogramowania za pomocą architektur n-warstwowych (813)
  
• Definiowanie komponentów za pomocą interfejsów (814)
  
• Wprowadzenie do architektury usług Enterprise (815)
  
  • Tworzenie prostych obiektów serwerowych (816)
  • Rozszerzenie usług składowych w konsoli MMC (822)
  • Debugowanie obiektów serwerowych (824)
  • Instalacja zdalna i lokalna (825)
  • Usprawnianie pracy z COM+ (826)
• Dodawanie instrumentacji i dokumentacji do obiektów serwerowych (833)
  
• Podsumowanie (833)
  
• Propozycje dalszych lektur (833)

Rozdział 35. Usługi związane z aktywacją (835)


• Zwiększanie skalowalności za pomocą aktywacji w czasie trwania (JIT) (835)
  
• Implementacja interfejsu COM+ IObjectControl (839)
  
• Poprawa wydajności za pomocą tworzenia puli obiektów (841)
  
• Łączenie aktywacji JITA z tworzeniem puli obiektów w celu poprawy skalowalności i wydajności (847)
  
• Zmiana wartości parametrów ObjectPooling w czasie instalacji (848)
  
• Przekazywanie argumentów czasu wykonania za pomocą ciągu znaków konstrukcji (849)
  
• Włączanie równoważenia obciążenia (852)
  
• Podsumowanie (852)
  
• Propozycje dalszych lektur (852)

Rozdział 36. Usługi związane z transakcjami (853)


• Upraszczanie kodu transakcyjnego za pomocą transakcji COM+ (853)
  
  • Transakcje i poziom izolacji (855)
  • Implementacja komponentu transakcyjnego (857)
• Kontrola granic transakcji i poziom izolacji (862)
  
  • Rozluźnianie wymogu izolacji za pomocą właściwości IsolationLevel (862)
  • Kontrola granic transakcji (863)
• Łączenie transakcji z pulą obiektów i ciągami znaków konstrukcji (864)
  
• Używanie stron internetowych i usług Web jako głównych obiektów transakcji (867)
  
• Podsumowanie (867)
  
• Propozycje dalszych lektur (867)

Rozdział 37. Zabezpieczanie przed jednoczesnym dostępem (869)


• Wielowątkowość i zabezpieczanie zasobów (869)
  
• Poprawianie rozwiązania za pomocą blokad wątków logicznych opartych na czynności (870)
  
• Kontrolowanie granic czynności (871)
  
• Łączenie czynności z aktywacją JIT, transakcjami i korzystaniem z puli (872)
  
• Podsumowanie (873)
  
• Propozycje dalszych lektur (873)

Rozdział 38. Usługi dla luźno powiązanych systemów (875)


• Buforowanie żądań za pomocą kolejkowanych komponentów (875)
  
  • Tworzenie prostego kolejkowanego komponentu (878)
  • Obsługa błędów (881)
  • Kolejkowane komponenty, transakcje i korzystanie z puli (884)
• Tworzenie systemów typu publikuj-subskrybuj za pomocą luźno powiązanych zdarzeń (885)
  
  • Tworzenie prostego luźno powiązanego zdarzenia (886)
  • Dodawanie stałych subskrypcji do zdarzenia LCE (889)
  • Dodawanie tymczasowych subskrypcji do zdarzenia LCE (892)
  • Zaawansowane zagadnienia związane z LCE (897)
• Podsumowanie (899)
  
• Propozycje dalszych lektur (899)

Rozdział 39. Zabezpieczanie komponentów serwerowych (901)


• Kontrola uwierzytelniania w aplikacjach COM+ (901)
  
• Dodawanie zabezpieczeń opartych na rolach w COM+ (904)
  
  • Przygotowywanie projektu testowego (904)
  • Włączanie zabezpieczeń opartych na rolach (908)
  • Definiowanie ról i przypisywanie do nich członków (908)
  • Autoryzacja użytkowników należących do danej roli za pomocą atrybutu SecurityRole (909)
  • Programowa autoryzacja użytkowników należących do ról za pomocą ContextUtil lub SecurityContext (911)
• Tworzenie zaufanych podsystemów za pomocą tożsamości (912)
  
• Zabezpieczanie kolejkowanych komponentów (913)
  
• Zabezpieczanie luźno powiązanych zdarzeń (914)
  
• Ukrywanie komponentów za pomocą atrybutu PrivateComponent (914)
  
• Podsumowanie (914)
  
• Propozycje dalszych lektur (914)

Rozdział 40. Zaawansowane programowanie usług Enterprise (915)


• Programowanie katalogu COM+ (916)
  
  • Programowanie tymczasowych subskrypcji luźno powiązanych zdarzeń (917)
  • Zamykanie aplikacji COM+ i usuwanie komponentów (919)
• Łączenie błyskawicznego tworzenia aplikacji i usług Enterprise (922)
  
• Podsumowanie (929)
  
• Propozycje dalszych lektur (929)

Dodatki (931)


Skorowidz (933)

pokaż cały spis treści

ukryj recenzje