O autorach (5)

O recenzencie technicznym (7)

Część I Wprowadzenie do ASP.NET MVC 3 (19)

Rozdział 1. Zagadnienia ogólne (21)

• Krótka historia programowania witryn WWW (21)
  
  • Tradycyjna technologia ASP.NET Web Forms (21)
  • Co poszło nie tak z ASP.NET Web Forms? (23)
• Programowanie witryn WWW - stan obecny (23)
  
  • Standardy WWW oraz REST (24)
  • Programowanie zwinne i sterowane testami (24)
  • Ruby on Rails (25)
  • Sinatra (25)
  • Node.js (25)
• Najważniejsze zalety ASP.NET MVC (26)
  
  • Architektura MVC (26)
  • Rozszerzalność (26)
  • Ścisła kontrola nad HTML i HTTP (27)
  • Łatwość testowania (27)
  • Zaawansowany system routingu (28)
  • Zbudowany na najlepszych częściach platformy ASP.NET (28)
  • Nowoczesne API (28)
  • ASP.NET MVC jest open source (29)
• Kto powinien korzystać z ASP.NET MVC? (29)
  
  • Porównanie z ASP.NET Web Forms (29)
  • Migracja z Web Forms do MVC (30)
  • Porównanie z Ruby on Rails (30)
  • Porównanie z MonoRail (30)
• Co nowego w ASP.NET MVC 3? (30)
  
• Podsumowanie (31)

Rozdział 2. Przygotowania (33)

• Przygotowanie stacji roboczej (33)
  
  • Instalowanie Visual Studio 2010 (33)
  • Instalowanie podstawowego oprogramowania (34)
  • Instalowanie opcjonalnych komponentów (35)
• Przygotowanie serwera (37)
  
  • Włączanie roli serwera WWW (37)
  • Instalowanie dodatkowych komponentów (38)
  • Konfigurowanie Web Deployment (39)
• Uzyskiwanie dalszych informacji (40)
  
• Podsumowanie (41)

Rozdział 3. Pierwsza aplikacja MVC (43)

• Tworzenie nowego projektu ASP.NET MVC (43)
  
  • Dodawanie pierwszego kontrolera (45)
  • Przedstawiamy ścieżki (47)
• Generowanie stron WWW (47)
  
  • Tworzenie i generowanie widoku (47)
  • Dynamiczne dodawanie treści (50)
• Tworzenie prostej aplikacji wprowadzania danych (51)
  
  • Przygotowanie sceny (51)
  • Projektowanie modelu danych (52)
  • Łączenie metod akcji (53)
  • Budowanie formularza (55)
  • Obsługa formularzy (57)
  • Dodanie kontroli poprawności (60)
  • Kończymy (63)
• Podsumowanie (65)

Rozdział 4. Wzorzec MVC (67)

• Historia MVC (67)
  
• Wprowadzenie do wzorca MVC (67)
  
  • Budowa modelu domeny (68)
  • Implementacja MVC w ASP.NET (69)
  • Porównanie MVC z innymi wzorcami (69)
  • Przedstawiamy wzorzec Smart UI (69)
• Modelowanie domeny (72)
  
  • Przykładowy model domeny (73)
  • Wspólny język (73)
  • Agregaty i uproszczenia (74)
  • Definiowanie repozytoriów (75)
• Budowanie luźno połączonych komponentów (76)
  
  • Wykorzystanie wstrzykiwania zależności (77)
  • Przykład specyficzny dla MVC (78)
  • Użycie kontenera wstrzykiwania zależności (79)
• Zaczynamy testy automatyczne (80)
  
  • Zadania testów jednostkowych (80)
  • Zadania testów integracyjnych (87)
• Podsumowanie (87)

Rozdział 5. Najważniejsze cechy języka (89)

• Najważniejsze cechy C# (89)
  
  • Użycie automatycznie implementowanych właściwości (89)
  • Użycie inicjalizatorów obiektów i kolekcji (91)
  • Użycie metod rozszerzających (93)
  • Użycie wyrażeń lambda (97)
  • Automatyczne wnioskowanie typów (98)
  • Użycie typów anonimowych (99)
  • Wykonywanie zapytań zintegrowanych z językiem (100)
