O autorze (19)

O recenzencie technicznym (21)

CZĘŚĆ I. WPROWADZENIE DO ASP.NET CORE MVC (23)

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

• Historia powstania ASP.NET Core MVC (25)
  
  • ASP.NET Web Forms (26)
  • Oryginalny framework MVC (27)
• Poznajemy ASP.NET Core (27)
  
  • Co nowego w ASP.NET Core MVC 2? (28)
  • Najważniejsze zalety ASP.NET Core MVC (28)
• Co powinienem wiedzieć? (31)
• Jaka jest struktura książki? (31)
  
  • Część I. Wprowadzenie do ASP.NET Core MVC (31)
  • Część II. Szczegółowe omówienie frameworka ASP.NET Core MVC (31)
• Gdzie znajdę przykładowe fragmenty kodu? (32)
• Podsumowanie (32)

Rozdział 2. Pierwsza aplikacja MVC (33)

• Instalacja Visual Studio (33)
• Instalacja .NET Core 2.0 SDK (34)
• Tworzenie nowego projektu ASP.NET Core MVC (35)
  
  • Edycja kontrolera (38)
  • Poznajemy trasy (40)
• Generowanie stron WWW (41)
  
  • Tworzenie i generowanie widoku (41)
  • Dynamiczne dodawanie treści (43)
• Tworzenie prostej aplikacji wprowadzania danych (45)
  
  • Przygotowanie sceny (45)
  • Projektowanie modelu danych (46)
  • Utworzenie drugiej metody akcji i widoku ściśle określonego typu (47)
  • Łączenie metod akcji (48)
  • Budowanie formularza (49)
  • Obsługa formularzy (51)
  • Wyświetlenie odpowiedzi (55)
  • Dodanie kontroli poprawności danych (57)
  • Nadanie stylu zawartości (63)
• Podsumowanie (68)

Rozdział 3. Wzorzec MVC, projekty i konwencje (69)

• Historia MVC (69)
• Wprowadzenie do wzorca MVC (69)
  
  • Poznajemy model (70)
  • Poznajemy kontroler (70)
  • Poznajemy widok (71)
  • Implementacja MVC w ASP.NET (71)
• Porównanie MVC z innymi wzorcami (72)
  
  • Poznajemy wzorzec Smart UI (72)
  • Architektura model-widok (73)
  • Klasyczna architektura trójwarstwowa (74)
  • Odmiany MVC (74)
• Poznajemy projekt ASP.NET Core MVC (75)
  
  • Utworzenie projektu (76)
  • Poznajemy konwencje MVC (79)
• Podsumowanie (80)

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

• Utworzenie przykładowego projektu (82)
  
  • Dodanie obsługi ASP.NET Core MVC (82)
  • Utworzenie komponentów aplikacji ASP.NET Core MVC (84)
• Użycie operatora warunkowego null (86)
  
  • Łączenie operatorów warunkowych null (87)
  • Łączenie operatorów: warunkowego i koalescencji (88)
• Użycie automatycznie implementowanych właściwości (89)
  
  • Użycie automatycznie implementowanych metod inicjalizacyjnych właściwości (90)
  • Utworzenie automatycznie implementowanych właściwości tylko do odczytu (91)
• Interpolacja ciągu tekstowego (93)
• Użycie inicjalizatorów obiektów i kolekcji (94)
  
  • Użycie inicjalizatora indeksu (95)
• Dopasowanie wzorca (96)
  
  • Dopasowanie wzorca w konstrukcji switch (97)
• Użycie metod rozszerzających (98)
  
  • Stosowanie metod rozszerzających do interfejsów (100)
  • Tworzenie filtrujących metod rozszerzających (101)
• Użycie wyrażeń lambda (103)
  
  • Definiowanie funkcji (104)
  • Użycie wyrażeń lambda w postaci metod i właściwości (107)
• Użycie inferencji typów i typów anonimowych (109)
  
  • Użycie typów anonimowych (110)
