• Jak tworzyć interfejs użytkownika?
• Jak uzyskać dostęp do danych z wykorzystaniem LINQ?
• Jak wdrażać napisany kod?

C# to jeden z głównych języków, który możesz wykorzystać jeżeli chcesz tworzyć rozwiązania dla platformy .NET. Jego najnowsza wersja 3.0 wniosła wiele nowości takich jak: typy domniemane, typy anonimowe, uproszczone inicjowanie obiektów oraz nowe słowa kluczowe ułatwiające korzystanie z zapytań SQL. Jednak oprócz tych nowości, w książce znajdziesz również wyczerpujący opis wszystkich elementów języka C# - począwszy od składni, skończywszy na wdrażaniu kodu. Nawiązując do najlepszych tradycji tej serii "Księga eksperta" książka "C# 3.0. Księga eksperta " stanowi kompletne źródło wiedzy na temat języka C# oraz platformy .NET w wersji 3.5.

Joe Mayo podzielił książkę na dziesięć głównych części. Wśród nich znajdziesz te poświęcone podstawom języka C#. Dowiesz się zatem, co to jest tak naprawdę platforma .NET, poznasz środowisko programistyczne Visual Studio 2008 oraz zaznajomisz się z jego elementami, składnią, wyrażeniami i instrukcjami języka C#. Część pierwsza tworzy podwaliny Twojej przygody z C# i platformą .NET. Kolejne części zawierają coraz bardziej zaawansowaną wiedzę. Szczególną uwagę warto zwrócić na te poświęcone programowaniu obiektowemu, dostępowi do danych z wykorzystaniem LINQ, tworzeniu interfejsu użytkownika czy też wdrażaniu kodu. Jeżeli jesteś programistą C# lub chcesz rozpocząć przygodę z tym językiem i platformą .NET jest to obowiązkowa pozycja w Twojej biblioteczce!

• Wprowadzenie do platformy .NET
• Środowisko programistyczne Visual Studio 2008
• Zasady komentowania kodu
• Operatory języka C#
• Różnica pomiędzy typami referencyjnymi i wartościowymi
• Operacje na łańcuchach
• Tablice oraz typy wyliczane
• Obiekty w C#
• Obsługa błędów i sytuacji wyjątkowych
• Programowanie oparte o zdarzenia
• Przestrzenie nazw
• Wykorzystanie klas abstrakcyjnych i interfejsów
• Zarządzanie czasem życia obiektów
• Wykorzystanie wyrażeń lambda i drzew wyrażeń
• Dostęp do danych z wykorzystaniem LINQ
• Zarządzanie danymi z wykorzystaniem ADO.NET
• Praca z plikami XML
• Tworzenie interfejsu użytkownika
• Tworzenie interfejsu użytkownika opartego o strony internetowe
• Wykorzystanie ASP.NET
• Komunikacja sieciowa
• Projektowanie aplikacji
• Zasady tworzenia systemów wielowarstwowych
• Zarządzanie procesami i wątkami
• Wdrażanie kodu
• Zabezpieczanie kodu
• Przygotowywanie pakietów instalacyjnych

Joe Mayo – znawca platformy .NET, właściciel firmy tworzącej własne rozwiązania o nią oparte. Jego wieloletnie zaangażowanie w społecznościach programistów zostało nieraz docenione – wielokrotnie uzyskiwał tytuł Most Valuable Professional (MVP). Prowadzi serwis internetowy http://www.csharp-station.com/.

Osoby które kupowały "C# 3.0 dla .NET 3.5. Księga eksperta", wybierały także:

• ASP .NET Core. Kurs video. Rozwijanie dodatkowych funkcjonalności Web API 89,00 zł, (26,70 zł -70%)
• ASP.NET Core. Kurs video. Tworzenie REST Web API 49,00 zł, (14,70 zł -70%)
• Gray Hat C#. Język C# w kontroli i łamaniu zabezpieczeń 57,74 zł, (17,90 zł -69%)
• ASP.NET Core 6. Kurs video. Rozwijaj aplikacje webowe z Entity Framework Core 178,97 zł, (62,64 zł -65%)
• PowerShell. Kurs video. Zarz 164,31 zł, (59,15 zł -64%)

Spis treści

C# 3.0 dla .NET 3.5. Księga eksperta -- spis treści

Wstęp (31)

Część I: Podstawy języka C# (37)

Rozdział 1. Wprowadzenie do platformy .NET (39)

• Co to jest .NET (40)
  
• Wspólne środowisko uruchomieniowe (CLR) (42)
  
  • Dlaczego wspólne środowisko uruchomieniowe jest ważne? (42)
  • Możliwości CLR (43)
  • Proces uruchamiania CLR (43)
• Biblioteka klas platformy .NET (FCL) (46)
  
• C# i inne języki platformy .NET (47)
  
• Wspólny system typów (CTS) (48)
  
• Specyfikacja wspólnego języka (CLS) (49)
  
• Podsumowanie (49)

Rozdział 2. Wprowadzenie do języka C# i środowiska Visual Studio 2008 (51)

• Budowanie prostego programu w języku C# (52)
  
• Tworzenie projektu w środowisku Visual Studio 2008 (VS2008) (56)
  
  • Uruchamianie kreatora nowego projektu (57)
  • Rozwiązania i projekty (60)
  • Kodowanie w środowisku VS2008 (60)
  • Budowanie i uruchamianie aplikacji (63)
  • Ustawianie opcji kompilatora (66)
• Komentowanie kodu (67)
  
  • Komentarze wielowierszowe (67)
  • Komentarze jednowierszowe (67)
  • Komentarze dokumentacji w standardzie XML (68)
• Identyfikatory i słowa kluczowe (70)
  
  • Identyfikatory (70)
  • Słowa kluczowe (71)
