.:$$:.

Kompletny przewodnik programisty opisujący możliwości Windows 2000.

Nowy system oferuje wiele specjalnych elementów, dzięki którym twoje programy mogą działać lepiej. Jednak wielu programistów nie stosuje ich, używając konkurencyjnego oprogramowania. Nie pozwól, by tak było w twoim przypadku. Jeśli nie wykorzystujesz w pełni wielozadaniowości, synchronizacji, komunikacji między procesami zarządzania pamięcią wirtualną -- nie wykorzystujesz w pełni możliwości Windows 2000.

W tej książce weteran Windows, Al Williams, przekaże ci wszystko, co powinieneś wiedzieć. Ta książka ułatwi:

• Wykorzystywanie procesów, wątków i włókien do uzyskania najwyższej możliwej wydajności;
• Synchronizowanie programów za pomocą semaforów, muteksów oraz sekcji krytycznych, co w przypadku wielozadaniowości ma podstawowe znaczenie;
• Komunikację pomiędzy procesami, wykorzystując kanały, RPC, gniazda poczty i inne techniki;
• Korzystanie z takich operacji wejścia-wyjścia, dzięki którym wyeliminowano konieczność oczekiwania na te operacje przez program;
• Korzystanie z zaawansowanego zarządzania pamięcią i sterowanie pamięcią wirtualną w Windows;
• Poznanie Rejestru -- rejestrowanie zdarzeń, zgłaszanie błędów oraz zabezpieczenia;
• Zapoznanie się z rozszerzeniami powłoki oraz konsolą MMC (Microsoft Management Console), a także z wykorzystywaniem biblioteki ATL (ActiveX Template Library);
• Przystosowanie programu do pracy w Internecie;
• Pisanie aplikacji konsoli, które ułatwiają wykonywanie prostych zadań;
• Tworzenie usług zapewniających kontrolę nad systemem nawet wtedy, gdy nie jest do niego zalogowany żaden użytkownik.

Co w tej książce znajdziesz dla siebie?

• Sposoby pełnego wykorzystania możliwości Windows 2000, prowadzące do powstania wydajniejszych i lepszych procesów;
• Kompletny przewodnik pomagający w zrozumieniu zaawansowanych funkcji systemu Windows 2000 obejmujący opis komunikacji pomiędzy procesami, wielozadaniowość, zabezpieczenia i problemy związane z siecią.

Ta książka została napisana dla:

• programistów tworzących systemowe aplikacje i narzędzia;
• twórców oprogramowania, którzy chcieliby jak najlepiej wykorzystywać możliwości Windows 2000.

O Autorze (13)
Wprowadzenie (15)

• Co znajdziesz w tej książce? (16)
• Czy ta książka jest dla Ciebie? (16)
• Czego potrzebujesz? (17)
• Zaczynamy! (17)

Rozdział 1. Windows 2000 - spojrzenie z góry (19)

• Dogłębne omówienie (19)
• Nowy język? (20)
• Krótka historia Windows (21)
• Wersje Windows (24)
• Architektura Windows (25)
• Kaprysy, osobliwości i różnice w systemach Windows (28)
• Narzędzia programistyczne (33)
• Podsumowanie (33)
• Natychmiastowe rozwiązania (34)
• Wybór narzędzia programistycznego (34)
• Architektura Windows (34)
• Procesy (35)
• Wywoływanie API z poziomu C++ (35)
• Wywoływanie API z poziomu VB (35)
• Wywoływanie API z poziomu Visual J++ (36)
• Zasoby internetowe (37)

Rozdział 2. Jak przeżyć z ActiveX (39)