• Użycie metod asynchronicznych (111)
  
  • Bezpośrednia praca z zadaniami (112)
  • Użycie słów kluczowych async i await (113)
• Pobieranie nazw (115)
• Podsumowanie (117)

Rozdział 5. Praca z silnikiem Razor (119)

• Utworzenie przykładowego projektu (120)
  
  • Definiowanie modelu (121)
  • Utworzenie kontrolera (121)
  • Tworzenie widoku (122)
• Korzystanie z obiektów modelu (123)
  
  • Używanie pliku poleceń importujących widoki (125)
• Praca z układami (126)
  
  • Tworzenie układu (127)
  • Stosowanie układu (129)
  • Użycie pliku ViewStart (129)
• Użycie wyrażeń Razor (131)
  
  • Wstawianie wartości danych (132)
  • Przypisanie wartości atrybutu (133)
  • Użycie konstrukcji warunkowych (134)
  • Wyświetlanie zawartości tablic i kolekcji (136)
• Podsumowanie (138)

Rozdział 6. Praca z Visual Studio (139)

• Utworzenie przykładowego projektu (139)
  
  • Utworzenie modelu (140)
  • Utworzenie kontrolera i widoku (141)
• Zarządzanie pakietami oprogramowania (142)
  
  • Poznajemy NuGet (143)
  • Poznajemy Bower (144)
• Poznajemy iteracyjny model programowania (148)
  
  • Modyfikacje widoków Razor (148)
  • Modyfikacje klas C# (149)
  • Użycie funkcji połączonych przeglądarek (157)
• Przygotowanie kodu JavaScript i CSS do wdrożenia (161)
  
  • Włączenie obsługi dostarczania treści statycznej (161)
  • Dodanie treści statycznej do projektu (162)
  • Uaktualnienie widoku (164)
  • Łączenie i minimalizacja plików w aplikacjach MVC (165)
• Podsumowanie (169)

Rozdział 7. Testy jednostkowe w aplikacji MVC (171)

• Utworzenie przykładowego projektu (172)
  
  • Włączenie obsługi wbudowanych atrybutów pomocniczych znaczników (172)
  • Dodanie akcji do kontrolera (173)
  • Utworzenie formularza do wprowadzania danych (173)
  • Uaktualnienie widoku Index (174)
• Testy jednostkowe w aplikacji MVC (175)
  
  • Utworzenie projektu testów jednostkowych (176)
  • Dodanie odwołania do projektu aplikacji (177)
  • Tworzenie i wykonywanie testów jednostkowych (177)
  • Izolowanie komponentów poddawanych testom jednostkowym (181)
• Usprawnianie testów jednostkowych (190)
  
  • Parametryzowanie testu jednostkowego (190)
  • Usprawnianie implementacji imitacji (194)
• Podsumowanie (199)

Rozdział 8. SportsStore - kompletna aplikacja (201)

• Zaczynamy (202)
  
  • Tworzenie projektu MVC (202)
  • Tworzenie projektu testów jednostkowych (206)
  • Sprawdzenie i uruchomienie aplikacji (207)
• Tworzenie modelu domeny (208)
  
  • Tworzenie repozytorium (208)
  • Tworzenie imitacji repozytorium (209)
  • Rejestrowanie usługi repozytorium (209)
• Wyświetlanie listy produktów (210)
  
  • Dodawanie kontrolera (211)
  • Dodawanie i konfigurowanie widoku (212)
  • Konfigurowanie trasy domyślnej (214)
  • Uruchamianie aplikacji (215)
• Przygotowanie bazy danych (215)
  
  • Instalowanie pakietu narzędzi Entity Framework Core (216)
  • Utworzenie klas bazy danych (217)
  • Utworzenie klasy repozytorium (217)
  • Definiowanie ciągu tekstowego połączenia (218)
  • Konfigurowanie aplikacji (219)
  • Utworzenie i zastosowanie migracji bazy danych (221)
  • Tworzenie danych początkowych (222)