• Konwencje i styl (73)
  
• Zmienne i typy (73)
  
  • Zmienne (73)
  • Typy proste (75)
  • Typ łańcuchowy (79)
• Przypisanie oznaczone (80)
  
• Komunikacja z programami (80)
  
  • Komunikacja za pomocą ekranu konsoli (81)
  • Komunikacja za pomocą wiersza poleceń (82)
  • Parametry wiersza poleceń w VS2008 (82)
  • Zwracanie wartości z programu (84)
• Podsumowanie (85)

Rozdział 3. Wyrażenia i instrukcje języka C# (87)

• Operatory języka C# (88)
  
  • Operatory jednoargumentowe (88)
  • Operatory dwuargumentowe (91)
  • Operatory relacji (93)
  • Operatory logiczne (95)
  • Operatory przypisania (98)
  • Operator trójargumentowy (98)
  • Inne operatory (99)
• Instrukcje (101)
  
• Bloki i zasięg zmiennych (102)
  
• Etykiety (103)
  
• Priorytet i łączność operatorów (103)
  
• Instrukcje wyboru i pętli (104)
  
  • Instrukcje if (104)
  • Instrukcje switch (106)
  • Pętle w języku C# (109)
  • Instrukcje goto (113)
  • Instrukcje break (114)
  • Instrukcje continue (115)
  • Instrukcje return (116)
• Podsumowanie (116)

Rozdział 4. Typy referencyjne i wartościowe (117)

• Krótkie wprowadzenie do typów referencyjnych i wartościowych (118)
  
• Ujednolicony system typów (119)
  
  • W jaki sposób działa ujednolicony system typów (119)
  • Użycie typu object w programowaniu ogólnym (120)
  • Wpływ opakowywania i rozpakowywania na wydajność (122)
• Przydział pamięci dla typu referencyjnego i wartościowego (124)
  
  • Przydział pamięci dla typu referencyjnego (125)
  • Przydział pamięci dla typu wartościowego (126)
• Przypisanie dla typu referencyjnego i wartościowego (127)
  
  • Przypisanie dla typu referencyjnego (127)
  • Przypisanie dla typu wartościowego (130)
• Więcej różnic między typami referencyjnymi a wartościowymi (131)
  
  • Różnice dziedziczenia pomiędzy typami referencyjnymi a wartościowymi (132)
  • Różnice konstrukcyjne i finalizacyjne pomiędzy typami referencyjnymi a wartościowymi (132)
  • Rozważania dotyczące rozmiaru obiektów dla typów referencyjnych i wartościowych (133)
• Typy języka C# i środowiska .NET Framework (134)
  
  • Zamienniki w języku C# i wspólny system typów (CTS) (134)
  • Użycie typu System.Guid (135)
  • Użycie typu System.DateTime (137)
• Typy dopuszczające wartości puste (141)
  
• Podsumowanie (144)

Rozdział 5. Operacje na łańcuchach (145)

• Typ string języka C# (146)
  
  • Formatowanie łańcuchów (147)
  • Porównywanie łańcuchów (150)
  • Sprawdzanie warunku równości łańcuchów (151)
  • Łączenie łańcuchów (152)
  • Kopiowanie łańcuchów (153)
  • Sprawdzanie zawartości łańcucha (154)
  • Wyodrębnianie informacji z łańcucha (154)
  • Wyrównywanie i przycinanie wyjściowego łańcucha (156)
  • Modyfikacja zawartości łańcucha (157)
  • Dzielenie i łączenie łańcuchów (159)
  • Operacje na znakach łańcucha (160)
  • Wpływ puli wewnętrznej na obsługę łańcuchów CLR (161)
• Klasa StringBuilder (163)
  
  • Metoda Append (163)
  • Metoda AppendFormat (163)
  • Metoda EnsureCapacity (164)
  • Metoda ToString (164)
• Wyrażenia regularne (165)
  
  • Podstawowe operacje na wyrażeniach regularnych (165)
  • Więcej wyrażeń regularnych (166)
  • Aplikacja służąca do ćwiczeń z wyrażeniami regularnymi (167)
• Podsumowanie (170)

Rozdział 6. Użycie tablic i typów wyliczeniowych (171)

• Tablice (172)
  
  • Tablice jednowymiarowe (173)
  • Tablice wielowymiarowe (175)
  • Tablice postrzępione (176)
• Klasa System.Array (178)
  
  • Zakresy tablic (178)
  • Przeszukiwanie i sortowanie (179)
• Użycie typów wyliczeniowych (180)
  
• Struktura System.Enum (184)
  
  • Przekształcenia między typami wyliczeniowymi, całkowitymi i łańcuchowymi (184)
  • Iteracyjne przetwarzanie elementów typu wyliczeniowego (185)
  • Inne elementy struktury System.Enum (186)
• Podsumowanie (187)

Rozdział 7. Debugowanie aplikacji za pomocą Visual Studio 2008 (189)

• Krokowe uruchamianie programu (190)
  
  • Program demonstrujący działanie debugera (190)
  • Ustawianie punktów wstrzymania (191)
  • Kontrola stanu programu (192)
  • Krokowe uruchamianie programu (194)
  • Inne przydatne polecenia ułatwiające debugowanie (195)
  • Użycie debugera w celu odnalezienia błędu w programie (196)
  • Podłączanie do procesów (200)
• Podsumowanie (203)

Część II: Programowanie zorientowane obiektowo w języku C# (205)

Rozdział 8. Projektowanie obiektów (207)

• Elementy obiektu (208)
  
• Elementy statyczne i instancyjne (209)
  
• Pola (210)
  
  • Pola stałe (210)
  • Pola readonly (211)
• Metody (211)
  