• Dogłębne omówienie (39)
• ActiveX kontra Java (41)
• Definicje (41)
• Struktura obiektu ActiveX (42)
• I to jest obiekt? (43)
• Ponowne wykorzystanie kodu (44)
• Polimorfizm (45)
• Kilka różnych zagadnień związanych z ActiveX (47)
• Interfejs IUnknown (49)
• Tworzenie obiektów i wyszukiwanie interfejsów (49)
• Więcej na temat liczników odwołań (50)
• Agregacja (51)
• Dodatkowe zagadnienia (52)
• Połączenie ActiveX z C++ (56)
• Dlaczego korzysta się bezpośrednio z C++ (56)
• Rejestr systemowy (57)
• Rejestr we własnej osobie (57)
• Zagadnienia związane z Rejestrem (59)
• To wszystko? (61)
• Rejestrowanie obiektów (62)
• Instalowanie klasy (64)
• Korzystanie z REGEDIT (65)
• Samodzielna rejestracja (66)
• Personalizowanie obiektów (67)
• Biblioteki typów (68)
• Makromania (74)
• Podstawy tworzenia klientów (74)
• Projekt prostego serwera (79)
• Prosty klient (80)
• Serwer w pliku EXE (82)
• Serwer w pliku DLL (91)
• Obsługa wielu interfejsów (94)
• Techniki MFC (95)
• Agregacja MFC (106)
• IDispatch (107)
• Nowe granice - COM+ (122)
• Podsumowanie (123)
• Natychmiastowe rozwiązania (124)
• ActiveX w łupinie orzecha (124)
• Rejestr (126)
• Przewodnik po standardowych interfejsach (127)
• Użycie MFC dla IDispatch (127)
• Użycie MFC dla zwykłych interfejsów (128)
• ATL (128)

Rozdział 3. Procesy, wątki oraz włókna (129)

• Dogłębne omówienie (130)
• Inne systemy operacyjne (130)
• Procesy (132)
• CreateProcess (134)
• Zadania i zestawy robocze (139)
• Wątki (140)
• Wątki i MFC (143)
• Lokalne dane wątku (144)
• Włókna (147)
• APC (149)
• Podsumowanie (150)
• Natychmiastowe rozwiązania (151)
• Uruchamianie nowego programu - sposób najprostszy (151)
• Uruchamianie nowego programu - sposób nieco trudniejszy (151)
• Uruchamianie nowego programu - sposób dla macho (151)
• Oczekiwanie na zakończenie działania programu i ustawianie (lub odczytywanie) kodu wyjścia (152)
• Tworzenie nowego wątku za pomocą Windows API (152)
• Tworzenie nowego wątku w bibliotece C++ (153)
• Wątki i MFC (153)
• Tworzenie wątku roboczego MFC (154)
• Tworzenie wątku MFC z interfejsem użytkownika (154)
• Sprawianie, by okna oraz komunikaty pojawiały się na pierwszym planie (155)
• Uzyskiwanie uchwytu procesu i wątku (155)
• Oczekiwanie na zakończenie działania wątku, ustawianie (lub odczytywanie) kodu wyjścia wątku (156)
• Manipulowanie wątkami MFC (156)
• Odczytywanie w MFC wartości zwróconej przez wątek (158)
• Pełny przykład w MFC (158)
• Korzystanie z lokalnych danych wątku (TLS) (164)
• Włókna (164)
• Alternatywy dla wątków (165)

Rozdział 4. Synchronizacja (167)

• Dogłębne omówienie (167)
• Definiowanie problemu (168)
• Więcej na temat synchronizacji (170)
• Szczegóły synchronizacji (171)
• Nieprzerywalne wywołania (173)
• Zdarzenia (173)
• Muteksy (175)
• Semafory (177)
• Bezpieczna synchronizacja (178)
• Korzystanie z funkcji WaitForMultipleObjects (178)
• Przerywalne oczekiwanie (179)
• Przerywalne timery (179)
• Sekcje krytyczne (180)
• Rozbudowany przykład (182)
• Inne uchwyty, na które można oczekiwać (189)
• Podsumowanie (190)
• Natychmiastowe rozwiązania (190)
• Wybór metody synchronizacji (190)
• Unikanie zakleszczeń (192)
• Korzystanie ze zdarzeń (193)
• Korzystanie z muteksów (193)
• Korzystanie z sekcji krytycznych (194)
• Korzystanie z semaforów (194)
• Oczekiwanie na kilka obiektów (195)
• Korzystanie z nieprzerywalnych operacji (195)
• Synchronizacja i MFC (195)

Rozdział 5. Operacje wejścia-wyjścia na plikach (201)