• Dodanie stronicowania (225)
  
  • Wyświetlanie łączy stron (227)
  • Ulepszanie adresów URL (235)
• Dodawanie stylu (237)
  
  • Instalacja pakietu Bootstrap (237)
  • Zastosowanie w aplikacji stylów Bootstrap (237)
  • Tworzenie widoku częściowego (240)
• Podsumowanie (242)

Rozdział 9. SportsStore - nawigacja (243)

• Dodawanie kontrolek nawigacji (243)
  
  • Filtrowanie listy produktów (243)
  • Ulepszanie schematu URL (247)
  • Budowanie menu nawigacji po kategoriach (251)
  • Poprawianie licznika stron (258)
• Budowanie koszyka na zakupy (261)
  
  • Definiowanie modelu koszyka (262)
  • Tworzenie przycisków koszyka (265)
  • Włączenie obsługi sesji (267)
  • Implementowanie kontrolera koszyka (268)
  • Wyświetlanie zawartości koszyka (270)
• Podsumowanie (272)

Rozdział 10. SportsStore - ukończenie koszyka na zakupy (275)

• Dopracowanie modelu koszyka za pomocą usługi (275)
  
  • Tworzenie klasy koszyka obsługującej magazyn danych (275)
  • Rejestrowanie usługi (276)
  • Uproszczenie kontrolera koszyka na zakupy (277)
• Kończenie budowania koszyka (278)
  
  • Usuwanie produktów z koszyka (278)
  • Dodawanie podsumowania koszyka (280)
• Składanie zamówień (282)
  
  • Utworzenie klasy modelu (282)
  • Dodawanie procesu składania zamówienia (284)
  • Implementowanie mechanizmu przetwarzania zamówień (286)
  • Zakończenie pracy nad kontrolerem koszyka (290)
  • Wyświetlanie informacji o błędach systemu kontroli poprawności (293)
  • Wyświetlanie strony podsumowania (294)
• Podsumowanie (295)

Rozdział 11. SportsStore - administracja (297)

• Zarządzanie zamówieniami (297)
  
  • Usprawnienie modelu (297)
  • Dodanie akcji i widoku (298)
• Dodajemy zarządzanie katalogiem (301)
  
  • Tworzenie kontrolera CRUD (302)
  • Implementowanie widoku listy (304)
  • Edycja produktów (305)
  • Dodawanie nowych produktów (317)
  • Usuwanie produktów (319)
• Podsumowanie (322)

Rozdział 12. SportsStore - bezpieczeństwo i wdrożenie aplikacji (323)

• Zabezpieczanie funkcji administracyjnych (323)
  
  • Utworzenie bazy danych dla systemu Identity (323)
  • Zdefiniowanie prostej polityki autoryzacji (328)
  • Utworzenie kontrolera AccountController i widoków (330)
  • Przetestowanie polityki bezpieczeństwa (334)
• Wdrożenie aplikacji (334)
  
  • Utworzenie baz danych (334)
  • Przygotowanie aplikacji (336)
  • Zastosowanie migracji bazy danych (339)
  • Zarządzanie wstawieniem danych początkowych do bazy danych (340)
  • Wdrożenie aplikacji (344)
• Podsumowanie (348)

Rozdział 13. Praca z Visual Studio Code (349)

• Przygotowanie środowiska programistycznego (349)
  
  • Instalacja Node.js (349)
  • Sprawdzenie instalacji Node (351)
  • Instalacja Git (351)
  • Sprawdzenie instalacji Git (351)
  • Instalacja narzędzia bower (352)
  • Instalacja .NET Core (352)
  • Sprawdzenie instalacji .NET Core (353)
  • Instalacja Visual Studio Code (353)
  • Sprawdzenie instalacji Visual Studio Code (354)
  • Instalacja rozszerzenia Visual Studio Code C# (355)
