O autorze (17)

O recenzencie technicznym (19)

CZĘŚĆ I. WPROWADZENIE DO ASP.NET MVC 4 (21)

Rozdział 1. Zagadnienia ogólne (23)

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

Rozdział 2. Pierwsza aplikacja MVC (35)

• Przygotowanie stacji roboczej (35)
• Tworzenie nowego projektu ASP.NET MVC (36)
  
  • Dodawanie pierwszego kontrolera (38)
  • Przedstawiamy ścieżki (40)
• Generowanie stron WWW (41)
  
  • Tworzenie i generowanie widoku (41)
  • Dynamiczne dodawanie treści (43)
• Tworzenie prostej aplikacji wprowadzania danych (45)
  
  • Przygotowanie sceny (45)
  • Projektowanie modelu danych (46)
  • Łączenie metod akcji (47)
  • Budowanie formularza (49)
  • Obsługa formularzy (51)
  • Dodanie kontroli poprawności (54)
  • Kończymy (60)
• Podsumowanie (61)

Rozdział 3. Wzorzec MVC (63)

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

Rozdział 4. Najważniejsze cechy języka (85)

• Utworzenie przykładowego projektu (85)
• Użycie automatycznie implementowanych właściwości (86)
• Użycie inicjalizatorów obiektów i kolekcji (89)
• Użycie metod rozszerzających (91)
  
  • Stosowanie metod rozszerzających do interfejsów (93)
  • Tworzenie filtrujących metod rozszerzających (95)
• Użycie wyrażeń lambda (97)
• Automatyczne wnioskowanie typów (100)
• Użycie typów anonimowych (100)
• Wykonywanie zapytań LINQ (102)
  
  • Opóźnione zapytania LINQ (105)
• Użycie metod asynchronicznych (107)
  
  • Użycie słów kluczowych async i await (108)
• Podsumowanie (109)

Rozdział 5. Praca z silnikiem Razor (111)

• Tworzenie projektu (111)
  
  • Definiowanie modelu (111)
  • Definiowanie kontrolera (112)
  • Tworzenie widoku (113)
• Korzystanie z obiektów modelu (114)
• Praca z układami (116)
  
  • Tworzenie układu (116)
  • Stosowanie układu (118)
  • Użycie pliku ViewStart (119)
  • Użycie układów współdzielonych (119)
• Użycie wyrażeń Razor (123)
  
  • Wstawianie wartości danych (124)
  • Przypisanie wartości atrybutu (125)
  • Użycie konstrukcji warunkowych (127)
  • Wyliczanie tablic i kolekcji (129)
  • Praca z przestrzenią nazw (132)
• Podsumowanie (132)

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

• Tworzenie przykładowego projektu (134)
  
  • Utworzenie klas modelu (134)
  • Dodanie kontrolera (135)
  • Dodanie widoku (136)
• Użycie Ninject (136)
  
  • Zrozumienie problemu (137)
  • Zaczynamy korzystać z Ninject (139)
  • Konfiguracja wstrzykiwania zależności na platformie MVC (141)
  • Tworzenie łańcucha zależności (144)
  • Definiowanie wartości właściwości i parametrów (146)
  • Użycie łączenia warunkowego (148)
• Testy jednostkowe w Visual Studio (149)
  
  • Tworzenie projektu testów jednostkowych (150)
  • Tworzenie testów jednostkowych (151)
  • Uruchamianie testów (nieudane) (154)
  • Implementacja funkcji (155)
  • Testowanie i poprawianie kodu (156)
• Użycie Moq (157)
  
  • Zrozumienie problemu (158)
  • Dodawanie Moq do projektu Visual Studio (159)
  • Dodanie obiektu imitacyjnego do testu jednostkowego (160)
  • Tworzenie obiektu imitacji (161)
  • Tworzenie bardziej skomplikowanych obiektów Mock (163)
• Podsumowanie (166)

Rozdział 7. SportsStore - kompletna aplikacja (167)

• Zaczynamy (168)
  
  • Tworzenie rozwiązania i projektów w Visual Studio (168)
  • Dodawanie referencji (169)
  • Konfigurowanie kontenera DI (171)
  • Uruchamiamy aplikację (172)
• Tworzenie modelu domeny (173)
  
  • Tworzenie abstrakcyjnego repozytorium (174)
  • Tworzenie imitacji repozytorium (174)
• Wyświetlanie listy produktów (175)
  
  • Dodawanie kontrolera (176)
  • Dodawanie widoku (177)
  • Konfigurowanie domyślnej ścieżki (178)
  • Uruchamianie aplikacji (179)