• Dogłębne omówienie (201)
• Dlaczego asynchroniczne wejście-wyjście? (203)
• Przegląd wejścia-wyjścia plików (203)
• Korzystanie z wątków (207)
• Nałożone wejście-wyjście (208)
• Porty dokańczania wejścia-wyjścia (211)
• Przykładowa aplikacja (212)
• Przykład wykorzystania portu dokańczania (216)
• Inny sposób dostępu do plików (219)
• Przykład (220)
• Podsumowanie (223)
• Natychmiastowe rozwiązania (224)
• Otwieranie pliku (224)
• Synchroniczny zapis i odczyt pliku (225)
• Wykrywanie końca pliku (synchroniczne) (225)
• Powielanie uchwytów plików (225)
• Zamykanie pliku (226)
• Uzyskiwanie asynchronicznego wejścia-wyjścia (226)
• Użycie asynchronicznego wejścia-wyjścia z wątkami (226)
• Rozpoczynanie nałożonej operacji wejścia-wyjścia (228)
• Dokańczanie asynchronicznego wejścia-wyjścia (229)
• Wykrywanie końca pliku (asynchroniczne) (229)
• Użycie ReadFileEx oraz WriteFileEx (230)
• Korzystanie z portów dokańczania (230)
• Pliki odwzorowane w pamięci (230)

Rozdział 6. Komunikacja między procesami (233)

• Dogłębne omówienie (233)
• O co tyle zamieszania? (235)
• Przegląd mechanizmów IPC w Windows 2000 (237)
• Prosta IPC (239)
• Użycie bibliotek DLL dla celów wspólnej pamięci (245)
• Inna technika korzystania ze wspólnej pamięci (249)
• Anonimowe potoki (250)
• Nazwane potoki (253)
• Gniazda poczty (255)
• O gniazdach (263)
• Gniazda MFC (282)
• RPC (299)
• Microsoft Message Queue (MSMQ) (307)
• Podsumowanie (308)
• Natychmiastowe rozwiązania (309)
• Podsumowanie metod IPC (309)
• Korzystanie z WM_COPYDATA (311)
• Użycie DLL-i w celu uzyskania wspólnej pamięci (311)
• Wspólna pamięć w odwzorowanych plikach (312)
• Korzystanie z anonimowych potoków (313)
• Korzystanie z nazwanych potoków (313)
• Zastępowanie standardowego uchwytu potokiem (314)
• Korzystanie z gniazd poczty (314)
• Korzystanie z gniazd (315)
• Korzystanie z RPC (316)
• Kiedy należy używać przestarzałych lub rzadko używanych metod IPC (317)

Rozdział 7. Zarządzanie pamięcią (319)

• Dogłębne omówienie (319)
• Dlaczego zajmować się zarządzaniem pamięcią? (320)
• Stronicowanie pamięci (321)
• Użycie VirtualAlloc (321)
• VirtualAlloc w praktyce (323)
• Korzystanie z atrybutów strony (324)
• Korzystanie ze stosów (329)
• Podsumowanie (331)
• Natychmiastowe rozwiązania (331)
• Kiedy używać VirtualAlloc (331)
• Użycie VirtualAlloc i VirtualFree (332)
• Ustawianie ochrony strony (333)
• Odczytywanie ochrony strony (333)
• Odpowiadanie na wyjątki (333)
• Tworzenie nowej sterty (334)
• Znajdowanie domyślnej sterty (335)
• Alokowanie i zwalnianie danych sterty (335)
• Kompaktowanie sterty (336)
• Debuggowanie sterty (336)
• Zagadnienia związane z wydajnością sterty (336)

Rozdział 8. System zabezpieczeń w Windows (339)

• Dogłębne omówienie (339)
• Cele zabezpieczeń (340)
• Przywileje i uprawnienia (341)
• Wypełnianie deskryptora zabezpieczeń (342)
• Wewnątrz SID (344)
• ACE i ACL (345)
• Rodzaje obiektów zabezpieczeń (345)
• Korzystanie z domyślnych zabezpieczeń (346)
• Budowanie deskryptorów zabezpieczeń (347)
• Tokeny i personifikacja (348)
• Budowanie określonych list ACL (348)
• Korzystanie z funkcji AccessCheck (352)
• Prywatne zabezpieczenia (353)
• Przywileje (356)
• Kerberos (356)
• Podsumowanie (357)
• Natychmiastowe rozwiązania (357)
• Uzyskiwanie właściciela obiektu (357)
• Konwertowanie SID na nazwę (358)
• Konwersja nazwy na SID (359)
• Tworzenie deskryptora (359)
• Konwersja pomiędzy deskryptorami absolutnymi a względnymi (360)
• Korzystanie z domyślnego deskryptora zabezpieczeń (360)
• Używanie uniwersalnego deskryptora zabezpieczeń (360)
• Używanie specyficznego deskryptora zabezpieczeń (361)
• Używanie prywatnych zabezpieczeń (361)