• Właściwości (212)
  
  • Deklarowanie właściwości (212)
  • Użycie właściwości (213)
  • Właściwości automatyczne (213)
  • Gotowy fragment kodu dla właściwości w środowisku VS2008 (214)
• Indeksatory (215)
  
• Gdzie mogą zostać użyte typy częściowe? (216)
  
• Klasy statyczne (217)
  
• Klasa System.Object (217)
  
  • Sprawdzanie typu obiektu (217)
  • Porównywanie referencji (218)
  • Sprawdzanie równości (218)
  • Uzyskiwanie wartości mieszających (219)
  • Klonowanie obiektów (219)
  • Używanie obiektów jako łańcuchów (220)
• Podsumowanie (221)

Rozdział 9. Implementacja reguł zorientowanych obiektowo (223)

• Dziedziczenie (224)
  
  • Klasy bazowe (225)
  • Wywoływanie elementów klasy bazowej (226)
  • Ukrywanie elementów klasy bazowej (227)
  • Obsługa wersji (227)
  • Klasy opieczętowane (230)
• Hermetyzacja organizacji wewnętrznej obiektu (231)
  
  • Ukrywanie danych (231)
  • Modyfikatory wspierające hermetyzację (232)
  • Modyfikatory dostępu do obiektów (235)
  • Zawieranie i dziedziczenie (236)
• Polimorfizm (237)
  
  • Rozpoznawanie problemów rozwiązywanych przez polimorfizm (238)
  • Rozwiązywanie problemów za pomocą polimorfizmu (241)
  • Właściwości polimorficzne (243)
  • Indeksatory polimorficzne (244)
  • Przesłanianie elementów klasy System.Object (245)
• Podsumowanie (247)

Rozdział 10. Metody kodowania i operatory tworzone przez użytkownika (249)

• Metody (250)
  
  • Definiowanie metod (250)
  • Zmienne lokalne (251)
  • Parametry metod (253)
• Przeciążanie metod (260)
  
• Przeciążanie operatorów (262)
  
  • Przeciążanie operatorów matematycznych dla typów tworzonych przez użytkownika (262)
  • Przeciążanie operatorów logicznych dla typów tworzonych przez użytkownika (265)
  • Inne wskazówki związane z przeciążaniem operatorów (266)
• Konwersje i przeciążanie operatorów konwersji (268)
  
  • Konwersje niejawne i jawne (268)
  • Operatory konwersji typów wartościowych stworzonych przez użytkownika (271)
  • Operatory konwersji typów referencyjnych stworzonych przez użytkownika (275)
• Metody częściowe (276)
  
• Metody rozszerzające (278)
  
• Podsumowanie (279)

Rozdział 11. Obsługa błędów i wyjątków (281)

• Dlaczego używa się obsługi wyjątków? (282)
  
• Składnia procedury obsługi wyjątku: podstawowy blok try/catch (283)
  
• Zapewnianie zwalniania zasobów przy użyciu bloków finally (285)
  
• Obsługa wyjątków (286)
  
  • Obsługa różnych typów wyjątków (286)
  • Obsługa i przekazywanie wyjątków (287)
  • Powrót ze stanu wyjątku (290)
• Tworzenie wyjątków przez użytkownika (293)
  
• Instrukcje checked i unchecked (295)
  
• Podsumowanie (297)

Rozdział 12. Programowanie oparte na zdarzeniach: obiekty delegowane i zdarzenia (299)

• Udostępnianie delegacji (301)
  
  • Definiowanie delegacji (301)
  • Tworzenie metod obsługujących delegacje (302)
  • Łączenie delegacji i metod obsługujących (302)
  • Wykonywanie metod poprzez delegacje (303)
  • Delegacje wielozakresowe (303)
  • Sprawdzanie równości delegacji (306)
• Implementacja wnioskowania delegacji (307)
  
• Przypisywanie metod anonimowych (307)
  
• Kodowanie zdarzeń (309)
  
  • Definiowanie procedur obsługi zdarzeń (310)
  • Rejestrowanie zdarzeń (311)
  • Implementacja zdarzeń (312)
  • Uruchamianie zdarzeń (314)
  • Modyfikacja metod zdarzeń Add i Remove (316)
• Podsumowanie (321)

Rozdział 13. Nazewnictwo i organizacja typów w przestrzeniach nazw (323)

• Dlaczego przestrzenie nazw muszą istnieć? (324)
  
  • Organizowanie kodu (325)
  • Unikanie konfliktów (325)
• Dyrektywy przestrzeni nazw (326)
  
  • Dyrektywa using (326)
  • Dyrektywa alias (327)
• Tworzenie przestrzeni nazw (329)
  
• Składowe przestrzeni nazw (333)
  
• Zasięg i widoczność (333)
  
• Kwalifikatory związane z synonimem przestrzeni nazw (335)
  
• Synonimy zewnętrznych przestrzeni nazw (336)
  
• Podsumowanie (338)

Rozdział 14. Implementacja klas abstrakcyjnych i interfejsów (339)

• Klasy abstrakcyjne (340)
  
• Różnice między klasami abstrakcyjnymi a interfejsami (343)
  
• Implementacja interfejsów (343)
  
• Definiowanie typów interfejsów (344)
  
  • Metody (345)
  • Właściwości (345)
  • Indeksatory (345)
  • Zdarzenia (346)
• Implementacja niejawna (346)
  
  • Implementacja interfejsu dla pojedynczej klasy (346)
  • Symulowanie zachowania polimorficznego (350)
• Implementacja jawna (355)
  
• Odwzorowanie interfejsu (361)
  
• Dziedziczenie interfejsu (363)
  
• Podsumowanie (365)

Część III: Używanie zaawansowanych funkcji języka C# (367)