• Przygotowanie bazy danych (179)
  
  • Tworzenie bazy danych (180)
  • Definiowanie schematu bazy danych (181)
  • Dodawanie danych do bazy (182)
  • Tworzenie kontekstu Entity Framework (183)
  • Tworzenie repozytorium produktów (184)
• Dodanie stronicowania (186)
  
  • Wyświetlanie łączy stron (188)
  • Ulepszanie adresów URL (195)
• Dodawanie stylu (196)
  
  • Definiowanie wspólnej zawartości w pliku układu (197)
  • Dodanie stylów CSS (197)
  • Tworzenie widoku częściowego (199)
• Podsumowanie (200)

Rozdział 8. SportsStore - nawigacja (201)

• Dodawanie kontrolek nawigacji (201)
  
  • Filtrowanie listy produktów (201)
  • Ulepszanie schematu URL (203)
  • Budowanie menu nawigacji po kategoriach (207)
  • Poprawianie licznika stron (214)
• Budowanie koszyka na zakupy (216)
  
  • Definiowanie encji koszyka (217)
  • Tworzenie przycisków koszyka (221)
  • Implementowanie kontrolera koszyka (222)
  • Wyświetlanie zawartości koszyka (224)
• Podsumowanie (227)

Rozdział 9. SportsStore - ukończenie koszyka na zakupy (229)

• Użycie dołączania danych (229)
  
  • Tworzenie własnego łącznika modelu (229)
• Kończenie budowania koszyka (234)
  
  • Usuwanie produktów z koszyka (234)
  • Dodawanie podsumowania koszyka (234)
• Składanie zamówień (237)
  
  • Rozszerzanie modelu domeny (237)
  • Dodawanie procesu zamawiania (238)
  • Implementowanie mechanizmu przetwarzania zamówień (241)
  • Rejestrowanie implementacji (243)
  • Zakończenie pracy nad kontrolerem koszyka (244)
  • Wyświetlanie informacji o błędach systemu kontroli poprawności (248)
  • Wyświetlanie strony podsumowania (249)
• Podsumowanie (249)

Rozdział 10. SportsStore - administracja (251)

• Dodajemy zarządzanie katalogiem (251)
  
  • Tworzenie kontrolera CRUD (251)
  • Tworzenie nowego pliku układu (253)
  • Implementowanie widoku listy (255)
  • Edycja produktów (260)
  • Tworzenie nowych produktów (271)
  • Usuwanie produktów (272)
• Podsumowanie (275)

Rozdział 11. SportsStore - bezpieczeństwo i ostatnie usprawnienia (277)

• Zabezpieczanie funkcji administracyjnych (277)
  
  • Realizacja uwierzytelniania z użyciem filtrów (278)
  • Tworzenie dostawcy uwierzytelniania (280)
  • Tworzenie kontrolera AccountController (281)
  • Tworzenie widoku (283)
• Przesyłanie zdjęć (286)
  
  • Rozszerzanie bazy danych (286)
  • Rozszerzanie modelu domeny (287)
  • Tworzenie interfejsu użytkownika do przesyłania plików (288)
  • Zapisywanie zdjęć do bazy danych (289)
  • Implementowanie metody akcji GetImage (290)
  • Wyświetlanie zdjęć produktów (292)
• Podsumowanie (293)

CZĘŚĆ II. ASP.NET MVC 4 - SZCZEGÓŁOWY OPIS (295)

Rozdział 12. Przegląd projektu MVC (297)

• Korzystanie z projektów MVC z Visual Studio (297)
  
  • Przedstawienie konwencji MVC (301)
• Debugowanie aplikacji MVC (302)
  
  • Tworzenie projektu (302)
  • Uruchamianie debugera Visual Studio (304)
  • Przerywanie pracy aplikacji przez debuger Visual Studio (306)
  • Użycie opcji Edit and Continue (310)
• Podsumowanie (313)

Rozdział 13. Routing URL (315)

• Tworzenie projektu routingu (316)
• Wprowadzenie do wzorców URL (318)
• Tworzenie i rejestrowanie prostej ścieżki (319)
  
  • Użycie prostej ścieżki (324)
• Definiowanie wartości domyślnych (325)
• Użycie statycznych segmentów adresu URL (327)
• Definiowanie własnych zmiennych segmentów (331)
  
  • Użycie własnych zmiennych jako parametrów metod akcji (334)
  • Definiowanie opcjonalnych segmentów URL (335)
  • Definiowanie ścieżek o zmiennej długości (337)
  • Definiowanie priorytetów kontrolerów na podstawie przestrzeni nazw (339)