• Przedstawiamy składnię silnika Razor (105)
  
  • Tworzenie projektu (105)
  • Prosty widok korzystający z silnika Razor (108)
• Podsumowanie (115)

Rozdział 6. Ważne narzędzia wspierające MVC (117)

• Użycie Ninject (117)
  
  • Tworzenie projektu (119)
  • Zaczynamy korzystać z Ninject (119)
  • Tworzenie łańcucha zależności (121)
  • Definiowanie wartości właściwości i parametrów (122)
  • Użycie samodzielnego łączenia (124)
  • Dołączanie do typu pochodnego (124)
  • Użycie łączenia warunkowego (125)
• Użycie Ninject w ASP.NET MVC (126)
  
• Testowanie jednostkowe w Visual Studio (128)
  
  • Tworzenie projektu (128)
  • Tworzenie testów jednostkowych (130)
  • Uruchamianie testów (nieudane) (133)
  • Implementacja funkcji (134)
• Użycie Moq (135)
  
  • Dodawanie Moq do projektu Visual Studio (135)
  • Tworzenie imitacji za pomocą Moq (135)
  • Testy jednostkowe z użyciem Moq (137)
  • Weryfikowanie przy użyciu Moq (139)
• Podsumowanie (139)

Rozdział 7. SportsStore - kompletna aplikacja (141)

• Zaczynamy (142)
  
  • Tworzenie rozwiązania i projektów w Visual Studio (142)
  • Dodawanie referencji (143)
  • Konfigurowanie kontenera DI (144)
  • Uruchamiamy aplikację (145)
• Tworzenie modelu domeny (146)
  
  • Tworzenie abstrakcyjnego repozytorium (147)
  • Tworzenie imitacji repozytorium (148)
• Wyświetlanie listy produktów (148)
  
  • Dodawanie kontrolera (148)
  • Dodawanie widoku (149)
  • Konfigurowanie domyślnej ścieżki (150)
  • Uruchamianie aplikacji (151)
• Przygotowanie bazy danych (151)
  
  • Tworzenie bazy danych (152)
  • Definiowanie schematu bazy danych (153)
  • Dodawanie danych do bazy (154)
  • Tworzenie kontekstu Entity Framework (154)
  • Tworzenie repozytorium produktów (156)
• Dodanie stronicowania (157)
  
  • Wyświetlanie łączy stron (158)
  • Ulepszanie adresów URL (165)
• Dodawanie stylu (165)
  
  • Definiowanie wspólnej zawartości w pliku układu (166)
  • Dodanie zasad CSS (167)
  • Tworzenie widoku częściowego (167)
• Podsumowanie (169)

Rozdział 8. SportsStore - nawigacja i koszyk na zakupy (171)

• Dodawanie kontrolek nawigacji (171)
  
  • Filtrowanie listy produktów (171)
  • Ulepszanie schematu URL (172)
  • Budowanie menu nawigacji po kategoriach (175)
  • Poprawianie licznika stron (182)
• Budowanie koszyka na zakupy (184)
  
  • Definiowanie encji koszyka (185)
  • Tworzenie przycisków koszyka (188)
  • Implementowanie kontrolera koszyka (189)
  • Wyświetlanie zawartości koszyka (190)
• Użycie dołączania danych (193)
  
  • Tworzenie własnego łącznika modelu (193)
• Kończenie budowania koszyka (197)
  
  • Usuwanie produktów z koszyka (197)
  • Dodawanie podsumowania koszyka (198)
• Składanie zamówień (200)
  
  • Rozszerzanie modelu domeny (200)
  • Dodawanie procesu zamawiania (201)
  • Implementowanie procesora zamówień (204)
  • Rejestrowanie implementacji (206)
  • Dokańczanie kontrolera koszyka (206)
  • Wyświetlanie informacji o błędach systemu kontroli poprawności (210)
  • Wyświetlanie strony podsumowania (210)
• Podsumowanie (212)

Rozdział 9. SportsStore - administracja (213)

