Visual Studio 2010 dla programistów C# - ebook

• Środowisko Visual Studio 2010, język C# 4.0 i podstawy projektowania aplikacji
• Bazy danych i technologia LINQ
• Nowy paradygmat zrównoleglenia aplikacji z biblioteką TPL
• Technologie Windows i wprowadzenie do XNA 4.0

Język C# na dobre zadomowił się już na rynku programistycznym. Zarówno on sam, jak i platforma .NET przydają się do najróżniejszych zastosowań, obejmujących nie tylko projektowanie złożonych aplikacji korzystających z baz danych, ale również usług systemu Windows lub gier. Pora więc zapoznać się z tym językiem programowania, oswoić ze środowiskiem Visual Studio 2010 firmy Microsoft i zorientować się, jak możesz wykorzystać nowe umiejętności. Ta obszerna książka o przekrojowym charakterze ułatwi Ci wejście w świat języka C#, platform .NET i XNA. Poznasz również wiele zaawansowanych technik programistycznych.

Z pierwszej części przewodnika poznasz język C# i bogate środowisko programistyczne Visual Studio 2010. Nauczysz się również jak wydajnie projektować aplikacje z graficznym interfejsem użytkownika. Kolejne części poruszają kwestie połączenia aplikacji z bazą danych i stosowania technologii LINQ. W dobie komputerów z wieloma procesorami o wielu rdzeniach bardzo ważna jest umiejętność tworzenia aplikacji wielowątkowych. Temu zagadnieniu poświęcona jest część czwarta dotycząca nowej biblioteki TPL. Znajdziesz tu także opis zagadnień związanych z usługami sieciowymi WCF i pracą z wykorzystaniem różnorodnych technologii Windows. Osobną część poświęcono także wprowadzeniu do technologii XNA 4.0 i budowaniu z jej pomocą gier korzystających z grafiki 2D. Jeśli chcesz programować w języku C#, nie możesz przegapić tej książki!

• Środowisko Visual Studio 2010, język C# i debugowanie kodu
• Projektowanie zorientowane obiektowo i przegląd komponentów Windows Forms
• Podstawy ADO.NET, eksport i prezentacja danych, transakcje i raportowanie
• Wprowadzenie do zapytań LINQ i tworzenie źródeł danych LINQ
• Programowanie współbieżne — wątki i zadania
• Klasa Parallel i dane w programach równoległych, technologia PLINQ
• Biblioteka WCF — tworzenie usług sieciowych nowej generacji
• Technologie Windows — rejestr systemu, komunikaty, usługi i automatyzacja
• Tworzenie gier w XNA 4.0, użycie shakerów HLSL
• Użycie wyrażeń regularnych – sposób na weryfikację wprowadzanych danych
• Testy jednostkowe – najlepsza metoda sprawdzania poprawności kodu

Wstęp (15)

Część I: Projektowanie aplikacji Windows (17)

Rozdział 1. Środowisko Visual Studio 2010 (19)

• Projektowanie interfejsu aplikacji (20)
  • Tworzenie projektu (20)
  • Dokowanie palety komponentów Toolbox (22)
  • Tworzenie interfejsu za pomocą komponentów Windows Forms (22)
  • Zapisywanie i wczytywanie projektu (24)
• Analiza kodu pierwszej aplikacji (24)
• Metody zdarzeniowe (29)
  • Metoda uruchamiana w przypadku wystąpienia zdarzenia kontrolki (29)
  • Testowanie metody zdarzeniowej (29)
  • Przypisywanie istniejącej metody do zdarzeń komponentów (31)
  • Edycja metody zdarzeniowej (32)
  • Modyfikowanie własności komponentów (32)
  • Wywoływanie metody zdarzeniowej z poziomu kodu (32)
  • Reakcja aplikacji na naciskanie klawiszy (33)

Rozdział 2. Debugowanie kodu (35)

• Skąd biorą się błędy i jak ich unikać? (35)
• Kontrolowane uruchamianie aplikacji w Visual C# (36)
  • Śledzenie wykonywania programu krok po kroku (F10 i F11) (37)
  • Run to Cursor (Ctrl+F10) (38)
  • Breakpoint (F9) (38)
  • Okna Locals i Watch (39)