• Ograniczenia ścieżek (342)
  
  • Ograniczanie ścieżki z użyciem wyrażeń regularnych (342)
  • Ograniczanie ścieżki do zbioru wartości (343)
  • Ograniczanie ścieżek z użyciem metod HTTP (343)
  • Definiowanie własnych ograniczeń (344)
• Routing żądań dla plików dyskowych (346)
  
  • Konfiguracja serwera aplikacji (347)
  • Definiowanie ścieżek dla plików na dysku (349)
• Pomijanie systemu routingu (350)
• Podsumowanie (351)

Rozdział 14. Zaawansowane funkcje routingu (353)

• Przygotowanie projektu (353)
• Generowanie wychodzących adresów URL w widokach (354)
  
  • Użycie systemu routingu do wygenerowania wychodzącego adresu URL (354)
  • Użycie innych kontrolerów (357)
  • Przekazywanie dodatkowych parametrów (358)
  • Definiowanie atrybutów HTML (360)
  • Generowanie w pełni kwalifikowanych adresów URL w łączach (360)
  • Generowanie adresów URL (nie łączy) (361)
  • Generowanie wychodzących adresów URL w metodach akcji (362)
  • Generowanie adresu URL na podstawie wybranej ścieżki (363)
• Dostosowanie systemu routingu (364)
  
  • Tworzenie własnej implementacji RouteBase (364)
  • Tworzenie własnego obiektu obsługi ścieżki (368)
• Korzystanie z obszarów (369)
  
  • Tworzenie obszaru (369)
  • Wypełnianie obszaru (371)
  • Rozwiązywanie problemów z niejednoznacznością kontrolerów (373)
  • Generowanie łączy do akcji z obszarów (374)
• Najlepsze praktyki schematu adresów URL (375)
  
  • Twórz jasne i przyjazne dla człowieka adresy URL (375)
  • GET oraz POST - wybierz właściwie (376)
• Podsumowanie (376)

Rozdział 15. Kontrolery i akcje (377)

• Wprowadzenie do kontrolerów (377)
  
  • Przygotowanie projektu (377)
  • Tworzenie kontrolera z użyciem interfejsu IController (378)
  • Tworzenie kontrolera przez dziedziczenie po klasie Controller (379)
• Odczytywanie danych wejściowych (380)
  
  • Pobieranie danych z obiektów kontekstu (380)
  • Użycie parametrów metod akcji (382)
• Tworzenie danych wyjściowych (383)
  
  • Wyniki akcji (385)
  • Zwracanie kodu HTML przez generowanie widoku (388)
  • Przekazywanie danych z metody akcji do widoku (391)
  • Wykonywanie przekierowań (394)
  • Zwracanie błędów i kodów HTTP (399)
• Podsumowanie (401)

Rozdział 16. Filtry (403)

• Użycie filtrów (403)
  
  • Wprowadzenie do czterech podstawowych typów filtrów (404)
  • Dołączanie filtrów do kontrolerów i metod akcji (405)
• Tworzenie projektu (406)
• Użycie filtrów autoryzacji (407)
  
  • Użycie własnego filtra autoryzacji (409)
  • Użycie wbudowanego filtra autoryzacji (409)
• Użycie filtrów wyjątków (410)
  
  • Tworzenie filtra wyjątku (411)
  • Użycie filtra wyjątków (412)
  • Użycie widoku w celu reakcji na wyjątek (414)
  • Użycie wbudowanego filtra wyjątków (417)
• Użycie filtrów akcji (419)
  
  • Implementacja metody OnActionExecuting (420)
  • Implementacja metody OnActionExecuted (421)
• Używanie filtra wyniku (423)
  
  • Użycie wbudowanych klas filtrów akcji i wyniku (424)
• Użycie innych funkcji filtrów (425)
  
  • Filtrowanie bez użycia atrybutów (426)
  • Użycie filtrów globalnych (427)
  • Określanie kolejności wykonywania filtrów (429)
• Użycie filtrów wbudowanych (431)
  
  • Użycie filtra RequireHttps (432)
  • Użycie filtra OutputCache (432)
• Podsumowanie (435)

Rozdział 17. Rozszerzanie kontrolerów (437)

• Tworzenie projektu (437)
• Tworzenie własnej fabryki kontrolerów (439)
  
  • Przygotowanie kontrolera zapasowego (441)
  • Utworzenie klasy kontrolera (442)
  • Implementacja innych metod interfejsu (442)
  • Rejestrowanie własnej fabryki kontrolerów (442)