• Dodajemy zarządzanie katalogiem (213)
  
  • Tworzenie kontrolera CRUD (214)
  • Generowanie tabeli z produktami dostępnymi w repozytorium (215)
  • Tworzenie nowego pliku układu (216)
  • Implementowanie widoku listy (218)
  • Edycja produktów (221)
  • Tworzenie nowych produktów (232)
  • Usuwanie produktów (232)
• Zabezpieczanie funkcji administracyjnych (235)
  
  • Konfiguracja uwierzytelniania Forms (235)
  • Realizacja uwierzytelniania z użyciem filtrów (236)
  • Tworzenie dostawcy uwierzytelniania (238)
  • Tworzenie kontrolera AccountController (239)
  • Tworzenie widoku (240)
• Przesyłanie zdjęć (242)
  
  • Rozszerzanie bazy danych (242)
  • Rozszerzanie modelu domeny (244)
  • Tworzenie interfejsu użytkownika do przesyłania plików (244)
  • Zapisywanie zdjęć do bazy danych (245)
  • Implementowanie metody akcji GetImage (246)
  • Wyświetlanie zdjęć produktów (247)
• Podsumowanie (249)

Część II ASP.NET MVC 3 - szczegółowy opis (251)

Rozdział 10. Przegląd projektu MVC (253)

• Korzystanie z projektów MVC z Visual Studio (253)
  
  • Użycie kontrolerów aplikacji internetowej i intranetowej (256)
  • Przedstawiamy konwencje MVC (257)
• Debugowanie aplikacji MVC (258)
  
  • Tworzenie projektu (258)
  • Uruchamianie debugera Visual Studio (258)
  • Przerywanie pracy aplikacji przez debuger Visual Studio (260)
  • Użycie opcji Edit and Continue (263)
• Wstrzykiwanie zależności na poziomie projektu (266)
  
• Podsumowanie (268)

Rozdział 11. Adresy URL, routing i obszary (269)

• Wprowadzenie do systemu routingu (269)
  
  • Tworzenie projektu routingu (270)
  • Wprowadzenie do wzorców URL (271)
  • Tworzenie i rejestrowanie prostej ścieżki (272)
  • Definiowanie wartości domyślnych (275)
  • Użycie statycznych segmentów adresu URL (277)
  • Definiowanie własnych zmiennych segmentów (280)
  • Definiowanie opcjonalnych segmentów URL (282)
  • Definiowanie ścieżek o zmiennej długości (282)
  • Definiowanie priorytetów kontrolerów na podstawie przestrzeni nazw (284)
  • Ograniczenia ścieżek (286)
  • Routing żądań dla plików dyskowych (290)
  • Pomijanie systemu routingu (292)
• Generowanie wychodzących adresów URL (293)
  
  • Przygotowanie projektu (293)
  • Generowanie wychodzących adresów URL w widokach (294)
  • Generowanie wychodzących adresów URL w metodach akcji (299)
  • Generowanie adresu URL na podstawie wybranej ścieżki (300)
• Dostosowanie systemu routingu (300)
  
  • Tworzenie własnej implementacji RouteBase (301)
  • Tworzenie własnego obiektu obsługi ścieżki (304)
• Korzystanie z obszarów (305)
  
  • Tworzenie obszaru (306)
  • Wypełnianie obszaru (307)
  • Rozwiązywanie problemów z niejednoznacznością kontrolerów (308)
  • Generowanie łączy do akcji z obszarów (310)
• Najlepsze praktyki schematu adresów URL (310)
  
  • Twórz jasne i przyjazne dla człowieka adresy URL (310)
  • GET oraz POST - wybierz właściwie (311)
• Podsumowanie (312)

Rozdział 12. Kontrolery i akcje (313)

• Wprowadzenie do kontrolerów (313)
  
  • Przygotowanie projektu (313)
  • Tworzenie kontrolera z użyciem interfejsu IController (313)
  • Tworzenie kontrolera przez dziedziczenie po klasie Controller (314)
• Odczytywanie danych wejściowych (316)
  
  • Pobieranie danych z obiektów kontekstu (316)
  • Użycie parametrów metod akcji (317)
