Używamy cookies, aby ułatwić korzystanie z Portalu. Możesz określić warunki przechowywania, dostępu do plików cookies w Twojej przeglądarce. Dowiedz się więcej.
strona główna Strona główna | Nowości | Promocje | Zapowiedzi Twoje konto | Zarejestruj | Schowek | Kontakt | Pomoc
mapa działów
Szukaj: szukanie zaawansowane
Koszyk
Książki \ Programowanie \ ASP, ADO

ASP.NET MVC 5. Zaawansowane programowanie Język: 1

978-83-283-0651-6

Cena Brutto: 118.65

Cena netto: 113.00

Ilość:
Wersja: Drukowana
Autor Adam Freeman
Liczba_stron 744
Wydawnictwo Helion
Oprawa twarda
Data_Wydania 2015-07-06

ASP.NET MVC 5

Zaawansowane programowanie


Książka z serii:

ASP.NET

Książka z grupy:

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.

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. To bardzo wartościowy podręcznik dla programistów.

ASP.NET MVC 5. Zaawansowane programowanie

- co 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)
powrót
 
Produkty Podobne
Programming ASP.NET Core
ASP.NET Core MVC 2. Zaawansowane programowanie. Wydanie VII
Zestaw 2 książek z serii Tajniki (C# i .NET Framework + ASP.NET Core 2.0)
Tajniki ASP.NET Core 2.0. Wzorzec MVC, konfiguracja, routing, wdrażanie i jeszcze więcej
ASP.NET Core in 24 Hours, Sams Teach Yourself
ASP.NET Core Application Development: Building an application in four sprints
Nowoczesne API. Ewoluujące aplikacje sieciowe w technologii ASP.NET
ASP.NET MVC 5, Bootstrap i Knockout.js. Tworzenie dynamicznych i elastycznych aplikacji internetowych
ASP.NET MVC 5. Zaawansowane programowanie
ASP.NET MVC 5 with Bootstrap and Knockout.js
Więcej produktów