• Wykorzystanie wbudowanej fabryki kontrolerów (443)
  
  • Nadawanie priorytetów przestrzeniom nazw (444)
  • Dostosowywanie sposobu tworzenia kontrolerów w DefaultControllerFactory (445)
• Tworzenie własnego obiektu wywołującego akcje (447)
• Użycie wbudowanego obiektu wywołującego akcje (449)
  
  • Użycie własnych nazw akcji (450)
  • Selekcja metod akcji (451)
• Poprawianie wydajności z użyciem specjalizowanych kontrolerów (456)
  
  • Użycie kontrolerów bezstanowych (456)
  • Użycie kontrolerów asynchronicznych (458)
• Podsumowanie (463)

Rozdział 18. Widoki (465)

• Tworzenie własnego silnika widoku (465)
  
  • Tworzenie przykładowego projektu (467)
  • Tworzenie własnej implementacji IView (468)
  • Tworzenie implementacji IViewEngine (468)
  • Rejestrowanie własnego silnika widoku (470)
  • Testowanie silnika widoku (470)
• Korzystanie z silnika Razor (472)
  
  • Tworzenie przykładowego projektu (472)
  • Sposób generowania widoków przez Razor (473)
  • Konfigurowanie wyszukiwania lokalizacji widoków (475)
• Dodawanie dynamicznych treści do widoku Razor (477)
  
  • Zastosowanie sekcji (478)
  • Użycie widoków częściowych (483)
  • Użycie akcji podrzędnych (486)
• Podsumowanie (488)

Rozdział 19. Metody pomocnicze (489)

• Tworzenie przykładowego projektu (489)
• Tworzenie własnej metody pomocniczej (491)
  
  • Tworzenie wewnętrznej metody pomocniczej HTML (491)
  • Tworzenie zewnętrznej metody pomocniczej HTML (492)
  • Zarządzanie kodowaniem ciągów tekstowych w metodzie pomocniczej (496)
• Użycie wbudowanych metod pomocniczych (500)
  
  • Przygotowania do obsługi formularzy (500)
  • Określenie ścieżki używanej przez formularz (507)
  • Użycie metod pomocniczych do wprowadzania danych (508)
  • Tworzenie znaczników select (513)
• Podsumowanie (515)

Rozdział 20. Szablonowe metody pomocnicze (517)

• Przegląd przykładowego projektu (517)
• Używanie szablonowych metod pomocniczych (519)
  
  • Generowanie etykiety i wyświetlanie elementów (522)
  • Użycie szablonowych metod pomocniczych dla całego modelu (525)
• Użycie metadanych modelu (527)
  
  • Użycie metadanych do sterowania edycją i widocznością (528)
  • Użycie metadanych dla etykiet (530)
  • Użycie metadanych wartości danych (531)
  • Użycie metadanych do wybierania szablonu wyświetlania (533)
  • Dodawanie metadanych do klasy zaprzyjaźnionej (535)
  • Korzystanie z parametrów typów złożonych (536)
• Dostosowywanie systemu szablonowych metod pomocniczych (538)
  
  • Tworzenie własnego szablonu edytora (538)
  • Tworzenie szablonu ogólnego (539)
  • Wymiana szablonów wbudowanych (540)
• Podsumowanie (541)

Rozdział 21. Metody pomocnicze URL i Ajax (543)

• Przegląd i przygotowanie projektu (543)
• Tworzenie podstawowych łączy i adresów URL (545)
• Nieprzeszkadzający Ajax (547)
  
  • Tworzenie widoku formularza synchronicznego (547)
  • Włączanie i wyłączanie nieprzeszkadzających wywołań Ajax (549)
• Użycie nieprzeszkadzających formularzy Ajax (550)
  
  • Przygotowanie kontrolera (550)
  • Tworzenie formularza Ajax (552)
  • Sposób działania nieprzeszkadzających wywołań Ajax (553)
• Ustawianie opcji Ajax (554)
  
  • Zapewnienie kontrolowanej degradacji (554)
  • Informowanie użytkownika o realizowanym żądaniu Ajax (556)
  • Wyświetlanie pytania przed wysłaniem żądania (557)
• Tworzenie łączy Ajax (558)
  
  • Zapewnienie kontrolowanej degradacji dla łączy (559)
• Korzystanie z funkcji wywołania zwrotnego w Ajaksie (560)
• Wykorzystanie JSON (562)
  
  • Dodanie obsługi JSON do kontrolera (562)
  • Przetwarzanie JSON w przeglądarce (564)
  • Przygotowanie danych do kodowania (565)
  • Wykrywanie żądań Ajax w metodach akcji (567)
