ASP.NET MVC 5. Zaawansowane programowanie - ebook

Rozpocznij tworzenie łatwych w obsłudze, zgodnych ze standardami oraz oferujących najlepszą wydajność aplikacji sieciowych na platformie opracowanej przez Microsoft

Platforma ASP.NET MVC powstała jako alternatywa dla ASP.NET Web Forms. Dzięki zastosowaniu architektury model-widok-kontroler (ang. Model View Controller) tworzony kod jest przejrzysty oraz zdecydowanie łatwiejszy w utrzymaniu. Ciągły rozwój tej platformy zaowocował wydaniem kolejnej wersji, oznaczonej numerem 5. Dzięki zawartym tu nowościom stworzysz jeszcze lepszy kod w krótszym czasie. Przekonaj się sam!

Niniejsze wydanie tej cenionej przez programistów książki zostało rozszerzone o nowości wprowadzone na platformie ASP.NET MVC 5. Wśród nich znajdziesz opisy sposobu definiowania tras za pomocą atrybutów C# oraz metody nadpisywania filtrów. Odkryjesz tu również omówienia biblioteki Bootstrap (dzięki czemu programiści otrzymują szeroką gamę wieloplatformowych opcji w zakresie tworzenia CSS i HTML5) oraz możliwości zintegrowanego środowiska programistycznego Visual Studio 2013. Ponadto dowiesz się, jak zabezpieczać poszczególne obszary aplikacji, w jaki sposób korzystać z filtrów lub routingu oraz jak obsługiwać żądania AJAX. Ta książka jest kompletnym przewodnikiem po platformie ASP.NET MVC 5. Musisz ją mieć!

Dzięki tej książce:

• poznasz nowości wprowadzone w wersji 5 platformy ASP.NET MVC
• poznasz architekturę MVC i z jej pomocą zbudujesz aplikację
• zaznajomisz się z nową wersją środowiska programistycznego Visual Studio 2013
• zdobędziesz dogłębną wiedzę o ASP.NET MVC5

Lektura obowiązkowa każdego programisty!

O autorze (17)

O recenzencie technicznym (18)

Rozdział 1. ASP.NET MVC w szerszym kontekście (19)

• Krótka historia programowania witryn WWW (19)
  • Co poszło nie tak z ASP.NET Web Forms? (20)
• Programowanie witryn WWW - stan obecny (21)
  • Standardy sieciowe oraz REST (21)
  • Programowanie zwinne i sterowane testami (22)
  • Ruby on Rails (22)
  • Node.js (22)
• Najważniejsze zalety ASP.NET MVC (23)
  • Architektura MVC (23)
  • Rozszerzalność (24)
  • Ścisła kontrola nad HTML i HTTP (24)
  • Łatwość testowania (24)
  • Zaawansowany system routingu (25)
  • Zbudowany na najlepszych częściach platformy ASP.NET (25)
  • Nowoczesne API (26)
  • ASP.NET MVC jest open source (26)
• Co powinienem wiedzieć? (26)
• Jaka jest struktura książki? (27)
  • Część I. Wprowadzenie do ASP.NET MVC 5 (27)
  • Część II. Szczegółowe omówienie platformy ASP.NET MVC (27)
• Co nowego w ASP.NET MVC 5? (27)
• Gdzie znajdę przykładowe fragmenty kodu? (28)
• Jakiego oprogramowania będę potrzebował? (28)
• Bootstrap (29)
• Podsumowanie (29)

Rozdział 2. Pierwsza aplikacja MVC (31)

• Przygotowanie Visual Studio (31)
• Tworzenie nowego projektu ASP.NET MVC (31)
  • Dodawanie pierwszego kontrolera (34)
  • Poznajemy trasy (37)
• Generowanie stron WWW (37)
  • Tworzenie i generowanie widoku (37)
  • Dynamiczne dodawanie treści (41)
• Tworzenie prostej aplikacji wprowadzania danych (42)
  • Przygotowanie sceny (42)
  • Projektowanie modelu danych (43)
  • Łączenie metod akcji (44)
  • Budowanie formularza (47)
  • Zdefiniowanie początkowego adresu URL (49)
  • Obsługa formularzy (50)
  • Dodanie kontroli poprawności (53)
  • Nadanie stylu zawartości (58)
  • Kończymy przykład (63)
• Podsumowanie (64)

Rozdział 3. Wzorzec MVC (65)

• Historia MVC (65)
• Wprowadzenie do wzorca MVC (66)
  • Budowa modelu domeny (66)
  • Implementacja MVC w ASP.NET (67)
  • Porównanie MVC z innymi wzorcami (67)
• Budowanie luźno połączonych komponentów (70)
  • Wykorzystanie wstrzykiwania zależności (71)
  • Użycie kontenera wstrzykiwania zależności (72)
• Zaczynamy testy automatyczne (74)
  • Zadania testów jednostkowych (74)
  • Zadania testów integracyjnych (79)
• Podsumowanie (79)

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

• Utworzenie przykładowego projektu (81)
  • Dodanie podzespołu System.Net.Http (83)
• Użycie automatycznie implementowanych właściwości (83)
• Użycie inicjalizatorów obiektów i kolekcji (86)
• Użycie metod rozszerzających (88)
  • Stosowanie metod rozszerzających do interfejsów (90)
  • Tworzenie filtrujących metod rozszerzających (92)
• Użycie wyrażeń lambda (93)
• Automatyczna inferencja typów (97)
• Użycie typów anonimowych (97)
• Wykonywanie zapytań LINQ (98)
  • Opóźnione zapytania LINQ (102)
• Użycie metod asynchronicznych (103)
  • Użycie słów kluczowych async i await (105)
• Podsumowanie (106)

Rozdział 5. Praca z silnikiem Razor (107)

• Utworzenie przykładowego projektu (107)
  • Definiowanie modelu (108)
  • Definiowanie kontrolera (108)
  • Tworzenie widoku (109)
• Korzystanie z obiektów modelu (109)
• Praca z układami (111)
  • Tworzenie układu (112)
  • Stosowanie układu (113)
  • Użycie pliku ViewStart (114)
  • Użycie układów współdzielonych (115)
• Użycie wyrażeń Razor (118)
  • Wstawianie wartości danych (119)
  • Przypisanie wartości atrybutu (121)
  • Użycie konstrukcji warunkowych (123)
  • Wyświetlanie zawartości tablic i kolekcji (125)
  • Praca z przestrzenią nazw (127)
• Podsumowanie (128)

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

• Tworzenie przykładowego projektu (130)
  • Utworzenie klas modelu (130)
  • Dodanie kontrolera (132)
  • Dodanie widoku (132)
• Użycie Ninject (133)
  • Zrozumienie problemu (133)
  • Dodawanie Ninject do projektu Visual Studio (135)
  • Zaczynamy korzystać z Ninject (136)
  • Konfiguracja wstrzykiwania zależności na platformie MVC (137)
  • Tworzenie łańcucha zależności (140)
  • Definiowanie wartości właściwości i parametrów konstruktora (142)
  • Użycie łączenia warunkowego (143)
  • Ustawienie obiektu zakresu (144)
• Testy jednostkowe w Visual Studio (147)
  • Tworzenie projektu testów jednostkowych (147)
  • Tworzenie testów jednostkowych (148)
  • Uruchamianie testów (nieudane) (152)
  • Implementacja funkcji (152)
  • Testowanie i poprawianie kodu (153)
• Użycie Moq (155)
  • Zrozumienie problemu (155)
  • Dodawanie Moq do projektu Visual Studio (157)
  • Dodanie obiektu imitacyjnego do testu jednostkowego (157)
  • Tworzenie bardziej skomplikowanych obiektów Mock (160)
• Podsumowanie (162)

Rozdział 7. SportsStore - kompletna aplikacja (163)

• Zaczynamy (164)
  • Tworzenie rozwiązania i projektów w Visual Studio (164)
  • Instalacja pakietów narzędziowych (166)
  • Dodawanie odwołań między projektami (166)
  • Konfigurowanie kontenera DI (167)
  • Uruchamiamy aplikację (168)
• Tworzenie modelu domeny (168)
  • Tworzenie abstrakcyjnego repozytorium (169)
  • Tworzenie imitacji repozytorium (169)
• Wyświetlanie listy produktów (171)
  • Dodawanie kontrolera (171)
  • Dodawanie układu, pliku ViewStart i widoku (172)
  • Konfigurowanie domyślnej trasy (173)
  • Uruchamianie aplikacji (174)
• Przygotowanie bazy danych (175)
  • Tworzenie bazy danych (176)
  • Definiowanie schematu bazy danych (177)
  • Dodawanie danych do bazy (179)
  • Tworzenie kontekstu Entity Framework (180)
  • Tworzenie repozytorium produktów (182)
• Dodanie stronicowania (184)
  • Wyświetlanie łączy stron (185)
  • Ulepszanie adresów URL (193)
• Dodawanie stylu (194)
  • Instalacja pakietu Bootstrap (194)
  • Zastosowanie w aplikacji stylów Bootstrap (195)
  • Tworzenie widoku częściowego (196)
• Podsumowanie (199)

Rozdział 8. SportsStore - nawigacja (201)

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

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

• Użycie dołączania danych (227)
  • Tworzenie własnego łącznika modelu (227)
• Kończenie budowania koszyka (231)
  • Usuwanie produktów z koszyka (232)
  • Dodawanie podsumowania koszyka (233)
• Składanie zamówień (236)
  • Rozszerzanie modelu domeny (236)
  • Dodawanie procesu składania zamówienia (236)
  • Implementowanie mechanizmu przetwarzania zamówień (242)
  • Rejestrowanie implementacji (244)
  • Zakończenie pracy nad kontrolerem koszyka (246)
  • Wyświetlanie informacji o błędach systemu kontroli poprawności (249)
  • Wyświetlanie strony podsumowania (251)
• Podsumowanie (252)

Rozdział 10. SportsStore - wersja mobilna (253)

• Kontekst programowania sieciowego dla urządzeń mobilnych (253)
  • Odstąpienie od działania (lub jego podjęcie na minimalnym możliwym poziomie) (254)
• Użycie układu responsywnego (255)
  • Utworzenie responsywnego nagłówka (256)
  • Tworzenie responsywnej listy produktów (260)
• Utworzenie zawartości specjalnie dla urządzeń mobilnych (267)
  • Utworzenie układu dla urządzeń mobilnych (268)
  • Utworzenie widoków dla urządzeń mobilnych (269)
• Podsumowanie (272)

Rozdział 11. SportsStore - administracja (275)

• Dodajemy zarządzanie katalogiem (275)
  • Tworzenie kontrolera CRUD (276)
  • Tworzenie nowego pliku układu (277)
  • Implementowanie widoku listy (278)
  • Edycja produktów (282)
  • Tworzenie nowych produktów (295)
  • Usuwanie produktów (298)
• Podsumowanie (301)

Rozdział 12. SportsStore - bezpieczeństwo i ostatnie usprawnienia (303)

• Zabezpieczanie kontrolera administracyjnego (303)
  • Zdefiniowanie prostej polityki bezpieczeństwa (303)
  • Realizacja uwierzytelniania z użyciem filtrów (305)
  • Tworzenie dostawcy uwierzytelniania (306)
  • Tworzenie kontrolera AccountController (308)
  • Tworzenie widoku (309)
• Przesyłanie zdjęć (312)
  • Rozszerzanie bazy danych (312)
  • Rozszerzanie modelu domeny (313)
  • Tworzenie interfejsu użytkownika do przesyłania plików (314)
  • Zapisywanie zdjęć do bazy danych (316)
  • Implementowanie metody akcji GetImage (317)
  • Wyświetlanie zdjęć produktów (321)
• Podsumowanie (322)

Rozdział 13. Wdrażanie aplikacji (323)

• Przygotowanie do użycia Windows Azure (324)
  • Tworzenie witryny internetowej i bazy danych (324)
  • Przygotowanie bazy danych do zdalnej administracji (325)
  • Tworzenie schematu bazy danych (326)
• Wdrażanie aplikacji (328)
• Podsumowanie (332)

Rozdział 14. Przegląd projektu MVC (333)

• Korzystanie z projektów MVC z Visual Studio (333)
  • Tworzenie projektu (334)
  • Przedstawienie konwencji MVC (337)
• Debugowanie aplikacji MVC (338)
  • Tworzenie przykładowego projektu (338)
  • Uruchamianie debugera Visual Studio (341)
  • Przerywanie pracy aplikacji przez debuger Visual Studio (342)
  • Użycie opcji Edit and Continue (347)
• Użycie funkcji połączonych przeglądarek (350)
• Podsumowanie (351)

Rozdział 15. Routing URL (353)

• Utworzenie przykładowego projektu (353)
  • Utworzenie przykładowych kontrolerów (355)
  • Utworzenie widoku (356)
  • Ustawienie początkowego adresu URL i przetestowanie aplikacji (356)
• Wprowadzenie do wzorców URL (357)
• Tworzenie i rejestrowanie prostej trasy (358)
  • Użycie prostej trasy (363)
• Definiowanie wartości domyślnych (363)
• Użycie statycznych segmentów adresu URL (366)
• Definiowanie własnych zmiennych segmentów (370)
  • Użycie własnych zmiennych jako parametrów metod akcji (372)
  • Definiowanie opcjonalnych segmentów URL (373)
  • Definiowanie tras o zmiennej długości (375)
  • Definiowanie priorytetów kontrolerów na podstawie przestrzeni nazw (377)
• Ograniczenia tras (380)
  • Ograniczanie trasy z użyciem wyrażeń regularnych (380)
  • Ograniczanie trasy do zbioru wartości (381)
  • Ograniczanie tras z użyciem metod HTTP (381)
  • Użycie ograniczeń dotyczących typu i wartości (383)
  • Definiowanie własnych ograniczeń (385)
• Użycie atrybutów routingu (387)
  • Włączanie i stosowanie atrybutów routingu (387)
  • Tworzenie tras za pomocą zmiennych segmentu (389)
  • Zastosowanie ograniczeń trasy (390)
  • Użycie prefiksu trasy (392)
• Podsumowanie (393)

Rozdział 16. Zaawansowane funkcje routingu (395)

• Utworzenie przykładowego projektu (396)
  • Uproszczenie tras (396)
  • Dodanie pakietu optymalizacyjnego (396)
  • Uaktualnienie projektu testów jednostkowych (397)
• Generowanie wychodzących adresów URL w widokach (397)
  • Użycie systemu routingu do wygenerowania wychodzącego adresu URL (397)
  • Użycie innych kontrolerów (400)
  • Przekazywanie dodatkowych parametrów (401)
  • Definiowanie atrybutów HTML (403)
  • Generowanie w pełni kwalifikowanych adresów URL w łączach (404)
  • Generowanie adresów URL (nie łączy) (405)
  • Generowanie wychodzących adresów URL w metodach akcji (406)
  • Generowanie adresu URL na podstawie wybranej trasy (407)
• Dostosowanie systemu routingu (408)
  • Tworzenie własnej implementacji RouteBase (408)
  • Tworzenie własnego obiektu obsługi trasy (412)
• Korzystanie z obszarów (414)
  • Tworzenie obszaru (414)
  • Wypełnianie obszaru (416)
  • Rozwiązywanie problemów z niejednoznacznością kontrolerów (417)
  • Tworzenie obszarów za pomocą atrybutów (418)
  • Generowanie łączy do akcji z obszarów (419)
• Routing żądań dla plików dyskowych (420)
  • Konfiguracja serwera aplikacji (421)
  • Definiowanie tras dla plików na dysku (422)
• Pomijanie systemu routingu (424)
• Najlepsze praktyki schematu adresów URL (424)
  • Twórz jasne i przyjazne dla człowieka adresy URL (425)
  • GET oraz POST - wybierz właściwie (426)
• Podsumowanie (426)

Rozdział 17. Kontrolery i akcje (427)

• Utworzenie przykładowego projektu (428)
  • Ustawienie początkowego adresu URL (428)
• Wprowadzenie do kontrolerów (428)
  • Tworzenie kontrolera z użyciem interfejsu IController (428)
  • Tworzenie kontrolera przez dziedziczenie po klasie Controller (430)
• Odczytywanie danych wejściowych (432)
  • Pobieranie danych z obiektów kontekstu (432)
  • Użycie parametrów metod akcji (433)
• Tworzenie danych wyjściowych (435)
  • Wyniki akcji (436)
  • Zwracanie kodu HTML przez generowanie widoku (440)
  • Przekazywanie danych z metody akcji do widoku (443)
  • Wykonywanie przekierowań (447)
  • Zwracanie błędów i kodów HTTP (452)
• Podsumowanie (453)

Rozdział 18. Filtry (455)

• Utworzenie przykładowego projektu (456)
  • Ustawienie początkowego adresu URL i przetestowanie aplikacji (458)
• Użycie filtrów (458)
  • Wprowadzenie do podstawowych typów filtrów (459)
  • Dołączanie filtrów do kontrolerów i metod akcji (460)
• Użycie filtrów autoryzacji (461)
  • Użycie własnego filtra autoryzacji (462)
  • Użycie wbudowanego filtra autoryzacji (463)
• Użycie filtrów uwierzytelniania (464)
  • Interfejs IAuthenticationFilter (464)
  • Implementacja sprawdzenia uwierzytelniania (466)
  • Połączenie filtrów uwierzytelniania i autoryzacji (468)
  • Obsługa ostatniego uwierzytelnienia w żądaniu (469)
• Użycie filtrów wyjątków (470)
  • Tworzenie filtra wyjątku (470)
  • Użycie filtra wyjątków (471)
  • Użycie widoku w celu reakcji na wyjątek (474)
  • Użycie wbudowanego filtra wyjątków (476)
• Użycie filtrów akcji (478)
  • Implementacja metody OnActionExecuting (479)
  • Implementacja metody OnActionExecuted (481)
• Używanie filtra wyniku (482)
  • Użycie wbudowanych klas filtrów akcji i wyniku (483)
• Użycie innych funkcji filtrów (485)
  • Filtrowanie bez użycia atrybutów (485)
  • Użycie filtrów globalnych (487)
  • Określanie kolejności wykonywania filtrów (489)
  • Nadpisywanie filtrów (491)
• Podsumowanie (494)

Rozdział 19. Rozszerzanie kontrolerów (495)

• Utworzenie przykładowego projektu (496)
  • Ustawienie początkowego adresu URL (498)
• Tworzenie własnej fabryki kontrolerów (498)
  • Przygotowanie kontrolera zapasowego (500)
  • Utworzenie klasy kontrolera (500)
  • Implementacja innych metod interfejsu (501)
  • Rejestrowanie własnej fabryki kontrolerów (501)
• Wykorzystanie wbudowanej fabryki kontrolerów (502)
  • Nadawanie priorytetów przestrzeniom nazw (502)
  • Dostosowywanie sposobu tworzenia kontrolerów w DefaultControllerFactory (504)
• Tworzenie własnego obiektu wywołującego akcje (506)
• Użycie wbudowanego obiektu wywołującego akcje (508)
  • Użycie własnych nazw akcji (508)
  • Selekcja metod akcji (509)
• Poprawianie wydajności z użyciem specjalizowanych kontrolerów (515)
  • Użycie kontrolerów bezstanowych (515)
  • Użycie kontrolerów asynchronicznych (517)
• Podsumowanie (521)

Rozdział 20. Widoki (523)

• Tworzenie własnego silnika widoku (523)
  • Tworzenie przykładowego projektu (526)
  • Tworzenie własnej implementacji IView (527)
  • Tworzenie implementacji IViewEngine (528)
  • Rejestrowanie własnego silnika widoku (529)
  • Testowanie silnika widoku (529)
• Korzystanie z silnika Razor (531)
  • Tworzenie przykładowego projektu (531)
  • Sposób generowania widoków przez Razor (532)
  • Konfigurowanie wyszukiwania lokalizacji widoków (533)
• Dodawanie dynamicznych treści do widoku Razor (536)
  • Zastosowanie sekcji układu (536)
  • Użycie widoków częściowych (541)
  • Użycie akcji potomnych (544)
• Podsumowanie (546)

Rozdział 21. Metody pomocnicze (547)

• Tworzenie przykładowego projektu (548)
  • Ustawienie początkowego adresu URL (549)
  • Przetestowanie aplikacji (549)
• Tworzenie własnej metody pomocniczej (549)
  • Tworzenie wewnętrznej metody pomocniczej HTML (549)
  • Tworzenie zewnętrznej metody pomocniczej HTML (551)
  • Zarządzanie kodowaniem ciągów tekstowych w metodzie pomocniczej (554)
• Użycie wbudowanych metod pomocniczych (559)
  • Przygotowania do obsługi formularzy (559)
  • Określenie trasy używanej przez formularz (565)
  • Użycie metod pomocniczych do wprowadzania danych (567)
  • Tworzenie znaczników select (571)
• Podsumowanie (573)

Rozdział 22. Szablonowe metody pomocnicze (575)

• Przygotowanie przykładowego projektu (576)
• Używanie szablonowych metod pomocniczych (578)
  • Generowanie etykiety i wyświetlanie elementów (581)
  • Użycie szablonowych metod pomocniczych dla całego modelu (583)
• Użycie metadanych modelu (586)
  • Użycie metadanych do sterowania edycją i widocznością (586)
  • Użycie metadanych dla etykiet (589)
  • Użycie metadanych wartości danych (590)
  • Użycie metadanych do wybierania szablonu wyświetlania (591)
  • Dodawanie metadanych do klasy zaprzyjaźnionej (593)
  • Korzystanie z parametrów typów złożonych (595)
• Dostosowywanie systemu szablonowych metod pomocniczych (596)
  • Tworzenie własnego szablonu edytora (596)
  • Tworzenie szablonu ogólnego (597)
  • Zastępowanie szablonów wbudowanych (599)
• Podsumowanie (599)

Rozdział 23. Metody pomocnicze URL i Ajax (601)

• Przygotowanie przykładowego projektu (602)
  • Definiowanie dodatkowych stylów CSS (603)
  • Instalacja pakietów NuGet (603)
• Tworzenie podstawowych łączy i adresów URL (603)
• Nieprzeszkadzający Ajax (605)
  • Tworzenie widoku formularza synchronicznego (606)
  • Włączanie i wyłączanie nieprzeszkadzających wywołań Ajax (607)
• Utworzenie nieprzeszkadzających formularzy Ajax (608)
  • Przygotowanie kontrolera (608)
  • Tworzenie formularza Ajax (610)
  • Sposób działania nieprzeszkadzających wywołań Ajax (612)
• Ustawianie opcji Ajax (612)
  • Zapewnienie kontrolowanej degradacji (612)
  • Informowanie użytkownika o realizowanym żądaniu Ajax (614)
  • Wyświetlanie pytania przed wysłaniem żądania (615)
• Tworzenie łączy Ajax (616)
  • Zapewnienie kontrolowanej degradacji dla łączy (618)
• Korzystanie z funkcji wywołania zwrotnego w technologii Ajax (618)
• Wykorzystanie JSON (621)
  • Dodanie obsługi JSON do kontrolera (621)
  • Przetwarzanie JSON w przeglądarce (622)
  • Przygotowanie danych do kodowania (624)
  • Wykrywanie żądań Ajax w metodach akcji (626)
• Podsumowanie (628)

Rozdział 24. Dołączanie modelu (629)

• Przygotowanie przykładowego projektu (630)
• Użycie dołączania modelu (632)
• Użycie domyślnego łącznika modelu (633)
  • Dołączanie typów prostych (634)
  • Dołączanie typów złożonych (636)
  • Dołączanie tablic i kolekcji (643)
• Ręczne wywoływanie dołączania modelu (648)
  • Obsługa błędów dołączania modelu (650)
• Dostosowanie systemu dołączania modelu (650)
  • Tworzenie własnego dostawcy wartości (651)
  • Tworzenie własnego łącznika modelu (653)
  • Rejestracja własnego łącznika modelu (655)
• Podsumowanie (656)

Rozdział 25. Kontrola poprawności modelu (657)

• Utworzenie przykładowego projektu (658)
  • Utworzenie układu (659)
  • Utworzenie widoków (660)
• Jawna kontrola poprawności modelu (661)
  • Wyświetlenie użytkownikowi błędów podczas kontroli poprawności (662)
• Wyświetlanie komunikatów kontroli poprawności (664)
  • Wyświetlanie komunikatów kontroli poprawności poziomu właściwości (667)
• Użycie alternatywnych technik kontroli poprawności (668)
  • Kontrola poprawności w łączniku modelu (668)
  • Definiowanie zasad poprawności za pomocą metadanych (670)
  • Definiowanie modeli automatycznie przeprowadzających kontrolę (675)
• Użycie kontroli poprawności po stronie klienta (677)
  • Aktywowanie i wyłączanie kontroli poprawności po stronie klienta (678)
  • Użycie kontroli poprawności po stronie klienta (679)
  • Jak działa kontrola poprawności po stronie klienta? (680)
• Wykonywanie zdalnej kontroli poprawności (681)
• Podsumowanie (684)

Rozdział 26. Paczki (685)

• Utworzenie przykładowego projektu (685)
  • Dodanie pakietów NuGet (685)
  • Utworzenie modelu i kontrolera (686)
  • Utworzenie układu i widoku (687)
• Profilowanie wczytywania skryptów i arkuszy stylów (689)
• Używanie paczek stylów i skryptów (691)
  • Dodanie pakietu NuGet (691)
  • Definiowanie paczki (692)
  • Stosowanie paczek (694)
  • Optymalizacja plików JavaScript i CSS (695)
• Podsumowanie (697)

Rozdział 27. Web API i aplikacje w postaci pojedynczej strony (699)

• Aplikacja w postaci pojedynczej strony (700)
• Utworzenie przykładowego projektu (700)
  • Tworzenie modelu (701)
  • Dodanie pakietów NuGet (702)
  • Tworzenie kontrolera Home (703)
  • Dodanie układu i widoków (703)
  • Ustawienie początkowego adresu URL i przetestowanie aplikacji (705)
• Zrozumienie Web API (706)
  • Tworzenie kontrolera Web API (707)
  • Testowanie kontrolera API (707)
• Jak działa kontroler API? (709)
  • Jak wybierana jest akcja kontrolera API? (710)
  • Mapowanie metod HTTP na metody akcji (711)
• Użycie Knockout do utworzenia aplikacji typu SPA (712)
  • Dodanie bibliotek JavaScript do układu (712)
  • Implementacja podsumowania (713)
  • Implementacja funkcji tworzenia rezerwacji (719)
• Ukończenie aplikacji (722)
  • Uproszczenie kontrolera Home (722)
  • Zarządzanie wyświetlaniem zawartości (723)
• Podsumowanie (725)

Skorowidz (727)