• Stan wyjątkowy (41)
  • Zgłaszanie wyjątków (41)
  • Przechwytywanie wyjątków w konstrukcji try..catch (42)

Rozdział 3. Język C# (45)

• Platforma .NET (46)
  • Środowisko uruchomieniowe (46)
  • Kod pośredni i podwójna kompilacja (46)
  • Skróty, które warto poznać (46)
• Podstawowe typy danych (47)
  • Deklaracja i zmiana wartości zmiennej (47)
  • Typy liczbowe oraz znakowy (48)
  • Określanie typu zmiennej przy inicjacji (pseudotyp var) (49)
  • Operatory (49)
  • Konwersje typów podstawowych (51)
  • Operatory is i as (51)
  • Łańcuchy (52)
  • Typ wyliczeniowy (54)
  • Leniwe inicjowanie zmiennych (55)
• Metody (55)
  • Przeciążanie metod (56)
  • Domyślne wartości argumentów metod - argumenty opcjonalne (nowość języka C# 4.0) (57)
  • Argumenty nazwane (nowość języka C# 4.0) (58)
  • Wartości zwracane przez metody (58)
  • Zwracanie wartości przez argument metody (58)
  • Delegacje i zdarzenia (59)
  • Wyrażenia lambda (60)
• Typy wartościowe i referencyjne (61)
  • Nullable (62)
  • Pudełkowanie (63)
• Typy dynamiczne (nowość języka C# 4.0) (63)
• Sterowanie przepływem (66)
  • Instrukcja warunkowa if..else (66)
  • Instrukcja wyboru switch (66)
  • Pętle (67)
• Wyjątki (68)
• Dyrektywy preprocesora (70)
  • Kompilacja warunkowa - ostrzeżenia (70)
  • Definiowanie stałych preprocesora (70)
  • Bloki (71)
• Atrybuty (71)
• Kolekcje (72)
  • "Zwykłe" tablice (72)
  • Pętla foreach (74)
  • Sortowanie (74)
  • Kolekcja List (75)
  • Kolekcja SortedList i inne słowniki (77)
  • Kolejka i stos (77)
  • Tablice jako argumenty metod oraz metody z nieokreśloną liczbą argumentów (78)
  • Słowo kluczowe yield (79)
• Nowa forma inicjacji obiektów i tablic (80)

Rozdział 4. Projektowanie zorientowane obiektowo (83)

• Przykład struktury (Ulamek) (84)
  • Przygotowanie projektu (84)
  • Konstruktor i statyczne obiekty składowe (84)
  • Pierwsze testy (85)
  • Konwersje na łańcuch (metoda ToString) i na typ double (86)
  • Metoda upraszczająca ułamek (86)
  • Własności (87)
  • Operatory arytmetyczne (88)
  • Operatory porównania oraz metody Equals i GetHashCode (89)
  • Operatory konwersji (90)
• Implementacja interfejsu (na przykładzie IComparable) (91)
• Definiowanie typów parametrycznych (92)
  • Definiowanie typów ogólnych (93)
  • Określanie warunków, jakie mają spełniać parametry (94)
  • Implementacja interfejsów przez typ ogólny (95)
  • Definiowanie aliasów (96)
  • Typy ogólne z wieloma parametrami (97)
• Rozszerzenia (98)
• Typy anonimowe (99)

Rozdział 5. Przegląd komponentów biblioteki Windows Forms (101)

• Notatnik.NET (101)
  • Projektowanie interfejsu aplikacji i menu główne (101)
  • Okna dialogowe i pliki tekstowe (106)
  • Edycja i korzystanie ze schowka (113)
  • Drukowanie (113)
• Elektroniczna kukułka (120)
  • Ekran powitalny (splash screen) (120)
  • Przygotowanie ikony w obszarze powiadamiania (122)
  • Odtwarzanie pliku dźwiękowego (125)
• Ustawienia aplikacji (126)
• Dywan graficzny (129)
• Lista uruchomionych procesów (132)

Rozdział 6. Przeciągnij i upuść (135)

• Podstawy (135)
  • Interfejs przykładowej aplikacji (135)
  • Inicjacja procesu przeciągania (137)
  • Akceptacja upuszczenia elementu (138)
  • Reakcja na upuszczenie elementu (139)
  • Czynności wykonywane po zakończeniu procesu przenoszenia i upuszczania (140)
  • Przenoszenie elementów między różnymi aplikacjami (140)
• Zagadnienia zaawansowane (140)
  • Opóźnione inicjowanie procesu przenoszenia (141)
  • Przenoszenie wielu elementów (142)
  • Przenoszenie plików (144)

Rozdział 7. Przezroczyste okna o dowolnym kształcie (147)

• Konfiguracja formy (147)
• Wczytywanie obrazu (148)
• Przezroczystość i łagodne znikanie okna (150)
• Zamykanie klawiszem Esc (151)
• Przenoszenie formy za dowolny punkt (151)
• Menu kontekstowe (152)

Rozdział 8. Projektowanie kontrolek (155)

• Komponent FileListBox (156)
  • Implementacja podstawowych funkcjonalności (156)
  • Rozbudowa komponentu o możliwość zmiany katalogu (163)
  • Właściwości (164)
  • Zdarzenia - interakcja z komponentem (168)
  • Odświeżanie komponentu i automatyczne śledzenie zmian w prezentowanym katalogu (173)
  • Kompilacja komponentu do postaci biblioteki DLL (175)
  • Prosty przykład wykorzystania komponentu FileListBox: przeglądanie plików tekstowych (179)
• Kolorowy pasek postępu (181)
  • Tworzenie projektu (182)
  • Rysowanie obramowania kontrolki (182)
  • Pola i własności (182)
  • Rysowanie paska postępu (185)
  • Metody (186)
  • Zdarzenia (186)

Rozdział 9. Studium przypadku: implementacja liczb zespolonych i ich użycie do rysowania fraktali (189)

• Implementacja liczb zespolonych (189)
  • Projekt struktury (190)
  • Własności (192)
  • Operatory (193)
  • Metody statyczne (195)
  • Testy (197)
• Rysowanie zbiorów Mandelbrota i Julii (198)
  • Trochę teorii (198)
  • Implementacja (200)

Część II: Technologie bazodanowe ADO.NET (203)

Rozdział 10. Podstawy ADO.NET (205)

• Podstawy relacyjnych baz danych (205)
• Technologia ADO.NET (206)
• Instalacja bazy Northwind (207)
• Połączenie ze źródłem danych (207)
• Modyfikacja danych w obiekcie DataSet (211)
  • Tworzenie nowych rekordów (211)
  • Edycja rekordów (215)
  • Wersjonowanie obiektu DataRow i kontrola wprowadzanych danych (216)
  • Usuwanie rekordów (220)
• Obiekt TableAdapter jako pomost między DataSet a źródłem danych (221)
  • Parametryzacja kwerend (221)
  • Edycja danych przy użyciu obiektu TableAdapter (224)
  • Integralność danych i ich usuwanie (224)
  • Wstawianie danych z wykorzystaniem obiektu TableAdapter (228)

Rozdział 11. Prezentacja danych (233)

• Mechanizm DataBinding - wiązanie danych z kontrolkami (233)
• Mechanizm DataBinding a komponent Chart (237)
• Komponent DataGridView (239)
  • Formatowanie danych wyświetlanych w komponencie DataGridView (240)
  • Tworzenie formularza z podformularzem (Master/Detail Form) (246)

Rozdział 12. Eksport danych (249)

• Informacje wstępne (249)
  • Eksport danych przy użyciu schowka systemowego (250)
  • Wstawianie danych do arkusza kalkulacyjnego z pominięciem schowka systemowego (253)
  • Transfer danych poprzez plik XML (254)
  • Eksport danych do formatu HTML (256)

Rozdział 13. Transakcje (257)

• Tworzenie i ręczna kontrola transakcji (257)
• Automatyczne zarządzanie transakcjami (261)
• Konkurencyjność i poziom izolacji transakcji (264)

Rozdział 14. Bezpieczeństwo w aplikacjach bazodanowych (265)

• Szyfrowanie połączenia (265)
• Zabezpieczenie kodu pośredniego przy użyciu Code Access Security (CAS) (270)
• ConnectionString a sposoby uwierzytelnienia w serwerze Microsoft SQL Server (274)
• Uwagi końcowe dotyczące projektowania aplikacji bazodanowych (275)

Rozdział 15. Raportowanie (277)

• Pierwszy raport (277)
  • Konfiguracja źródła danych (278)
  • Projektowanie raportu (279)
  • Kolumny obliczeniowe raportu (280)
  • Stosowanie formatu prezentacji danych (281)
  • Grupowanie danych (282)
• Projektowanie graficznego układu raportu (283)
  • Etykiety, rysunki i listy (284)
  • Prezentacja danych w postaci macierzowej (287)
• Parametry raportu i filtrowanie danych (289)
  • Filtr definiowany na poziomie raportu (289)
  • Filtrowanie raportu na etapie pobierania danych źródłowych (290)
• Kluczowe wskaźniki efektywności (292)
• Wykresy (294)
• Tworzenie raportu zawierającego podraport (295)
• Eksport danych przy użyciu raportu (297)

Część III: LINQ (303)

Rozdział 16. Wprowadzenie do zapytań LINQ na przykładzie kolekcji (LINQ to Objects) (305)

• • Pobieranie danych (filtrowanie i sortowanie) (306)
  • Najprostsza prezentacja pobranych danych (307)
  • Analiza pobranych danych (307)
  • Wybór elementu (307)
  • Weryfikowanie danych (308)
  • Prezentacja w grupach (308)
  • Łączenie zbiorów danych (308)
  • Łączenie danych z różnych źródeł w zapytaniu LINQ - operator join (309)
  • Możliwość modyfikacji danych źródła (309)

Rozdział 17. LINQ to DataSet (311)

• Konfiguracja kontrolki DataSet (312)
• LINQ to DataSet, czyli tam i z powrotem (313)
• Rozszerzenie AsEnumerable klasy DataTable (316)
  • Obliczenia wykonywane na danych z tabeli (316)
  • Dowolność sortowania i filtrowania pobieranych danych (316)

Rozdział 18. LINQ to SQL (317)

• Klasa encji (317)
• Pobieranie danych (319)
• Aktualizacja danych w bazie (319)
  • Modyfikacje istniejących rekordów (320)
  • Dodawanie i usuwanie rekordów (320)
  • Inne operacje (321)
• Wizualne projektowanie klasy encji (322)
  • O/R Designer (322)
  • Współpraca z kontrolkami tworzącymi interfejs aplikacji (325)
  • Kreator źródła danych i automatyczne tworzenie interfejsu użytkownika (325)
  • Łączenie danych z dwóch tabel - operator join (328)
  • Relacje (Associations) (328)
• Korzystanie z procedur składowanych (331)
  • Pobieranie danych za pomocą procedur składowanych (331)
  • Modyfikowanie danych za pomocą procedur składowanych (331)
  • Wykonywanie dowolnych poleceń SQL (332)

Rozdział 19. Trzy sposoby na odczytywanie i zapisywanie danych w plikach XML (335)

• Podstawy języka XML (335)
  • Deklaracja (335)
  • Elementy (336)
  • Atrybuty (336)
  • Komentarze (336)
• Klasy XmlTextReader i XmlTextWriter (336)
  • Zapis do pliku XML (337)
  • Odczyt danych z pliku XML (338)
  • Analiza i odczyt pliku XML o nieznanej strukturze (339)
• Serializacja obiektów do pliku XML (341)
  • Serializacja obiektu do pliku XML (342)
  • Deserializacja obiektu z pliku XML (343)
• XML i ADO.NET (343)
  • Wczytywanie danych z pliku XML do komponentu DataSet (344)
  • Zapisywanie zmian do pliku XML za pośrednictwem DataSet (345)
• LINQ to XML (346)
  • Tworzenie pliku XML za pomocą klas XDocument i XElement (346)
  • Pobieranie wartości z elementów o znanej pozycji w drzewie (347)
  • Przenoszenie danych z kolekcji do pliku XML (349)
  • Przenoszenie danych z bazy danych (komponentu DataSet) do pliku XML (350)
  • Zapytania LINQ (350)
  • Modyfikacja pliku XML (351)

Rozdział 20. Tworzenie źródeł danych LINQ (353)

• Źródło liczb losowych (353)
  • IEnumerable (353)
  • IEnumerable<> (355)
  • Oddzielenie źródła od jego interfejsu (357)
  • IQueryable i IOrderedQueryable (359)
  • IQueryable<> i IOrderedQueryable<> (360)
  • Drzewo wyrażenia (361)
• Tabela w pliku tekstowym, czyli LINQ to TXT (367)
  • Proste rozwiązanie (367)
  • Plan projektu "pełnego" źródła danych (370)
  • Klasa odpowiedzialna za odczytanie pliku tekstowego (370)
  • Modelowanie danych (mapowanie typów) (374)
  • Projekt źródła danych i analizator zapytania (377)
  • Przetwarzanie danych z analizatora (384)
  • Edycja danych w źródle LINQ i dodawanie nowych rekordów (393)
  • Przykład wykorzystania biblioteki LINQ to TXT (397)

Rozdział 21. Entity Framework (401)

• Podstawy Entity Framework (401)
  • Entity Framework - pierwszy projekt (402)
  • Plik .edmx (405)
• Praca z obiektami Entity Framework. LINQ to Entities and Entity SQL (409)
  • Pierwsze zapytanie oparte na modelu encji (409)
  • Filtrowanie danych (411)
  • Projekcja danych (412)
  • Grupowanie danych (414)
  • Związki między encjami w zapytaniach (415)
  • Sortowanie wyników zapytania (417)
  • Wykorzystanie programowania równoległego w zapytaniach LINQ to Entities (418)
  • Tworzenie, modyfikowanie i usuwanie obiektów encji (419)
• Inne funkcje Entity Framework (421)
  • Zachłanne i leniwe ładowanie (Eager and lazy loading) (421)
  • Wykorzystanie procedur składowanych do modyfikacji encji (424)
  • Wykorzystanie procedur składowanych do pobierania danych (428)
  • Tworzenie tabel w bazie danych na podstawie modelu encji (431)
  • Dziedziczenie typu tabela na hierarchię (434)
  • Dziedziczenie typu tabela na typ (438)
  • Entity Framework i POCO (441)

Część IV: Programowanie współbieżne (447)

Rozdział 22. Wątki (449)

• Monte Carlo (449)
• Obliczenia bez użycia dodatkowych wątków (450)
• Przeniesienie obliczeń do osobnego wątku (451)
• Usypianie wątku (452)
• Przerywanie działania wątku (Abort) (453)
• Wstrzymywanie i wznawianie działania wątku (454)
• Wątki działające w tle (455)
• Zmiana priorytetu wątku (455)
• Użycie wielu wątków i problemy z generatorem liczb pseudolosowych (456)
• Czekanie na ukończenie pracy wątku (Join) (458)
• Sekcje krytyczne (lock) (460)
• Przesyłanie danych do wątku (461)
• Pula wątków (463)
• Jeszcze raz o komunikacji między wątkami (465)
• Synchronizacja wątków - rejestr braków (466)
• Korzystanie z muteksów w celu zapobiegania uruchamianiu wielu instancji aplikacji (466)

Rozdział 23. Zadania - nowy przepis na programowanie współbieżne w platformie .NET 4.0 (469)

• Tworzenie zadania (469)
• Praca z zadaniami (470)
• Dane przekazywane do zadań (471)
• Dane zwracane przez zadania (472)
• Przykład: test liczby pierwszej (472)
• Synchronizacja zadań (473)
• Przykład: sztafeta zadań (474)
• Przerywanie zadań (475)
• Stan zadania (478)
• Fabryka zadań (480)
• Planista i zarządzanie kolejkowaniem zadań (482)
• Ustawienia zadań (485)

Rozdział 24. Klasa Parallel. Zrównoleglanie pętli (487)

• Równoległa pętla for (487)
• Równoległa pętla foreach (489)
• Metoda Invoke (489)
• Ustawienia pętli równoległych. Klasa ParallelOptions (490)
• Przerywanie pętli za pomocą CancellationToken (490)
• Kontrola wykonywania pętli (491)
• Synchronizacja pętli równoległych. Obliczanie ? metodą Monte Carlo (492)
• Wielowątkowa klasa Random (496)

Rozdział 25. Dane w programach równoległych (499)

• Praca ze zbiorami danych w programowaniu równoległym (499)
  • Współbieżne struktury danych (499)
  • Kolekcja CollectionBag (500)
  • Współbieżne kolejka i stos (501)
  • Praca z BlockingCollection (501)
  • Własna kolekcja współbieżna (503)
  • Agregacja (506)
  • Agregacje dla kolekcji równoległych (507)
• PLINQ - zrównoleglone zapytania LINQ (511)
  • Przykład zapytania PLINQ (511)
  • Jak działa równoległe LINQ? (512)
  • Kiedy PLINQ jest wydajne? (514)
  • Metody przekształcające dane wynikowe (515)
  • Przerywanie zapytań (515)
  • Metoda ForAll (517)

Część V: Usługi sieciowe, czyli WCF od A do C (519)

• Potrzeba matką wynalazku (520)

Rozdział 26. WCF - jak to ugryźć? (523)

• Podstawy działania (523)
  • Biblioteki i przestrzenie nazw (523)
• WCF = A + B + C (524)
  • C jak contract (524)
  • B jak binding (524)
  • A jak address (528)
• Pierwszy serwis (529)
• Hosting (534)
  • Self-Hosting (534)
  • IIS (538)
  • Serwis windowsowy (540)
  • WAS (542)
• Klient (542)

Rozdział 27. Narzędzia i konfiguracja (547)

• Narzędzia (547)
• Konfiguracja kluczem do wszystkiego - bliższe spojrzenie (550)
  • (551)
  • (551)
  • (553)
  • (553)
  • (553)
  • (553)
  • (554)
  • (554)
  • (554)

Rozdział 28. Wybrane nowości WCF w platformie .NET 4.0 (557)

• Uproszczona konfiguracja (557)
• Discovery (558)
• Serwis routujący (562)

Część VI: Technologie Windows (569)

Rozdział 29. Rejestr systemu Windows (571)

• Korzystanie z rejestru (571)
  • Odczytywanie danych z rejestru (571)
  • Zapisywanie oraz odczytywanie położenia i rozmiaru formy w prywatnym kluczu aplikacji (573)
  • Usuwanie klucza z rejestru (575)
• Przeglądarka skojarzeń plików (575)
  • Informacja o typach plików przechowywana w rejestrze (575)
  • Przygotowanie interfejsu (577)
  • Odczytywanie listy rozszerzeń (578)
  • Pobieranie opisu, polecenia głównego i domyślnego edytora dla podanego typu plików (579)

Rozdział 30. Zarządzane biblioteki DLL i mechanizm odzwierciedlenia (583)

• Tworzenie zarządzanej biblioteki DLL (584)
  • Projekt biblioteki DLL (584)
  • Dodawanie referencji do biblioteki systemowej platformy .NET (584)
  • Wyświetlanie informacji o systemie i platformie .NET (585)
• Statyczne ładowanie bibliotek DLL (586)
  • Dołączanie do projektu bibliotek DLL użytkownika (586)
• Dynamiczne ładowanie zarządzanych bibliotek DLL i dynamiczne rozpoznawanie typów (587)
  • Dynamiczne ładowanie zarządzanej biblioteki .dll (587)
  • Analiza zawartości biblioteki załadowanej dynamicznie (588)
  • Weryfikacja obecności w bibliotece DLL klasy o znanej nazwie (589)
  • Lista metod w klasie z biblioteki DLL (589)
  • Weryfikacja obecności konkretnej metody w klasie z biblioteki DLL (590)
  • Lista argumentów wybranej metody (591)
  • Uruchamianie metody statycznej z klasy wczytanej z biblioteki DLL (593)
  • Uruchamianie metody na rzecz instancji obiektu. Przekazywanie parametrów i odczytywanie zwracanej wartości (593)
• Użycie typu dynamic (595)
• Korzystanie z bibliotek DLL jako wtyczek (MEF) (595)
  • Gospodarz i wtyczka w jednej aplikacji (595)
  • Rozdzielenie gospodarza i wtyczki (598)
  • Katalog (599)
  • Wiele wtyczek implementujących ten sam interfejs (600)
  • Metadane (601)

Rozdział 31. Mechanizm PInvoke (603)

• Funkcja bez argumentów (603)
• Problemy z argumentami (605)
• Zwracanie wartości przez argumenty (606)
• Zwracanie tablicy znaków w funkcjach WinAPI (608)

Rozdział 32. Komunikaty Windows (609)

• Wysyłanie komunikatów Windows (609)
  • Identyfikacja aplikacji (609)
  • Wysyłanie komunikatu do okna o znanym uchwycie (611)
  • Komunikaty jako sposób porozumiewania się z systemem (611)
• Odbieranie komunikatów Windows (612)
  • Monitor komunikatów (612)
  • Reakcja na wybrany komunikat (613)

Rozdział 33. Integracja kodu zarządzanego i niezarządzanego (615)

• Kod zarządzany (nadzorowany) (616)
• Import funkcji z biblioteki systemowej. Wersja bez zabezpieczeń (617)
• Import funkcji z biblioteki systemowej. Wersja z zabezpieczeniem (619)
• Import wielu funkcji z biblioteki DLL. Klasa opakowująca (621)
• Import wielu funkcji z biblioteki DLL. Ładowanie bibliotek DLL (625)
• Różne wersje funkcji WinAPI (627)
• Konwersja typów zarządzanych i niezarządzanych (628)
• Przekazywanie struktur do funkcji niezarządzanych (628)
• Projekt własnej biblioteki DLL. Integracja projektu zarządzanego i niezarządzanego (632)
• Przekazywanie ciągów znakowych i wskaźników bez użycia struktury IntPtr (634)
• Wywołanie zwrotne i kopiowanie obszarów pamięci kodu niezarządzanego (635)

Rozdział 34. Usługi Windows (637)

• Tworzenie usługi (638)
• Instalacja usługi (641)
  • Przygotowanie projektu i ręczna instalacja usługi (641)
  • Projekt instalatora usługi (644)
• Odczytywanie błędów generowanych w trakcie pracy usługi (645)
• Zarządzanie usługą z poziomu innej aplikacji (646)

Rozdział 35. Automatyzacja (649)

• Technologie COM (649)
• Excel jako serwer automatyzacji (650)
  • Pobranie informacji o aktualnie uruchomionej aplikacji Excel (651)
  • Uruchamianie i zamykanie serwera automatyzacji MS Excel (652)
  • Eksplorowanie danych w arkuszu kalkulacyjnym (654)
  • Korzystanie z okien dialogowych serwera automatyzacji. Zapisywanie danych w pliku (655)
  • Zapisywanie danych z wykorzystaniem okna dialogowego aplikacji klienckiej (656)
  • Edycja danych w komórkach Excela (656)
  • Obsługa zdarzeń serwera automatyzacji (658)
  • Korzystanie z funkcji matematycznych i statystycznych Excela (659)
• Serwer automatyzacji Microsoft Word (661)
  • Uruchamianie aplikacji Microsoft Word i tworzenie nowego dokumentu lub otwieranie istniejącego (661)
  • Wywoływanie funkcji Worda na przykładzie sprawdzania pisowni i drukowania (662)
  • Wstawianie tekstu do bieżącego dokumentu Worda (663)
  • Zapisywanie bieżącego dokumentu Worda (663)
  • Zaznaczanie i kopiowanie całego tekstu dokumentu Worda do schowka (664)
  • Kopiowanie zawartości dokumentu Worda do komponentu RichTextBox bez użycia schowka (z pominięciem formatowania tekstu) (664)
  • Formatowanie zaznaczonego fragmentu tekstu w dokumencie Worda (665)
• Serwer automatyzacji przeglądarki Internet Explorer (665)
• Projektowanie własnego serwera automatyzacji (667)
  • Przykład prostego projektu serwera automatyzacji (667)
  • Testy (669)

Rozdział 36. Odtwarzanie multimediów przy użyciu technologii ActiveX (671)

• Odtwarzanie plików multimedialnych (671)
• Wstrzymywanie, wznawianie i prezentowanie informacji o postępie odtwarzania pliku (672)
• Wybór odtwarzanego pliku (674)
• Kontrola głośności odtwarzania (675)
• Przewijanie odtwarzanego pliku (675)
• Widok pełnego ekranu (676)
• Implementacja listy odtwarzanych plików (676)

Rozdział 37. Visual Studio Tools for Office (681)

• Elementy języka C# 4.0 ułatwiające tworzenie dodatków dla pakietu Office (682)
• Szablon projektu dodatku do skoroszytu (682)
• Komponenty Windows Forms w arkuszu Excela (684)
• Tworzenie wykresu w skoroszycie przy użyciu dodatku napisanego w C# (686)
• Modyfikacja wstążki menu w aplikacji MS Excel (687)
• Ukrycie standardowych zakładek wstążki menu w aplikacji Excel (690)
• Tworzenie panelu zadań aplikacji MS Excel (690)
• Formatowanie komórek (693)
• Obsługa zdarzeń (695)
• Dodatki na poziomie aplikacji (696)
  • Interfejs aplikacji (696)
  • Implementacja funkcjonalności aplikacji (698)
• Zarządzanie dodatkami w aplikacji MS Excel (702)
  • Instalacja dodatku (702)
  • Usunięcie dodatku (702)
• Podsumowanie (703)

Część VII: Grafika 2D w XNA 4.0 (705)

Rozdział 38. Struktura projektu gry w XNA (707)

• Pola klasy gry (708)
• Metody gry (708)
• Pętla gry (709)

Rozdział 39. Wyświetlanie obrazów (713)

• Rysowanie obrazu za pomocą obiektu SpriteBatch. Klasa Sprite (714)
• Układ współrzędnych (719)

Rozdział 40. Wykrywanie kolizji (721)

• Animacja piłki (721)
• Wykrywanie i obsługa kolizji (723)

Rozdział 41. Obsługa kontrolerów gry (klawiatura, mysz i gamepad) (727)

Rozdział 42. Komponenty gry (731)

Rozdział 43. Oprawa dźwiękowa (739)

• XACT (739)
• MediaPlayer (745)

Rozdział 44. Wyświetlanie tekstu (747)

Rozdział 45. Gra z komputerem (751)

Rozdział 46. Shadery i efekty w XNA (755)

• Proces renderowania (755)
• Podstawy języka HLSL (756)
  • Typy zmiennych (756)
  • Semantyka (757)
  • Sterowanie przepływem (758)
  • Definiowanie funkcji (758)
• Efekty, techniki, przebiegi (758)
• Przykład efektu HLSL i jego wykorzystanie w grze XNA (759)
• Kilka przykładów efektów (762)
• Drżenie ekranu w Pongu (764)

Dodatek A: Aplikacje konsolowe i informacje o systemie (767)

• Klasa Console (767)
  • Projekt aplikacji konsolowej (767)
  • Drukowanie napisów w konsoli (768)
  • Czekanie na akceptację użytkownika (769)
  • Odczytywanie danych z klawiatury (769)
  • Komunikat "okienkowy" w aplikacji konsolowej (770)
• Informacje o środowisku aplikacji (771)
  • Podstawowe informacje o systemie i profilu użytkownika (771)
  • Katalogi specjalne zdefiniowane w bieżącym profilu użytkownika (772)
  • Odczytywanie zmiennych środowiskowych (773)
  • Lista dysków logicznych (773)

Dodatek B: Instalacja SQL Server 2008 Express Edition i bazy danych AdventureWorks (775)

• Instalacja SQL Server 2008 Express Edition (775)
• Instalacja bazy danych AdventureWorks (779)
• Uruchamianie...