• Podsumowanie (570)

Rozdział 22. Dołączanie modelu (571)

• Przygotowanie projektu (571)
• Użycie dołączania modelu (573)
• Użycie domyślnego łącznika modelu (575)
  
  • Dołączanie typów prostych (575)
  • Dołączanie typów złożonych (578)
  • Dołączanie tablic i kolekcji (584)
• Jawne wywoływanie dołączania modelu (589)
  
  • Obsługa błędów dołączania modelu (590)
• Dostosowanie systemu dołączania modelu (591)
  
  • Tworzenie własnego dostawcy wartości (591)
  • Tworzenie własnego łącznika modelu (594)
  • Rejestracja własnego łącznika modelu (596)
• Podsumowanie (597)

Rozdział 23. Kontrola poprawności modelu (599)

• Tworzenie projektu (599)
• Jawna kontrola poprawności modelu (602)
  
  • Wyświetlenie użytkownikowi błędów podczas kontroli poprawności (603)
• Wyświetlanie komunikatów kontroli poprawności (604)
  
  • Wyświetlanie komunikatów kontroli poprawności poziomu właściwości (608)
• Użycie alternatywnych technik kontroli poprawności (608)
  
  • Kontrola poprawności w łączniku modelu (609)
  • Definiowanie zasad poprawności za pomocą metadanych (610)
  • Definiowanie modeli samokontrolujących się (616)
• Użycie kontroli poprawności po stronie klienta (618)
  
  • Aktywowanie i wyłączanie kontroli poprawności po stronie klienta (618)
  • Użycie kontroli poprawności po stronie klienta (619)
  • Jak działa kontrola poprawności po stronie klienta? (620)
• Wykonywanie zdalnej kontroli poprawności (621)
• Podsumowanie (624)

Rozdział 24. Paczki i tryby wyświetlania (625)

• Domyślne biblioteki skryptów (625)
• Tworzenie przykładowej aplikacji (627)
• Zarządzanie skryptami i stylami (630)
  
  • Profilowanie wczytywania skryptów i arkuszy stylów (630)
• Używanie paczek stylów i skryptów (632)
  
  • Stosowanie paczek (635)
  • Używanie sekcji script (637)
  • Profilowanie wprowadzonych zmian (638)
• Przygotowanie aplikacji dla urządzeń mobilnych (640)
  
  • Aplikacja standardowa (641)
  • Użycie widoków i układów przeznaczonych dla urządzeń mobilnych (642)
  • Tworzenie własnych trybów wyświetlania (643)
• Podsumowanie (646)

Rozdział 25. Web API (647)

• Zrozumienie Web API (647)
• Tworzenie aplikacji Web API (648)
  
  • Tworzenie modelu i repozytorium (648)
  • Tworzenie kontrolera Home (650)
  • Utworzenie widoku i CSS (651)
• Tworzenie kontrolera API (653)
  
  • Testowanie kontrolera API (655)
• Jak działa kontroler API? (656)
  
  • Jak wybierana jest akcja kontrolera API? (657)
  • Mapowanie metod HTTP na metody akcji (657)
• Tworzenie kodu JavaScript wykorzystującego interfejs Web API (658)
  
  • Tworzenie funkcji podstawowych (659)
  • Dodanie obsługi edycji nowych rezerwacji (661)
  • Dodanie obsługi usuwania rezerwacji (663)
  • Dodanie obsługi tworzenia rezerwacji (664)
• Podsumowanie (665)

Rozdział 26. Wdrażanie aplikacji (667)

• Przygotowanie aplikacji do dystrybucji (668)
  
  • Wykrywanie błędów widoku (668)
  • Wyłączanie trybu debugowania (670)
  • Usunięcie nieużywanych ciągów tekstowych połączenia (670)
• Przygotowanie do użycia Windows Azure (671)
  
  • Tworzenie witryny internetowej i bazy danych (672)
  • Przygotowanie bazy danych do zdalnej administracji (674)
  • Tworzenie schematu bazy danych (674)
• Wdrażanie aplikacji (676)
• Podsumowanie (680)

Skorowidz (681)

• Titel: ASP.NET MVC 4. Zaawansowane programowanie
• Autor: Adam Freeman, Steven Sanderson
• Originaler Titel: Pro ASP.NET MVC 4 (Professional Apress)
• Übersetzung: Robert Górczyński
• ISBN: 978-83-246-7300-1, 9788324673001
• Veröffentlichungsdatum: 2013-11-14
• Format: E-book
• Artikelkennung: aspmv4
• Verleger: Helion