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 Core MVC 2. Zaawansowane programowanie. Wydanie VII Język: 1

978-83-283-4600-0

Cena Brutto: 129.00

Cena netto: 122.86

Ilość:
Wersja: Drukowana
Autor Adam Freeman
Liczba_stron 1000
Wydawnictwo Helion
Oprawa oprawa twarda
Data_Wydania 2018-05-11

ASP.NET Core MVC 2

Zaawansowane programowanie. Wydanie VII


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

    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)

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