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
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
Designing Evolvable Web APIs with ASP.NET
Programming Microsoft ASP.NET MVC, 3rd Edition
SignalR Programming in Microsoft ASP.NET
ASP.NET Web Forms. Kompletny przewodnik dla programistów interaktywnych aplikacji internetowych w Visual Studio
ASP.NET MVC. Kompletny przewodnik dla programistów interaktywnych aplikacji internetowych w Visual Studio
Więcej produktów