Rozdział 15. Zarządzanie czasem życia obiektu (369)

• Inicjalizacja obiektów (370)
  
  • Konstruktory instancyjne (371)
  • Przeciążanie konstruktorów (372)
  • Konstruktory domyślne (374)
  • Konstruktory prywatne (374)
  • Dziedziczenie i kolejność konkretyzacji (375)
  • Konstruktory statyczne (379)
• Inicjalizatory obiektów (380)
  
• Finalizacja obiektów (381)
  
• Automatyczne zarządzanie pamięcią (382)
  
  • Przydzielanie pamięci (383)
  • Wewnętrzna organizacja mechanizmu oczyszczania pamięci (384)
  • Optymalizacja mechanizmu oczyszczania pamięci (385)
• Właściwe zwalnianie zasobów (386)
  
  • Problemy z finalizatorami (387)
  • Wzorzec Dispose (387)
  • Instrukcja using (389)
• Współpraca z mechanizmem oczyszczania pamięci (390)
  
  • Sterowanie obiektami (390)
• Podsumowanie (392)

Rozdział 16. Deklarowanie atrybutów i testowanie kodu za pomocą mechanizmów refleksji (393)

• Użycie atrybutów (394)
  
  • Użycie pojedynczego atrybutu (395)
  • Użycie wielu atrybutów (396)
• Użycie parametrów atrybutów (396)
  
  • Parametry pozycyjne (397)
  • Parametry nazwane (398)
• Obiekty docelowe atrybutu (398)
  
• Tworzenie własnych atrybutów (400)
  
  • Atrybut AttributeUsage (400)
• Użycie mechanizmu refleksji (404)
  
  • Uzyskiwanie informacji o programie (404)
• Wykorzystanie refleksji dla atrybutów (410)
  
  • Dynamiczne aktywowanie kodu (411)
  • Tworzenie pakietów kodu w trakcie działania programu przy użyciu API Reflection.Emit (413)
• Podsumowanie (417)

Rozdział 17. Parametryzowanie typów poprzez szablony klas i tworzenie iteratorów (419)

• Kolekcje bezszablonowe (420)
  
• Korzyści ze stosowania szablonów (421)
  
  • Problemy rozwiązywane przez stosowanie szablonów (422)
  • Szablony są zorientowane obiektowo (425)
  • Dokonywanie wyboru między tablicami, kolekcjami bezszablonowymi i kolekcjami szablonowymi (426)
• Tworzenie typów szablonowych (428)
  
  • Implementacja listy jednokierunkowej za pomocą szablonów (428)
  • Używanie szablonów poza kolekcjami (436)
  • Definiowanie typu za pomocą szablonów (439)
• Implementacja iteratorów (443)
  
  • Iterator GetEnumerator (444)
  • Iteratory metod (446)
  • Iteratory właściwości (446)
  • Iteratory indeksatorów (447)
  • Iterator operatora (449)
  • Iteratory jako ciągi wartości (450)
  • Zwalnianie iteratorów (451)
• Podsumowanie (452)

Rozdział 18. Wyrażenia lambda i drzewa wyrażeń (453)

• Wyrażenia lambda (454)
  
  • Składnia wyrażeń lambda (454)
  • Użycie wyrażeń lambda (455)
  • Delegacje i wyrażenia lambda (456)
• Drzewa wyrażeń (461)
  
  • Przekształcanie wyrażenia lambda na drzewo wyrażeń (461)
  • Przekształcanie drzewa wyrażeń na wyrażenie lambda (462)
• Podsumowanie (463)

Część IV: Dostęp do danych przy użyciu LINQ i platformy .NET (465)

Rozdział 19. Dostęp do danych z wykorzystaniem LINQ (467)

• Technologia LINQ to Objects (469)
  
  • Podstawowa składnia LINQ (469)
  • Wyodrębnianie projekcji (470)
  • Filtrowanie danych (471)
  • Sortowanie wyników zapytania (472)
  • Grupowanie danych (472)
  • Łączenie danych (472)
  • Tworzenie hierarchii za pomocą grupowania połączeń (473)
• Wykonywanie zapytań do baz relacyjnych za pomocą technologii LINQ to SQL (474)
  
  • Definiowanie kontekstu danych DataContext (474)
  • Zapytania przy użyciu DataContext (478)
  • Modyfikacja obiektów DataContext (478)
  • Wywołanie procedur składowanych (480)
  • Użycie funkcji SQL (481)
  • Modyfikowanie bazy danych za pomocą procedur składowanych (481)
  • Modyfikacja logiki obsługi danych poprzez użycie metod częściowych (484)
• Standardowe operatory zapytań (488)
  
  • Operatory sortujące (488)
  • Operatory ustawiania (489)
  • Operatory filtrujące (491)
  • Operatory kwantyfikatorów (492)
  • Operatory projekcji (492)
  • Operatory partycjonowania (493)
  • Operatory łączenia (494)
  • Operatory grupowania (495)
  • Operatory generujące (495)
  • Operatory równości (496)
  • Operatory elementarne (497)
  • Operatory konwersji (498)
  • Operator wiązania (498)
  • Operatory agregacji (499)
• Podsumowanie (500)

Rozdział 20. Zarządzanie danymi z wykorzystaniem ADO.NET (501)

• Architektura ADO.NET (502)
  
  • Komponenty ADO.NET (502)
  • Tryby otwartego i zamkniętego połączenia (504)
  • Dostawcy danych (505)
• Wykonywanie połączeń (507)
  
• Przeglądanie danych (508)
  
• Modyfikacja danych (512)
  
  • Wstawianie danych (512)
  • Aktualizacja danych (512)
  • Usuwanie danych (513)
• Wywoływanie procedur składowanych (514)
  