• Utworzenie projektu ASP.NET Core (356)
• Przygotowanie projektu z użyciem Visual Studio Code (356)
  
  • Zarządzanie pakietami działającymi po stronie klienta (357)
  • Konfigurowanie aplikacji (359)
  • Kompilacja i uruchomienie projektu (359)
• Odtworzenie aplikacji PartyInvites (360)
  
  • Utworzenie modelu i repozytorium (360)
  • Utworzenie bazy danych (363)
  • Utworzenie kontrolera i widoków (365)
• Testy jednostkowe w Visual Studio Code (369)
  
  • Utworzenie testu jednostkowego (369)
  • Wykonanie testów (371)
• Podsumowanie (371)

CZĘŚĆ II. ASP.NET CORE MVC 2 W SZCZEGÓŁACH (373)

Rozdział 14. Konfigurowanie aplikacji (375)

• Utworzenie przykładowego projektu (377)
• Konfigurowanie projektu (378)
  
  • Dodawanie pakietów do projektu (379)
  • Dodawanie pakietów narzędziowych do projektu (381)
• Poznajemy klasę Program (381)
  
  • Poznajemy szczegóły konfiguracji (382)
• Poznajemy klasę Startup (385)
  
  • Poznajemy usługi ASP.NET (388)
  • Poznajemy oprogramowanie pośredniczące ASP.NET (391)
  • Poznajemy sposób wywoływania metody Configure() (401)
  • Dodawanie pozostałych komponentów oprogramowania pośredniczącego (405)
• Konfigurowanie aplikacji (410)
  
  • Użycie danych konfiguracyjnych (414)
  • Konfigurowanie systemu rejestrowania danych (416)
  • Konfigurowanie mechanizmu wstrzykiwania zależności (420)
• Konfiguracja usług MVC (421)
• Praca ze skomplikowaną konfiguracją (423)
  
  • Utworzenie oddzielnych zewnętrznych plików konfiguracyjnych (423)
  • Utworzenie różnych metod konfiguracyjnych (424)
  • Utworzenie różnych klas konfiguracyjnych (426)
• Podsumowanie (428)

Rozdział 15. Routing URL (429)

• Utworzenie przykładowego projektu (430)
  
  • Utworzenie klasy modelu (431)
  • Utworzenie przykładowych kontrolerów (431)
  • Utworzenie widoku (433)
• Wprowadzenie do wzorców URL (434)
• Tworzenie i rejestrowanie prostej trasy (435)
• Definiowanie wartości domyślnych (436)
  
  • Definiowanie osadzonych wartości domyślnych (438)
• Użycie statycznych segmentów adresu URL (440)
• Definiowanie własnych zmiennych segmentów (444)
  
  • Użycie własnych zmiennych jako parametrów metod akcji (447)
  • Definiowanie opcjonalnych segmentów URL (448)
  • Definiowanie tras o zmiennej długości (450)
• Ograniczenia tras (452)
  
  • Ograniczanie trasy z użyciem wyrażeń regularnych (456)
  • Użycie ograniczeń dotyczących typu i wartości (457)
  • Ograniczanie trasy do zbioru wartości (458)
  • Definiowanie własnych ograniczeń (460)
• Użycie atrybutów routingu (462)
  
  • Przygotowanie do użycia atrybutów routingu (462)
  • Włączanie i stosowanie atrybutów routingu (463)
  • Zastosowanie ograniczeń trasy (466)
• Podsumowanie (467)

Rozdział 16. Zaawansowane funkcje routingu (469)

• Utworzenie przykładowego projektu (470)
• Generowanie wychodzących adresów URL w widokach (471)
  
  • Wygenerowanie wychodzącego adresu URL (472)
  • Generowanie adresów URL (nie łączy) (482)
• Dostosowanie systemu routingu (484)
  
  • Zmiana konfiguracji systemu routingu (484)
  • Tworzenie własnej implementacji klasy routingu (485)