• Tworzenie danych wyjściowych (319)
  
  • Wyniki akcji (320)
  • Zwracanie kodu HTML przez generowanie widoku (322)
  • Przekazywanie danych z metody akcji do widoku (327)
  • Wykonywanie przekierowań (331)
  • Zwracanie danych tekstowych (333)
  • Zwracanie danych XML (336)
  • Zwracanie danych JSON (336)
  • Zwracanie plików i danych binarnych (337)
  • Zwracanie błędów i kodów HTTP (339)
  • Tworzenie własnego wyniku akcji (341)
• Podsumowanie (343)

Rozdział 13. Filtry (345)

• Użycie filtrów (345)
  
  • Wprowadzenie do czterech podstawowych typów filtrów (346)
  • Dołączanie filtrów do kontrolerów i metod akcji (347)
  • Użycie filtrów autoryzacji (348)
  • Użycie filtrów wyjątków (353)
  • Użycie filtrów akcji i wyniku (356)
  • Użycie innych funkcji filtrów (361)
  • Użycie filtrów wbudowanych (366)
• Podsumowanie (369)

Rozdział 14. Rozszerzanie kontrolerów (371)

• Komponenty potoku przetwarzania żądania (371)
  
• Tworzenie własnej fabryki kontrolerów (372)
  
  • Definiowanie własnej fabryki kontrolerów (372)
  • Rejestrowanie własnej fabryki kontrolerów (374)
• Wykorzystanie wbudowanej fabryki kontrolerów (374)
  
  • Nadawanie priorytetów przestrzeniom nazw (374)
  • Dostosowywanie sposobu tworzenia kontrolerów w DefaultControllerFactory (375)
• Tworzenie własnego obiektu wywołującego akcje (377)
  
• Użycie wbudowanego obiektu wywołującego akcje (378)
  
  • Użycie własnych nazw akcji (379)
  • Selekcja metod akcji (380)
  • Użycie selektorów metod akcji do obsługi żądań REST (383)
• Poprawianie wydajności z użyciem specjalizowanych kontrolerów (385)
  
  • Użycie kontrolerów bezstanowych (385)
  • Użycie kontrolerów asynchronicznych (386)
• Podsumowanie (394)

Rozdział 15. Widoki (395)

• Tworzenie własnego silnika widoku (395)
  
  • Tworzenie własnej implementacji IView (397)
  • Tworzenie implementacji IViewEngine (397)
  • Rejestrowanie własnego silnika widoku (398)
• Korzystanie z silnika Razor (401)
  
  • Sposób generowania widoków przez Razor (401)
  • Wstrzykiwanie zależności w widokach Razor (402)
  • Konfigurowanie wyszukiwania lokalizacji widoków (404)
• Dodawanie dynamicznych treści do widoku Razor (405)
  
  • Użycie kodu wbudowanego (405)
• Użycie metod pomocniczych HTML (410)
  
  • Tworzenie wewnętrznej metody pomocniczej HTML (411)
  • Tworzenie zewnętrznej metody pomocniczej HTML (411)
  • Użycie wbudowanych metod pomocniczych (413)
• Zastosowanie sekcji (425)
  
  • Sprawdzanie istnienia sekcji (427)
  • Generowanie sekcji opcjonalnych (428)
• Użycie widoków częściowych (428)
  
  • Tworzenie widoku częściowego (428)
  • Użycie silnie typowanych widoków częściowych (430)
• Użycie akcji podrzędnych (431)
  
  • Tworzenie akcji podrzędnych (431)
  • Wywoływanie akcji podrzędnych (432)
• Podsumowanie (433)

Rozdział 16. Szablony modelu (435)

• Użycie metod pomocniczych widoku szablonowego (435)
  
  • Nadawanie stylów wygenerowanym znacznikom HTML (438)
  • Użycie metadanych modelu (440)
  • Użycie metadanych wartości danych (443)
  • Korzystanie z parametrów typów złożonych (447)