• Obsługa danych w trybie autonomicznym (514)
  
  • Wczytywanie danych do obiektu DataSet (515)
  • Zapisywanie modyfikacji DataSet do bazy danych (516)
• Użycie LINQ to DataSet (519)
  
  • Obiekty DataTable jako źródła danych (520)
  • Dostęp do pól przy zachowaniu ścisłej kontroli typów (520)
• Podsumowanie (521)

Rozdział 21. Przetwarzanie danych w formacie XML (523)

• Przesyłanie strumieniowe danych XML (524)
  
• Zapisywanie danych XML (525)
  
• Odczytywanie danych XML (527)
  
• Użycie XML DOM (528)
  
  • Odczytywanie dokumentu XML przy użyciu XPathDocument (529)
  • Modyfikacja dokumentu XML przy użyciu XmlDocument (530)
• Prostszy sposób przetwarzania danych przy wykorzystaniu LINQ to XML (531)
  
  • Obiekty LINQ to XML (531)
  • Tworzenie dokumentów XML (531)
  • Obsługa przestrzeni nazw dla LINQ to XML (533)
  • Odczytywanie dokumentów XML (534)
  • Wykonywanie zapytań dla dokumentów XML (534)
  • Modyfikacja dokumentów XML (535)
• Podsumowanie (536)

Rozdział 22. Dostęp do danych za pomocą ADO.NET Entity Framework (537)

• Encje (539)
  
• Tworzenie modelu EDM (Entity Data Model) w Visual Studio 2008 (539)
  
• Tworzenie zapytań za pomocą Entity SQL (543)
  
  • Dostęp do encji (543)
  • Wybieranie danych z encji (544)
• Tworzenie własnych encji (545)
  
  • Schematy i odwzorowania (546)
  • Dodawanie własnych encji (547)
• Wykorzystanie implementacji LINQ to Entities (550)
  
  • Kwerendy do encji (550)
  • Modyfikowanie danych encji (551)
• Podsumowanie (552)

Rozdział 23. Dostęp do danych w sieci za pośrednictwem usług ADO.NET Data Services (555)

• Dodanie usług ADO.NET Data Services do projektu (556)
  
• Dostęp do usług ADO.NET Data Services za pośrednictwem HTTP i URI (558)
  
  • Wyświetlanie zestawów encji (558)
  • Wybieranie elementów encji (558)
  • Filtrowanie wyników (561)
  • Sortowanie encji (563)
  • Używanie powiązań encji (563)
• Tworzenie kodu z biblioteką ADO.NET Data Services Client Library (565)
  
  • Tworzenie projektu klienta (565)
  • Wykonywanie zapytań do encji za pomocą WebDataQuery (565)
  • Dodawanie encji (567)
  • Aktualizacja encji (568)
  • Usuwanie encji (569)
  • Tworzenie zapytań z wykorzystaniem LINQ dla usług danych (569)
  • Wykorzystanie klas wygenerowanych za pomocą narzędzia DataSvcUtil.exe (570)
• Podsumowanie (571)

Część V: Tworzenie interfejsów użytkownika (573)

Rozdział 24. Interfejs użytkownika w aplikacjach konsolowych (575)

• Aplikacja PasswordGenerator (576)
  
• Komunikacja programu z użytkownikiem (577)
  
• Obsługa z wiersza poleceń (578)
  
• Dodawanie koloru i pozycjonowanie elementów w oknie konsoli (579)
  
• Podsumowanie (582)

Rozdział 25. Tworzenie aplikacji w oparciu o formularze Windows Forms (583)

• Formularze Windows Forms - informacje podstawowe (584)
  
• Tworzenie aplikacji Windows Forms Application w VS2008 (588)
  
  • Wizualne projektowanie interfejsu w środowisku VS2008 (588)
  • Pliki aplikacji Windows Forms Application (590)
  • Środowisko Windows Forms Designer (590)
• Kontrolki dostępne w Windows Forms (597)
  
• Kontrolki MenuStrip, StatusStrip i ToolStrip (600)
  
• Prezentacja danych za pomocą kontrolek DataGrid i DataBind (601)
  
  • Przygotowanie projektu dla prezentacji danych (602)
  • Wyświetlanie danych za pomocą kontrolki ListBox (603)
  • Wyświetlanie danych za pomocą kontrolki DataGridView (603)
• Podstawy GDI+ (605)
  
  • Obiekty Brush, Pen, Graphics - pędzel, ołówek i rysunek (605)
  • Wyświetlanie tekstu i czcionki (606)
• Pozostałe okna dialogowe (608)
  
  • Okna modalne i niemodalne (608)
  • Komunikacja między oknami (610)
  • Pozostałe predefiniowane okna dialogowe (612)
• Podsumowanie (614)

Rozdział 26. Tworzenie aplikacji Windows Presentation Foundation (WPF) (615)

• Język XAML (616)
  
  • Wprowadzenie do aplikacji WPF (617)
  • Podstawy XAML (618)
  • Kontrolki w XAML (619)
• Rozmieszczanie elementów w tworzonym oknie (621)
  
  • Rozmieszczanie kontrolek i określanie ich rozmiarów (621)
  • Powierzchnia Canvas (622)
  • Powierzchnia WrapPanel (623)
  • Powierzchnia StackPanel (623)
  • Powierzchnia UniformGrid (624)
  • Powierzchnia Grid (625)
  • Powierzchnia DockPanel (628)