• Korzystanie z obszarów (496)
  
  • Tworzenie obszaru (496)
  • Utworzenie trasy obszaru (497)
  • Wypełnianie obszaru (498)
  • Generowanie łączy do akcji z obszarów (500)
• Najlepsze praktyki schematu adresów URL (502)
  
  • Twórz jasne i przyjazne dla człowieka adresy URL (502)
  • GET oraz POST - wybierz właściwie (503)
• Podsumowanie (503)

Rozdział 17. Kontrolery i akcje (505)

• Utworzenie przykładowego projektu (506)
  
  • Przygotowanie widoków (507)
• Poznajemy kontrolery (509)
• Tworzenie kontrolera (509)
  
  • Tworzenie kontrolera POCO (510)
  • Użycie klasy bazowej kontrolera (512)
• Pobieranie danych kontekstu (513)
  
  • Pobieranie danych z obiektów kontekstu (513)
  • Użycie parametrów metod akcji (517)
• Generowanie odpowiedzi (519)
  
  • Wygenerowanie odpowiedzi za pomocą obiektu kontekstu (519)
  • Poznajemy wyniki akcji (520)
  • Wygenerowanie odpowiedzi HTML (522)
  • Wykonywanie przekierowań (530)
  • Zwrot różnego typu treści (537)
  • Udzielanie odpowiedzi wraz z zawartością plików (540)
  • Zwracanie błędów i kodów HTTP (541)
  • Pozostałe klasy wyniku akcji (543)
• Podsumowanie (544)

Rozdział 18. Wstrzykiwanie zależności (545)

• Utworzenie przykładowego projektu (546)
  
  • Utworzenie modelu i repozytorium (547)
  • Utworzenie kontrolera i widoku (548)
  • Utworzenie projektu testów jednostkowych (550)
• Utworzenie luźno powiązanych ze sobą komponentów (550)
  
  • Analiza luźno powiązanych ze sobą komponentów (551)
• Wprowadzenie do wstrzykiwania zależności na platformie ASP.NET (557)
  
  • Przygotowanie do użycia mechanizmu wstrzykiwania zależności (557)
  • Konfigurowanie dostawcy usługi (559)
  • Testy jednostkowe kontrolera wraz ze zdefiniowaną zależnością (560)
  • Użycie łańcucha zależności (561)
  • Użycie mechanizmu wstrzykiwania zależności dla konkretnego typu (564)
• Poznajemy cykl życiowy usługi (566)
  
  • Użycie cyklu życiowego usługi (566)
  • Zastosowanie cyklu życiowego zasięgu (572)
  • Zastosowanie cyklu życiowego usługi typu singleton (573)
• Użycie wstrzyknięcia akcji (575)
• Użycie atrybutów wstrzykiwania właściwości (575)
• Ręczne żądanie obiektu implementacji (576)
• Podsumowanie (577)

Rozdział 19. Filtry (579)

• Utworzenie przykładowego projektu (580)
  
  • Włączenie szyfrowania SSL (581)
  • Utworzenie kontrolera i widoku (581)
• Użycie filtrów (583)
• Poznajemy filtry (586)
  
  • Pobieranie danych kontekstu (587)
• Użycie filtrów autoryzacji (587)
  
  • Użycie filtru autoryzacji (588)
• Użycie filtrów akcji (591)
  
  • Utworzenie filtru akcji (592)
  • Utworzenie asynchronicznego filtru akcji (593)
• Używanie filtru wyniku (594)
  
  • Utworzenie filtru wyniku (595)
  • Utworzenie asynchronicznego filtru wyniku (596)
  • Utworzenie filtru hybrydowego - akcji i wyniku (598)
• Użycie filtrów wyjątków (599)
  
  • Utworzenie filtru wyjątku (601)
• Użycie mechanizmu wstrzykiwania zależności z filtrami (603)
  
  • Spełnienie zależności filtru (603)
  • Zarządzanie cyklem życiowym filtru (607)