Rozdział 9. Rejestr i dzienniki (363)

• Dogłębne omówienie (363)
• Porzucamy pliki INI? (365)
• Rejestr - z bliska i osobiście (365)
• Uwagi dotyczące Rejestru (367)
• I to wszystko? (378)
• Co się w nim znajduje? (378)
• Budowanie plików REG (379)
• Wewnątrz typu pliku (381)
• Dzienniki (382)
• Źródła zdarzeń (383)
• Tworzenie plików komunikatów (384)
• Komunikaty systemowe (386)
• Operacje na dzienniku (387)
• Natychmiastowe rozwiązania (390)
• Otwieranie klucza Rejestru (390)
• Wyszukiwanie podkluczy (391)
• Wyszukiwanie wartości (391)
• Korzystanie z Rejestru zamiast z plików INI (391)
• Tworzenie plików REG (392)
• Tworzenie plików INF (393)
• Tworzenie biblioteki DLL komunikatów (394)
• Rejestrowanie biblioteki DLL komunikatów (394)
• Zapisywanie zdarzeń do dziennika (395)
• Zamiana kodów błędów w komunikaty (395)

Rozdział 10. Sztuczki z powłoką z użyciem ATL (397)

• Dogłębne omówienie (397)
• Rozszerzenia powłoki (398)
• Podstawowe ATL (400)
• Użycie MFC zamiast ATL (405)
• ATL kontra MFC (412)
• Programy obszaru powiadamiania (412)
• O inteligentnych wskaźnikach (416)
• Skróty (416)
• MMC (420)
• Podsumowanie (440)
• Natychmiastowe rozwiązania (440)
• O rozszerzeniach powłoki (440)
• Rozwiązywanie skrótów (441)
• Tworzenie skrótu (442)
• Pisanie programów ikon obszaru powiadamiania (442)
• Różnorodne wywołania powłoki (443)
• O MMC (443)
• Pisanie przystawek MMC (444)

Rozdział 11. Programowanie Internetu i sieci (445)

• Dogłębne omówienie (445)
• Skróty Internetu (446)
• Użycie Internet Explorera (454)
• WebPost API (469)
• Internet i MFC (481)
• Przegląd Active Directory Services (491)
• Podsumowanie (492)
• Natychmiastowe rozwiązania (493)
• Praca ze skrótami internetowymi (493)
• Metody komunikacji poprzez Internet (494)
• Korzystanie z URL-i w zasobach (494)
• Wewnątrz Internet Explorera (495)
• Korzystanie z modelu obiektów przeglądarki (496)
• Korzystanie z okien dialogowych HTML (496)
• Korzystanie ze wsparcia dla Internetu wbudowanego w MFC (497)

Rozdział 12. Aplikacje konsoli i usługi (499)

• Dogłębne omówienie (499)
• Tworzenie prostej aplikacji konsoli (500)
• Usługi (524)
• Usługa zorientowana obiektowo (532)
• Podsumowanie (537)
• Natychmiastowe rozwiązania (538)
• Tworzenie programu konsoli (538)
• Użycie MFC w programach konsoli (538)
• Metody dostępu do konsoli (538)
• Tworzenie głównej konsoli dla programu GUI (539)
• Tworzenie i korzystanie z dodatkowych konsol (540)
• Obsługa zdarzeń konsoli (540)
• Wyszukiwanie uchwytu okna konsoli (541)
• Wewnątrz usług (541)
• Dostęp do usługi (542)
• Bazowa klasa C++ dla usługi (542)
• Debuggowanie usług (543)

Dodatek A Poza granicę (545)

• Czy wszystko wiesz? (545)
• Technologie baz danych (546)
• Użycie MAPI (546)
• Zarządzanie kolorem (547)
• DirectX (548)
• OpenGL (548)
• Statyczne obrazy (549)
• Wyszukiwanie dodatkowych informacji (549)

Dodatek B Programistyczna Odyseja (551)

• Przyszłość? (551)
• Duże zagrożenie (552)
• Co to oznacza dla mnie? (553)
• Bądź przygotowany (553)
• Rada na dzisiaj (553)