reklama - zainteresowany?

ASP.NET Core MVC 2. Zaawansowane programowanie. Wydanie VII - Helion

ASP.NET Core MVC 2. Zaawansowane programowanie. Wydanie VII
ebook
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
stron: 1000, Format: ebook
Data wydania: 2018-04-01
Księgarnia: Helion

Cena książki: 64,50 zł (poprzednio: 129,00 zł)
Oszczędzasz: 50% (-64,50 zł)

Dodaj do koszyka ASP.NET Core MVC 2. Zaawansowane programowanie. Wydanie VII

Tagi: ASP | Tworzenie stron WWW

Framework ASP.NET Core MVC 2 powstał jako alternatywa ASP.NET Web Forms. Microsoft zbudował tę platformę całkowicie od podstaw. Dzięki zastosowaniu nowoczesnej architektury model - widok - kontroler programiści otrzymali narzędzie do szybszego tworzenia doskonalszego kodu. Łatwo się przekonać, że ten framework powstał wskutek kompletnej zmiany podejścia do technologii sieciowych: ASP.NET Core MVC 2 jest w pełni niezależny od platformy sprzętowej, a zastosowany wysoko produktywny model programowania zapewnia poprawną architekturę kodu, łatwe stosowanie testów jednostkowych oraz potężne możliwości rozbudowywania tworzonych systemów.

Ta książka jest kolejnym, zaktualizowanym i poprawionym wydaniem bardzo cenionego przez programistów podręcznika. Forma publikacji się nie zmieniła, jednak zawarte w niej informacje zostały gruntownie przejrzane. Wyjaśniono tu najważniejsze koncepcje frameworka ASP.NET Core MVC 2. Omówiono budowę kompletnej i w pełni funkcjonalnej aplikacji ASP.NET Core MVC 2, którą można wykorzystać w charakterze szablonu we własnych projektach. Oprócz podstaw zaprezentowano tu także bardziej zaawansowane tematy, takie jak routing URL, kontrolery RESTful, stosowanie silnika Razor i wiele innych ważnych zagadnień.

W tej książce między innymi:

  • solidne podstawy koncepcji MVC i ASP.NET Core MVC 2
  • stosowanie najlepszych funkcji ASP.NET Core MVC 2 we własnych projektach
  • praca z Visual Studio 2017, C# 7, Entity Framework 2, .NET Core 2 i Visual Studio Code
  • modyfikacja klas C# i korzystanie z kontrolerów, akcji, filtrów
  • konfiguracja ASP.NET Core Identity

Dodaj do koszyka ASP.NET Core MVC 2. Zaawansowane programowanie. Wydanie VII

 

Osoby które kupowały "ASP.NET Core MVC 2. Zaawansowane programowanie. Wydanie VII", wybierały także:

  • ASP.NET MVC. Kurs video. Poziom pierwszy. Programowanie aplikacji internetowych
  • ASP.NET Core, Angular i Bootstrap. Kompletny przybornik front-end developera
  • ASP.NET Core 2 i Angular 5. Przewodnik dla Full-Stack Web Developera
  • ASP.NET Core 2.0. Wprowadzenie

Dodaj do koszyka ASP.NET Core MVC 2. Zaawansowane programowanie. Wydanie VII

Spis treści

ASP.NET Core MVC 2. Zaawansowane programowanie. Wydanie VII eBook -- spis treści

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)

Dodaj do koszyka ASP.NET Core MVC 2. Zaawansowane programowanie. Wydanie VII

Code, Publish & WebDesing by CATALIST.com.pl



(c) 2005-2020 CATALIST agencja interaktywna, znaki firmowe należą do wydawnictwa Helion S.A.