• Użycie filtrów globalnych (610)
• Poznajemy i zmieniamy kolejność wykonywania filtrów (612)
  
  • Zmiana kolejności filtrów (614)
• Podsumowanie (615)

Rozdział 20. Kontrolery API (617)

• Utworzenie przykładowego projektu (618)
  
  • Utworzenie modelu i repozytorium (618)
  • Utworzenie kontrolera i widoków (620)
• Poznajemy rolę kontrolerów typu RESTful (624)
  
  • Problem związany z szybkością działania aplikacji (624)
  • Problem związany z efektywnością działania aplikacji (624)
  • Problem związany z otwartością aplikacji (625)
• Poznajemy kontrolery typu API i REST (625)
  
  • Utworzenie kontrolera API (626)
  • Testowanie kontrolera API (630)
  • Użycie kontrolera API w przeglądarce WWW (635)
• Poznajemy sposoby formatowania treści (637)
  
  • Poznajemy domyślną politykę treści (637)
  • Poznajemy negocjację treści (639)
  • Określanie formatu danych akcji (641)
  • Pobranie formatu danych z trasy lub ciągu tekstowego zapytania (642)
  • Włączenie pełnej negocjacji treści (644)
  • Otrzymywanie danych w różnych formatach (645)
• Podsumowanie (646)

Rozdział 21. Widoki (647)

• Utworzenie przykładowego projektu (648)
• Tworzenie własnego silnika widoku (649)
  
  • Tworzenie własnej implementacji IView (651)
  • Tworzenie implementacji IViewEngine (652)
  • Rejestrowanie własnego silnika widoku (653)
  • Testowanie silnika widoku (654)
• Korzystanie z silnika Razor (656)
  
  • Przygotowanie przykładowego projektu (656)
  • Poznajemy widoki Razor (658)
• Dodawanie dynamicznych treści do widoku Razor (662)
  
  • Zastosowanie sekcji układu (663)
  • Użycie widoków częściowych (668)
  • Dodanie treści JSON do widoku (670)
• Konfigurowanie silnika Razor (672)
  
  • Poznajemy ekspandery widoku (673)
• Podsumowanie (678)

Rozdział 22. Komponenty widoku (679)

• Utworzenie przykładowego projektu (680)
  
  • Utworzenie modeli i repozytoriów (680)
  • Utworzenie kontrolera i widoków (682)
  • Konfigurowanie aplikacji (685)
• Poznajemy komponent widoku (686)
• Utworzenie komponentu widoku (686)
  
  • Utworzenie komponentu widoku typu POCO (687)
  • Dziedziczenie po klasie bazowej ViewComponent (688)
  • Poznajemy wynik działania komponentu widoku (690)
  • Pobieranie danych kontekstu (695)
  • Tworzenie asynchronicznego komponentu widoku (701)
• Utworzenie hybrydy - kontroler i komponent widoku (703)
  
  • Utworzenie widoku hybrydowego (704)
  • Użycie klasy hybrydowej (705)
• Podsumowanie (707)

Rozdział 23. Poznajemy atrybuty pomocnicze znaczników (709)

• Utworzenie przykładowego projektu (710)
  
  • Utworzenie modelu i repozytorium (710)
  • Utworzenie kontrolera, układu i widoków (711)
  • Konfigurowanie aplikacji (714)
• Utworzenie atrybutu pomocniczego znacznika (715)
  
  • Zdefiniowanie klasy atrybutu pomocniczego znacznika (715)
  • Rejestrowanie atrybutu pomocniczego znacznika (719)
  • Użycie atrybutu pomocniczego znacznika (719)
  • Zarządzanie zasięgiem atrybutu pomocniczego znacznika (721)