• Dostosowywanie systemu metod pomocniczych widoku szablonowego (448)
  
  • Tworzenie własnego szablonu edytora (448)
  • Tworzenie własnego szablonu wyświetlania (450)
  • Tworzenie szablonu ogólnego (452)
  • Wymiana szablonów wbudowanych (453)
  • Użycie właściwości ViewData.TemplateInfo (454)
  • Przekazywanie dodatkowych metadanych do szablonu (455)
• System dostawców metadanych (456)
  
  • Tworzenie własnego dostawcy metadanych modelu (457)
  • Dostosowywanie adnotacji danych dostawcy metadanych modelu (458)
• Podsumowanie (459)

Rozdział 17. Dołączanie modelu (461)

• Użycie dołączania danych (461)
  
• Użycie domyślnego łącznika modelu (462)
  
  • Dołączanie typów prostych (463)
  • Dołączanie typów złożonych (464)
  • Dołączanie tablic i kolekcji (467)
• Jawne wywoływanie dołączania modelu (469)
  
  • Ograniczanie dołączania do wybranego źródła danych (470)
  • Obsługa błędów dołączania modelu (471)
• Użycie dołączania modelu w celu pobierania przesłanych plików (472)
  
• Dostosowanie systemu dołączania danych (472)
  
  • Tworzenie własnego dostawcy wartości (473)
  • Tworzenie łącznika modelu obsługującego zależności (474)
  • Tworzenie własnego łącznika modelu (475)
  • Tworzenie dostawcy łączników modelu (477)
  • Użycie atrybutu ModelBinder (478)
• Podsumowanie (478)

Rozdział 18. Kontrola poprawności modelu (479)

• Tworzenie projektu (479)
  
• Jawna kontrola poprawności modelu (481)
  
• Wyświetlanie komunikatów kontroli poprawności (482)
  
  • Wyświetlanie komunikatów kontroli poprawności poziomu właściwości (486)
• Użycie alternatywnych technik kontroli poprawności (487)
  
  • Kontrola poprawności w łączniku modelu (488)
  • Definiowanie zasad poprawności za pomocą metadanych (491)
  • Definiowanie modeli samokontrolujących się (494)
  • Tworzenie własnego dostawcy kontroli poprawności (495)
• Użycie kontroli poprawności po stronie klienta (499)
  
  • Aktywowanie i wyłączanie kontroli poprawności po stronie klienta (499)
  • Użycie kontroli poprawności po stronie klienta (502)
  • Jak działa kontrola poprawności po stronie klienta? (504)
  • Modyfikowanie kontroli poprawności na kliencie (505)
• Wykonywanie zdalnej kontroli poprawności (511)
  
• Podsumowanie (513)

Rozdział 19. Nieprzeszkadzający Ajax (515)

• Użycie nieprzeszkadzających wywołań Ajax w MVC (515)
  
  • Tworzenie projektu (515)
  • Włączanie i wyłączanie nieprzeszkadzających wywołań Ajax (518)
  • Użycie nieprzeszkadzających formularzy Ajax (518)
  • Sposób działania nieprzeszkadzających wywołań Ajax (520)
• Ustawianie opcji Ajax (520)
  
  • Zapewnienie kontrolowanej degradacji (520)
  • Informowanie użytkownika o realizowanym żądaniu Ajax (522)
  • Wyświetlanie pytania przed wysłaniem żądania (523)
• Tworzenie łączy Ajax (524)
  
  • Zapewnienie kontrolowanej degradacji dla łączy (526)
• Korzystanie z funkcji wywołania zwrotnego w Ajaksie (527)
  
• Wykorzystanie JSON (529)
  
  • Dodanie obsługi JSON do kontrolera (530)
  • Przetwarzanie JSON w przeglądarce (531)
  • Wykrywanie żądań Ajax w metodach akcji (532)
  • Odbieranie danych JSON (533)
• Podsumowanie (535)

Rozdział 20. jQuery (537)

• Tworzenie projektu (537)
  
• Odwoływanie się do jQuery (539)
  
• Tworzenie kodu jQuery (541)
  
  • Utworzenie środowiska testowego dla jQuery (542)