• Kontrolki WPF (629)
  
  • Kontrolka Border (629)
  • Kontrolka Button (630)
  • Kontrolka CheckBox (630)
  • Kontrolka ComboBox (630)
  • Kontrolka ContentControl (630)
  • Kontrolka DockPanel (631)
  • Kontrolka DocumentViewer (631)
  • Kontrolka Ellipse (632)
  • Kontrolka Expander (632)
  • Kontrolka Frame (633)
  • Kontrolka Grid (633)
  • Kontrolka GridSplitter (633)
  • Kontrolka GroupBox (634)
  • Kontrolka Image (634)
  • Kontrolka Label (634)
  • Kontrolka ListBox (635)
  • Kontrolka ListView (635)
  • Kontrolka MediaElement (635)
  • Kontrolka Menu (635)
  • Kontrolka PasswordBox (636)
  • Kontrolka ProgressBar (636)
  • Kontrolka RadioButton (636)
  • Kontrolka Rectangle (637)
  • Kontrolka RichTextBox (637)
  • Kontrolka ScrollBar (637)
  • Kontrolka ScrollViewer (637)
  • Kontrolka Separator (638)
  • Kontrolka Slider (638)
  • Kontrolka StackPanel (639)
  • Kontrolka StatusBar (639)
  • Kontrolka TabControl (639)
  • Kontrolka TextBlock (639)
  • Kontrolka TextBox (640)
  • Kontrolka ToolBar (640)
  • Kontrolka ToolBarPanel (640)
  • Kontrolka ToolBarTray (641)
  • Kontrolka TreeView (641)
  • Kontrolka UniformGrid (641)
  • Kontrolka Viewbox (642)
  • Kontrolka WindowsFormsHost (642)
  • Kontrolka WrapPanel (643)
• Obsługa zdarzeń (643)
  
• Powiązanie kontrolek z danymi (644)
  
  • Przekazywanie danych (644)
  • Wyświetlanie listy danych (645)
• Style i formatowanie kontrolek (649)
  
• Podsumowanie (651)

Część VI: Projektowanie interfejsów użytkownika w oparciu o strony internetowe (653)

Rozdział 27. Tworzenie aplikacji sieciowych za pomocą ASP.NET (655)

• Model aplikacji sieciowej (656)
  
  • Wysokopoziomowy model aplikacji sieciowej (656)
  • Gdzie znajduje się kod C# aplikacji sieciowej? (657)
  • Skalowalność i zarządzanie stanem (657)
  • Czas reakcji aplikacji (658)
  • Korzyści z zastosowania ASP.NET (659)
• Tworzenie projektu ASP.NET w VS2008 (660)
  
• Strona ASP.NET (661)
  
  • Elementy formularza (661)
  • Kod ukryty i cykl życia strony (664)
• Kontrolki (667)
  
  • Kontrolki serwerowe (667)
  • Kontrolki HTML (669)
• Zarządzanie stanem (669)
  
  • Application - globalny stan aplikacji (670)
  • Cache - przechowywanie informacji, które można aktualizować (671)
  • Context - przechowywanie stanu pojedynczego żądania (672)
  • Pliki cookie (672)
  • Session - informacje użytkownika (673)
  • ViewState - informacje o stanie strony (673)
  • Strony wzorcowe i kontrolki użytkownika (674)
• Nawigacja (678)
  
  • Rozmieszczenie elementów za pomocą pliku web.sitemap (679)
  • Nawigacja za pomocą kontrolki Menu (680)
  • Implementacja kontrolki TreeView (681)
  • Wykorzystanie ścieżki nawigacji (684)
• Wykorzystywanie tematów (685)
  
  • Tworzenie tematu (685)
  • Tworzenie skórek (686)
  • Tworzenie arkuszy stylów (687)
• Zabezpieczanie witryny (688)
  
• Prezentacja danych (691)
  
  • Tworzenie obiektu biznesowego (691)
  • Przykład powiązania danych (692)
  • Powiązanie danych za pomocą kontrolki ObjectDataSource (693)
• Podsumowanie (695)

Rozdział 28. Wykorzystanie ASP.NET AJAX w aplikacjach sieciowych (697)

• Czym jest AJAX? (698)
  
• Tworzenie witryny z wykorzystaniem ASP.NET AJAX (699)
  
• Cykl życia strony AJAX (700)
  
• Wykorzystywanie bibliotek skryptowych (701)
  
• Kontrolki ASP.NET AJAX (703)
  
  • Kontrolka UpdatePanel (704)
  • Kontrolka UpdateProgress (705)
  • Kontrolka Timer (706)
• Dostęp do kontrolek z poziomu kodu JavaScript (707)
  
  • Kontrolki z identyfikatorami prostymi (707)
  • Kontrolki z identyfikatorami złożonymi (709)
• Wywołanie usługi sieciowej z użyciem ASP.NET AJAX (714)
  
  • Za i przeciw wykorzystaniu technologii AJAX z usługami sieciowymi (714)
  • Wykorzystanie technologii AJAX z usługami sieciowymi (715)
• Podsumowanie (718)

Rozdział 29. Tworzenie zaawansowanych aplikacji sieciowych za pomocą Silverlight (721)

• Z czego składa się Silverlight? (722)
  
  • Miejsce WPF i XAML w technologii Silverlight (722)
  • Zależności pomiędzy Silverlight a ASP.NET, JavaScript i AJAX (723)
• Projekty Silverlight w środowisku VS2008 (723)
  
  • Tworzenie projektu Silverlight (724)
  • Elementy projektu Silverlight (724)
• Obsługa zdarzeń w aplikacji Silverlight (728)
  
  • Kod obsługi zdarzenia kontrolki Silverlight (730)
  • Silverlight i źródła danych (731)
• Prezentacja plików multimedialnych (734)
  
  • Wykorzystanie kontrolki MediaPlayer w formularzu aplikacji sieciowej (734)
  • Zarządzanie kontrolką MediaElement z poziomu języka C# (736)
• Animacja elementów interfejsu użytkownika (738)
  
• Podsumowanie (740)