• Zaawansowane funkcje atrybutu pomocniczego znacznika (725)
  
  • Tworzenie elementów skrótu (726)
  • Umieszczanie treści przed elementem i po nim (728)
  • Pobieranie danych kontekstu widoku za pomocą mechanizmu wstrzykiwania zależności (732)
  • Praca z modelem widoku (734)
  • Koordynacja między atrybutami pomocniczymi znaczników (736)
  • Zawieszenie wygenerowania elementu (738)
• Podsumowanie (739)

Rozdział 24. Użycie atrybutów pomocniczych znaczników formularza (741)

• Przygotowanie przykładowego projektu (742)
  
  • Wyzerowanie widoków i układu (742)
• Praca ze znacznikami formularza HTML (744)
  
  • Zdefiniowanie metody docelowej formularza (745)
  • Użycie funkcji CSRF (745)
• Praca ze znacznikami <input> (747)
  
  • Konfigurowanie znaczników <input> (748)
  • Formatowanie wartości danych (750)
• Praca ze znacznikiem <label> (753)
• Praca ze znacznikami <select> i <option> (755)
  
  • Użycie źródła danych do przygotowania znacznika <select> (756)
  • Wygenerowanie znaczników <option> na podstawie typu wyliczeniowego (756)
• Praca ze znacznikiem <textarea> (761)
• Weryfikacja atrybutów pomocniczych znaczników formularza (763)
• Podsumowanie (763)

Rozdział 25. Używanie pozostałych wbudowanych atrybutów pomocniczych znaczników (765)

• Przygotowanie przykładowego projektu (766)
• Używanie atrybutu pomocniczego znacznika <environment> (767)
• Używanie atrybutów pomocniczych znaczników obsługujących pliki JavaScript i CSS (767)
  
  • Zarządzanie plikami JavaScript (768)
  • Zarządzanie arkuszami stylów CSS (777)
• Praca ze znacznikiem <a> (780)
• Praca ze znacznikiem <image> (781)
• Użycie buforowanych danych (782)
  
  • Określenie czasu wygaśnięcia buforowanej treści (785)
  • Użycie wariantów buforowania (787)
• Użycie względnego adresu URL w aplikacji (788)
• Podsumowanie (791)

Rozdział 26. Dołączanie modelu (793)

• Utworzenie przykładowego projektu (794)
  
  • Utworzenie modelu i repozytorium (794)
  • Utworzenie kontrolera i widoku (796)
  • Konfigurowanie aplikacji (797)
• Poznajemy dołączanie modelu (799)
  
  • Poznajemy dołączanie wartości domyślnej (800)
  • Dołączanie typów prostych (802)
  • Dołączanie typów złożonych (803)
  • Dołączanie tablic i kolekcji (813)
• Określanie źródła dołączania modelu (819)
  
  • Wybór standardowego źródła danych dla funkcji dołączania modelu (821)
  • Użycie nagłówków jako źródła danych dla funkcji dołączania modelu (822)
  • Użycie treści żądania jako źródła danych dla funkcji dołączania modelu (825)
• Podsumowanie (827)

Rozdział 27. Kontrola poprawności danych modelu (829)

• Utworzenie przykładowego projektu (830)
  
  • Utworzenie modelu (831)
  • Utworzenie kontrolera (832)
  • Utworzenie układu i widoków (832)
• Potrzeba stosowania kontroli poprawności danych modelu (834)
• Jawna kontrola poprawności modelu (835)
  
  • Wyświetlenie użytkownikowi błędów podczas kontroli poprawności (838)
  • Wyświetlanie komunikatów kontroli poprawności (840)
  • Wyświetlanie błędów kontroli poprawności na poziomie właściwości (843)
  • Wyświetlanie błędów kontroli poprawności na poziomie modelu (845)
• Definiowanie reguł poprawności za pomocą metadanych (848)
  
  • Tworzenie własnego atrybutu kontroli poprawności (851)
• Użycie kontroli poprawności po stronie klienta (853)
• Wykonywanie zdalnej kontroli poprawności (856)
• Podsumowanie (859)