• Podstawy jQuery (544)
  
  • Poznajemy selektory jQuery (545)
  • Użycie filtrów jQuery (546)
  • Poznajemy metody jQuery (548)
  • Czekając na DOM (549)
  • Użycie metod CSS z jQuery (550)
  • Manipulowanie modelem DOM (552)
• Użycie zdarzeń jQuery (555)
  
• Użycie efektów wizualnych jQuery (556)
  
• Użycie jQuery UI (558)
  
  • Odwoływanie się do jQuery UI (558)
  • Tworzenie lepszych przycisków (559)
  • Użycie kontrolki Slider (560)
• Podsumowanie (562)

Część III Tworzenie udanych projektów ASP.NET MVC 3 (565)

Rozdział 21. Bezpieczeństwo i słabe punkty (567)

• Każde dane mogą być sfałszowane (567)
  
  • Fałszowanie żądań HTTP (569)
• Skrypty międzywitrynowe i wstrzykiwanie HTML (570)
  
  • Przedstawiamy ataki XSS (570)
  • Kodowanie HTML w Razor (571)
  • Kontrola żądań (572)
  • Kodowanie ciągów znaków JavaScript a XSS (574)
• Przejęcie sesji (576)
  
  • Obrona przez sprawdzanie adresu IP klienta (576)
  • Obrona przez ustawienie w cookie znacznika HttpOnly (577)
• Międzywitrynowe fałszowanie żądań (577)
  
  • Atak (578)
  • Obrona (578)
  • Ochrona przed atakami CSRF z użyciem metod zapobiegających fałszerstwom (579)
• Wstrzykiwanie SQL (580)
  
  • Atak (580)
  • Obrona z użyciem zapytań parametrycznych (581)
  • Obrona z użyciem odwzorowania obiektowo-relacyjnego (581)
• Bezpieczne korzystanie z biblioteki MVC (581)
  
  • Nie udostępniaj przypadkowo metod akcji (581)
  • Nie używaj dołączania modelu w celu zmiany wrażliwych właściwości (582)
• Podsumowanie (582)

Rozdział 22. Uwierzytelnianie i autoryzacja (583)

• Użycie uwierzytelniania Windows (583)
  
• Użycie uwierzytelniania Forms (585)
  
  • Konfiguracja uwierzytelniania Forms (586)
  • Uwierzytelnianie Forms bez użycia cookies (587)
• Członkostwo, role i profile (588)
  
  • Konfigurowanie i wykorzystanie członkostwa (589)
  • Konfigurowanie i wykorzystanie ról (597)
  • Konfigurowanie i wykorzystanie profili (600)
• Dlaczego nie należy korzystać z uwierzytelniania bazującego na adresach URL (604)
  
• Ograniczanie dostępu z użyciem adresów IP oraz domen (604)
  
• Podsumowanie (606)

Rozdział 23. Instalacja (607)

• Przygotowanie aplikacji do dystrybucji (607)
  
  • Wykrywanie błędów przed instalacją (607)
  • Kontrolowanie dynamicznej kompilacji stron (608)
  • Przygotowanie do instalacji binarnej (609)
  • Przygotowanie pliku Web.config do przekształcania (609)
  • Przygotowanie projektu do instalacji bazy danych (619)
• Podstawy działania serwera IIS (621)
  
  • Witryny Web (621)
  • Katalogi wirtualne (621)
  • Pule aplikacji (621)
  • Wiązanie witryn z nazwami hostów, adresami IP oraz portami (622)
• Przygotowanie serwera do instalacji (622)
  
• Instalowanie aplikacji (624)
  
  • Instalowanie aplikacji przez kopiowanie plików (624)
  • Użycie pakietu instalacyjnego (625)
  • Publikowanie jednym kliknięciem (628)
• Podsumowanie (629)

• Titel: ASP.NET MVC 3 Framework. Zaawansowane programowanie
• Autor: Steven Sanderson, Adam Freeman
• Originaler Titel: Pro ASP.NET MVC 3 Framework
• Übersetzung: Paweł Gonera
• ISBN: 978-83-246-6600-3, 9788324666003
• Veröffentlichungsdatum: 2012-11-06
• Format: E-book
• Artikelkennung: aspmv3
• Verleger: Helion