Część VII: Komunikacja za pomocą technologii dostępnych w .NET (741)

Rozdział 30. Technologie komunikacji sieciowej w .NET (743)

• Implementacja programu z wykorzystaniem gniazd (744)
  
  • Program serwera (744)
  • Program klienta (747)
• Implementacja programu z wykorzystaniem protokołu HTTP (751)
  
• Transfer plików za pomocą protokołu FTP (753)
  
  • Umieszczanie plików w serwerze FTP (753)
  • Pobieranie plików z serwera FTP (755)
• Wysyłanie wiadomości za pomocą protokołu SMTP (757)
  
  • Sposób na szybkie wysłanie wiadomości e-mail (757)
  • Wysyłanie wiadomości z załącznikami (758)
• Podsumowanie (758)

Rozdział 31. Tworzenie usług dla systemu Windows (761)

• Tworzenie projektu usługi w VS2008 (762)
  
  • Kreator Windows Service Wizard (762)
  • Elementy projektu usługi dla Windows (762)
• Tworzenie kodu usług dla Windows (765)
  
  • Przesłaniane metody w usługach dla Windows (765)
  • Implementacja metod usługi (767)
  • Konfiguracja usługi (770)
• Instalowanie usługi w systemie Windows (771)
  
  • Konfiguracja komponentu ServiceProcessInstaller (771)
  • Konfiguracja komponentu ServiceInstaller (772)
  • Wdrażanie usługi (773)
• Kontroler komunikacji z usługą (774)
  
• Podsumowanie (776)

Rozdział 32. Technologia .NET Remoting (777)

• Podstawy technologii Remoting (778)
  
  • Serwer w technologii Remoting (779)
  • Klient w technologii Remoting (781)
  • Uruchomienie aplikacji (784)
• Kanały (788)
  
• Zarządzanie życiem obiektów (791)
  
• Podsumowanie (793)

Rozdział 33. Tworzenie tradycyjnych usług sieciowych ASMX (795)

• Podstawy usług sieciowych (796)
  
  • Technologie usług sieciowych (796)
  • Prosta usługa sieciowa (797)
  • Wyświetlanie informacji o usłudze sieciowej (798)
• Wykorzystywanie usług sieciowych (802)
  
• Podsumowanie (807)

Rozdział 34. Tworzenie usług sieciowych z wykorzystaniem WCF (809)

• Tworzenie aplikacji WCF w VS2008 (810)
  
• Kontrakt usługi sieciowej (812)
  
  • Interfejs usługi WCF (812)
  • Deklaracja atrybutu ServiceContract (814)
  • Deklaracja atrybutów OperationsContract (815)
  • Tworzenie kontraktów danych (815)
• Implementacja logiki usługi sieciowej (817)
  
• Konfigurowanie usługi sieciowej (819)
  
  • Element service (820)
  • Element endpoint (punkt końcowy) (820)
  • Element behavior (821)
• Wykorzystywanie usługi sieciowej (822)
  
  • Referencja do usługi (822)
  • Tworzenie kodu aplikacji klienta w celu wywołania usługi sieciowej (823)
• Podsumowanie (824)

Część VIII: Architektura i projektowanie aplikacji (825)

Rozdział 35. Kreator klas - Visual Studio 2008 Class Designer (827)

• Wizualizacja kodu (828)
  
  • Prezentacja obiektów (828)
  • Prezentacja związków, dziedziczenia i interfejsów (831)
• Tworzenie modelu obiektowego za pomocą narzędzia Class Designer (834)
  
• Podsumowanie (839)

Rozdział 36. Wzorce projektowe w C# (841)

• Przegląd wzorców projektowych (842)
  
• Wzorzec Iterator (842)
  
  • Implementacja interfejsu IEnumerable (843)
  • Implementacja interfejsu IEnumerator (844)
  • Wykorzystanie iteratora (849)
  • Niezwykłe zachowanie pętli foreach (850)
  • Uproszczenie wzorca Iterator z wykorzystaniem iteratorów C# (853)
• Wzorzec Proxy (854)
  
  • Przykład wzorca Proxy (855)
  • Użycie obiektu Proxy (857)
• Wzorzec Template (858)
  
  • Wykorzystanie wzorca Template w .NET Framework (859)
  • Przykład implementacji wzorca Template (860)
• Podsumowanie (863)

Rozdział 37. Tworzenie systemów wielowarstwowych (865)

• Problemy związane z technologią RAD (866)
  
  • Aplikacja RAD w pięć minut (866)
  • Narzędzia RAD a tworzenie wydajnych rozwiązań (867)
• Architektura wielowarstwowa (869)
  
  • Architektura aplikacji (869)
  • Architektura wielowarstwowa - podział logiczny (869)
  • Architektura warstwowa - podział fizyczny (871)
  • Podejście do architektury aplikacji (872)
• Przykłady architektury wielowarstwowej (872)
  
  • Aplikacje wielowarstwowe, umieszczone w pojedynczych komponentach (873)
  • Aplikacje wielowarstwowe, umieszczone w kilku komponentach (880)
• Podsumowanie (884)

Rozdział 38. Windows Workflow (885)

• Tworzenie projektu aplikacji przebiegu (886)
  
• Tworzenie sekwencji przebiegu (887)
  
  • Tworzenie przebiegu (887)
  • Kod wygenerowany dla przebiegu (890)
• Tworzenie przebiegu stanów (891)
  
  • Model przebiegu stanów wizyty lekarskiej (892)
  • Tworzenie przebiegu stanów (892)
  • Przekazywanie informacji pomiędzy hostem a przebiegiem za pomocą ExternalDataExchangeService (894)
  • Obsługa zdarzeń w przebiegu stanów (899)
• Podsumowanie (903)

Część IX: Przegląd biblioteki .NET Framework Class Library (905)

Rozdział 39. Zarządzanie procesami i wątkami (907)

• Zarządzanie procesami z wykorzystaniem biblioteki .NET (908)
  
  • Uruchamianie nowego procesu (909)
  • Praca z uruchomionymi procesami (912)
• Wielowątkowość (914)
  
  • Tworzenie nowych wątków (914)
  • Uruchomienie wątku - wariant uproszczony (915)
  • Przekazywanie parametrów do wątków (915)
  • Obiekt ThreadPool (916)
• Synchronizacja wątków (917)
  
  • Instrukcja lock (917)
  • Klasa Monitor - rzeczywista implementacja instrukcji lock (918)
  • Zachowanie równowagi pomiędzy wątkami zapisu i odczytu (919)
• Podsumowanie (921)

Rozdział 40. Tworzenie różnych wersji językowych aplikacji (923)

• Pliki zasobów (924)
  
  • Tworzenie pliku zasobów (924)
  • Zapis do pliku zasobów (927)
  • Odczyt z pliku zasobów (928)
  • Konwersja pliku zasobów (929)
  • Tworzenie zasobów graficznych (931)
• Ustawienia regionalne (936)
  
  • Implementacja ustawień dla wielu regionów (937)
  • Wyszukiwanie zasobów (942)
• Podsumowanie (943)

Rozdział 41. Używanie mechanizmu Interop (usługi P/Invoke i COM) oraz tworzenie kodu nienadzorowanego (945)

• Kod nienadzorowany (946)
  
  • Znaczenie pojęcia "kod nienadzorowany" (947)
  • Magia wskaźników (947)
  • Operator sizeof() (951)
  • Operator stackalloc (952)
  • Instrukcja fixed (954)
• Usługa Platform Invoke (957)
  
• Komunikacja z komponentami COM w .NET (959)
  
  • Wczesne wiązanie (959)
  • Późne wiązanie (961)
• Udostępnianie komponentów środowiska .NET w formie komponentów COM (962)
  
• Wprowadzenie do obsługi usług COM+ (964)
  
  • Transakcje (966)
  • Aktywacja kompilacji JIT (967)
  • Tworzenie puli obiektów (968)
  • Inne usługi (969)
• Podsumowanie (969)

Rozdział 42. Debugowanie aplikacji z wykorzystaniem typów przestrzeni System.Diagnostics (971)

• Debugowanie w formie podstawowej (973)
  
• Debugowanie warunkowe (974)
  
• Śledzenie działania programu (977)
  
• Tworzenie asercji (979)
  
• Wykorzystywanie wbudowanych liczników wydajności (980)
  
• Implementacja zegarów (987)
  
• Tworzenie własnego licznika wydajności (988)
  
• Analiza wydajności na podstawie zebranych próbek (997)
  
• Podsumowanie (1005)

Część X: Wdrażanie kodu (1007)

Rozdział 43. Złożenia i wersjonowanie (1009)

• Składniki złożenia (1010)
  
  • Pliki manifestu (1011)
  • Atrybuty (1011)
• Funkcjonalności złożeń (1013)
  
  • Identyfikacja (1014)
  • Zakres (1014)
  • Wersjonowanie (1014)
  • Zabezpieczenie (1014)
• Konfiguracja (1016)
  
  • Sekcja Startup (1016)
  • Sekcja Runtime (1017)
• Wdrażanie złożeń (1019)
  
• Podsumowanie (1019)

Rozdział 44. Zabezpieczanie kodu (1021)

• Zabezpieczanie dostępu do kodu (1022)
  
  • Dowody (1022)
  • Uprawnienia (1023)
  • Grupy kodowe (1023)
  • Poziomy zabezpieczeń (1025)
  • Żądania uprawnień (1026)
  • Implementacja zasad bezpieczeństwa (1028)
• Zabezpieczanie za pomocą ról (1031)
  
• Narzędzia związane z systemami zabezpieczeń (1033)
  
• Podsumowanie (1033)

Rozdział 45. Tworzenie pakietów instalacyjnych w środowisku Visual Studio 2008 (1035)

• Kreator tworzenia programów instalacyjnych w VS2008 (1036)
  
• Dodatkowe ustawienia konfiguracyjne programu instalacyjnego (1039)
  
  • System plików (1039)
  • Zapisy w rejestrze (1040)
  • Typy plików (1040)
  • Interfejs użytkownika (1040)
  • Warunki instalacji (1042)
  • Akcje niestandardowe (1042)
• Podsumowanie (1043)

Rozdział 46. Wdrażanie aplikacji desktopowych (1045)

• Wdrożenie aplikacji z wykorzystaniem ClickOnce (1046)
  
• Konfigurowanie narzędzia ClickOnce (1049)
  
• Podsumowanie (1050)

Rozdział 47. Rozpowszechnianie aplikacji sieciowych (1051)

• Anatomia aplikacji sieciowej (1052)
  
• Tworzenie serwera aplikacji sieciowych (1052)
  
• Tworzenie katalogu wirtualnego (1054)
  
• Wdrażanie aplikacji w serwerze (1055)
  
• Publikowanie aplikacji sieciowej bezpośrednio ze środowiska VS2008 (1056)
  
• Podsumowanie (1057)

Część XI: Dodatki (1059)

Dodatek A: Opcje kompilatora (1061)

• Opcje zaawansowane (1062)
  
• Opcje dla złożeń (1063)

Dodatek B: System pomocy w .NET Framework (1065)

• Książka (1066)
  
• Indeks (1066)
  
• Dokumentacja .NET Framework Class Library (1067)
  
• Mechanizmy wyszukiwania (1067)
  
• Ulubione strony internetowe (1068)
  
• Podsumowanie (1068)

Skorowidz (1069)