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
Znajdź podobne książki
Ostatnio czytane w tej kategorii
Darmowy fragment publikacji:
Tytuł oryginału: Pro ASP.NET Core MVC 2, 7th Edition
Tłumaczenie: Robert Górczyński
ISBN: 978-83-283-4600-0
Original edition copyright © 2017 by Adam Freeman
All rights reserved.
Polish edition copyright © 2018 by HELION SA.
All rights reserved.
All rights reserved. No part of this book may be reproduced or transmitted in any form or by any
means, electronic or mechanical, including photocopying, recording or by any information storage
retrieval system, without permission from the Publisher.
Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej
publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną,
fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje
naruszenie praw autorskich niniejszej publikacji.
Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi
ich właścicieli.
Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje
były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie,
ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich.
Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności
za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce.
Wydawnictwo HELION
ul. Kościuszki 1c, 44-100 GLIWICE
tel. 32 231 22 19, 32 230 98 63
e-mail: helion@helion.pl
WWW: http://helion.pl (księgarnia internetowa, katalog książek)
Pliki z przykładami omawianymi w książce można znaleźć pod adresem:
ftp://ftp.helion.pl/przyklady/aspnm7.zip
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/aspnm7
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Printed in Poland.
• Kup książkę
• Poleć książkę
• Oceń książkę
• Księgarnia internetowa
• Lubię to! » Nasza społeczność
(cid:132) (cid:132) (cid:132)
Spis tre(cid:258)ci
O autorze ........................................................................................................19
O recenzencie technicznym .............................................................................21
Cz(cid:218)(cid:258)(cid:202) I
Wprowadzenie do ASP.NET Core MVC ....................................... 23
Rozdzia(cid:239) 1. ASP.NET Core MVC w szerszym kontek(cid:258)cie .....................................................25
Historia powstania ASP.NET Core MVC ................................................................................ 25
ASP.NET Web Forms ...........................................................................................................26
Oryginalny framework MVC ..............................................................................................27
Poznajemy ASP.NET Core .......................................................................................................... 28
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(cid:239) 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
Poleć książkęKup książkęASP.NET CORE MVC 2. ZAAWANSOWANE PROGRAMOWANIE
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(cid:239) 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(cid:239) 4. Najwa(cid:285)niejsze cechy j(cid:218)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
6
Poleć książkęKup książkę (cid:132) SPIS TRE(cid:165)CI
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(cid:239) 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(cid:239) 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
7
Poleć książkęKup książkęASP.NET CORE MVC 2. ZAAWANSOWANE PROGRAMOWANIE
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
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
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
Rozdzia(cid:239) 7.
Rozdzia(cid:239) 8.
8
Poleć książkęKup książkę (cid:132) SPIS TRE(cid:165)CI
Rozdzia(cid:239) 9.
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
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(cid:239) 10. SportsStore — uko(cid:241)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(cid:239) 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
9
Poleć książkęKup książkęASP.NET CORE MVC 2. ZAAWANSOWANE PROGRAMOWANIE
Edycja produktów .............................................................................................................. 305
Dodawanie nowych produktów ....................................................................................... 317
Usuwanie produktów ......................................................................................................... 319
Podsumowanie ...........................................................................................................................322
Rozdzia(cid:239) 12. SportsStore — bezpiecze(cid:241)stwo i wdro(cid:285)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(cid:239) 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# .............................................................. 354
Utworzenie projektu ASP.NET Core .....................................................................................355
Przygotowanie projektu z użyciem Visual Studio Code ...............................................356
Zarządzanie pakietami działającymi po stronie klienta ................................................ 357
Konfigurowanie aplikacji .................................................................................................. 358
Kompilacja i uruchomienie projektu .............................................................................. 359
Odtworzenie aplikacji PartyInvites .......................................................................................359
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 ..................................................................................... 370
Wykonanie testów .............................................................................................................. 370
Podsumowanie ...........................................................................................................................371
10
Poleć książkęKup książkę (cid:132) SPIS TRE(cid:165)CI
Cz(cid:218)(cid:258)(cid:202) II
ASP.NET Core MVC 2 w szczegó(cid:239)ach ........................................ 373
Rozdzia(cid:239) 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(cid:239) 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
11
Poleć książkęKup książkęASP.NET CORE MVC 2. ZAAWANSOWANE PROGRAMOWANIE
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(cid:239) 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(cid:239) 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
12
Poleć książkęKup książkę (cid:132) SPIS TRE(cid:165)CI
Rozdzia(cid:239) 18. Wstrzykiwanie zale(cid:285)no(cid:258)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(cid:239) 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
13
Poleć książkęKup książkęASP.NET CORE MVC 2. ZAAWANSOWANE PROGRAMOWANIE
Poznajemy i zmieniamy kolejność wykonywania filtrów .............................................612
Zmiana kolejności filtrów ................................................................................................. 614
Podsumowanie ...........................................................................................................................615
Rozdzia(cid:239) 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(cid:239) 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
14
Poleć książkęKup książkę (cid:132) SPIS TRE(cid:165)CI
Rozdzia(cid:239) 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(cid:239) 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(cid:239) 24. U(cid:285)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 .......................................................................................................... 746
Praca ze znacznikami input ...............................................................................................747
Konfigurowanie znaczników input ............................................................................ 748
Formatowanie wartości danych ....................................................................................... 750
15
Poleć książkęKup książkęASP.NET CORE MVC 2. ZAAWANSOWANE PROGRAMOWANIE
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(cid:239) 25. U(cid:285)ywanie pozosta(cid:239)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(cid:239) 26. Do(cid:239)(cid:200)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(cid:239) 27. Kontrola poprawno(cid:258)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
16
Poleć książkęKup książkę (cid:132) SPIS TRE(cid:165)CI
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(cid:239) 28. Rozpocz(cid:218)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 ........................................................ 88
Pobierz darmowy fragment (pdf)
Gdzie kupić całą publikację:
ASP.NET Core MVC 2. Zaawansowane programowanie. Wydanie VII
Autor: Adam Freeman
Opinie na temat publikacji:
Inne popularne pozycje z tej kategorii:
Czytaj również:
Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką :