English version

Książki:

• polskie
podział tematyczny
 
• anglojęzyczne
podział tematyczny
 
Newsletter:

• Zamów informacje o nowościach z wybranego tematu
 
Informacje:

• o księgarni

• koszty wysyłki

• kontakt

• Cookies na stronie

Szukasz podpowiedzi? Nie znasz tytułu? Pomożemy Ci, napisz! Podaj adres e-mail: możesz też zadzwonić +48 512 994 090

ASP.NET MVC 5

Zaawansowane programowanie

---

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

---

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)

---

744 stron, Format: 17.0x24.5cm, oprawa twarda