Rozdział 28. Rozpoczęcie pracy z ASP.NET Core Identity (861)

• Utworzenie przykładowego projektu (862)
  
  • Utworzenie kontrolera i widoku (863)
• Konfiguracja ASP.NET Core Identity (865)
  
  • Utworzenie klasy użytkownika (865)
  • Utworzenie klasy kontekstu bazy danych (867)
  • Konfigurowanie ciągu tekstowego połączenia z bazą danych (867)
  • Utworzenie bazy danych systemu ASP.NET Core Identity (869)
• Używanie systemu ASP.NET Core Identity (870)
  
  • Lista kont użytkowników (870)
  • Utworzenie konta użytkownika (872)
  • Kontrola poprawności hasła (876)
  • Kontrola poprawności informacji o użytkowniku (884)
• Ukończenie przygotowania funkcji administracyjnych (889)
  
  • Implementacja funkcji usunięcia konta użytkownika (890)
  • Implementacja funkcji edycji konta użytkownika (891)
• Podsumowanie (896)

Rozdział 29. Użycie ASP.NET Core Identity (897)

• Utworzenie przykładowego projektu (897)
• Uwierzytelnianie użytkownika (898)
  
  • Przygotowanie do implementacji uwierzytelniania (900)
  • Dodanie funkcji uwierzytelniania użytkownika (903)
  • Testowanie uwierzytelniania (905)
• Uwierzytelnianie użytkownika z uwzględnieniem roli (906)
  
  • Tworzenie i usuwanie ról (907)
  • Zarządzanie użytkownikami przypisanymi do roli (912)
  • Używanie ról podczas autoryzacji (917)
• Przygotowanie bazy danych (921)
• Podsumowanie (924)

Rozdział 30. Zaawansowane funkcje ASP.NET Core Identity (925)

• Utworzenie przykładowego projektu (926)
• Dodawanie kolejnych właściwości do klasy przedstawiającej użytkownika (926)
  
  • Przygotowanie do migracji bazy danych (930)
  • Testowanie nowych właściwości (931)
• Praca z oświadczeniami i polityką (931)
  
  • Poznajemy oświadczenie (932)
  • Tworzenie oświadczenia (936)
  • Użycie polityki autoryzacji (939)
  • Użycie polityki w celu autoryzacji dostępu do zasobu (945)
• Uwierzytelnianie za pomocą dostawcy zewnętrznego (950)
  
  • Zarejestrowanie aplikacji w Google (951)
  • Włączenie uwierzytelniania za pomocą Google (951)
• Podsumowanie (956)

Rozdział 31. Konwencje dotyczące modelu i ograniczenia akcji (957)

• Utworzenie przykładowego projektu (957)
  
  • Utworzenie modelu widoku, kontrolera i widoku (958)
• Używanie modelu aplikacji i konwencji modelu (960)
  
  • Poznajemy model aplikacji (961)
  • Role konwencji modelu (965)
  • Utworzenie konwencji modelu (965)
  • Kolejność wykonywania konwencji modelu (970)
  • Utworzenie globalnych konwencji modelu (971)
• Używanie ograniczeń akcji (973)
  
  • Przygotowanie przykładowego projektu (973)
  • Poznajemy ograniczenie akcji (975)
  • Utworzenie ograniczenia akcji (976)
  • Spełnianie zależności w ograniczeniu akcji (981)
• Podsumowanie (983)

Skorowidz (985)

• Tytuł: ASP.NET Core MVC 2. Zaawansowane programowanie. Wydanie VII
• Autor: Adam Freeman
• Tytuł oryginału: Pro ASP.NET Core MVC 2, 7th Edition
• Tłumaczenie: Robert Górczyński
• ISBN: 978-83-283-4601-7, 9788328346017
• Data wydania: 2018-05-11
• Format: Ebook
• Identyfikator pozycji: aspnm7
• Wydawca: Helion