ASP.NET MVC 3 Framework. Zaawansowane programowanie

ASP.NET MVC 3 Framework. Zaawansowane programowanie

Autorzy: Steven Sanderson Adam Freeman

Wydawnictwo: Helion

Kategorie: Informatyka

Typ: e-book

Formaty: EPUB MOBI

Ilość stron: 648

cena od: 79.20 zł



Twórz rozbudowane aplikacje webowe!





ASP.NET MVC 3 to kolejny krok w ewolucji platformy ASP.NET firmy Microsoft. W tej bibliotece programowania witryn WWW połączono efektywność i schludność architektury model-widok-kontroler (MVC), najnowsze pomysły i techniki programowania zwinnego oraz najlepsze części istniejącej platformy ASP.NET. Jest ona więc alternatywą dla tradycyjnych projektów ASP.NET Web Forms i ma nad tą platformą znaczną przewagę. Szkielet ASP.NET MVC 3 pozwoli Ci błyskawicznie stworzyć skalowalne, łatwe w utrzymaniu i rozwijaniu aplikacje internetowe, a jego wykorzystanie da Ci niepowtarzalną szansę dziecinnie łatwego stosowania testów jednostkowych i podejścia TDD (ang. test driven development). Co jeszcze możesz zyskać dzięki ASP.NET MVC 3?





O tym przekonasz się w trakcie lektury tej wyjątkowej książki. Jej autorzy przyjęli słuszną, zasadę, że dobry przykład mówi więcej niż kilka stron suchej teorii. Zobaczysz więc, jak wzorzec MVC sprawdza się w praktyce, jakie są jego zalety i wady oraz jak unikać typowych pułapek. Nauczysz się korzystać z filtrów, konfigurować kontrolery oraz projektować wydajny model. W dzisiejszych czasach bezpieczeństwo aplikacji stawiane jest na pierwszym miejscu, dlatego szczególną uwagę powinieneś zwrócić na rozdział poświęcony zabezpieczaniu stworzonego przez Ciebie rozwiązania. Ta książka to kompletna pozycja dla każdego programisty ASP.NET.





Sięgnij po nią i przekonaj się, że:



  • wzorzec MVC ułatwia pracę


  • jego zastosowanie korzystnie wpływa na jakość kodu


  • bezpieczeństwo aplikacji jest najważniejsze


  • implementacja wzorca MVC nie musi być trudna!






Wykorzystaj nowoczesne wzorce w Twoich projektach!













Tytuł oryginału: Pro ASP.NET MVC 3 Framework

Tłumaczenie: Paweł Gonera

ISBN: 978-83-246-4822-1

Original edition copyright © 2011 by Adam Freeman and Steven Sanderson.

All rights reserved.

Polish edition copyright © 2012 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.

Wydawnictwo HELION dołożyło wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie bierze jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Wydawnictwo HELION nie ponosi 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/aspmv3.zip

Drogi Czytelniku!

Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres

http://helion.pl/user/opinie/aspmv3

Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.

Printed in Poland.

• Kup książkę

• Księgarnia internetowa

• Poleć książkę

• Lubię to! » Nasza społeczność

• Oceń książkę

Spis treci

O autorach ...............................................................................................................5

O recenzencie technicznym ......................................................................................7

Cz I

Wprowadzenie do ASP.NET MVC 3 .................................................. 19

Rozdzia 1.

Zagadnienia ogólne ...............................................................................................21

Krótka historia programowania witryn WWW .............................................................................. 21

Tradycyjna technologia ASP.NET Web Forms ........................................................................ 21

Co poszło nie tak z ASP.NET Web Forms? .............................................................................. 23

Programowanie witryn WWW — stan obecny .............................................................................. 23

Standardy WWW oraz REST ...................................................................................................... 24

Programowanie zwinne i sterowane testami ............................................................................ 24

Ruby on Rails ................................................................................................................................. 25

Sinatra ............................................................................................................................................. 25

Node.js ............................................................................................................................................ 25

Najważniejsze zalety ASP.NET MVC ............................................................................................... 26

Architektura MVC ........................................................................................................................ 26

Rozszerzalność .............................................................................................................................. 26

Ścisła kontrola nad HTML i HTTP ............................................................................................ 27

Łatwość testowania ....................................................................................................................... 27

Zaawansowany system routingu ................................................................................................ 28

Zbudowany na najlepszych częściach platformy ASP.NET ................................................... 28

Nowoczesne API ........................................................................................................................... 28

ASP.NET MVC jest open source ................................................................................................ 29

Kto powinien korzystać z ASP.NET MVC? ..................................................................................... 29

Porównanie z ASP.NET Web Forms ......................................................................................... 29

Migracja z Web Forms do MVC ................................................................................................ 30

Porównanie z Ruby on Rails ....................................................................................................... 30

Porównanie z MonoRail .............................................................................................................. 30

Co nowego w ASP.NET MVC 3? ...................................................................................................... 30

Podsumowanie ..................................................................................................................................... 31

Kup książkę

Poleć książkę

SPIS TRECI

Rozdzia 2.

Przygotowania ......................................................................................................33

Przygotowanie stacji roboczej ............................................................................................................ 33

Instalowanie Visual Studio 2010 ................................................................................................ 33

Instalowanie podstawowego oprogramowania ........................................................................ 34

Instalowanie opcjonalnych komponentów ............................................................................... 35

Przygotowanie serwera ....................................................................................................................... 37

Włączanie roli serwera WWW ................................................................................................... 37

Instalowanie dodatkowych komponentów ............................................................................... 38

Konfigurowanie Web Deployment ............................................................................................ 39

Uzyskiwanie dalszych informacji ...................................................................................................... 40

Podsumowanie ..................................................................................................................................... 41

Rozdzia 3.

Pierwsza aplikacja MVC .........................................................................................43

Tworzenie nowego projektu ASP.NET MVC ................................................................................. 43

Dodawanie pierwszego kontrolera ............................................................................................. 45

Przedstawiamy ścieżki .................................................................................................................. 47

Generowanie stron WWW ................................................................................................................ 47

Tworzenie i generowanie widoku .............................................................................................. 47

Dynamiczne dodawanie treści .................................................................................................... 50

Tworzenie prostej aplikacji wprowadzania danych ........................................................................ 51

Przygotowanie sceny .................................................................................................................... 51

Projektowanie modelu danych ................................................................................................... 52

Łączenie metod akcji .................................................................................................................... 53

Budowanie formularza ................................................................................................................. 55

Obsługa formularzy ...................................................................................................................... 57

Dodanie kontroli poprawności ................................................................................................... 60

Kończymy ...................................................................................................................................... 63

Podsumowanie ..................................................................................................................................... 65

Rozdzia 4.

Wzorzec MVC .........................................................................................................67

Historia MVC ....................................................................................................................................... 67

Wprowadzenie do wzorca MVC ....................................................................................................... 67

Budowa modelu domeny ............................................................................................................. 68

Implementacja MVC w ASP.NET .............................................................................................. 69

Porównanie MVC z innymi wzorcami ...................................................................................... 69

Przedstawiamy wzorzec Smart UI .............................................................................................. 69

Modelowanie domeny ......................................................................................................................... 72

Przykładowy model domeny ....................................................................................................... 73

Wspólny język ............................................................................................................................... 73

Agregaty i uproszczenia ............................................................................................................... 74

Definiowanie repozytoriów ......................................................................................................... 75

Budowanie luźno połączonych komponentów ............................................................................... 76

Wykorzystanie wstrzykiwania zależności ................................................................................. 77

Przykład specyficzny dla MVC ................................................................................................... 78

Użycie kontenera wstrzykiwania zależności ............................................................................. 79

Zaczynamy testy automatyczne ......................................................................................................... 80

Zadania testów jednostkowych ................................................................................................... 80

Zadania testów integracyjnych ................................................................................................... 87

Podsumowanie ..................................................................................................................................... 87

Rozdzia 5.

Najwaniejsze cechy jzyka ...................................................................................89

Najważniejsze cechy C# ...................................................................................................................... 89

Użycie automatycznie implementowanych właściwości ........................................................ 89

Użycie inicjalizatorów obiektów i kolekcji ................................................................................ 91

10

Kup książkę

Poleć książkę

SPIS TRECI

Użycie metod rozszerzających .................................................................................................... 93

Użycie wyrażeń lambda ............................................................................................................... 97

Automatyczne wnioskowanie typów ......................................................................................... 98

Użycie typów anonimowych ....................................................................................................... 99

Wykonywanie zapytań zintegrowanych z językiem .............................................................. 100

Przedstawiamy składnię silnika Razor ............................................................................................ 105

Tworzenie projektu .................................................................................................................... 105

Prosty widok korzystający z silnika Razor .............................................................................. 108

Podsumowanie ................................................................................................................................... 115

Rozdzia 6.

Wane narzdzia wspierajce MVC .....................................................................117

Użycie Ninject .................................................................................................................................... 117

Tworzenie projektu .................................................................................................................... 119

Zaczynamy korzystać z Ninject ................................................................................................ 119

Tworzenie łańcucha zależności ................................................................................................. 121

Definiowanie wartości właściwości i parametrów ................................................................. 122

Użycie samodzielnego łączenia ................................................................................................. 124

Dołączanie do typu pochodnego .............................................................................................. 124

Użycie łączenia warunkowego .................................................................................................. 125

Użycie Ninject w ASP.NET MVC ................................................................................................... 126

Testowanie jednostkowe w Visual Studio ...................................................................................... 128

Tworzenie projektu .................................................................................................................... 128

Tworzenie testów jednostkowych ............................................................................................ 130

Uruchamianie testów (nieudane) ............................................................................................. 133

Implementacja funkcji ............................................................................................................... 134

Użycie Moq ......................................................................................................................................... 135

Dodawanie Moq do projektu Visual Studio ........................................................................... 135

Tworzenie imitacji za pomocą Moq ......................................................................................... 135

Testy jednostkowe z użyciem Moq .......................................................................................... 137

Weryfikowanie przy użyciu Moq ............................................................................................. 139

Podsumowanie ................................................................................................................................... 139

Rozdzia 7.

SportsStore — kompletna aplikacja ....................................................................141

Zaczynamy .......................................................................................................................................... 142

Tworzenie rozwiązania i projektów w Visual Studio ............................................................ 142

Dodawanie referencji ................................................................................................................. 143

Konfigurowanie kontenera DI .................................................................................................. 144

Uruchamiamy aplikację ............................................................................................................. 145

Tworzenie modelu domeny ............................................................................................................. 146

Tworzenie abstrakcyjnego repozytorium ................................................................................ 147

Tworzenie imitacji repozytorium ............................................................................................. 148

Wyświetlanie listy produktów ......................................................................................................... 148

Dodawanie kontrolera ............................................................................................................... 148

Dodawanie widoku ..................................................................................................................... 149

Konfigurowanie domyślnej ścieżki .......................................................................................... 150

Uruchamianie aplikacji .............................................................................................................. 151

Przygotowanie bazy danych ............................................................................................................. 151

Tworzenie bazy danych ............................................................................................................. 152

Definiowanie schematu bazy danych ...................................................................................... 153

Dodawanie danych do bazy ....................................................................................................... 154

Tworzenie kontekstu Entity Framework ................................................................................. 154

Tworzenie repozytorium produktów ...................................................................................... 156

11

Kup książkę

Poleć książkę

SPIS TRECI

Dodanie stronicowania ..................................................................................................................... 157

Wyświetlanie łączy stron ........................................................................................................... 158

Ulepszanie adresów URL ........................................................................................................... 165

Dodawanie stylu ................................................................................................................................. 165

Definiowanie wspólnej zawartości w pliku układu ................................................................ 166

Dodanie zasad CSS ..................................................................................................................... 167

Tworzenie widoku częściowego ............................................................................................... 167

Podsumowanie ................................................................................................................................... 169

Rozdzia 8.

SportsStore — nawigacja i koszyk na zakupy .....................................................171

Dodawanie kontrolek nawigacji ...................................................................................................... 171

Filtrowanie listy produktów ...................................................................................................... 171

Ulepszanie schematu URL ......................................................................................................... 172

Budowanie menu nawigacji po kategoriach ........................................................................... 175

Poprawianie licznika stron ........................................................................................................ 182

Budowanie koszyka na zakupy ........................................................................................................ 184

Definiowanie encji koszyka ....................................................................................................... 185

Tworzenie przycisków koszyka ................................................................................................ 188

Implementowanie kontrolera koszyka .................................................................................... 189

Wyświetlanie zawartości koszyka ............................................................................................. 190

Użycie dołączania danych ................................................................................................................ 193

Tworzenie własnego łącznika modelu ..................................................................................... 193

Kończenie budowania koszyka ........................................................................................................ 197

Usuwanie produktów z koszyka ............................................................................................... 197

Dodawanie podsumowania koszyka ........................................................................................ 198

Składanie zamówień .......................................................................................................................... 200

Rozszerzanie modelu domeny .................................................................................................. 200

Dodawanie procesu zamawiania .............................................................................................. 201

Implementowanie procesora zamówień ................................................................................. 204

Rejestrowanie implementacji .................................................................................................... 206

Dokańczanie kontrolera koszyka ............................................................................................. 206

Wyświetlanie informacji o błędach systemu kontroli poprawności ................................... 210

Wyświetlanie strony podsumowania ....................................................................................... 210

Podsumowanie ................................................................................................................................... 212

Rozdzia 9.

SportsStore — administracja ...............................................................................213

Dodajemy zarządzanie katalogiem .................................................................................................. 213

Tworzenie kontrolera CRUD .................................................................................................... 214

Generowanie tabeli z produktami dostępnymi w repozytorium ......................................... 215

Tworzenie nowego pliku układu .............................................................................................. 216

Implementowanie widoku listy ................................................................................................ 218

Edycja produktów ....................................................................................................................... 221

Tworzenie nowych produktów ................................................................................................. 232

Usuwanie produktów ................................................................................................................. 232

Zabezpieczanie funkcji administracyjnych .................................................................................... 235

Konfiguracja uwierzytelniania Forms ..................................................................................... 235

Realizacja uwierzytelniania z użyciem filtrów ........................................................................ 236

Tworzenie dostawcy uwierzytelniania ..................................................................................... 238

Tworzenie kontrolera AccountController .............................................................................. 239

Tworzenie widoku ...................................................................................................................... 240

Przesyłanie zdjęć ................................................................................................................................ 242

Rozszerzanie bazy danych ......................................................................................................... 242

Rozszerzanie modelu domeny .................................................................................................. 244

12

Kup książkę

Poleć książkę

SPIS TRECI

Tworzenie interfejsu użytkownika do przesyłania plików ................................................... 244

Zapisywanie zdjęć do bazy danych ........................................................................................... 245

Implementowanie metody akcji GetImage ............................................................................. 246

Wyświetlanie zdjęć produktów ................................................................................................. 247

Podsumowanie ................................................................................................................................... 249

Cz II

ASP.NET MVC 3 — szczegóowy opis ............................................ 251

Rozdzia 10. Przegld projektu MVC ........................................................................................253

Korzystanie z projektów MVC z Visual Studio ............................................................................. 253

Użycie kontrolerów aplikacji internetowej i intranetowej ................................................... 256

Przedstawiamy konwencje MVC ............................................................................................. 257

Debugowanie aplikacji MVC ........................................................................................................... 258

Tworzenie projektu .................................................................................................................... 258

Uruchamianie debugera Visual Studio .................................................................................... 258

Przerywanie pracy aplikacji przez debuger Visual Studio .................................................... 260

Użycie opcji Edit and Continue ................................................................................................ 263

Wstrzykiwanie zależności na poziomie projektu .......................................................................... 266

Podsumowanie ................................................................................................................................... 268

Rozdzia 11. Adresy URL, routing i obszary ..............................................................................269

Wprowadzenie do systemu routingu .............................................................................................. 269

Tworzenie projektu routingu .................................................................................................... 270

Wprowadzenie do wzorców URL ............................................................................................ 271

Tworzenie i rejestrowanie prostej ścieżki ................................................................................ 272

Definiowanie wartości domyślnych ......................................................................................... 275

Użycie statycznych segmentów adresu URL .......................................................................... 277

Definiowanie własnych zmiennych segmentów .................................................................... 280

Definiowanie opcjonalnych segmentów URL ........................................................................ 282

Definiowanie ścieżek o zmiennej długości .............................................................................. 282

Definiowanie priorytetów kontrolerów na podstawie przestrzeni nazw ........................... 284

Ograniczenia ścieżek .................................................................................................................. 286

Routing żądań dla plików dyskowych ..................................................................................... 290

Pomijanie systemu routingu ..................................................................................................... 292

Generowanie wychodzących adresów URL ................................................................................... 293

Przygotowanie projektu ............................................................................................................. 293

Generowanie wychodzących adresów URL w widokach ...................................................... 294

Generowanie wychodzących adresów URL w metodach akcji ............................................ 299

Generowanie adresu URL na podstawie wybranej ścieżki ................................................... 300

Dostosowanie systemu routingu ..................................................................................................... 300

Tworzenie własnej implementacji RouteBase ........................................................................ 301

Tworzenie własnego obiektu obsługi ścieżki .......................................................................... 304

Korzystanie z obszarów .................................................................................................................... 305

Tworzenie obszaru ...................................................................................................................... 306

Wypełnianie obszaru .................................................................................................................. 307

Rozwiązywanie problemów z niejednoznacznością kontrolerów ....................................... 308

Generowanie łączy do akcji z obszarów .................................................................................. 310

Najlepsze praktyki schematu adresów URL .................................................................................. 310

Twórz jasne i przyjazne dla człowieka adresy URL ............................................................... 310

GET oraz POST — wybierz właściwie ..................................................................................... 311

Podsumowanie ................................................................................................................................... 312

13

Kup książkę

Poleć książkę

SPIS TRECI

Rozdzia 12. Kontrolery i akcje .................................................................................................313

Wprowadzenie do kontrolerów ....................................................................................................... 313

Przygotowanie projektu ............................................................................................................. 313

Tworzenie kontrolera z użyciem interfejsu IController ....................................................... 313

Tworzenie kontrolera przez dziedziczenie po klasie Controller .......................................... 314

Odczytywanie danych wejściowych ................................................................................................ 316

Pobieranie danych z obiektów kontekstu ................................................................................ 316

Użycie parametrów metod akcji ............................................................................................... 317

Tworzenie danych wyjściowych ...................................................................................................... 319

Wyniki akcji ................................................................................................................................. 320

Zwracanie kodu HTML przez generowanie widoku ............................................................. 322

Przekazywanie danych z metody akcji do widoku ................................................................. 327

Wykonywanie przekierowań .................................................................................................... 331

Zwracanie danych tekstowych .................................................................................................. 333

Zwracanie danych XML ............................................................................................................. 336

Zwracanie danych JSON ............................................................................................................ 336

Zwracanie plików i danych binarnych ..................................................................................... 337

Zwracanie błędów i kodów HTTP ........................................................................................... 339

Tworzenie własnego wyniku akcji ............................................................................................ 341

Podsumowanie ................................................................................................................................... 343

Rozdzia 13. Filtry ....................................................................................................................345

Użycie filtrów ..................................................................................................................................... 345

Wprowadzenie do czterech podstawowych typów filtrów ................................................... 346

Dołączanie filtrów do kontrolerów i metod akcji .................................................................. 347

Użycie filtrów autoryzacji .......................................................................................................... 348

Użycie filtrów wyjątków ............................................................................................................ 353

Użycie filtrów akcji i wyniku ..................................................................................................... 356

Użycie innych funkcji filtrów .................................................................................................... 361

Użycie filtrów wbudowanych .................................................................................................... 366

Podsumowanie ................................................................................................................................... 369

Rozdzia 14. Rozszerzanie kontrolerów ....................................................................................371

Komponenty potoku przetwarzania żądania ................................................................................. 371

Tworzenie własnej fabryki kontrolerów ......................................................................................... 372

Definiowanie własnej fabryki kontrolerów ............................................................................. 372

Rejestrowanie własnej fabryki kontrolerów ............................................................................ 374

Wykorzystanie wbudowanej fabryki kontrolerów ........................................................................ 374

Nadawanie priorytetów przestrzeniom nazw ......................................................................... 374

Dostosowywanie sposobu tworzenia kontrolerów w DefaultControllerFactory .............. 375

Tworzenie własnego obiektu wywołującego akcje ........................................................................ 377

Użycie wbudowanego obiektu wywołującego akcje ..................................................................... 378

Użycie własnych nazw akcji ...................................................................................................... 379

Selekcja metod akcji .................................................................................................................... 380

Użycie selektorów metod akcji do obsługi żądań REST ....................................................... 383

Poprawianie wydajności z użyciem specjalizowanych kontrolerów .......................................... 385

Użycie kontrolerów bezstanowych .......................................................................................... 385

Użycie kontrolerów asynchronicznych ................................................................................... 386

Podsumowanie ................................................................................................................................... 394

14

Kup książkę

Poleć książkę

SPIS TRECI

Rozdzia 15. Widoki .................................................................................................................395

Tworzenie własnego silnika widoku ............................................................................................... 395

Tworzenie własnej implementacji IView ................................................................................ 397

Tworzenie implementacji IViewEngine .................................................................................. 397

Rejestrowanie własnego silnika widoku .................................................................................. 398

Korzystanie z silnika Razor .............................................................................................................. 401

Sposób generowania widoków przez Razor ............................................................................ 401

Wstrzykiwanie zależności w widokach Razor ........................................................................ 402

Konfigurowanie wyszukiwania lokalizacji widoków ............................................................. 404

Dodawanie dynamicznych treści do widoku Razor ..................................................................... 405

Użycie kodu wbudowanego ...................................................................................................... 405

Użycie metod pomocniczych HTML .............................................................................................. 410

Tworzenie wewnętrznej metody pomocniczej HTML .......................................................... 411

Tworzenie zewnętrznej metody pomocniczej HTML ........................................................... 411

Użycie wbudowanych metod pomocniczych ......................................................................... 413

Zastosowanie sekcji ........................................................................................................................... 425

Sprawdzanie istnienia sekcji ...................................................................................................... 427

Generowanie sekcji opcjonalnych ............................................................................................ 428

Użycie widoków częściowych .......................................................................................................... 428

Tworzenie widoku częściowego ............................................................................................... 428

Użycie silnie typowanych widoków częściowych .................................................................. 430

Użycie akcji podrzędnych ................................................................................................................. 431

Tworzenie akcji podrzędnych ................................................................................................... 431

Wywoływanie akcji podrzędnych ............................................................................................. 432

Podsumowanie ................................................................................................................................... 433

Rozdzia 16. Szablony modelu .................................................................................................435

Użycie metod pomocniczych widoku szablonowego ................................................................... 435

Nadawanie stylów wygenerowanym znacznikom HTML .................................................... 438

Użycie metadanych modelu ...................................................................................................... 440

Użycie metadanych wartości danych ....................................................................................... 443

Korzystanie z parametrów typów złożonych .......................................................................... 447

Dostosowywanie systemu metod pomocniczych widoku szablonowego ................................. 448

Tworzenie własnego szablonu edytora .................................................................................... 448

Tworzenie własnego szablonu wyświetlania ........................................................................... 450

Tworzenie szablonu ogólnego .................................................................................................. 452

Wymiana szablonów wbudowanych ....................................................................................... 453

Użycie właściwości ViewData.TemplateInfo .......................................................................... 454

Przekazywanie dodatkowych metadanych do szablonu ....................................................... 455

System dostawców metadanych ...................................................................................................... 456

Tworzenie własnego dostawcy metadanych modelu ............................................................ 457

Dostosowywanie adnotacji danych dostawcy metadanych modelu ................................... 458

Podsumowanie ................................................................................................................................... 459

Rozdzia 17. Doczanie modelu ..............................................................................................461

Użycie dołączania danych ................................................................................................................ 461

Użycie domyślnego łącznika modelu .............................................................................................. 462

Dołączanie typów prostych ....................................................................................................... 463

Dołączanie typów złożonych ..................................................................................................... 464

Dołączanie tablic i kolekcji ........................................................................................................ 467

15

Kup książkę

Poleć książkę

SPIS TRECI

Jawne wywoływanie dołączania modelu ........................................................................................ 469

Ograniczanie dołączania do wybranego źródła danych ........................................................ 470

Obsługa błędów dołączania modelu ........................................................................................ 471

Użycie dołączania modelu w celu pobierania przesłanych plików ............................................ 472

Dostosowanie systemu dołączania danych .................................................................................... 472

Tworzenie własnego dostawcy wartości .................................................................................. 473

Tworzenie łącznika modelu obsługującego zależności ......................................................... 474

Tworzenie własnego łącznika modelu ..................................................................................... 475

Tworzenie dostawcy łączników modelu .................................................................................. 477

Użycie atrybutu ModelBinder .................................................................................................. 478

Podsumowanie ................................................................................................................................... 478

Rozdzia 18. Kontrola poprawnoci modelu ............................................................................479

Tworzenie projektu ........................................................................................................................... 479

Jawna kontrola poprawności modelu ............................................................................................. 481

Wyświetlanie komunikatów kontroli poprawności ..................................................................... 482

Wyświetlanie komunikatów kontroli poprawności poziomu właściwości ........................ 486

Użycie alternatywnych technik kontroli poprawności ................................................................. 487

Kontrola poprawności w łączniku modelu ............................................................................. 488

Definiowanie zasad poprawności za pomocą metadanych .................................................. 491

Definiowanie modeli samokontrolujących się ....................................................................... 494

Tworzenie własnego dostawcy kontroli poprawności ........................................................... 495

Użycie kontroli poprawności po stronie klienta ........................................................................... 499

Aktywowanie i wyłączanie kontroli poprawności po stronie klienta ................................. 499

Użycie kontroli poprawności po stronie klienta .................................................................... 502

Jak działa kontrola poprawności po stronie klienta? ............................................................. 504

Modyfikowanie kontroli poprawności na kliencie ................................................................ 505

Wykonywanie zdalnej kontroli poprawności ................................................................................ 511

Podsumowanie ................................................................................................................................... 513

Rozdzia 19. Nieprzeszkadzajcy Ajax ......................................................................................515

Użycie nieprzeszkadzających wywołań Ajax w MVC .................................................................. 515

Tworzenie projektu .................................................................................................................... 515

Włączanie i wyłączanie nieprzeszkadzających wywołań Ajax ............................................. 518

Użycie nieprzeszkadzających formularzy Ajax ...................................................................... 518

Sposób działania nieprzeszkadzających wywołań Ajax ........................................................ 520

Ustawianie opcji Ajax ........................................................................................................................ 520

Zapewnienie kontrolowanej degradacji .................................................................................. 520

Informowanie użytkownika o realizowanym żądaniu Ajax ................................................. 522

Wyświetlanie pytania przed wysłaniem żądania .................................................................... 523

Tworzenie łączy Ajax ........................................................................................................................ 524

Zapewnienie kontrolowanej degradacji dla łączy .................................................................. 526

Korzystanie z funkcji wywołania zwrotnego w Ajaksie ............................................................... 527

Wykorzystanie JSON ......................................................................................................................... 529

Dodanie obsługi JSON do kontrolera ...................................................................................... 530

Przetwarzanie JSON w przeglądarce ........................................................................................ 531

Wykrywanie żądań Ajax w metodach akcji ............................................................................ 532

Odbieranie danych JSON .......................................................................................................... 533

Podsumowanie ................................................................................................................................... 535

16

Kup książkę

Poleć książkę

SPIS TRECI

Rozdzia 20. jQuery ..................................................................................................................537

Tworzenie projektu ........................................................................................................................... 537

Odwoływanie się do jQuery ............................................................................................................. 539

Tworzenie kodu jQuery .................................................................................................................... 541

Utworzenie środowiska testowego dla jQuery ....................................................................... 542

Podstawy jQuery ................................................................................................................................ 544

Poznajemy selektory jQuery ..................................................................................................... 545

Użycie filtrów jQuery ................................................................................................................. 546

Poznajemy metody jQuery ........................................................................................................ 548

Czekając na DOM ....................................................................................................................... 549

Użycie metod CSS z jQuery ....................................................................................................... 550

Manipulowanie modelem DOM .............................................................................................. 552

Użycie zdarzeń jQuery ...................................................................................................................... 555

Użycie efektów wizualnych jQuery ................................................................................................. 556

Użycie jQuery UI ............................................................................................................................... 558

Odwoływanie się do jQuery UI ................................................................................................ 558

Tworzenie lepszych przycisków ............................................................................................... 559

Użycie kontrolki Slider .............................................................................................................. 560

Podsumowanie ................................................................................................................................... 562

Cz III

Tworzenie udanych projektów ASP.NET MVC 3 ............................. 565

Rozdzia 21. Bezpieczestwo i sabe punkty ............................................................................567

Każde dane mogą być sfałszowane .................................................................................................. 567

Fałszowanie żądań HTTP .......................................................................................................... 569

Skrypty międzywitrynowe i wstrzykiwanie HTML ...................................................................... 570

Przedstawiamy ataki XSS ........................................................................................................... 570

Kodowanie HTML w Razor ...................................................................................................... 571

Kontrola żądań ............................................................................................................................ 572

Kodowanie ciągów znaków JavaScript a XSS ......................................................................... 574

Przejęcie sesji ...................................................................................................................................... 576

Obrona przez sprawdzanie adresu IP klienta ......................................................................... 576

Obrona przez ustawienie w cookie znacznika HttpOnly ...................................................... 577

Międzywitrynowe fałszowanie żądań ............................................................................................. 577

Atak ............................................................................................................................................... 578

Obrona .......................................................................................................................................... 578

Ochrona przed atakami CSRF z użyciem metod zapobiegających fałszerstwom ............. 579

Wstrzykiwanie SQL ........................................................................................................................... 580

Atak ............................................................................................................................................... 580

Obrona z użyciem zapytań parametrycznych ........................................................................ 581

Obrona z użyciem odwzorowania obiektowo-relacyjnego .................................................. 581

Bezpieczne korzystanie z biblioteki MVC ...................................................................................... 581

Nie udostępniaj przypadkowo metod akcji ............................................................................ 581

Nie używaj dołączania modelu w celu zmiany wrażliwych właściwości ............................ 582

Podsumowanie ................................................................................................................................... 582

Rozdzia 22. Uwierzytelnianie i autoryzacja .............................................................................583

Użycie uwierzytelniania Windows .................................................................................................. 583

Użycie uwierzytelniania Forms ....................................................................................................... 585

Konfiguracja uwierzytelniania Forms ..................................................................................... 586

Uwierzytelnianie Forms bez użycia cookies ........................................................................... 587

17

Kup książkę

Poleć książkę

SPIS TRECI

Członkostwo, role i profile ............................................................................................................... 588

Konfigurowanie i wykorzystanie członkostwa ....................................................................... 589

Konfigurowanie i wykorzystanie ról ........................................................................................ 597

Konfigurowanie i wykorzystanie profili .................................................................................. 600

Dlaczego nie należy korzystać z uwierzytelniania bazującego na adresach URL ..................... 604

Ograniczanie dostępu z użyciem adresów IP oraz domen .......................................................... 604

Podsumowanie ................................................................................................................................... 606

Rozdzia 23. Instalacja .............................................................................................................607

Przygotowanie aplikacji do dystrybucji .......................................................................................... 607

Wykrywanie błędów przed instalacją ...................................................................................... 607

Kontrolowanie dynamicznej kompilacji stron ....................................................................... 608

Przygotowanie do instalacji binarnej ....................................................................................... 609

Przygotowanie pliku Web.config do przekształcania ............................................................ 609

Przygotowanie projektu do instalacji bazy danych ................................................................ 619

Podstawy działania serwera IIS ........................................................................................................ 621

Witryny Web ............................................................................................................................... 621

Katalogi wirtualne ....................................................................................................................... 621

Pule aplikacji ................................................................................................................................ 621

Wiązanie witryn z nazwami hostów, adresami IP oraz portami ......................................... 622

Przygotowanie serwera do instalacji ............................................................................................... 622

Instalowanie aplikacji ........................................................................................................................ 624

Instalowanie aplikacji przez kopiowanie plików .................................................................... 624

Użycie pakietu instalacyjnego ................................................................................................... 625

Publikowanie jednym kliknięciem ........................................................................................... 628

Podsumowanie ................................................................................................................................... 629

Skorowidz ............................................................................................................631

18

Kup książkę

Poleć książkę

R O Z D Z I A 1 8

„ „ „

Kontrola poprawnoci modelu

W poprzednim rozdziale przedstawiliśmy, w jaki sposób na podstawie żądań HTTP biblioteka MVC tworzy obiekty modelu w procesie dołączania modelu. Zakładaliśmy, że dane wprowadzone przez użytkownika były prawidłowe. W rzeczywistości użytkownicy często wprowadzają dane, z których nie możemy skorzystać, i tym zajmiemy się teraz — kontrolą poprawności danych modelu.

Kontrola poprawności modelu jest procesem, dzięki któremu upewniamy się, że otrzymane dane nadają się do użycia w modelu, a jeżeli nie, dostarczamy użytkownikom informacje pomagające rozwiązać problem.

Pierwsza część procesu — sprawdzanie otrzymanych danych — jest jednym ze sposobów zapewnienia integralności danych w modelu domeny. Przez odrzucenie danych, które nie mają sensu w kontekście naszej domeny, zapobiegamy powstawaniu dziwnych i niechcianych stanów aplikacji. Druga część — pomoc użytkownikowi w rozwiązaniu problemu — jest równie ważna. Jeżeli nie zapewnimy użytkownikowi informacji i narzędzi potrzebnych do interakcji z aplikacją w oczekiwany przez nas sposób, szybko spowodujemy jego frustrację. W przypadku aplikacji dostępnych publicznie często powoduje to wycofywanie się użytkowników, natomiast w przypadku aplikacji korporacyjnych może to skutkować spowolnieniem ich działań. Każda z tych sytuacji jest niepożądana.

Na szczęście biblioteka MVC zapewnia rozbudowaną obsługę kontroli poprawności modelu. Pokażemy teraz, w jaki sposób korzystać z podstawowych funkcji, a następnie przejdziemy do bardziej zaawansowanych technik sterowania procesem kontroli poprawności.

Tworzenie projektu

Potrzebna jest nam prosta aplikacja MVC, w której będziemy mogli stosować różne techniki kontroli poprawności modelu. Na jej potrzeby utworzyliśmy klasę modelu widoku o nazwie Appointment, zamieszczoną na listingu 18.1.

Listing 18.1. Klasa modelu widoku

using System;

using System.ComponentModel.DataAnnotations;

namespace MvcApp.Models {

public class Appointment {

public string ClientName { get; set; }

[DataType(DataType.Date)]

public DateTime Date {get; set;}

Kup książkę

Poleć książkę

CZ II „ ASP.NET MVC 3 — SZCZEGÓOWY OPIS

public bool TermsAccepted { get; set; }

}

}

Na listingu 18.2 zamieszczony jest widok generujący edytory dla klasy Appointment, zapisany w pliku MakeBooking.cshtml.

Listing 18.2. Widok edytora

@model MvcApp.Models.Appointment

@{

ViewBag.Title = "Rezerwacja";

}

<h4>Rezerwacja wizyty</h4>

@using (Html.BeginForm()) {

<p>Nazwisko: @Html.EditorFor(m => m.ClientName)</p>

<p>Data wizyty: @Html.EditorFor(m => m.Date)</p>

<p>@Html.EditorFor(m => m.TermsAccepted) Akceptuj warunki</p>

<input type="submit" value="Wylij rezerwacj" />

}

Na listingu 18.3 zamieszczona jest klasa kontrolera, AppointmentController, posiadająca metody akcji operujące na obiektach Appointment.

Listing 18.3. Klasa AppointmentController

public class AppointmentController : Controller {

private IAppointmentRepository repository;

public AppointmentController(IAppointmentRepository repo) {

repository = repo;

}

public ViewResult MakeBooking() {

return View(new Appointment { Date = DateTime.Now });

}

[HttpPost]

public ViewResult MakeBooking(Appointment appt) {

repository.SaveAppointment(appt);

return View("Completed", appt);

}

}

Kontroler realizuje znany już nam wzorzec. Metoda akcji MakeBooking generuje widok MakeBooking.cshtml.

Widok ten zawiera formularz, którego dane są przesyłane do drugiej wersji metody MakeBooking, oczekującej parametru Appointment. Łącznik modelu tworzy obiekt Appointment na podstawie wartości elementów formularza HTML, a następnie przekazuje go do metody akcji, zapisującej nowy obiekt w repozytorium, które zostanie dostarczone poprzez wstrzykiwanie zależności (utworzyliśmy tylko szkielet repozytorium — dane wizyty są ignorowane, ponieważ chcemy się tu skupić wyłącznie na kontroli poprawności). Po przekazaniu wizyty do repozytorium kontroler generuje widok Completed.cshtml, który pozwala przekazać informację zwrotną dla użytkownika. Na rysunku 18.1 przedstawiona jest ta sekwencja widoków.

480

Kup książkę

Poleć książkę

ROZDZIA 18. „ KONTROLA POPRAWNOCI MODELU

Rysunek 18.1. Kolejność widoków w przykładowej aplikacji

Obecnie nasza aplikacja będzie akceptowała dowolne przesłane przez użytkownika dane, ale aby zachować integralność aplikacji i modelu domeny, wymagamy spełnienia trzech warunków przed zaakceptowaniem przesłanych przez użytkownika danych wizyty:

x użytkownik musi podać nazwisko,

x użytkownik musi podać przyszłą datę (w formacie mm-dd-rrrr),

x użytkownik musi zaznaczyć pole wyboru informujące o zaakceptowaniu zasad.

Kontrola poprawności modelu jest procesem umożliwiającym wymuszenie tych wymagań. W kolejnych punktach pokażemy różne techniki pozwalające weryfikować dane przesłane przez użytkownika oraz przekazanie użytkownikowi informacji, dlaczego nie możemy wykorzystać dostarczonych danych.

Jawna kontrola poprawnoci modelu

Najbardziej bezpośrednim sposobem kontroli poprawności modelu jest wykonanie tej operacji w metodzie akcji.

Realizacja tego zadania jest zamieszczona na listingu 18.4.

Listing 18.4. Jawna kontrola poprawności modelu

[HttpPost]

public ViewResult MakeBooking(Appointment appt) {

if (string.IsNullOrEmpty(appt.ClientName)) {

ModelState.AddModelError("ClientName", "Prosz poda swoje nazwisko.");

}

if (ModelState.IsValidField("Date") && DateTime.Now > appt.Date) {

ModelState.AddModelError("Date", "Prosz poda przysz dat.");

}

if (!appt.TermsAccepted) {

ModelState.AddModelError("TermsAccepted", "Zaakceptowanie zasad jest wymagane.");

}

if (ModelState.IsValid) {

repository.SaveAppointment(appt);

return View("Completed", appt);

} else {

return View();

}

}

481

Kup książkę

Poleć książkę

CZ II „ ASP.NET MVC 3 — SZCZEGÓOWY OPIS

Sprawdzamy tu wartości przypisane przez łącznik modelu do właściwości obiektu parametru i rejestrujemy wszystkie znalezione błędy we właściwości ModelState, którą kontroler dziedziczy po swojej klasie bazowej.

Dla przykładu przeanalizujemy, w jaki sposób sprawdzamy właściwość ClientName:

if (string.IsNullOrEmpty(appt.ClientName)) {

ModelState.AddModelError("ClientName", "Prosz poda swoje nazwisko.");

}

Chcemy, aby użytkownik podał wartość tej właściwości, więc do jej sprawdzenia wykorzystujemy statyczną metodę string.IsNullOrEmpty. Jeżeli nie otrzymamy wartości, wywołujemy metodę ModelState.AddModelError, podając nazwę właściwości, której dotyczy błąd (ClientName), oraz komunikat, jaki powinien być wyświetlony użytkownikowi, aby mu pomóc przy rozwiązaniu problemu ( Proszę podać swoje nazwisko. ).

Za pomocą właściwości ModelState.IsValidField jesteśmy w stanie sprawdzić, czy łącznik modelu był w stanie przypisać wartość do właściwości. Wykonaliśmy to dla właściwości Date, aby upewnić się, czy łącznik modelu skonwertował przekazaną przez użytkownika wartość; jeżeli nie, nie ma sensu wykonywać dodatkowych sprawdzeń i raportować kolejnych błędów.

Po sprawdzeniu wszystkich właściwości w obiekcie modelu odczytujemy właściwość ModelState.IsValid w celu sprawdzenia, czy wystąpiły błędy. Właściwość ta ma wartość false, jeżeli zarejestrowane zostały jakiekolwiek błędy lub jeżeli łącznik modelu napotkał problemy:

if (ModelState.IsValid) {

repository.SaveAppointment(appt);

return View("Completed", appt);

} else {

return View();

}

Jeżeli nie wystąpiły błędy, zapisujemy wizytę za pomocą repozytorium i generujemy widok Completed. Jeżeli pojawiły się problemy, wywołujemy po prostu metodę View bez parametrów. Powoduje to ponowne wygenerowanie bieżącego widoku, dzięki czemu użytkownik zobaczy informacje o błędach i będzie mógł skorygować wprowadzane dane.

Metody pomocnicze widoku szablonowego używane do wygenerowania edytorów dla właściwości modelu obsługują błędy kontroli poprawności. Jeżeli dla właściwości zostanie zaraportowany błąd, metoda pomocnicza doda do pola tekstowego klasę CSS o nazwie input-validation-error. Plik ~/Content/Site.css zawiera następującą domyślną definicję tego stylu:

.input-validation-error {

border: 1px solid #ff0000;

background-color: #ffeeee;

}

Powoduje ona ustawienie czerwonej ramki oraz różowego tła w elemencie, w którym wystąpił błąd.

Na rysunku 18.2 przedstawiony jest ten efekt dla wszystkich trzech właściwości.

Wywietlanie komunikatów kontroli poprawnoci

Style CSS dołączane przez metody widoku szablonowego do elementów tekstowych informują o wystąpieniu problemu w polu, ale nie pozwalają przekazać mu danych o samym problemie. Na szczęście dostępne są inne metody pomocnicze HTML wspierające nas w tym zadaniu. Na listingu 18.5 pokazane jest użycie jednej z tych metod w widoku MakeBooking.

Listing 18.5. Użycie metody pomocniczej podsumowania

@model MvcApp.Models.Appointment

@{

ViewBag.Title = "Rezerwacja";

482

Kup książkę

Poleć książkę

ROZDZIA 18. „ KONTROLA POPRAWNOCI MODELU

Rysunek 18.2. Błędy powodują wyróżnienie elementów

Nadawanie stylu polom wyboru

Niektóre przegl darki, w tym Chrome i Firefox, ignoruj style nadawane polom tekstowym, co prowadzi do powstania niespójnego wygl du strony. Rozwi zaniem jest zast pienie szablonu edytora Boolean wasnym, umieszczonym w ~/Views/Shared/EditorTemplates/Boolean.cshtml, w którym pole wyboru jest osadzone w elemencie div. Poniej jest zamieszczony uywany przez nas szablon, ale moesz go dostosowa do swoich aplikacji:

@model bool?

@if (ViewData.ModelMetadata.IsNullableValueType) {

@Html.DropDownListFor(m => m, new SelectList(new [] {"Nie ustawiono", "Prawda", "Fasz"}, Model))

} else {

ModelState state = ViewData.ModelState[ViewData.ModelMetadata.PropertyName];

bool value = Model ?? false;

if (state != null && state.Errors.Count > 0) {

<div class="input-validation-error" style="float:left">

@Html.CheckBox("", value)

</div>

} else {

@Html.CheckBox("", value)

}

}

W szablonie tym umie cili my pole wyboru w elemencie div, do którego do czany jest styl input-

´validation-error, jeeli zostay zarejestrowane bdy modelu skojarzone z wa ciwo ci obsugiwan przez

szablon. Wicej informacji na temat wymiany szablonów edytorów znajduje si w rozdziale 16.

}

<h4>Rezerwacja wizyty</h4>

@using (Html.BeginForm()) {

@Html.ValidationSummary()

<p>Nazwisko: @Html.EditorFor(m => m.ClientName)</p>

483

Kup książkę

Poleć książkę

CZ II „ ASP.NET MVC 3 — SZCZEGÓOWY OPIS

<p>Data wizyty: @Html.EditorFor(m => m.Date)</p>

<p>@Html.EditorFor(m => m.TermsAccepted) Akceptuj warunki</p>

<input type="submit" value="Wylij rezerwacj" />

}

Metoda pomocnicza Html.ValidationSummary pozwala wyświetlić podsumowanie błędów kontroli poprawności zarejestrowanych dla strony. Jeżeli nie ma błędów, metoda pomocnicza nie generuje żadnego kodu HTML.

Na rysunku 18.3 przedstawione jest działanie pola podsumowania.

Rysunek 18.3. Wyświetlanie podsumowania kontroli poprawności

Pole podsumowania wyświetla komunikaty zarejestrowane przez metodę akcji w obiekcie ModelState.

Na listingu 18.6 zamieszczony jest kod HTML wygenerowany przez tę metodę.

Listing 18.6. Kod HTML wygenerowany przez metodę pomocniczą ValidationSummary

<div class="validation-summary-errors" data-valmsg-summary="true">

<ul>

<li>Prosz poda swoje nazwisko.</li>

<li>Prosz poda przysz dat.</li>

<li>Zaakceptowanie zasad jest wymagane.</li>

</ul>

</div>

Informacja o błędach są wyrażane jako lista umieszczona w elemencie div, do którego jest dołączona klasa CSS validation-summary-errors. Styl jest zdefiniowany w pliku ~/Content/Site.css i w razie potrzeby może być zmieniony. Domyślny styl powoduje użycie pogrubionego, czerwonego tekstu:

.validation-summary-errors {

font-weight: bold;

color: #ff0000;

}

Metoda ValidationSummary posiada kilka przeciążonych wersji; najprzydatniejsze są zamieszczone w tabeli 18.1.

Niektóre z przeciążonych wersji metody ValidationSummary pozwalają nam na wskazanie, że powinny być wyświetlone wyłącznie komunikaty o błędach na poziomie modelu. Błędy, jakie rejestrowaliśmy do tej pory w ModelState, były błędami na poziomie właściwości, co oznacza, że wystąpił problem z wartością podaną w danej właściwości i jej zmiana może rozwiązać problem.

484

Kup książkę

Poleć książkę

ROZDZIA 18. „ KONTROLA POPRAWNOCI MODELU

Tabela 18.1. Najprzydatniejsze przeciążone wersje metody ValidationSummary Przeciona metoda

Opis

Html.ValidationSummary()

Generuje podsumowanie dla wszystkich błędów.

Html.ValidationSummary(bool)

Jeżeli parametr bool ma wartość true, to wyświetlane są tylko

komunikaty o błędach poziomu modelu (patrz wyjaśnienie

pod tabelą). Jeżeli parametr ma wartość false, wyświetlane

są komunikaty o wszystkich błędach.

Html.ValidationSummary(string)

Wyświetla komunikat (przekazany w parametrze typu string)

przed podsumowaniem wszystkich błędów.

Html.ValidationSummary(bool, string)

Wyświetla komunikat przed błędami. Jeżeli parametr bool

ma wartość true, wyświetlane są wyłącznie komunikaty o błędach

poziomu modelu.

Z kolei błędy na poziomie modelu mogą być wykorzystywane, jeżeli powstaje problem z interakcją pomiędzy dwoma właściwościami (lub większą ich liczbą). Wyobraźmy sobie, że klient Jan nie może składać rezerwacji w poniedziałki. Na listingu 18.7 pokazany jest sposób wymuszenia tej zasady i raportowania problemów za pomocą błędów kontroli poprawności na poziomie modelu.

Listing 18.7. Błąd kontroli poprawności na poziomie modelu

public ViewResult MakeBooking(Appointment appt) {

if (string.IsNullOrEmpty(appt.ClientName)) {

ModelState.AddModelError("ClientName", "Prosz poda swoje nazwisko.");

}

if (ModelState.IsValidField("Date") && DateTime.Now > appt.Date) {

ModelState.AddModelError("Date", "Prosz poda przysz dat.");

}

if (!appt.TermsAccepted) {

ModelState.AddModelError("TermsAccepted", "Zaakceptowanie zasad jest wymagane.");

}

if (ModelState.IsValidField("ClientName") && ModelState.IsValidField("Date")

&& appt.ClientName == "Jan" && appt.Date.DayOfWeek == DayOfWeek.Monday) {

ModelState.AddModelError("", "Jan nie moe rezerwowa w poniedziaki.");

}

if (ModelState.IsValid) {

repository.SaveAppointment(appt);

return View("Completed", appt);

} else {

return View();

}

}

Zanim sprawdzimy, czy Jan próbuje zarezerwować wizytę na poniedziałek, korzystamy z metody ModelState.IsValidField w celu upewnienia się, że mamy prawidłowe wartości pól ClientName oraz Date. Oznacza to, że nie możemy wygenerować błędu poziomu modelu do momentu spełnienia warunków dla właściwości.

Błędy poziomu modelu rejestrujemy, podając pusty ciąg znaków ("") jako pierwszy parametr metody ModelState.AddModelError:

ModelState.AddModelError("", "Jan nie moe rezerwowa w poniedziaki."); 485

Kup książkę

Poleć książkę

CZ II „ ASP.NET MVC 3 — SZCZEGÓOWY OPIS

Użycie metody ValidationSummary z parametrem bool pozwala nam wyświetlić informacje wyłącznie o błędach na poziomie modelu, co jest pokazane na rysunku 18.4.

Rysunek 18.4. Wyświetlanie wyłącznie informacji o błędach na poziomie modelu Jak można zauważyć na rysunku, mamy tu dwa błędy kontroli poprawności. Pierwszym jest błąd na poziomie modelu, który wystąpił, gdy Jan próbował zarezerwować wizytę na poniedziałek. Drugi wynika z braku zaznaczenia pola akceptacji zasad. Ponieważ w podsumowaniu wyświetlamy wyłącznie komunikaty o błędach poziomu modelu, użytkownik nie zobaczy żadnej informacji o braku zaznaczenia opcji.

Wyświetlanie komunikatów

kontroli poprawności poziomu właściwości

Powodem ograniczania komunikatów o błędach wyświetlanych w podsumowaniu do błędów poziomu modelu jest możliwość wyświetlania komunikatów o błędach poziomu właściwości obok pól. W takim przypadku nie chcemy powielać komunikatów z poziomu właściwości. Na listingu 18.8 zamieszczony jest zaktualizowany widok MakeBooking, w którym komunikaty o błędach poziomu modelu są wyświetlane w podsumowaniu, a o błędach na poziomie właściwości — obok odpowiedniego pola.

Metoda pomocnicza Html.ValidationMessageFor wyświetla komunikaty o błędach dla poszczególnych właściwości modelu. Na rysunku 18.5 przedstawiony jest wynik działania tej metody.

Listing 18.8. Użycie komunikatów o błędach poziomu właściwości

@model MvcApp.Models.Appointment

@{

ViewBag.Title = "Rezerwacja";

}

<h4>Rezerwacja wizyty</h4>

@using (Html.BeginForm()) {

@Html.ValidationSummary(true)

<p>

Nazwisko: @Html.EditorFor(m => m.ClientName)

486

Kup książkę

Poleć książkę

ROZDZIA 18. „ KONTROLA POPRAWNOCI MODELU

@Html.ValidationMessageFor(m => m.ClientName)

</p>

<p>

Data wizyty: @Html.EditorFor(m => m.Date)

@Html.ValidationMessageFor(m => m.Date)

</p>

<p>

@Html.EditorFor(m => m.TermsAccepted) Akceptuj warunki

@Html.ValidationMessageFor(m => m.TermsAccepted)

</p>

<input type="submit" value="Wylij rezerwacj" />

}

Rysunek 18.5. Użycie komunikatów kontroli poprawności dla pojedynczych właściwości Oczywiście nie ma sensu wyświetlanie informacji o błędach z poziomu modelu obok określonej właściwości, więc umieścimy je w osobnej sekcji, wygenerowanej za pomocą metody pomocniczej Html.ValidationSummary, jak pokazano na rysunku 18.6.

Rysunek 18.6. Wyświetlanie komunikatów o błędach modelu oraz właściwości Uycie alternatywnych technik kontroli poprawnoci

Wykonywanie kontroli poprawności w metodzie akcji jest tylko jedną z technik dostępnych w bibliotece MVC.

W kolejnych punktach przedstawimy inne podejścia do tego zagadnienia.

487

Kup książkę

Poleć książkę

CZ II „ ASP.NET MVC 3 — SZCZEGÓOWY OPIS

Kontrola poprawności w łączniku modelu

Domyślny łącznik modelu wykonuje kontrolę poprawności w ramach procesu dołączania. Na rysunku 18.7

pokazane jest, co się stanie, gdy wyczyścimy pole Date i wyślemy dane formularza.

Rysunek 18.7. Komunikat kontroli poprawności z łącznika modelu

Zauważ, że dla pola Date wyświetlany jest komunikat o błędzie (wróciliśmy tu do wyświetlania wszystkich komunikatów o błędach w podsumowaniu). Komunikat ten został dodany przez łącznik modelu, ponieważ nie był on w stanie utworzyć obiektu DateTime z pustego pola formularza.

Łącznik modelu realizuje podstawową kontrolę poprawności dla każdej właściwości w obiekcie modelu.

Jeżeli wartość nie zostanie dostarczona, będzie wygenerowany komunikat pokazany na rysunku 18.7. Jeżeli podamy wartość, której nie da się przekształcić na typ właściwości modelu, wyświetlony zostanie inny komunikat (rysunek 18.8).

Rysunek 18.8. Błąd kontroli poprawności formatu wyświetlany przez łącznik modelu Wbudowana klasa łącznika modelu, DefaultModelBinder, posiada kilka użytecznych metod, które możemy nadpisać w celu dodania kontroli poprawności do łącznika. Metody te są opisane w tabeli 18.2.

Możemy nadpisać metody zamieszczone w tabeli 18.2, dodając w ten sposób logikę kontroli poprawności do łącznika. Przykład jest zamieszczony na listingu 18.9. Ilustruje on jedynie możliwość użycia tego rozwiązania, ale zalecamy korzystanie z dostawców kontroli poprawności przedstawionych w dalszej części rozdziału.

Kontrola poprawności w łączniku modelu wygląda na bardziej skomplikowaną, niż jest w rzeczywistości.

Logika kontroli poprawności jest taka sama jak w metodzie akcji. Kontrolę poprawności na poziomie właściwości realizujemy w metodzie SetProperty. Metoda ta jest wywoływana dla każdej właściwości modelu. Z punktu widzenia procesu dołączania obiekt modelu nie został w pełni utworzony, więc przy kontroli poprawności korzystamy z parametrów metody. Odczytujemy nazwę właściwości z parametru PropertyDescriptor, przypisaną wartość z parametru object, a dostęp do ModelState mamy poprzez parametr BindingContext.

488

Kup książkę

Poleć książkę

ROZDZIA 18. „ KONTROLA POPRAWNOCI MODELU

Tabela 18.2. Metody klasy DefaultModelBinder pozwalające na dodanie kontroli poprawności do procesu dołączania modelu

Metoda

Opis

Domylna implementacja

OnModelUpdated

Wywoływana w momencie,

Stosuje zasady poprawności zdefiniowane przez metadane

gdy łącznik próbuje przypisać

modelu oraz rejestruje wszystkie błędy w ModelState.

wartości do wszystkich

Użycie metadanych do kontroli poprawności zostanie

właściwości obiektu modelu.

opisane w dalszej części rozdziału.

SetProperty

Wywoływana, gdy łącznik

Jeżeli właściwość nie może zawierać wartości null, a nie

chce przypisać wartość

ma wartości do przypisania, w ModelState rejestrowany

do określonej właściwości.

jest błąd The <nazwa> field is required (rysunek 18.7).

Jeżeli istnieje wartość, która nie może być skonwertowana,

to rejestrowany jest błąd The value <wartość> is not valid

for <nazwa> (rysunek 18.8).

Listing 18.9. Dziedziczenie po klasie DefaultModelBinder w celu dodania kontroli poprawności do procesu dołączania using System;

using System.ComponentModel;

using System.Web.Mvc;

using MvcApp.Models;

namespace MvcApp.Infrastructure {

public class ValidatingModelBinder : DefaultModelBinder {

protected override void SetProperty(ControllerContext controllerContext,

ModelBindingContext bindingContext, PropertyDescriptor propertyDescriptor,

object value) {

// upewnij się, że zostanie wywołana implementacja bazowa

base.SetProperty(controllerContext, bindingContext, propertyDescriptor, value);

// wykonanie naszej kontroli poprawności na poziomie właściwości

switch (propertyDescriptor.Name) {

case "ClientName":

if (string.IsNullOrEmpty((string)value)) {

bindingContext.ModelState.AddModelError("ClientName",

"Prosz poda nazwisko.");

}

break;

case "Date":

if (bindingContext.ModelState.IsValidField("Date") &&

DateTime.Now > ((DateTime)value)) {

bindingContext.ModelState.AddModelError("Date",

"Prosz poda przysz dat.");

}

break;

case "TermsAccepted":

if (!((bool)value)) {

bindingContext.ModelState.AddModelError("TermsAccepted",

"Zaakceptowanie warunków jest obowizkowe.");

}

break;

}

}

protected override void OnModelUpdated(ControllerContext controllerContext,

ModelBindingContext bindingContext) {

489

Kup książkę

Poleć książkę

CZ II „ ASP.NET MVC 3 — SZCZEGÓOWY OPIS

// upewnij się, że zostanie wywołana implementacja bazowa

base.OnModelUpdated(controllerContext, bindingContext);

// pobierz model

Appointment model = bindingContext.Model as Appointment;

// wykonaj kontrolę poprawności na poziomie modelu

if (model != null &&

bindingContext.ModelState.IsValidField("ClientName") &&

bindingContext.ModelState.IsValidField("Date") &&

model.ClientName == "Jan" &&

model.Date.DayOfWeek == DayOfWeek.Monday) {

bindingContext.ModelState.AddModelError("",

"Jan nie moe rezerwowa w poniedziaki.");

}

}

}

}

Kontrolę poprawności na poziomie modelu realizujemy w metodzie OnModelUpdate. W tym momencie procesu dołączania wartości są przypisane do obiektu modelu, więc możemy odczytywać właściwości w celu wykonania kontroli.

„ Ostrzeenie Przy korzystaniu z cznika do realizacji kontroli poprawno ci jest wane, aby wywoa bazowe

implementacje metod SetProperty oraz OnModelUpdated. W przeciwnym razie stracimy cz wanych funkcji,

takich jak kontrola poprawno ci modelu z uyciem metadanych (przedstawiona w dalszej cz ci rozdziau).

Kolejnym krokiem jest zarejestrowanie naszego łącznika w metodzie Application_Start znajdującej się w pliku Global.asax:

protected void Application_Start() {

AreaRegistration.RegisterAllAreas();

ModelBinders.Binders.Add(typeof(Appointment), new ValidatingModelBinder()); RegisterGlobalFilters(GlobalFilters.Filters);

RegisterRoutes(RouteTable.Routes);

}

Ponieważ przenieśliśmy logikę kontroli poprawności klasy modelu Appointment do łącznika, możemy uprościć metodę akcji do postaci pokazanej na listingu 18.10.

Listing 18.10. Uproszczona metoda akcji

[HttpPost]

public ViewResult MakeBooking(Appointment appt) {

if (ModelState.IsValid) {

repository.SaveAppointment(appt);

return View("Completed", appt);

} else {

return View();

}

}

490

Kup książkę

Poleć książkę

ROZDZIA 18. „ KONTROLA POPRAWNOCI MODELU

Wszystkie błędy zarejestrowane w łączniku będą dostępne w metodzie akcji, w kolekcji ModelState. Dzięki temu możemy sprawdzić właściwość ModelState.IsValid, która będzie miała wartość false w przypadku, gdy łącznik zarejestruje błędy kontroli poprawności. Jeżeli nie występowały błędy, zapisujemy obiekt Appointment za pomocą repozytorium i generujemy widok Completed. Jeżeli wystąpiły błędy walidacji, generujemy bieżący widok i wyświetlamy komunikaty o błędach.

Definiowanie zasad poprawności za pomocą metadanych

Nie musimy definiować logiki kontroli poprawności w sposób programowy. Biblioteka MVC pozwala na użycie metadanych do definiowania zasad poprawności modelu. Zaletą użycia metadanych jest wymuszenie zasad kontroli poprawności w każdym procesie dołączania danych do klasy modelu — w przeciwieństwie do wykorzystywania pojedynczych metod akcji. Atrybuty kontroli poprawności są wykrywane i wymuszane przez wbudowaną klasę łącznika modelu, DefaultModelBinder. Atrybuty te są stosowane w klasie modelu w sposób pokazany na listingu 18.11.

Listing 18.11. Użycie atrybutów do definiowania zasad poprawności

using System;

using System.ComponentModel.DataAnnotations;

using MvcApp.Infrastructure;

namespace MvcApp.Models {

public class Appointment {

[Required]

public string ClientName { get; set; }

[DataType(DataType.Date)]

[Required(ErrorMessage="Prosz poda dat")]

public DateTime Date { get; set; }

[Range(typeof(bool), "true", "true", ErrorMessage="Zaakceptowanie warunków jest

´obowi zkowe")]

public bool TermsAccepted { get; set; }

}

}

Użyliśmy tu dwóch atrybutów kontroli poprawności — Required oraz Range. Atrybut Required powoduje powstanie błędu kontroli poprawności, jeżeli użytkownik nie poda wartości dla właściwości. Atrybut Range pozwala określić akceptowalny zakres wartości. W tabeli 18.3 zamieszczone są wbudowane atrybuty kontroli poprawności.

Wszystkie atrybuty kontroli poprawności pozwalają nam określić własny komunikat o błędzie przez ustawienie właściwości ErrorMessage, tak jak w poniższym przykładzie:

[Required(ErrorMessage="Prosz poda dat.")]

Jeżeli nie podamy własnego komunikatu o błędzie, to będzie użyty domyślny, jak pokazano na rysunkach 18.7

i 18.8. Atrybuty kontroli poprawności są dosyć proste i pozwalają wyłącznie na kontrolę poprawności na poziomie właściwości. Mimo to mamy sporo narzędzi, aby zapewnić spójne działanie tego mechanizmu. Weźmy pod uwagę atrybut zastosowany dla właściwości TermsAccepted.

[Range(typeof(bool), "true", "true", ErrorMessage="Zaakceptowanie warunków jest obowizkowe.")]

public bool TermsAccepted { get; set; }

Chcemy upewnić się, że użytkownik zaznaczy pole wyboru zaakceptowania warunków. Nie możemy użyć atrybutu Required, ponieważ metody pomocnicze widoku szablonowego generują ukryte pole HTML w celu upewnienia się, że otrzymamy wartość nawet w przypadku, gdy pole nie jest zaznaczone. Aby ominąć ten problem, 491

Kup książkę

Poleć książkę

CZ II „ ASP.NET MVC 3 — SZCZEGÓOWY OPIS

Tabela 18.3. Wbudowane atrybuty kontroli poprawności

Atrybut

Przykad

Opis

Compare

[Compare("MyOtherProperty")]

Dwie właściwości muszą mieć taką samą

wartość. Jest to przydatne, jeżeli prosimy

użytkownika o dwukrotne podanie tej samej

danej, na przykład adresu e-mail lub hasła.

Range

[Range(10, 20)]

Wartość numeryczna (lub właściwość typu

implementującego IComparable) musi mieć

wartość pomiędzy podanym minimum

i maksimum. Aby zdefiniować granicę tylko

z jednej strony, należy użyć stałych MinValue

lub MaxValue — na przykład

[Range(int.MinValue, 50)].

RegularExpression

[RegularExpression("wzorzec")]

Wartość znakowa musi pasować

do zdefiniowanego wyrażenia regularnego. Zwróć

uwagę, że wzorzec musi pasować do całego

wyrażenia podanego przez użytkownika, a nie

tylko do jego fragmentu. Domyślnie dopasowania

rozpoznają wielkie i małe litery, ale można

to zmienić, dodając modyfikator (?i) — czyli

[RegularExpression("(?i) wzorzec")].

Required

[Required]

Wartość musi być niepusta lub być ciągiem

znaków zawierającym tylko spacje. Jeżeli chcesz

traktować białe znaki jako prawidłową zawartość,

użyj [Required(AllowEmptyStrings = true)].

StringLength

[StringLength(10)]

Wartość znakowa musi być nie dłuższa niż

podana wartość maksymalna. Możemy również

określić minimalną długość: [StringLength(10,

MinimumLength=2)].

użyliśmy atrybutu Range, który pozwala określić typ oraz górną i dolną granicę w postaci wartości znakowych.

Przez ustawienie obu granic na true utworzyliśmy odpowiednik atrybutu Required dla właściwości bool edytowanej za pomocą pola wyboru.

„ Wskazówka Atrybut DataType nie moe by uywany do kontroli poprawno ci danych uytkownika — stanowi

wy cznie podpowied przy emitowaniu warto ci z zastosowaniem metod pomocniczych widoku szablonowego

(opisanych w rozdziale 16.). Dlatego nie naley oczekiwa, e atrybut DataType(DataType.EmailAddress) pozwoli wymusi odpowiedni format.

Tworzenie wasnego atrybutu kontroli poprawnoci

Sztuczka z użyciem atrybutu Range do odtworzenia działania atrybutu Required jest nieco dziwna. Na szczęście nie jesteśmy ograniczeni wyłącznie do wbudowanych atrybutów; można również tworzyć własne przez odziedziczenie po klasie ValidationAttribute i implementację własnej logiki kontroli poprawności. Przykład takiej klasy jest zamieszczony na listingu 18.12.

Listing 18.12. Tworzenie własnego atrybutu kontroli poprawności

public class MustBeTrueAttribute : ValidationAttribute {

public override bool IsValid(object value) {

492

Kup książkę

Poleć książkę

ROZDZIA 18. „ KONTROLA POPRAWNOCI MODELU

return value is bool && (bool)value;

}

}

Nasz nowy atrybut zmienia metodę IsValid z klasy bazowej. Jest to metoda wywoływana przez łącznik, do której przekazywana jest wartość wprowadzona przez użytkownika. W tym przykładzie nasza logika kontroli poprawności jest prosta — wartość jest prawidłowa, jeżeli jest typu bool o wartości true. Aby poinformować, że wartość jest prawidłowa, zwracamy true z metody isValid. Atrybutu tego możemy użyć w poniższy sposób:

[MustBeTrue(ErrorMessage="Zaakceptowanie warunków jest obowi zkowe.")]

public bool TermsAccepted { get; set; }

Jest to przyjemniejsze i łatwiejsze niż nadużywanie atrybutu Range. Możemy również dziedziczyć po wbudowanych atrybutach kontroli poprawności w celu rozszerzania zakresu ich funkcji. Na listingu 18.13

pokazujemy, jak wykorzystać atrybut Required do upewnienia się, że została podana data spełniająca nasze wymagania.

Listing 18.13. Dziedziczenie po wbudowanym atrybucie kontroli poprawności public class FutureDateAttribute : RequiredAttribute {

public override bool IsValid(object value) {

return base.IsValid(value) &&

value is DateTime &&

((DateTime)value) > DateTime.Now;

}

}

Oprócz funkcji zawartej w klasie bazowej dodaliśmy własną logikę kontroli poprawności. Atrybutu tego używamy identycznie jak poprzedniego:

[DataType(DataType.Date)]

[FutureDate(ErrorMessage="Prosz poda przysz dat.")]

public DateTime Date { get; set; }

Tworzenie wasnego atrybutu kontroli poprawnoci modelu

Przedstawione do tej pory atrybuty poprawności odnoszą się do poszczególnych właściwości modelu, co oznacza, że możemy generować tylko błędy kontroli poprawności na poziomie właściwości. Możemy również użyć metadanych do kontroli poprawności całego modelu w sposób pokazany na listingu 18.14.

Listing 18.14. Atrybuty kontroli poprawności modelu

public class AppointmentValidatorAttribute : ValidationAttribute {

public AppointmentValidatorAttribute() {

ErrorMessage = "Jan nie moe rezerwowa w poniedziaki.";

}

public override bool IsValid(object value) {

Appointment app = value as Appointment;

if (app == null || string.IsNullOrEmpty(app.ClientName) || app.Date == null) {

// nie mamy modelu właściwego typu lub nie mamy

// wartości wymaganych właściwości ClientName oraz Date

return true;

} else {

return !(app.ClientName == "Jan" && app.Date.DayOfWeek == DayOfWeek.Monday); 493

Kup książkę

Poleć książkę

CZ II „ ASP.NET MVC 3 — SZCZEGÓOWY OPIS

}

}

}

Parametr object przekazany przez łącznik modelu do metody IsValid powinien być typu Appointment.

Nasz atrybut kontroli poprawności modelu dołączamy do samej klasy modelu:

[AppointmentValidator]

public class Appointment {

[Required]

public string ClientName { get; set; }

[DataType(DataType.Date)]

[FutureDate(ErrorMessage="Prosz poda przysz dat.")]

public DateTime Date { get; set; }

[MustBeTrue(ErrorMessage="Zaakceptowanie warunków jest obowizkowe.")]

public bool TermsAccepted { get; set; }

}

Nasz atrybut kontroli poprawności modelu nie będzie używany, jeżeli jakikolwiek z atrybutów poziomu właściwości zarejestrował błąd poprawności. Nie jest to dokładnie ten sam efekt, jaki osiągnęliśmy, umieszczając kod kontroli poprawności w metodzie akcji. Powoduje to ryzyko wydłużania procesu poprawiania błędów przez użytkownika. Jeżeli użytkownik na przykład poda wartości dla właściwości ClientName oraz Date, ale nie zaznaczy pola dla warunków, to atrybut MustBeTrue spowoduje wyświetlenie komunikatu o błędzie poprawności; jest on pokazany w lewej części rysunku 18.9.

Rysunek 18.9. Stopniowe zgłaszanie problemów z wartościami wejściowymi Użytkownik poprawia błąd i ponownie wysyła dane — po czym otrzymuje inny komunikat, pokazany w prawej części rysunku 18.9. Z perspektywy użytkownika niejawnie akceptujemy wartość dla nazwiska i daty, nie oznaczając ich jako błędnych w pierwszym panelu. Może się to wydawać niewielkim problemem, ale warto przeanalizować każdą sytuację, która może frustrować użytkowników.

Definiowanie modeli samokontrolujących się

Inną techniką kontroli poprawności jest utworzenie modeli samokontrolujących się, w których kod weryfikacji poprawności jest częścią klasy modelu. Samokontrolujące się klasy modelu tworzymy przez zaimplementowanie interfejsu IValidatableObject w sposób pokazany na listingu 18.15.

494

Kup książkę

Poleć książkę

ROZDZIA 18. „ KONTROLA POPRAWNOCI MODELU

Listing 18.15. Samokontrolująca się klasa modelu

public class Appointment : IValidatableObject {

public string ClientName { get; set; }

[DataType(DataType.Date)]

public DateTime Date { get; set; }

public bool TermsAccepted { get; set; }

public IEnumerable<ValidationResult> Validate(ValidationContext validationContext) {

List<ValidationResult> errors = new List<ValidationResult>(); if (string.IsNullOrEmpty(ClientName)) {

errors.Add(new ValidationResult("Prosz poda nazwisko."));

}

if (DateTime.Now > Date) {

errors.Add(new ValidationResult("Prosz poda przysz dat."));

}

if (errors.Count == 0 && ClientName == "Jan"

&& Date.DayOfWeek == DayOfWeek.Monday) {

errors.Add(new ValidationResult("Jan nie moe rezerwowa w poniedziaki."));

}

if (!TermsAccepted) {

errors.Add(new ValidationResult("Zaakceptowanie warunków jest obowi zkowe."));

}

return errors;

}

}

Interfejs IValidatableObject definiuje jedną z metod, Validate. Metoda ta otrzymuje parametr ValidationContext; choć typ ten nie jest specyficzny dla MVC, to nie ma problemów z jego użyciem. Wynikiem metody Validate jest kolekcja obiektów ValidationResult, z których każdy reprezentuje pojedynczy błąd kontroli poprawności.

Jeżeli nasza klasa modelu implementuje interfejs IValidatableObject, to metoda Validate zostanie wywołana po przypisaniu wartości do każdej z właściwości modelu. Podejście to łączy ze sobą elastyczność umieszczenia logiki kontroli poprawności w metodzie akcji ze spójnością wywoływania przez proces dołączania modelu przy tworzeniu obiektów modelu. Niektórzy programiści nie lubią umieszczać logiki kontroli poprawności w klasie modelu, ale uważamy, że nieźle pasuje to do wzorca projektowego MVC — dodatkowo podoba się nam elastyczność i spójność.

Tworzenie własnego dostawcy kontroli poprawności

Alternatywnym podejściem do kontroli poprawności jest utworzenie własnego dostawcy kontroli poprawności.

Realizujemy to przez odziedziczenie po klasie ModelValidationProvider i nadpisanie metody GetValidators.

Na listingu 18.16 zamieszczony jest nasz dostawca kontroli poprawności, którego nazwaliśmy CustomValidationProvider.

495

Kup książkę

Poleć książkę

CZ II „ ASP.NET MVC 3 — SZCZEGÓOWY OPIS

Listing 18.16. Własna klasa dostawcy kontroli poprawności

public class CustomValidationProvider : ModelValidatorProvider {

public override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context) {

if (metadata.ContainerType == typeof(Appointment)) {

return new ModelValidator[] {

new AppointmentPropertyValidator(metadata, context)

};

} else if (metadata.ModelType == typeof(Appointment)) {

return new ModelValidator[] {

new AppointmentValidator(metadata, context)

};

}

return Enumerable.Empty<ModelValidator>();

}

}

Metoda GetValidation jest wywoływana jeden raz dla każdej właściwości modelu, a następnie dla całego modelu. Wynikiem metody jest lista obiektów ModelValidator. Każdy ze zwróconych obiektów ModelValidator będzie użyty do zweryfikowania właściwości lub modelu.

Możemy zdefiniować metodę GetValidation w dowolny sposób. Jeżeli nie chcemy oferować kontroli poprawności dla właściwości lub modelu, to po prostu zwracamy pustą listę. Aby zademonstrować funkcję dostawcy kontroli poprawności, zdecydowaliśmy się zaimplementować jeden obiekt dla właściwości klasy Appointment oraz jeden dla klasy Appointment.

Aby sprawdzić, do jakich celów został wywołany obiekt kontroli poprawności, odczytujemy wartość właściwości ModelMetadata przekazanej do metody jako parametr. Dostępne trzy parametry tej metody są opisane w tabeli 18.4.

Tabela 18.4. Przydatne właściwości klasy ModelMetadata

Waciwo

Opis

ContainerType

Gdy zostaniemy poproszeni o dostarczenie obiektu kontroli poprawności dla właściwości, zwraca typ zawierającego ją modelu. Jeżeli na przykład jesteśmy proszeni o obiekt kontroli poprawności dla właściwości Appointment.ClientName, ContainerType będzie zwracać typ klasy Appointment.

PropertyName

Zwraca nazwę właściwości, dla której dostarczany jest obiekt kontroli poprawności.

Jeżeli na przykład jesteśmy proszeni o obiekt kontroli poprawności dla właściwości Appointment.ClientName, PropertyType będzie zwracać wartość ClientName.

ModelType

Jeżeli jesteśmy proszeni o obiekt kontroli poprawności dla modelu, to ta właściwość będzie zwracać typ obiektu modelu.

„ Wskazówka Poniszy przykad pokazujemy wy cznie jako ilustracj sposobu do czania wasnych dostawców kontroli poprawno ci do biblioteki. Nie powiniene uywa tej techniki w zwykych scenariuszach kontroli poprawno ci,

w których zastosowanie atrybutów metadanych lub IValidatableObject bdzie wystarczaj ce i znacznie prostsze.

Z dostawców kontroli poprawno ci powinno si korzysta wy cznie w skomplikowanych scenariuszach, na przykad

przy dynamicznym adowaniu zasad poprawno ci z bazy danych lub implementowaniu wasnej biblioteki kontroli

poprawno ci.

Na listingu 18.17 zamieszczona jest nasza klasa dziedzicząca po ModelBinder, używana dla właściwości.

496

Kup książkę

Poleć książkę

ROZDZIA 18. „ KONTROLA POPRAWNOCI MODELU

Listing 18.17. Obiekt kontroli poprawności działający na poziomie właściwości public class AppointmentPropertyValidator : ModelValidator {

public AppointmentPropertyValidator(ModelMetadata metadata, ControllerContext context)

: base(metadata, context) {

}

public override IEnumerable<ModelValidationResult> Validate(object container) {

Appointment appt = container as Appointment;

if (appt != null) {

switch (Metadata.PropertyName) {

case "ClientName":

if (string.IsNullOrEmpty(appt.ClientName)) {

return new ModelValidationResult[] {

new ModelValidationResult {

MemberName = "ClientName",

Message = "Prosz poda nazwisko."

}};

}

break;

case "Date":

if (appt.Date == null || DateTime.Now > appt.Date) {

return new ModelValidationResult[] {

new ModelValidationResult {

MemberName = "Date",

Message = "Prosz poda przysz dat."

}};

}

break;

case "TermsAccepted":

if (!appt.TermsAccepted) {

return new ModelValidationResult[] {

new ModelValidationResult {

MemberName = "TermsAccepted",

Message = "Zaakceptowanie warunków jest obowizkowe."

}};

}

break;

}

}

return Enumerable.Empty<ModelValidationResult>();

}

}

Obiekt ModelData przekazany do konstruktora informuje o tym, którą właściwość powinna kontrolować dana instancja klasy AppointmentPropertyValidator. Po wywołaniu metody Validate przełączamy się na wartość Metadata.PropertyName i wykonujemy odpowiednią weryfikację. Jeżeli wystąpi błąd, zwracamy listę zawierającą jeden obiekt ModelValidationResult. System kontroli poprawności modelu pozwala na zwrócenie w razie potrzeby różnych błędów, ale nie potrzebujemy tego, ponieważ wykonujemy tylko jedno sprawdzenie dla każdej właściwości klasy Appointment.

Proces kontroli poprawności całego modelu jest nieco inny. Na listingu 18.18 zamieszczona jest klasa kontroli poprawności.

497

Kup książkę

Poleć książkę

CZ II „ ASP.NET MVC 3 — SZCZEGÓOWY OPIS

Listing 18.18. Obiekt kontroli poprawności działający na poziomie modelu public class AppointmentValidator : ModelValidator {

public AppointmentValidator(ModelMetadata metadata, ControllerContext context)

: base(metadata, context) {

}

public override void Validate(Appointment container,

IList<ModelValidationResult> errors) {

Appointment appt = (Appointment)Metadata.Model;

if (appt.ClientName == "Jan" && appt.Date.DayOfWeek == DayOfWeek.Monday) {

errors.Add(new ModelValidationResult {

MemberName = "",

Message = "Jan nie moe rezerwowa w poniedziaki."

});

}

}

}

W czasie kontroli modelu nie istnieje kontener, więc jego parametr ma wartość null. Na początek odczytujemy model z właściwości Modeldata.Model, a następnie wykonujemy kontrolę poprawności. Aby zaraportować błąd na poziomie modelu, ustawiamy właściwość MemberName w obiekcie ModelValidationResult na pusty ciąg znaków ("").

„ Wskazówka Biblioteka MVC wywoa nasz obiekt kontroli poprawno ci modelu wy cznie wtedy, gdy aden z obiektów

kontroli poprawno ci nie zwróci bdu. Jest to rozs dne, poniewa bazuje na zaoeniu, e nie mona sprawdza poprawno ci modelu, jeeli wyst piy bdy we wa ciwo ciach.

Rejestrowanie wasnego dostawcy kontroli poprawnoci

Musimy teraz zarejestrować własnego dostawcę kontroli poprawności w bibliotece MVC, co realizujemy w metodzie Application_Start znajdującej się w pliku Globlal.asax. Na listingu 18.19 zamieszczony jest sposób rejestracji naszej klasy dostawcy kontroli poprawności dla klasy Appointment.

Listing 18.19. Rejestrowanie własnego dostawcy kontroli poprawności

protected void Application_Start() {

AreaRegistration.RegisterAllAreas();

ModelValidatorProviders.Providers.Add(new CustomValidationProvider());

RegisterGlobalFilters(GlobalFilters.Filters);

RegisterRoutes(RouteTable.Routes);

}

Naszą klasę dodajemy do zbioru dostawców kontroli poprawności za pomocą metody

ModelValidatorProviders.Providers.Add. Nasz dostawca będzie użyty równolegle z wbudowanymi dostawcami, co oznacza, że można również wykorzystać inne techniki przedstawione w tym rozdziale. Jeżeli chcesz usunąć pozostałych dostawców, możesz to zrobić za pomocą metody Clear, zanim dodasz własnego dostawcę.

ModelValidatorProviders.Providers.Clear();

498

Kup książkę

Poleć książkę

ROZDZIA 18. „ KONTROLA POPRAWNOCI MODELU

Uycie kontroli poprawnoci po stronie klienta

Do tej pory demonstrowaliśmy techniki kontroli poprawności będące przykładami kontroli poprawności po stronie serwera. Techniki te wymagają przesłania danych na serwer, skontrolowania ich na serwerze, a następnie odesłania wyniku kontroli (informacji o udanym przetworzeniu danych lub listy błędów wymagających skorygowania).

W aplikacji WWW użytkownicy wymagają zwykle szybkiej kontroli poprawności — bez konieczności wysyłania czegokolwiek na serwer. Taki mechanizm kontroli poprawności po stronie klienta jest zwykle implementowany z użyciem JavaScriptu. Dane wprowadzone przez użytkownika są kontrolowane przed wysłaniem na serwer, dzięki czemu reakcja aplikacji jest natychmiastowa i użytkownik od razu może korygować problemy.

Biblioteka MVC wspiera nieprzeszkadzającą kontrolę poprawności po stronie klienta. Słowo nieprzeszkadzająca oznacza, że zasady kontroli poprawności są wyrażane za pomocą atrybutów dodawanych do generowanych elementów HTML. Są one interpretowane przez bibliotekę JavaScript będącą częścią biblioteki MVC, wykorzystującą wartości atrybutów do skonfigurowania biblioteki jQuery Validation, która realizuje faktyczną kontrolę poprawności.

„ Wskazówka W MVC 3 skorzystano z biblioteki jQuery Validation, natomiast we wcze niejszych wersjach uywane

byy biblioteki JavaScript napisane w firmie Microsoft. Nie byy one najlepsze i cho s nadal dostpne w bibliotece, nie ma powodu z nich korzysta.

Słowo nieprzeszkadzający jest używane powszechnie w kontekście kodu JavaScript. Jest to luźny termin wskazujący na trzy cechy kodu. Pierwszą jest oddzielenie kodu JavaScript realizującego kontrolę poprawności od elementów HTML, dzięki czemu nie musimy dołączać logiki kontroli poprawności do naszych widoków, a generowany kod HTML jest czytelniejszy.

Drugą cechą jest realizacja kontroli poprawności z użyciem progresywnego rozszerzania. Oznacza to, że w przypadku braku obsługi wszystkich funkcji JavaScript przez przeglądarkę kontrola poprawności będzie realizowana z zastosowaniem prostszych technik. Jeżeli użytkownik na przykład zablokował JavaScript, to będzie wykorzystywana kontrola poprawności po stronie serwera bez wpływania w jakikolwiek sposób na działanie aplikacji (nie będą wyświetlane nieprzyjemne komunikaty o błędach ani nie będzie wymagane wykonanie dodatkowych akcji).

Trzecią cechą jest użycie zbioru praktyk pozwalających na ograniczenie wpływu niespójności w działaniu przeglądarek. Do tego tematu wrócimy w czasie przedstawiania biblioteki jQuery w rozdziale 20.

W kolejnych punktach pokażemy, w jaki sposób działają wbudowane mechanizmy kontroli poprawności, oraz zademonstrujemy sposoby ich rozszerzenia w celu zapewnienia własnych mechanizmów kontroli poprawności po stronie klienta.

„ Wskazówka Kontrola poprawno ci po stronie klienta skupia si na weryfikowaniu pojedynczych wa ciwo ci. Faktycznie

trudno jest skonfigurowa kontrol poprawno ci po stronie klienta dla modelu, uywaj c mechanizmów dostarczonych

w bibliotece MVC. Z tego powodu wikszo aplikacji MVC 3 korzysta z kontroli poprawno ci po stronie klienta

dla wa ciwo ci i bazuje na kontroli poprawno ci po stronie serwera dla caego modelu, stosuj c jedn z technik

przedstawionych w poprzedniej cz ci tego rozdziau.

Aktywowanie i wyłączanie kontroli poprawności po stronie klienta

Kontrola poprawności po stronie klienta jest sterowana za pomocą dwóch ustawień w pliku Web.config, pokazanych na listingu 18.20.

Listing 18.20. Sterowanie kontrolą poprawności po stronie klienta

<configuration>

<appSettings>

<add key="ClientValidationEnabled" value="true"/> 499

Kup książkę

Poleć książkę

CZ II „ ASP.NET MVC 3 — SZCZEGÓOWY OPIS

<add key="UnobtrusiveJavaScriptEnabled" value="true"/>

</appSettings>

...

Aby kontrola poprawności po stronie klienta działała, oba te ustawienia muszą mieć wartość true. Podczas generowania projektu MVC 3 Visual Studio tworzy te wpisy i przypisuje im wartość true. Możemy na przykład programowo kontrolować te ustawienia w pliku Global.asax w sposób pokazany na listingu 18.21.

Listing 18.21. Programowe sterowanie kontrolą poprawności po stronie klienta protected void Application_Start() {

AreaRegistration.RegisterAllAreas();

HtmlHelper.ClientValidationEnabled = true;

HtmlHelper.UnobtrusiveJavaScriptEnabled = true;

RegisterGlobalFilters(GlobalFilters.Filters);

RegisterRoutes(RouteTable.Routes);

}

Możemy również włączać i wyłączać kontrolę poprawności po stronie klienta dla pojedynczych widoków.

Powoduje to nadpisanie pokazanych powyżej opcji konfiguracji. Na listingu 18.22 przedstawiony jest sposób sterowania programowego wewnątrz bloku kodu Razor, w którym wyłączamy kontrolę poprawności dla danego widoku.

Listing 18.22. Sterowanie kontrolą poprawności po stronie klienta dla pojedynczego widoku

@model MvcApp.Models.Appointment

@{

ViewBag.Title = "Rezerwacja";

HtmlHelper.ClientValidationEnabled = false;

}

...

Oba te ustawienia muszą mieć wartość true, aby działała kontrola poprawności po stronie klienta, co oznacza, że wystarczy jedno z nich ustawić na false, aby wyłączyć funkcję. Ponadto należy upewnić się, że są dodane odwołania do trzech bibliotek JavaScript, wyróżnionych na listingu 18.23.

Listing 18.23. Odwołania do bibliotek JavaScript wymaganych do kontroli poprawności po stronie klienta

<!DOCTYPE html>

<html>

<head>

<title>@ViewBag.Title</title>

<link href="@Url.Content("~/Content/Site.css")" rel="stylesheet" type="text/css" />

<script src="@Url.Content("~/Scripts/jquery-1.5.1.min.js")"

type="text/javascript"></script>

<script src="@Url.Content("~/Scripts/jquery.validate.min.js")"

type="text/javascript"></script>

<script src="@Url.Content("~/Scripts/jquery.validate.unobtrusive.min.js")"

type="text/javascript"></script>

</head>

<body>

500

Kup książkę

Poleć książkę

ROZDZIA 18. „ KONTROLA POPRAWNOCI MODELU

@RenderBody()

</body>

</html>

Możemy dodawać te pliki do każdego widoku, w którym chcemy użyć kontroli poprawności po stronie klienta, ale zwykle prościej jest umieścić te odwołania w pliku układu, tak jak na zamieszczonym listingu.

„ Ostrzeenie Kolejno , w której s umieszczone pliki jQuery, jest znacz ca. Jeeli j zmienisz, okae si, e kontrola poprawno ci po stronie klienta nie dziaa.

Katalog scripts zawiera dwie wersje każdej z bibliotek JavaScript. Wersje, których nazwy kończą się na min.js, są wersjami zminimalizowanymi, co oznacza, że wszystkie odstępy, komentarze i inne niekrytyczne dane są usunięte, co zmniejsza rozmiar pliku biblioteki. Wersje zminimalizowane mogą być znacznie mniejsze i zwykle są używane w środowiskach produkcyjnych w celu ograniczenia ilości danych pobieranych przez klienta. W czasie tworzenia aplikacji zwykle są wykorzystywane wersje niezminimalizowane, dzięki czemu można debugować (lub po prostu czytać) JavaScript w przypadku wystąpienia problemów.

Uycie CDN dla bibliotek JavaScript

Na listingu 18.22 odwoujemy si do bibliotek jQuery znajduj cych si w folderze ~/Scripts naszej aplikacji.

Alternatywnym podej ciem jest zaadowanie tych plików z sieci Content Delivery Network (CDN) firmy Microsoft.

Jest to usuga bezpatna. Dostpnych jest kilka rozsianych geograficznie serwerów, które obsuguj dania pobrania plików bibliotek JavaScript dla aplikacji MVC, uywaj c serwera znajduj cego si najbliej uytkownika.

Istnieje kilka zalet korzystania z CDN. Otó czas, jaki zajmuje zaadowanie aplikacji przez przegl dark uytkownika, moe si zmniejszy, poniewa serwery CDN s szybsze i znajduj si bliej uytkownika ni serwery aplikacji.

Dodatkowo zalety te cz si, jeeli uytkownik pobra ju wymagane pliki w innej aplikacji, która korzysta z plików z tej samej lokalizacji CDN. Kolejn zalet jest zmniejszenie obci enia serwera oraz zuycia cza wykorzystywanego do dostpu do aplikacji. Pliki jQuery s zwykle najwikszymi elementami, jakie musimy dostarczy do przegl darki w ramach aplikacji MVC, wic w przypadku pobierania tych plików z serwerów firmy Microsoft zmniejszamy wasne koszty. Aby skorzysta z CDN, musimy zmieni atrybut src znacznika script, by wskazywa

na nastpuj ce adresy URL:

http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.5.1.min.js

http://ajax.aspnetcdn.com/ajax/jquery.validate/1.7/jquery.validate.min.js

http://ajax.aspnetcdn.com/ajax/mvc/3.0/jquery.validate.unobtrusive.min.js

Dla przykadu znacznik script odwouj cy si do podstawowej biblioteki jQuery bdzie wygl da nastpuj co:

<script src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.5.1.min.js"

type="text/javascript"></script>

Serwery CDN obsuguj wiele obsuguj wiele wersji biblioteki jQuery, wic dla kadego pliku musimy wybra prawidowy adres URL. List dostpnych plików (oraz ich adresów URL) mona zobaczy na stronie www.asp.net/ajaxlibrary/cdn.ashx.

Usuga CDN jest przydatna w aplikacjach udostpnianych w internecie, ale jeeli projekt jest przeznaczony dla intranetu, to uycie CDN nie ma wikszego sensu. W takim przypadku szybciej i taniej jest pobra biblioteki JavaScript z serwera aplikacji.

501

Kup książkę

Poleć książkę

CZ II „ ASP.NET MVC 3 — SZCZEGÓOWY OPIS

Użycie kontroli poprawności po stronie klienta

Po włączeniu kontroli poprawności po stronie klienta i upewnieniu się, że w widoku istnieją odwołania do biblioteki jQuery, możemy zacząć weryfikację danych użytkownika. Najprostszym sposobem realizacji tego zadania jest użycie atrybutów metadanych wykorzystywanych wcześniej do kontroli poprawności po stronie serwera, takich jak Required, Range czy StringLength. Na listingu 18.24 zamieszczona jest klasa modelu Appointment z dodanymi tymi adnotacjami.

Listing 18.24. Atrybuty kontroli poprawności zastosowane w klasie modelu Appointment public class Appointment {

[Required]

[StringLength(10, MinimumLength=3)]

public string ClientName { get; set; }

[DataType(DataType.Date)]

[Required(ErrorMessage="Prosz poda dat")]

public DateTime Date { get; set; }

public bool TermsAccepted { get; set; }

}

Więcej informacji na temat tych atrybutów można znaleźć w punkcie „Definiowanie zasad poprawności za pomocą metadanych”, we wcześniejszej części rozdziału. Mechanizmy kontroli poprawności działające po stronie klienta wyświetlają błędy kontroli poprawności nieco inaczej w przypadku użycia podsumowań oraz komunikatów, więc zmodyfikowaliśmy widok MakingBooking, aby korzystał z obu mechanizmów (listing 18.25).

Listing 18.25. Dodanie podsumowania kontroli poprawności oraz elementów do formularza HTML

@model MvcApp.Models.Appointment

@{

ViewBag.Title = "Rezerwacja";

}

<h4>Rezerwacja wizyty</h4>

@using (Html.BeginForm()) {

@Html.ValidationSummary()

<p>Nazwisko: @Html.EditorFor(m => m.ClientName)

@Html.ValidationMessageFor(m => m.ClientName)</p>

<p>Data wizyty: @Html.EditorFor(m => m.Date)

@Html.ValidationMessageFor(m => m.Date)</p>

<p>@Html.EditorFor(m => m.TermsAccepted) Akcepuj warunki

@Html.ValidationMessageFor(m => m.TermsAccepted)</p>

<input type="submit" value="Wylij rezerwacj" />

}

Gdy otrzymamy żądanie wywołujące metodę akcji MakeBooking z naszego kontrolera, generujemy widok MakeBooking.cshtml — jest to standardowe działanie. Jednak gdy klikniemy przycisk wysłania danych, zasady kontroli poprawności danych dodane do klasy Appointment będą wykorzystywane w przeglądarce z użyciem JavaScript, jak pokazano na rysunku 18.10.

502

Kup książkę

Poleć książkę

ROZDZIA 18. „ KONTROLA POPRAWNOCI MODELU

Rysunek 18.10. Komunikaty o błędach kontroli poprawności po stronie klienta Wyświetlane komunikaty wyglądają identycznie jak te generowane po stronie serwera, ale do ich wygenerowania nie była konieczna komunikacja z serwerem. Jeżeli masz serwer i przeglądarkę zainstalowaną na tym samym komputerze, trudno jest zauważyć różnicę w szybkości działania, ale w przypadku połączeń internetowych lub zatłoczonych sieci korporacyjnych różnica może być spora. Istnieje również jeszcze jedna różnica. Kontrola poprawności po stronie klienta jest wykonywana przy pierwszej próbie przesłania danych formularza, ale później jest realizowana po każdym naciśnięciu klawisza lub zmianie fokusu w formularzu HTML.

Gdy wpiszemy literę J do pola ClientName, spowoduje to spełnienie warunku z atrybutu Required dodanego do tej właściwości w klasie Appointment. Jednak zauważone jest naruszenie zasady z atrybutu StringLength, więc obok pola pojawia się następny komunikat, pokazany na rysunku 18.11.

Rysunek 18.11. Automatyczna aktualizacja komunikatów kontroli poprawności po stronie klienta Komunikat o błędzie obok pola się zmienił. Nie wykonaliśmy żadnych specjalnych akcji, aby się to stało; po prostu wpisaliśmy znak do pola. Kontrola poprawności została wykonana ponownie i wyświetlił się komunikat o nowym błędzie.

„ Wskazówka Zwró uwag, e podsumowanie kontroli poprawno ci utworzone za pomoc metody

Html.ValidationSummary nie zmienia si — nie jest ono aktualizowane do momentu ponownego kliknicia przycisku Wy lij rezerwacj. To wa nie mieli my na my li, mówi c, e podsumowania dziaaj inaczej ni komunikaty

dla wa ciwo ci w przypadku uycia kontroli poprawno ci po stronie klienta.

503

Kup książkę

Poleć książkę

CZ II „ ASP.NET MVC 3 — SZCZEGÓOWY OPIS

Kontynuujemy pisanie i gdy dojdziemy do litery n w słowie Jan, spełnione zostaną obie zasady poprawności zdefiniowane dla właściwości ClientName w klasie Appointment. Została podana wartość mająca długość od trzech do dziesięciu znaków. W tym momencie komunikaty o błędach przy polu znikają, a wyróżnienie pola jest usuwane, jak pokazano na rysunku 18.12.

Rysunek 18.12. Automatyczne usuwanie sygnalizacji błędów kontroli poprawności Użytkownik otrzymuje natychmiastową informację o błędzie kontroli poprawności, ponadto komunikat o błędzie jest aktualizowany w czasie wprowadzania danych. Trudno to pokazać w postaci serii ekranów, ale jest to znacznie bardziej przyjazny sposób kontroli poprawności danych. Nie tylko zapewnia lepsze działanie interfejsu użytkownika, ale również oznacza, że aplikacja otrzymuje mniej żądań POST, które muszą być przetworzone przez serwer. Gdy mamy satysfakcjonującą nas wartość właściwości ClientName, ponownie przesyłamy dane formularza. Jest to jedyny moment, w którym jest aktualizowane podsumowanie, co jest pokazane na rysunku 18.13.

Rysunek 18.13. Przesłanie danych formularza aktualizuje podsumowanie kontroli poprawności Rzadsza aktualizacja podsumowań powoduje, że są one mniej atrakcyjne niż komunikaty przy polach, szczególnie gdy dla pola jest zdefiniowanych kilka zasad poprawności. Nie oznacza to, że nie powinniśmy używać podsumowań, ale należy to robić rozważnie, biorąc pod uwagę efekt, jaki zobaczą użytkownicy.

Jak działa kontrola poprawności po stronie klienta?

Jedną z zalet użycia funkcji kontroli poprawności po stronie klienta w bibliotece MVC jest brak konieczności tworzenia kodu JavaScript. Zamiast tego zasady poprawności są definiowane za pomocą atrybutów HTML.

504

Kup książkę

Poleć książkę

ROZDZIA 18. „ KONTROLA POPRAWNOCI MODELU

Poniżej zamieszczony jest kod HTML wygenerowany przez metodę pomocniczą Html.EditorFor dla właściwości ClientName przy wyłączonej kontroli poprawności po stronie klienta.

<input class="text-box single-line" id="ClientName" name="ClientName"

type="text" value="" />

Po włączeniu kontroli poprawności i wygenerowaniu edytora otrzymamy następujący kod:

<input class="text-box single-line" data-val="true" data-val-length="The field ClientName must be

´a string with a minimum length of 3 and a maximum length of 10." data-val-length-max="10"

´data-val-length-min="3" data-val-required="The ClientName field is required." id="ClientName"

ńame="ClientName" type="text" value="" />

Kontrola poprawności po stronie klienta nie generuje bezpośrednio żadnego kodu JavaScript ani danych JSON sterujących procesem kontroli poprawności; podobnie jak w pozostałych częściach biblioteki MVC

są wykorzystywane konwencje.

Pierwszym dodanym atrybutem jest data-val. Biblioteka jQuery Validation identyfikuje pola wymagające kontroli poprawności przez wyszukiwanie tego atrybutu.

Poszczególne zasady poprawności są specyfikowane za pomocą atrybutu w postaci data-val-< nazwa>, gdzie nazwa jest zasadą do zastosowania. Na przykład atrybut Required dodany do klasy modelu powoduje wygenerowanie w HTML-u atrybutu data-val-required. Wartość skojarzona z atrybutem stanowi komunikat o błędzie skojarzony z zasadą. Niektóre zasady wymagają dodatkowych atrybutów. Można zauważyć, że definicja długości pola została przekształcona na atrybuty data-val-length-min oraz data-val-length-max, w których zdefiniowana została minimalna i maksymalna długość napisu.

Interpretacja zasad poprawności jest realizowana przez bibliotekę jQuery Validation, na bazie której są zbudowane mechanizmy kontroli poprawności po stronie klienta.

Jedną z lepszych cech kontroli poprawności po stronie klienta jest użycie tych samych atrybutów do tworzenia zasad poprawności wykorzystywanych po stronie klienta oraz po stronie serwera. Oznacza to, że dane w przeglądarkach nieobsługujących JavaScriptu podlegają takiej samej kontroli poprawności jak w przeglądarkach obsługujących ten język, bez wykonywania żadnych dodatkowych operacji.

Modyfikowanie kontroli poprawności na kliencie

Wbudowana obsługa kontroli poprawności na kliencie sprawdza się bardzo dobrze, ale jest ograniczona do sześciu atrybutów zamieszczonych w tabeli 18.3, we wcześniejszej części rozdziału. Biblioteka jQuery Validation obsługuje nieco więcej zasad poprawności, a biblioteka nieprzeszkadzającej kontroli poprawności w MVC pozwala nam skorzystać z nich przy stosunkowo niewielkim nakładzie pracy.

Jawne tworzenie atrybutów kontroli poprawnoci w HTML

Najbardziej bezpośrednią metodą wykorzystania dodatkowych zasad poprawności jest ręczne wygenerowanie w widoku wymaganych atrybutów, jak pokazano na listingu 18.26.

Listing 18.26. Ręczne generowanie atrybutów kontroli poprawności w HTML

@model MvcApp.Models.Appointment

@{

ViewBag.Title = "Rezerwacja";

}

<h4>Rezerwacja wizyty</h4>

@using (Html.BeginForm()) {

@Html.ValidationSummary()

505

Kup książkę

Poleć książkę

CZ II „ ASP.NET MVC 3 — SZCZEGÓOWY OPIS

Kontrola poprawnoci po stronie klienta w MVC a kontrola poprawnoci w jQuery Funkcja kontroli poprawno ci po stronie klienta w bibliotece MVC jest zbudowana w oparciu o bibliotek jQuery Validation i jeeli masz takie yczenie, moesz korzysta z niej bezpo rednio, ignoruj c funkcje MVC. Biblioteka

ta jest bardzo elastyczna i bogata w moliwo ci. Warto si z ni zapozna, choby po to, aby zrozumie, jak mona

modyfikowa funkcje MVC w celu najlepszego moliwego wykorzystania dostpnych opcji kontroli poprawno ci.

Do uycia biblioteki jQuery Validation niezbdna jest pewna znajomo JavaScriptu. Poniej zamieszczony jest przykad

wymaganego skryptu.

$(document).ready(function () {

$('form').validate({

errorLabelContainer: '#validtionSummary',

wrapper: 'li',

rules: {

ClientName: {

required: true,

}

},

messages: {

ClientName: "Prosz poda nazwisko."

}

});

});

Funkcje kontroli poprawno ci po stronie klienta dostpne w MVC ukrywaj kod JavaScript, a dodatkowo

pozwalaj realizowa identyczne funkcje kontroli poprawno ci na kliencie i serwerze. Oba podej cia mog by

wykorzystane w aplikacji MVC, cho powinni my ostronie podchodzi do ich mieszania w jednym widoku, poniewa

mog pojawi si niechciane interakcje. Wicej informacji na temat biblioteki jQuery Validation mona znale na stronie http://bassistance.de/jquery-plugins.

<p>Nazwisko:

@Html.TextBoxFor(m => m.ClientName, new { data_val = "true", data_val_email = "Podaj prawidowy adres e-mail.",

data_val_required = "Podaj swoje nazwisko."})

@Html.ValidationMessageFor(m => m.ClientName)</p>

<p>Data wizyty: @Html.EditorFor(m => m.Date)

@Html.ValidationMessageFor(m => m.Date)</p>

<p>@Html.EditorFor(m => m.TermsAccepted) Akceptuj warunki

@Html.ValidationMessageFor(m => m.TermsAccepted)</p>

<input type="submit" value="Wylij rezerwacj" />

}

Jeżeli chcemy dodać kolejne atrybuty do znacznika, nie możemy użyć metod pomocniczych widoku szablonowego do wygenerowania właściwości dla edytora, więc zamiast tego zastosowaliśmy metodę Html.TextBoxFor w wersji akceptującej typ anonimowy z atrybutami HTML.

„ Wskazówka Segmenty nazw atrybutów HTML s rozdzielane cznikami (-), ale cznik jest znakiem nielegalnym w nazwach zmiennych C#. Aby obej ten problem, podajemy nazwy atrybutów z uyciem podkre le (_), które

s automatycznie konwertowane na czniki w czasie generowania kodu HTML.

506

Kup książkę

Poleć książkę

ROZDZIA 18. „ KONTROLA POPRAWNOCI MODELU

Po wygenerowaniu widoku otrzymamy następujący kod HTML dla właściwości ClientName:

<input data-val="true" data-val-email="Podaj prawidowy adres e-mail."

data-val-required="Podaj swoje nazwisko." id="ClientName"

name="ClientName" type="text" value="" />

Zasada required jest również generowana przez atrybut Required. Zasada email pozwala upewnić się, że wartość prowadzona do pola ma format prawidłowego adresu e-mail. W tabeli 18.5 opisane są zasady kontroli poprawności, z których możemy skorzystać.

Tabela 18.5. Użyteczne zasady kontroli poprawności dostępne w jQuery Zasada

Atrybut kontroli

Opis

poprawnoci

poprawnoci

Required

Required

Wymaga podania wartości; jest to zasada wykorzystywana przez

atrybut Required.

Length

StringLength

Liczba znaków w podanej wartości musi być większa lub równa

minimum i (lub) mniejsza lub równa maksimum. Minimalna długość

jest definiowana za pomocą atrybutu data-val-length-min, a maksymalna

długość za pomocą atrybutu data-val-length-max. Możemy podać

jedynie atrybut –min lub –max, co spowoduje ograniczenie tylko jednego

aspektu długości wartości.

Range

Range

Wartość musi znajdować się pomiędzy granicami zdefiniowanymi

za pomocą atrybutów data-val-required-min i data-val-required-max.

Można podać tylko jeden z tych atrybutów, co spowoduje kontrolę

tylko górnego lub dolnego limitu wartości.

Regex

RegularExpression

Wartość musi pasować do wyrażenia regularnego zdefiniowanego

za pomocą atrybutu data-val-regexp-pattern.

Equalto

Compare

Wartość musi być taka sama jak wartość w elemencie wskazanym

za pomocą atrybutu data-val-equalto-other.

Email

-

Wartość musi być prawidłowym adresem e-mail.

Url

-

Wartość musi być prawidłowym adresem URL.

Date

-

Wartość musi być prawidłową datą.

Number

-

Wartość musi być liczbą (może zawierać cyfry po przecinku).

Digits

-

Wartość musi zawierać wyłącznie cyfry.

Creditcard

-

Wartość musi być prawidłowym numerem karty kredytowej.

Zasady kontroli poprawności, dla których nie istnieją odpowiednie atrybuty C#, pozwalają na sprawdzenie formatu, ale nie są w stanie sprawdzić, czy wartość jest naprawdę prawidłowa. Na przykład zasada poprawności creaditcard sprawdza, czy wartość jest w prawidłowym formacie dla numeru karty kredytowej oraz czy wartość spełnia schemat kodowania Luhn, który jest używany do sprawdzania sumy kontrolnej. Oczywiście nie ma gwarancji, że wartość podana przez użytkownika reprezentuje kartę kredytową faktycznie wydaną przez instytucję finansową.

Podobnie zasady email oraz url pozwalają sprawdzić, czy format adresu e-mail lub URL jest prawidłowy, ale nie sprawdzają, czy konto e-mail lub strona WWW są dostępne. Jeżeli potrzebujesz bardziej rygorystycznej kontroli, to przydatną funkcją jest zdalna kontrola poprawności, którą przedstawimy w dalszej części rozdziału.

507

Kup książkę

Poleć książkę

CZ II „ ASP.NET MVC 3 — SZCZEGÓOWY OPIS

Tworzenie atrybutów modelu obsugujcych kontrol poprawnoci

po stronie klienta

Dodawanie atrybutów HTML do naszych elementów widoku jest proste, ale powoduje, że kontrola poprawności jest realizowana wyłącznie po stronie klienta. Możemy temu przeciwdziałać przez wykonanie tej samej kontroli w metodzie akcji lub łączniku, ale lepszą techniką jest utworzenie własnego atrybutu kontroli poprawności, który działa w taki sam sposób jak wbudowane atrybuty i uruchamia kontrolę poprawności realizowaną na serwerze i kliencie. Na listingu 18.27 zamieszczony jest atrybut kontroli poprawności realizujący kontrolę formatu adresu e-mail na serwerze.

Listing 18.27. Atrybut kontroli poprawności realizujący kontrolę poprawności formatu adresu e-mail na serwerze public class EmailAddressAttribute : ValidationAttribute {

private static readonly Regex emailRegex = new Regex(".+@.+\\..+");

public EmailAddressAttribute() {

ErrorMessage = "Podaj prawidowy adres e-mail.";

}

public override bool IsValid(object value) {

return !string.IsNullOrEmpty((string)value) &&

emailRegex.IsMatch((string)value);

}

}

Jest to podejście takie same jak w przypadku tworzenia atrybutów kontroli poprawności po stronie serwera, które przedstawialiśmy we wcześniejszej części rozdziału. Tworzymy klasę dziedziczącą po ValidationAttribute i zmieniamy metodę IsValid, w której umieszczamy naszą logikę kontroli poprawności.

„ Uwaga Aby zachowa prostot, w przykadzie tym uyli my bardzo prostego wyraenia regularnego do kontroli

adresu e-mail. W sieci mona atwo znale bardziej zaawansowane wzorce.

Aby umożliwić działanie kontroli poprawności po stronie klienta, musimy zaimplementować interfejs IClientValidatable, zamieszczony na listingu 18.28.

Listing 18.28. Interfejs IClientValidatable

public interface IClientValidatable {

IEnumerable<ModelClientValidationRule> GetClientValidationRules(

ModelMetadata metadata, ControllerContext context);

}

Interfejs ten definiuje jedną metodę, GetClientValidationRules, która zwraca listę obiektów ModelClientValidationRule. Każdy obiekt ModelClientValidationRule opisuje zasadę kontroli poprawności po stronie klienta, jaką należy zastosować, komunikat o błędzie wyświetlany w przypadku złamania tej zasady oraz wszystkie inne parametry wymagane do jej działania. Na listingu 18.29 zamieszczony jest kod ilustrujący sposób dodania kontroli poprawności po stronie klienta w klasie EmailAddressAttribute z listingu 18.27.

Listing 18.29. Dodanie obsługi strony klienckiej w klasie EmailAddressAttribute public class EmailAddressAttribute : ValidationAttribute, IClientValidatable {

private static readonly Regex emailRegex = new Regex(".+@.+\\..+");

public EmailAddressAttribute() {

508

Kup książkę

Poleć książkę

ROZDZIA 18. „ KONTROLA POPRAWNOCI MODELU

ErrorMessage = "Podaj prawidowy adres e-mail.";

}

public override bool IsValid(object value) {

return !string.IsNullOrEmpty((string)value) &&

emailRegex.IsMatch((string)value);

}

public IEnumerable<ModelClientValidationRule> GetClientValidationRules(

ModelMetadata metadata, ControllerContext context) {

return new List<ModelClientValidationRule> {

new ModelClientValidationRule {

ValidationType = "email",

ErrorMessage = this.ErrorMessage

},

new ModelClientValidationRule {

ValidationType = "required",

ErrorMessage = this.ErrorMessage

}

};

}

}

Możemy zwrócić tyle obiektów ModelClientValidationRule potrzebnych do zdefiniowania zbioru zasad po stronie klienta, ile potrzeba do wymuszenia naszych zasad poprawności. W przedstawionym przykładzie użyliśmy zasad email oraz required (ustawiając właściwość ValidationType w obiekcie ModelClientValidationRule), które korzystają z komunikatu o błędzie zdefiniowanego w atrybucie (za pomocą właściwości ErrorMessage).

Nasz nowy atrybut możemy przypisać do klasy modelu identycznie jak każdy inny atrybut kontroli poprawności: public class Appointment {

[EmailAddress]

public string ClientName { get; set; }

...

Gdy tworzony jest edytor dla właściwości ClientName, silnik widoku analizuje użyte przez nas metadane, wyszukuje naszą implementację IClientValidatable i generuje atrybuty HTML przedstawione w poprzednim punkcie. Przesłane dane są ponownie sprawdzane za pomocą naszej metody IsValid. Nasz nowy atrybut jest używany do kontroli poprawności zarówno na serwerze, jak i na kliencie, co jest przyjemniejsze, bezpieczniejsze i bardziej spójne niż jawne generowanie atrybutów HTML.

Tworzenie wasnych zasad poprawnoci na kliencie

Przedstawione w tabeli 18.5 wbudowane zasady kontroli poprawności na kliencie są użyteczne, ale nie wyczerpują wszystkich możliwości. Na szczęście możesz przygotować własne zasady, jeżeli jesteś w stanie napisać kilka wierszy kodu JavaScript.

Obsługa kontroli poprawności na kliencie jest ograniczona w bibliotece MVC do zasad dostępnych w bazowej bibliotece jQuery. Sprowadza się to do tego, że możemy dostosowywać istniejące zasady na wiele sposobów, ale jeżeli chcemy utworzyć coś bardziej skomplikowanego, musimy zostawić wbudowaną obsługę kontroli poprawności z MVC i operować bezpośrednio na jQuery. Mimo że mamy narzucone ograniczenie, możemy tworzyć nowe, użyteczne mechanizmy.

Na przykład funkcje kontroli poprawności bazujące na kliencie nie obsługują pól wyboru w sposób prawidłowy, podobnie jak przedstawione wcześniej atrybuty kontroli poprawności na serwerze. Możemy utworzyć nową, kliencką zasadę poprawności, która będzie korzystała z zasady jQuery rule dla pól wyboru, jak pokazano na listingu 18.30.

509

Kup książkę

Poleć książkę

CZ II „ ASP.NET MVC 3 — SZCZEGÓOWY OPIS

Listing 18.30. Tworzenie własnego odwzorowania pomiędzy funkcjami kontroli poprawności w MVC i jQuery

<!DOCTYPE html>

<html>

<head>

<title>@ViewBag.Title</title>

<link href="@Url.Content("~/Content/Site.css")" rel="stylesheet" type="text/css" />

<script src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.5.1.min.js"

type="text/javascript"></script>

<script src="http://ajax.aspnetcdn.com/ajax/jquery.validate/1.7/jquery.validate.min.js"

type="text/javascript"></script>

<script src="http://ajax.aspnetcdn.com/ajax/mvc/3.0/jquery.validate.unobtrusive.js"

type="text/javascript"></script>

<script type="text/javascript">

jQuery.validator.unobtrusive.adapters.add("checkboxtrue", function (options) {

if (options.element.tagName.toUpperCase() == "INPUT" && options.element.type.toUpperCase() == "CHECKBOX") {

options.rules["required"] = true;

if (options.message) {

options.messages["required"] = options.message;

}

}

});

</script>

</head>

<body>

@RenderBody()

</body>

</html>

Utworzyliśmy tu nową zasadę o nazwie checkboxtrue, która za pomocą zasady required z jQuery Validation ma za zadanie sprawdzić, czy pole wyboru jest zaznaczone. Skrypt ten dodaliśmy do pliku układu w projekcie ( _Layout.cshtml), dzięki czemu jest on dostępny we wszystkich widokach.

„ Uwaga Dodawanie nowych zasad kontroli poprawno ci jest zaawansowanym procesem, który wymaga dobrej

znajomo ci biblioteki jQuery Validation oraz obsugi kontroli poprawno ci po stronie klienta z biblioteki MVC.

Nie bdziemy wyja nia, jak dziaa skrypt z listingu 18.29, ale jeeli chcesz nauczy si dodawa nowe zasady poprawno ci, to na pocz tek warto zapozna si z kodem ródowym z pliku jQuery.validate.unobtrusive.js.

Po utworzeniu klienckiej zasady poprawności możemy utworzyć korzystający z niej atrybut. We wcześniejszej części rozdziału pokazaliśmy, jak utworzyć serwerowy atrybut kontroli poprawności, który pozwala upewnić się, że pole wyboru jest zaznaczone. Na listingu 18.29 rozszerzyliśmy tę klasę atrybutu o obsługę strony klienckiej, wykorzystując zasadę checkboxtrue z listingu 18.31.

Listing 18.31. Dodanie kontroli poprawności po stronie klienckiej w klasie MustBeTrueAttribute public class MustBeTrueAttribute : ValidationAttribute, IClientValidatable {

public override bool IsValid(object value) {

return value is bool && (bool)value;

510

Kup książkę

Poleć książkę

ROZDZIA 18. „ KONTROLA POPRAWNOCI MODELU

}

public IEnumerable<ModelClientValidationRule> GetClientValidationRules(

ModelMetadata metadata, ControllerContext context) {

return new ModelClientValidationRule[] {

new ModelClientValidationRule {

ValidationType = "checkboxtrue",

ErrorMessage = this.ErrorMessage

}};

}

}

Teraz możemy korzystać z atrybutu MustBeTrue dla właściwości typu bool w klasach modelu, dzięki czemu upewnimy się, że użytkownik zaznaczy pole wyboru przed przesłaniem danych na serwer.

Wykonywanie zdalnej kontroli poprawnoci

Ostatnią funkcją kontroli poprawności, jaką zajmiemy się w tym rozdziale, jest zdalna kontrola poprawności.

Jest to technika kontroli poprawności po stronie klienta, która wywołuje na serwerze metodę akcji wykonującą kontrolę poprawności.

Częstym przykładem stosowania zdalnej kontroli poprawności jest sprawdzanie w czasie rejestracji, czy nazwa użytkownika jest dostępna. Po przesłaniu danych przez użytkownika wykonywana jest kontrola poprawności na serwerze. W procesie tym do serwera wysyłane są żądania Ajax, za pomocą których sprawdzamy, czy podana przez użytkownika nazwa jest dostępna. Jeżeli nazwa użytkownika jest zajęta, wyświetlany jest komunikatu o błędzie kontroli poprawności, a użytkownik może podać inną wartość.

Może to wyglądać jak zwykła kontrola poprawności po stronie klienta, ale podejście to ma kilka zalet.

Po pierwsze, tylko część właściwości trzeba kontrolować zdalnie; w przypadku pozostałych możemy korzystać z zalet kontroli na kliencie. Po drugie, żądania są względnie niewielkie i skupione na kontroli poprawności, a nie przetwarzaniu całego modelu obiektu. Oznacza to, że możemy minimalizować spadek wydajności, jaki będą wywoływać te żądania.

Trzecią różnicą jest to, że zdalna kontrola poprawności jest realizowana w tle. Użytkownik nie musi klikać przycisku Wyślij i czekać na wygenerowanie i załadowanie nowego widoku. Dzięki temu interfejs użytkownika szybciej reaguje, szczególnie gdy połączenie pomiędzy przeglądarką a serwerem jest powolne.

Trzeba pamiętać, że zdalna kontrola poprawności jest kompromisem; pozwala zachować równowagę pomiędzy kontrolą poprawności na kliencie i serwerze, ale wymaga wysłania żądań do serwera aplikacji i nie jest tak szybka jak kontrola poprawności na serwerze.

„ Wskazówka Obsug Ajax oraz JSON w bibliotece MVC przedstawiamy w rozdziale 19.

Pierwszym krokiem w kierunku użycia zdalnej kontroli poprawności jest utworzenie metody akcji, która będzie sprawdzała poprawność jednej z właściwości modelu. W naszej klasie modelu Appointment będziemy kontrolować poprawność właściwości Date, upewniając się, że podana data jest datą przyszłą (jest to początkowa zasada poprawności, jaką zdefiniowaliśmy na początku tego rozdziału). Na listingu 18.32 pokazana jest metoda ValidateDate, którą dodaliśmy do klasy AppointmentController.

Listing 18.32. Dodanie metody kontroli poprawności do kontrolera

public class AppointmentController : Controller {

private IAppointmentRepository repository;

public AppointmentController(IAppointmentRepository repo) {

repository = repo;

511

Kup książkę

Poleć książkę

CZ II „ ASP.NET MVC 3 — SZCZEGÓOWY OPIS

}

public ViewResult MakeBooking() {

return View(new Appointment { Date = DateTime.Now });

}

public JsonResult ValidateDate(string Date) {

DateTime parsedDate;

if (!DateTime.TryParse(Date, out parsedDate)) {

return Json("Prosz poda prawidow dat (mm/dd/rrrr).", JsonRequestBehavior.AllowGet);

} else if (DateTime.Now > parsedDate) {

return Json("Prosze poda przysz dat.", JsonRequestBehavior.AllowGet);

} else {

return Json(true, JsonRequestBehavior.AllowGet);

}

}

[HttpPost]

public ViewResult MakeBooking(Appointment appt) {

if (ModelState.IsValid) {

repository.SaveAppointment(appt);

return View("Completed", appt);

} else {

return View();

}

}

}

Metody akcji obsługujące kontrolę poprawności muszą zwracać wartość typu JsonResult, a nazwa parametru metody musi być taka sama jak kontrolowane pole. W naszym przypadku jest to Date. Musimy upewnić się, że możemy uzyskać obiekt DateTime z przesłanej przez użytkownika wartości, a jeżeli się to uda, sprawdzamy, czy data jest datą przyszłą.

„ Wskazówka Mogliby my skorzysta z do czania modelu, definiuj c parametr tej metody akcji jako DateTime, ale w takim przypadku nasza metoda kontroli poprawno ci nie bdzie wywoana, jeeli uytkownik poda nieprawidow

warto , jak na przykad jabko. Dzieje si tak, poniewa cznik modelu nie bdzie w stanie utworzy obiektu DateTime z podanej warto ci i zgosi wyj tek. Funkcja zdalnej kontroli poprawno ci nie ma moliwo ci przedstawienia

wyj tku, wic zako czy dziaanie. W takim przypadku pole nie zostanie wyrónione, wic uytkownik bdzie mia

wraenie, e wprowadzona warto jest prawidowa. Jako naczeln zasad w zdalnej kontroli poprawno ci naley

przyj , e metody akcji oczekuj parametru typu string i jawnie wykonuj konwersje typów, parsowanie lub do czanie modelu.

Wyniki kontroli poprawności wyrażamy za pomocą metody Json, która tworzy wynik JSON analizowany przez skrypt zdalnej kontroli poprawności działający na serwerze. Jeżeli przetwarzana wartość spełnia nasze wymagania, przekazujemy true jako parametr do metody Json w następujący sposób: return Json(true, JsonRequestBehavior.AllowGet);

Jeżeli wartość nie spełnia naszych oczekiwań, przekazujemy komunikat kontroli poprawności w następujący sposób:

return Json(" Prosz poda przysz dat. ", JsonRequestBehavior.AllowGet); 512

Kup książkę

Poleć książkę

ROZDZIA 18. „ KONTROLA POPRAWNOCI MODELU

W obu przypadkach musimy również przekazać wartość JsonRequestBehavior.AllowGet jako parametr.

Jest to wymagane, ponieważ biblioteka MVC domyślnie nie pozwala na żądania GET zwracające JSON, więc musimy zmienić to ustawienie. Bez tego parametru żądania kontroli poprawności zostaną bez żadnego komunikatu odrzucone i informacje o błędach nie będą wyświetlane na kliencie.

„ Ostrzeenie Metoda akcji kontroli poprawno ci bdzie wywoana przy pierwszym przesaniu formularza, a nastpnie

za kadym razem, gdy uytkownik zmieni dane. Kade naci nicie klawisza spowoduje wysanie dania do serwera.

W przypadku niektórych aplikacji moe to spowodowa znaczn liczb da , wic trzeba o tym pamita przy

okre laniu mocy obliczeniowej serwera oraz przepustowo ci cza wymaganego dla aplikacji. Dodatkowo mona

zdecydowa, aby nie korzysta ze zdalnej kontroli poprawno ci wa ciwo ci, które s zbyt kosztowne (na przykad

jeeli musimy odpyta powoln usug sieciow w celu sprawdzenia, czy nazwa jest unikatowa).

Podsumowanie

W rozdziale tym przedstawiliśmy szeroką gamę technik pozwalających na realizowanie kontroli poprawności modelu, dzięki którym możemy upewnić się, że podane przez użytkownika dane spełniają ograniczenia, jakie zdefiniowaliśmy dla naszego modelu danych.

Kontrola poprawności jest ważnym zagadnieniem — utworzenie prawidłowego mechanizmu weryfikacji danych w aplikacji jest niezbędne, aby oszczędzić użytkownikom frustracji przy pracy z aplikacją. Równie ważne jest to, że zachowujemy spójność danych modelu i w naszym systemie nie zapisujemy danych o niskiej jakości.

513

Kup książkę

Poleć książkę

CZ II „ ASP.NET MVC 3 — SZCZEGÓOWY OPIS

514

Kup książkę

Poleć książkę

Skorowidz

A

ASP.NET Forms, 235

ASP.NET MVC, 21

adresy

ASP.NET SQL Server Setup Wizard, 591

kwalifikowane, 298

ASP.NET Web Forms, 21, 31

URL, 165, 311

asynchroniczne

przychodzące, 293

metody akcji, 389

wychodzące, 293

programowanie, 393

względne, 298

zadania, 389

agregaty, 74

atak

Ajax, Asynchronous JavaScript and XML, 515

CSRF, 578

akcja asynchroniczna, 393

na witryny, 408

akcje podrzędne, 431

XSS, 408, 570, 576

aktualizacje

atrybut

komunikatów, 503

AdditionalMetadata, 455

testów jednostkowych, 172

Authorize, 237, 586

aktywator kontrolerów, 375

Bind, 466, 582

antywzorzec, 70

Debug, 259

anulowanie żądania, 357

DisplayName, 442, 443

aplikacja

enctype, 245, 472

smart UI, 69

HiddenInput, 224, 440

SportsStore, 141, 168, 607

HttpPost, 380

aplikacje

Locator, 616

kontrolery, 68

ModelBinder, 478

modele, 68

MustBeTrue, 494

widoki, 68

NonAction, 380, 582

architektura

path, 605

model-widok, 70

SessionState, 386

model-widok-prezenter, 71

UIHint, 445, 452

model-widok-widok-model, 72

ValidateInput, 573

MVC, 26, 45

atrybuty

trójwarstwowa, 71

kontroli poprawności, 492, 508

asercje, 81

selektora metody akcji, 381

ASP.NET, 21

testów jednostkowych, 139

ASP.NET Development Server, 36

Kup książkę

Poleć książkę

SKOROWIDZ

automatyczne

cookie

wnioskowanie typów, 98

.ASPXANONYMOUS, 602

implementowanie właściwości, 90

.ASPXAUTH, 585

automatyzacja

HttpOnly, 577

interfejsu użytkownika, 87

zapobiegające fałszerstwom, 579

przeglądarki, 87

CRUD, 141, 213

autoryzacja, 583

czas nieaktywności, 392

bazująca na adresach URL, 604

czas oczekiwania, 392

B

D

baza

dane

danych uwierzytelniania, 592

identyfikacyjne, 589

SQL Server, 591

JSON, 531

BDD, 24

profilu, 600

bezpieczeństwo, 567

stronicowania, 162

bezpiecznie zakodowany znacznik, 571

tekstowe, 333

bezstanowa natura HTTP, 29

ViewState, 27

bezwzględne wyrażenie XPath, 618

DDD, 72

biblioteka

debuger, 259

ASP.NET, 28, 604

debugowanie, 146, 258–266

ASP.NET MVC, 21

testów jednostkowych, 266

jQuery, 537

widoków Razor, 262

jQuery Validation, 505

definiowanie

LINQ, 100

encji koszyka, 185

Moq, 136

interfejsu, 121, 204

MVC Framework, 27

klasy metadanych, 447

ORM, 151

kodu CSS, 167

Rails, 25

kodu Razor, 109

blok

kontrolera, 106

@section, 426

metody rozszerzającej, 93

get, 90

modelu, 106

set, 90

prefiksów, 464

try...catch, 65

sekcji, 425

blokowanie

struktury danych profilu, 600

dostępu do cookie, 576

typu w Ninject, 120

wątków, 389

użytkownika i hasła, 236

błąd 404, 275

widoku w sekcjach, 427

kontroli poprawności, 63, 485, 488, 494

właściwości, 89, 90

niejednoznaczności klas, 284

zasad poprawności, 491

niejednoznaczności kontrolera, 309

degradowanie łączy Ajax, 526

błędy

DI, dependency injection, 77

dołączania modelu, 471

dodawanie

weryfikacji, 62

ASP.NET MVC, 609

buforowanie, 368

atrybutów HTML, 571

atrybutu Authorize, 237

danych do bazy, 154

C

danych modelu widoku, 161

DI do aplikacji, 266

CDN, Content Delivery Network, 27, 501

elementów do DOM, 553

Chrome, 543

elementów konfiguracji, 612

ciąg połączenia, 619, 620

elementów script, 518

632

Kup książkę

Poleć książkę

SKOROWIDZ

filtra, 347

zasad kontroli poprawności, 510

filtrów do akcji, 363

zdjęcia, 248

funkcji do roli serwera WWW, 585

znacznika @using, 407

imitacji implementacji, 148

dołączanie

klasy modelu, 53

danych, 461

kontrolek nawigacji, 171

klasy, 125

kontrolera, 45, 148

kolekcji

kontrolera do obszaru, 308

indeksowanych, 468

kontroli poprawności, 61

o niesekwencyjnych indeksach, 468

łącza do formularza, 53

typów niestandardowych, 467

łącza do widoku, 54

modelu, 59, 72, 193, 461, 472

łączy Ajax, 525

selektywne właściwości, 466

metadanych, 445

tablic i kolekcji, 467

metody akcji, 149

typów prostych, 463

metody akcji do kontrolera, 54

typów złożonych, 464

metody do interfejsu repozytorium, 225

domena, 68

modelu widoku, 159

domena aplikacji, 52

modelu widoku ProductsListViewModel, 161

domyślny łącznik modelu, 462

Moq, 135

dopasowanie

obsługi kategorii, 172

adresów URL, 272, 277, 282

obsługi strony klienckiej, 508

ścieżek, 294

obszaru, 306

dostawca

pakietu EntityFramework, 155

danych o członkostwie, 589, 596

podsumowania koszyka, 198

danych profilu, 602

powiązań Ninject, 119, 239

kontroli poprawności, 498

powiązań Ninject dla IOrderProcessor, 206

łączników modelu, 477

powiązania z repozytorium, 156

metadanych modelu, 457

procesu zamawiania, 201

ról, 599

przestrzeni nazw, 161, 407

wartości, 318

przycisku usuwania, 197

dostęp do

przycisku Zamówienie, 201

cookie, 576

punktu zatrzymania, 261

dostawców wartości, 476

referencji, 143

funkcji administracyjnych, 569

roli do Windows Server, 38

funkcji silnika widoku, 396

silnie typowanego widoku, 54

dynamiczna

stronicowania, 157

kompilacja stron, 608

stylu, 165

zmiana widoczności, 563

ścieżki, 291

dynamiczne tworzenie

treści, 50, 554

treści, 50

treści dynamicznych, 406

zapytań SQL, 580

widoku, 59

dynamicznie typowany widok, 410

Checkout, 202

dystrybucja aplikacji, 607

HTML, 52

dziedziczenie

Index, 108, 192

po klasie DefaultModelBinder, 489

List, 150

własnego dostawcy metadanych, 459

LogOn, 241

Summary, 199

właściwości, 122

E

właściwości do klasy Product, 244

edycja produktu, 229

zależności, 121

edycja żądania HTTP, 569

zasad CSS, 167

EF, Entity Framework, 151

633

Kup książkę

Poleć książkę

SKOROWIDZ

efekty wizualne jQuery, 556

formularz

efektywność wykorzystania łącza, 30

HTML, 55

elementy

serwerowy, 57

ipSecurity, 605

wysyłki, 203

projektu MVC 3, 255, 256

funkcja

Select, 418

Edit and Continue, 264

encja Cart, 185

inicjalizatora obiektów, 92

jQuery(), 544

kontroli poprawności, 227

F

o nazwie code-first, 154

publikowania, 628

fabryka

stronicowania, 158

dostawcy wartości, 474

ViewBag, 112, 264

kontrolerów, 372, 375

ViewData, 264

kontrolerów wbudowana, 374

Visual Web Developer, 34

fałszowanie żądań, CSRF, 567, 577

funkcje

fałszywe poczucie bezpieczeństwa, 573

aplikacji, 151

Fiddler, 569

dla wywołań zwrotnych, 527

filtr, 237, 345

filtrów, 361

akcji, 357, 363

JavaScript, 527

Authorize, 346

kontenera DI, 79

autoryzacji, 579

kontroli poprawności, 510

wbudowany, 351

przycisków jQuery UI, 559

własny, 350

globalny, 365

G

HandleErrorAttribute, 355

OutputCache, 366, 368

generowanie

parametrów It, 137

adresu URL, 298–300, 419

RequireHttps, 366

edytora, 439

uwierzytelniania, 236, 345

elementów HTML, 437

wbudowany wyjątków, 354

kodu HTML, 436

wyniku, 359

liczby produktów, 183

filtrowanie

listy kategorii, 177, 178

bez użycia atrybutów, 361

łączy, 418

kolekcji obiektów, 96

rusztowania, 437

listy produktów, 171

sekcji opcjonalnych, 428

szablonów, 449

według kategorii, 173, 174

tabeli, 215

filtrująca metoda rozszerzająca, 96

widoków, 48, 59, 109

filtry

wychodzących adresów URL, 294, 299, 303

akcji i wyniku, 356

wyników, 319

autoryzacji, 348

wyniku akcji, 322

formularzy jQuery, 548

znaczników HTML, 438

globalne, 362

generyczne typy parametrów, 137

jQuery, 547

gettery, 90

parametrów Moq, 136

globalne priorytety, 375

treści jQuery, 548

główna encja, 74

wbudowane, 366

graficzny interfejs użytkownika, GUI, 21

wyjątków, 353

Firebug, 542, 569

H

Firefox, 542

formatowanie danych, 454

HTTP, 568

634

Kup książkę

Poleć książkę

SKOROWIDZ

I

ICalculator, 403

IClientValidatable, 508

IDE, zintegrowane środowisko programistyczne, 117

IController, 313

identyfikatory elementów, 546

IControllerActivator, 375

IIS, Internet Information Services, 28

IControllerFactory, 372, 373

IIS 7.5, 37

IDiscountHelper, 121

IIS Express, 36

IEmailSender, 79

implementacja

IEmailService, 77

filtra wyjątku, 354

IEnumerable<T>, 96

filtra wyniku, 358

IExceptionFilter, 353

funkcji, 134

IMembersRepository, 78, 81

GetImage, 246

IModelBinder, 194, 462

IControllerActivator, 376

IOrderProcessor, 204

IDependencyResolver, 266

IProductRepository, 147, 156

interfejsu, 77, 94, 204

IResultFilter, 358

IPriceReducer, 128

IRouteConstraint, 288

IValueCalculator, 125

IRouteHandler, 304

IValueProvider, 470

IValidatableObject, 495

IView, 397

IValueCalculator, 118

IViewEngine, 397

IValueProvider, 473

metody

IView, 396

AddBid, 85

IViewEngine, 395

GetVirtualPath, 304

System.Web.Mvc.IController, 314

Menu, 177

użytkownika, UI, 21

SaveProduct, 226

użytkownika typu CRUD, 213

MVC, 69

IoC, inversion of control, 77

własnego filtra autoryzacji, 352

widoku listy, 218

J

importowanie przestrzeni nazw, 406

informacje o błędach systemu, 210

jawna kontrola poprawności modelu, 481

inicjalizator obiektu, 91

język C#, 89

inicjowanie kolekcji, 92

jQuery, 537

instalacja bazy danych, 619

filtry, 547

instalacja binarna, 609

filtry formularzy, 548

instalowanie

filtry treści, 548

aplikacji MVC, 37

metody, 549

dodatkowych komponentów, 38

metody CSS, 552

opcjonalnych komponentów, 35

metody efektów wizualnych, 558

pakietu, 624–626

metody przeciążone, 551

podstawowego oprogramowania, 34

selektory, 545

Visual Studio 2010, 33

selektory atrybutów, 546

instancje baz danych użytkowników, 590

jQuery UI, 558

instrukcja using, 160

JSON, JavaScript Object Notation, 529

IntelliSense, 56

IntelliSense dla jQuery, 541

K

interakcje w aplikacji MVC, 69

interfejs

katalog

IActionFilter, 356

.NET Framework, 591

IActionInvoker, 377

Abstract, 204

IAuthorizationFilter, 348

Admin, 306

IAuthProvider, 238

App_Data, 591

635

Kup książkę

Poleć książkę

SKOROWIDZ

katalog

GuestResponse, 53

Concrete, 204

HandleErrorAttribute, 355

Content, 217

HomeController, 46

Controllers, 45, 314

IControllerFactory, 385

Derived, 315

It, 137

Infrastructure, 302

JsonResult, 336

Models, 53, 239

LegacyController, 301

scripts, 501

LegacyRoute, 302

Shared, 113, 218

LinqValueCalculator, 120

Views, 48

LogOnViewModel, 239

katalogi wirtualne, 621

ModelMetadata, 496

kierowanie żądań, 303

MvcHtmlString, 572

klamry, 92

MyEmailSender, 77

klasa

MyPriceReducer, 129

AccountController, 240

NinjectControllerFactory, 126, 144, 145, 156, 239

ActionExecutedContext, 358

PagingHelpers, 159

ActionExecutingContext, 356

PagingInfo, 159

ActionFilterAttribute, 347, 360

PasswordResetHelper, 77

ActionMethodSelectorAttribute, 381

Product, 119, 147

ActionResult, 50

ProductController, 148

AdminAreaRegistration, 306

ProductsListViewModel, 171

AdminController, 78, 80, 215, 245

RedirectResult, 321

AjaxOptions, 520, 527

RoleProvider, 599

Appointment, 479, 502, 515

RouteCollection, 271

AppointmentController, 480, 516

RouteData, 303

AreaRegistrationContext, 307

ShippingDetails, 200, 202

AuthorizationContext, 350

ShoppingCart, 93, 94, 118, 124

BasicController, 314

SqlProfileProvider, 600, 601

Cart, 186

SqlRoleProvider, 597

CartController, 193, 206

System.Activator, 475

CartIndexViewModel, 191

System.Console, 89

CartModelBinder, 194

System.Web.Mvc.Controller, 315

Chart, 423

System.Web.Mvc.RedirectResult, 321

Controller, 315

TagBuilder, 413

filtry, 315

TemplateInfo, 454

metody akcji, 315

ViewData, 330

wynik akcji, 315

ViewEngineResult, 396

Controller. ViewBag, 50

ViewResult, 227

ControllerContext, 194, 350

WebGrid, 419, 420, 422

CustomControllerFactory, 372

WebMail, 64

DataAnnotationsModelMetadataProvider, 459

ModelMetadata, 456

DefaultControllerFactory, 374, 375

FormsAuthentication, 238

DefaultDiscountHelper, 121

klasy

DefaultModelBinder, 462, 463, 489

bazowe kontrolerów, 45

EfDbContext, 155

dostawcy członkostwa, 595

EFProductRepository, 156

dostawcy kontroli poprawności, 496

EmailOrderProcessor, 204

fabryki dostawców wartości, 473

EmailSettings, 206

modelu, 435, 450

ExceptionContext, 353

zagnieżdżone, 464

FakeRepository, 129, 135

złożone, 464

FormCollection, 471

osprzętu testów, 80

FormsAuthentication, 238

pomocnicze, 419, 423

FormsAuthProvider, 238

pomocnicze wbudowane, 424

636

Kup książkę

Poleć książkę

SKOROWIDZ

repozytorium, 156

kontrola

z testami jednostkowymi, 131

plików, 290

zwracająca skrypt, 408

poprawności, 61, 72, 210, 229, 484

klucz UseNamespaceFallback, 286

danych modelu, 479

kod

na poziomie modelu, 490

HTML, 538

po stronie klienta, 231, 242, 499–506, 510

HTTP 301, 331

w łączniku modelu, 488

HTTP 302, 331

żądań, 27, 572

źródłowy biblioteki MVC, 36, 41

kontroler, 45, 68, 313

kodowanie

AccountController, 239, 256

ciągów znaków, 408, 574

asynchroniczny, 388

HTML, 409

HomeController, 256

HTML w Razor, 571

koszyka, 189

kolejność

obsługujący obiekty JSON, 534

ścieżek, 279

ProductController, 107

widoków, 481

UserProfileController, 577

wykonywania filtrów, 364

kontrolery

kompilacja, 54

asynchroniczne, 386, 387, 394

komunikat

bezstanowe, 385

kontroli poprawności, 488

dziedziczące, 319

o błędzie, 355, 400, 486, 503

kontrolka

o błędzie 404, 586

GridView, 164

konfigurowanie

Slider, 560

.NET 4, 624

kontrolki, 69

Debug, 259

konwencje

dostawcy członkostwa, 589, 590

dla klas kontrolerów, 257

IIS, 622

dla układów, 258

kontenera DI, 144

dla widoków, 257

Moq, 136

MVC, 257

Ninject, 120

kopiowanie elementów script, 540

nowej witryny, 623

koszyk, 184

ograniczeń, 605

profili, 600

routingu, 47, 309

L

ról, 597

SqlMembershipProvider, 590

licznik stron, 182

SqlProfileProvider, 600

LINQ, Language Integrated Query, 29, 100

SqlRoleProvider, 597

LINQ to Entities, 106

ścieżki, 150, 628

lista kategorii, 177

uwierzytelniania

logika

Forms, 235, 586. 588

aplikacji, 406

w IIS, 584

prezentacji, 406

Web Deployment, 39

proceduralna, 406

wyszukiwania lokalizacji widoków, 404

lokalne proxy, 569

zachowania, 136

luźne powiązanie, 76

konflikt

nazw, 309

powiązań, 624

konsola JavaScript w Chromie, 544

ładowanie

kontener

jQuery, 542

DI, 79, 117

pakietu instalacyjnego, 627

ViewBag, 227

637

Kup książkę

Poleć książkę

SKOROWIDZ

łącza

Change, 581

do akcji, 310

ChangeLoginName, 80

kategorii, 180

Checkout, 202

niewłaściwe, 183

ChildAction, 368

łącze Enable editing, 265

Completed, 389

łączenie

Create, 232

metod akcji, 53

CreateController, 373

metod rozszerzających, 97

CreateMetadata, 458, 459

segmentów URL, 278

DataCompleted, 391

łączenie

Delete, 233, 235

selektorów, 545

DoPasswordChange(), 582

selektorów atrybutów, 546

Edit, 221, 578

warunkowe, 125

EditorForModel, 224

ze słownikiem, 469

ExecuteResult, 324

żądań z kontrolerami, 373

File, 338

łącznik domyślny modelu, 475

FilterByCategory, 97

łącznik modelu, 193, 318, 472, 475

FindView, 400

FormsAuthentication.Decrypt, 585

M

GetCart, 194

GetControllerInstance, 127

manipulowanie

GetControllerSessionBehavior, 373

atrybutami elementów konfiguracji, 615

GetConverter, 447

klasami CSS, 552

GetImage, 246

modelem DOM, 552

GetLegacyURL, 301

mechanizm

GetProducts, 136

akcji potomnych, 175

GetRemoteData, 388

filtrów, 236

GetRolesForUser, 599

ViewBag, 180, 328

GetValidation, 496

mechanizmy członkostwa, 589, 600

GetValue, 476

menedżer IIS, 39, 586, 588

HandleUnauthorizedRequest, 351

menu nawigacji, 175

HandleUnknownAction, 382

metadane, 224

Html.ActionLink, 298

metadane modelu, 72, 440

Html.AntiForgeryToken(), 579

metoda

Html.AntiForgeryToken(), 579

ActionLink, 53, 294

Html.BeginForm, 56

AddBid, 83, 84

Html.EditorFor, 203, 436

AddBinding, 206

Html.EditorForModel, 441

AddBindings, 127, 156

Html.ValidationSummary, 62, 242

addClass, 551

IgnoreRoute, 292

AddSeries, 424

Index, 191, 215, 216

Ajax.ActionLink, 525

Is<T>, 137

Ajax.BeginForm, 521

JavaScriptStringEncode, 575

All_Prices_Are_Changed, 132

Json, 512

Application_Start, 271, 307

List, 161

AreaRegistration, 307

LogOn, 239

Async, 389

MapRoute, 273, 286

AuthorizeCore, 351

Match, 289

BeginForm, 189

Menu, 176

BindModel, 462

ModelState.IsValidField, 485

button, 560

Ninject WithPropertyValue, 123

CanChangeLoginName, 81

OnActionExecuted, 357

CannotAddLowerBid, 84

OnActionExecuting, 356

638

Kup książkę

Poleć książkę

SKOROWIDZ

OnAuthorization, 351

rozszerzające opóźnione, 102

OnException, 353

statyczne klasy Assert, 133

OrderByDescending, 102

statyczne klasy It, 137

Partial, 428

szablonowe, 436

RegisterArea, 306

testowe, 81

RegisterGlobalFilters, 362

uznane za akcje, 378

RegisterRoutes, 107, 271, 291, 293

zapobiegające fałszerstwom, 579

ReleaseController, 373

międzywitrynowe fałszowanie żądań, CSRF, 567, 577

RenderAction, 176, 177

migracja z Web Forms do MVC, 30

RenderBody, 426

model

RenderPartial, 169

domeny, 52, 68, 73

SaveProduct, 226

domeny aukcji, 75

slider, 562

systemu z agregatami, 74

string.IsNullOrEmpty, 482

widoku, 327

Summary, 198

modelowanie domeny, 72

UpdateModel, 469

moduł administracyjny, 141

UpdateProduct, 139

modyfikowanie

Url.Action, 174, 522

danych POST, 569

UrlHelper.GenerateURL, 295

DOM, 569

ValidationSummary, 484

domyślnego widoku Razor, 166

View, 324

MonoRail, 30

WebGrid.Column, 421

Moq, 135

WebGrid.GetHtml, 421

MSDN, Microsoft Developer Network, 41

WebMail.Send, 65

MVC, model-widok-kontroler, 45, 67

WebRequest.BeginGetResponse, 394

WithPropertyValue, 123

N

metody

akcji, 45, 69

nadawanie stylu polom wyboru, 483

akcji kontroli poprawności, 513

nadpisywanie metod HTTP, 384

CSS z jQuery, 552

nagłówek Referer, 588

dołączania warunkowego, 126

narzędzia

efektów wizualnych z jQuery, 558

automatyzacji UI, 24

jQuery, 548

testów jednostkowych, 24

klasy DefaultControllerFactory, 377

narzędzie

klasy DefaultModelBinder, 489

IIS, 592

metody kontroli poprawności, 511

imitujące, 117

mające parametry generyczne, 379

Kompilacja, 609

manipulowania modelem DOM, 555

Menedżer serwera, 584

nawigowania w modelu DOM, 555

ORM, 30

obsługi zdarzeń, 69

testów automatycznych, 30

osprzętu testów, 83

ThemeRoller, 559

pomocnicze, 422

WAT, 592, 593

pomocnicze

WebPI, 34

do wprowadzania danych, 415

nawiasy klamrowe, 99

HTML, 410, 418

nazwa widoku, 50

szablonów rusztowań, 438

nazwy ścieżek, 272

wbudowane, 413

nazwy własne akcji, 379

wewnętrzne, 411

niejawne typowanie, 98

widoku szablonowego, 435, 438

niejednoznaczność

zewnętrzne, 411

kontrolerów, 308

rozszerzające, 28, 93, 94

metod akcji, 382

rozszerzające LINQ, 102, 103

639

Kup książkę

Poleć książkę

SKOROWIDZ

nieprzeszkadzające wywołania Ajax, 515

żądania POST, 58

sposób działania, 520

żądań, 383

włączanie obsługi, 518

żądań JSON, 532

Ninject, 117

obszar MVC, 305

Node.js, 25

odbieranie danych JSON, 533

odczyt

O

danych

z ViewBag, 113, 329

obiekt

z ViewData, 330

Cart, 195

zdjęć, 246

domeny, 68

odwołanie do jQuery, 540

EFDbContext, 156

odwrócenie kontroli, 77

EmailSettings, 206

odwzorowanie obiektowo-relacyjne, 581

ExceptionContext, 353

ograniczanie

FormsAuthenticationTicket, 585

adresów IP, 605

HtmlHelper, 412

dołączania, 470

kernel Ninject, 119

dostępu, 604, 605

kontekstu, 316, 317

dostępu do lokalizacji, 605

kontroli poprawności, 497, 498

łącznika do danych formularza, 470

ModelData, 497

ograniczenia niestandardowe, 289

modelu, 109

ograniczenia ścieżek, 286

modelu widoku, 327, 356

okno

MvcHtmlString, 413

Add Controller, 214

MvcRouteHendler, 272

Add View, 49

obsługi ścieżki, 305

Configuration Manager, 619

Product, 97

New ASP.NET MVC 3 Project, 254

Route, 286, 295

New Project, 142

RouteData, 303

obsługi wyjątku, 263

TemplateInfo, 455

Publish Web, 629

ViewBag, 50

Server Explorer, 152

ViewEngineResult, 396

Solution Explorer, 144, 148

wbudowany wywołujący akcje, 378

Test Results, 134

wywołujący akcje, 377, 462

ominięcie kodowania danych, 572

zarządzający zależnościami, 375

ominięcie kontroli poprawności, 569

obrony przed atakami CSRF, 578

opcja

obsługa

compilation, 608

adresów URL, 293

Edit and Continue, 263

błędów, 471

MvcBuildViews, 608

danych zdjęcia, 245

requireSSL, 586

degradacji, 526

operacje na domenie, 68

formularzy, 57

operator @Model, 60

JSON, 530

operator Href, 63

komunikatu w pliku szablonu, 229

OSI, Open Source Initiative, 29

kontroli poprawności, 512

osprzęt testu, 80

nieznanych akcji, 382

prób logowania, 586

P

stanu, 29

ścieżki, 304

parametr

usług sieciowych REST, 383

Cart, 207

właściwości, 447, 448

ControllerContext, 194

wyjątków, 262, 392

fileDownloadName, 338

zależności, 78

Func, 97

640

Kup książkę

Poleć książkę

SKOROWIDZ

konstruktora, 123

połączenie z SQL Server Express, 156

ModelBindingContext, 194

powiązanie z repozytorium, 156

object, 494

powrót do właściwości standardowej, 91

opcjonalny, 157

prefiksy HTML, 454

out, 318

priorytety kontrolerów, 284

ref, 318

priorytety przestrzeni nazw, 374

ShippingDetails, 207

proces dołączania modelu, 469

typu generycznego, 410

profile, 589, 600

parametry

profile anonimowe, 601

filtra OutputCache, 367

program

metody CreateMetadata, 458

aspnet_regsql.exe, 591

metody WebGrid.Column, 421

Fiddler, 569

metody WebGrid.GetHtml, 421

Menedżer IIS, 598

obowiązkowe, 318

telnet, 569

opcjonalne, 318

programowanie

przekazywane do metody File, 338

.NET, 41

platforma testów jednostkowych, 117

asynchroniczne, 393

plik

sterowane domeną, 72

_AdminLayout.cshtml, 216, 218, 227, 231

sterowane testami, TDD, 24, 82

_Layout.cshtml, 113, 114, 167

sterowane zachowaniami, BDD, 24

_viewstart, 113

zwinne, 25

_ViewStart.cshtml, 113

projekt

Admin.css, 217

ControllersAndActions, 313

Administration.config, 596

DebuggingDemo, 259

Global.asax, 107, 231, 270, 307

MvcApp, 515

Global.asax.cs, 47, 172

Razor MVC, 160

Index.cshtml, 48, 219

SportsStore, 143

jquery.unobtrusive-ajax.js, 518

SportsStore.Domain, 156, 200

jquery-1.5.1.min.js, 518

SportsStore.WebUI, 156, 161, 179

List.cshtml, 163

WorkingWithAreas, 306

MyView.cshtml, 315

prototypowanie interfejsu użytkownika, 70

Site.css, 167, 179

przechwytywanie żądania, 291

StaticContent.html, 290

przejęcie sesji, 576

przekazywanie danych, 112

układu, 227

metadanych, 455

Web.config, 155, 160, 206, 407, 586, 610, 612

parametrów, 391

Web.Debug.config, 610

z metody akcji do widoku, 327

Web.Release.config, 610

z użyciem ViewBag, 328

pliki

z użyciem ViewData, 329

.cshtml, 49

przekierowanie, 238, 331, 332

.mdf, 590

do adresu URL, 300

.vbhtml, 404

do innej akcji, 299

jQuery, 539

trwałe, 331

przekształceń Web.config, 610

z użyciem literału znakowego, 332

wyszukiwane przez Razor, 404

żądania URL, 290

.eml, 206

przekształcenie

pobieranie

InsertAfter, 613

danych, 316

InsertBefore, 613

pobieranie danych z ViewBag, 51

Remove, 614

podsumowanie instalacji, 628

RemoveAll, 614

pole PageSize, 157

przerywanie operacji asynchronicznej, 393

połączenie z bazą danych, 155

przesłanianie metod HTTP, 384

641

Kup książkę

Poleć książkę

SKOROWIDZ

przestrzenie nazw, 285

S

PartyInvites.Models, 58

System.Linq, 102

samodzielne łączenie, 124

System.Web.Mvc, 224

samokontrolująca się klasa modelu, 495

przesyłanie danych edycji, 228

schemat

przesyłanie zdjęć produktów, 242

adresów URL, 310

przeszukiwanie danych parametrów, 462

bazy danych, 153

przetwarzanie JSON, 531, 532

segment

przetwarzanie ścieżek, 290

mieszany, 278

przycisk, 560

opcjonalny, 282

Dodaj do koszyka, 184

własny, 280

Kontynuuj zakupy, 193

segmenty adresu URL, 271, 277

Publish, 629

sekcja authentication, 236

Zamówienie, 201

sekcje opcjonalne, 428

przykłady użycia jQuery, 544

sekcje w pliku układu, 425

publikowanie jednym kliknięciem, 628

selektor $(this), 553

pule aplikacji, 621

selektory jQuery, 545

punkty zatrzymania, 260

Selenium RC, 87

separacja zadań, 75, 406

R

serwer IIS, 38, 621

serwer WWW, 36

raportowanie kategorii, 181

settery, 90

referencja do System.Web.Mvc, 224

sfałszowane dane, 567

rejestrowanie

silnie typowane

aktywatora kontrolerów, 376

kontrolki, 416

dostawcy ról, 599

metody pomocnicze, 417

dostawcy uwierzytelniania, 596

widoki, 409

implementacji, 206

widoki częściowe, 430

implementacji RouteBase, 303

silnik

klasy CartModelBinder, 194

ASPX, 43, 395, 401

klasy NinjectControllerFactory, 145

Brail, 400

klasy w bibliotece, 127

NHaml, 400

ścieżki, 272

NVelocity, 400

własnego dostawcy metadanych, 458

Razor, 30, 43, 105, 395, 401

własnego dostawcy profili, 603

Spark, 400

własnego silnika widoku, 398

Sinatra, 25

własnej fabryki kontrolerów, 374

składane adresy URL, 165

relacje pomiędzy typami, 119

składanie zamówień, 200

repozytoria, 75

składnia silnika Razor, 105

reprezentacja JSON, 529

składnia zapytania, 101

REST, Representational State Transfer, 24

składniki klasy

role, 589

ModelMetadata, 456

role w aplikacjach MVC, 597

TemplateInfo, 454

routing żądań dla plików dyskowych, 290, 291

skrypt jQuery, 533

rozdzielanie komponentów, 76

skrypty międzywitrynowe XSS, 408, 567

rozszerzalność, 26

słowo kluczowe

rozszerzanie modelu domeny, 244

model, 327

Ruby on Rails, 25, 30

select, 101

this, 93

rzutowanie parametru, 301

using, 102

var, 98, 100

yield, 96

642

Kup książkę

Poleć książkę

SKOROWIDZ

słowo nieprzeszkadzający, 499

technologia

sortowanie, 101

„przeciągnij i upuść”, 30

sprawdzanie

Ajax, 25

adresu IP klienta, 576

ASP.NET, 21

istnienia sekcji, 427

ASP.NET Web Forms, 21

konfiguracji, 258

technologie programowania WWW, 22

uwierzytelniania, 345

telnet, 569

SQL Server, 36, 151

test jednostkowy

stan sesji, 385

adresy URL, 273

standardy WWW, 24

akcja Index, 216

sterowanie zawartością tabeli, 561

dane stronicowania, 162

stosowanie filtrów, 348

filtrowanie według kategorii, 174

stosowanie metody rozszerzającej, 95

generowanie listy kategorii, 178

stronicowanie, 157

generowanie widoku, 325

style CSS, 482

kody statusu HTTP, 341

dla elementów edytora, 225

kontroler koszyka, 196

dla widoków administracyjnych, 217

łącza stron, 160

system

metoda Edit, 222

dołączania danych, 472

obiekty modelu widoku, 328

routingu, 47, 269, 290

odczyt zdjęć, 246

zarządzania migracjami, 30

ograniczenia ścieżek, 288

szablon

opcjonalne segmenty URL, 283

CRUD, 214

przekierowania, 333

DateTime.cshtml, 454

przekierowanie, 332

Empty, 254

przesyłanie danych, 228

Internet Application, 80, 254

raportowanie kategorii, 181

Intranet Application, 254, 583

segmenty statyczne, 279

MVC Internet Application, 236

stronicowanie, 158

Object, 447

testowanie koszyka, 186

szablony

usuwanie produktów, 234

projektu, 44

uwierzytelnianie, 243

rusztowań, 437

ViewBag, 329

wbudowane widoku, 446

ViewData, 330

widoku edytora, 450, 452

wartości domyślne, 277

wyświetlania, 451

wychodzące adresy URL, 295

szkielet klasy MyPriceReducer, 129

wyniki plikowe, 340

zliczanie produktów, 183

zmienne segmentów przechwytujących, 284

zmienne własnych segmentów, 281

ścieżka domyślna, 107, 150, 461

zwracanie wyników, 335

ścieżki, 175, 272

funkcji stronicowania, 158

nazwane, 300

integracyjne, 87

o zmiennej długości, 282

jednostkowe, 128

środowisko

jednostkowe kontrolerów i akcji, 322

klasy CartController, 196, 208

niezależnych dostawców oprogramowania, 24

kontrolera AccountController, 243

testowe dla jQuery, 542

PageLinks, 160

regresyjne, 80

T

segmentów statycznych, 279

testowanie

TDD, 82, 86

widoku, 50

techniki instalacji, 607

wzorca URL, 276

643

Kup książkę

Poleć książkę

SKOROWIDZ

testy

kontekstu Entity Framework, 154

automatyczne, 80

kontrolera, 107, 313

integracyjne, 80, 87

AccountController, 239

jednostkowe, 80, 85, 132

asynchronicznego, 387

jednostkowe z użyciem Moq, 137

CRUD, 214

treści dynamiczne, 405

koszyka, 189

treści statyczne, 405

nawigacji, 176

tryb

koszyka, 184

Condition, 618

łańcucha zależności, 121

debug, 608

łącznika modelu, 193, 474, 475

tryby atrybutu Locator, 617

łączy Ajax, 524

tryby uwierzytelniania IIS, 584

łączy stron, 160

tworzenie

metody akcji, 54

abstrakcyjnego repozytorium, 147

metody akcji Edit, 221

agregatów, 75

metody pomocniczej, 411

akcji podrzędnych, 431

modelu domeny, 146

aplikacji SportsStore, 242

obiektów, 91

atrybutu kontroli poprawności, 492, 505

obiektu ViewResult, 326

bazy danych, 152

obszaru, 306

danych JSON, 337

ograniczenia ścieżki, 289

danych stronicowania, 182

pakietu instalacyjnego, 626

danych wyjściowych, 319

parametrów, 391

domyślnych ścieżek, 47

pliku Admin.css, 218

dostawcy

pliku układu, 216

kontroli poprawności, 495

pomocniczej aplikacji, 594

łączników modelu, 477

produktów, 232

metadanych, 457

projektu, 43, 105, 119, 128

profili, 602

projektu DebuggingDemo, 259

ról, 599

projektu routingu, 270

uwierzytelniania, 238

projektu testów jednostkowych, 143

wartości, 473

prostych adresów URL, 28

elementów, 554

przycisków, 559

elementów HTML, 437

przycisków koszyka, 188

fabryki kontrolerów, 372

przyjaznych adresów URL, 310

filtra autoryzacji, 349

pustego rozwiązania, 142

filtra globalnego, 363

repozytorium produktów, 156

filtra wyjątku, 353

sekwencji obiektów, 419

filtrów akcji, 359

filtrów wyniku, 359

silnika widoku, 395

filtrujących metod rozszerzających, 96

szablonów, 447

formularza HTML, 519

szablonu edytora, 448

formularzy, 413, 414

szablonu ogólnego, 452

imitacji, 135

szablonu wyświetlania, 450

imitacji repozytorium, 148

ścieżki, 272

implementacji interfejsu, 121

tablicy, 93

implementacji RouteBase, 301

testowych obiektów danych, 138

interfejsu użytkownika, 244

testów jednostkowych, 130

klasy dziedziczącej, 124

typu anonimowego, 99

klasy modelu domeny, 106

układu Razor, 217

klasy Product, 147

widoku, 47, 48, 107, 240

kodu jQuery, 541

Completed, 211

kodu zabezpieczeń, 349

częściowego, 167, 177, 428, 449

kont dla użytkowników, 584

Edit, 223

644

Kup książkę

Poleć książkę

SKOROWIDZ

edycji, 221

sygnalizacji błędów, 504

Index, 219

zależności, 77

z formularzem, 55

uwierzytelnianie, 583

wielu formularzy, 189

bez cookie, 587

własnego dostawcy danych członkostwa, 595

Forms, 236, 576, 585

własnego wyniku akcji, 341

Windows, 236, 583

własnych zasad autoryzacji, 351

użycie

własnych zasad braku autoryzacji, 352

atrybutu Locator, 617

wykresu, 424

metadanych, 440–444

wyrażeń XPath, 618

metod CSS z jQuery, 550

zasad poprawności, 509

przekształceń atrybutów, 615

znaczników select, 417

zdarzeń jQuery, 555

tylne wejście, 582

typ

V

ActionResult, 323

DataType, 444

Visual Studio, 142

JsonRequestBehavior, 530

obsługa HTML5, 254

nullable, 61

Visual Web Developer 2010 Express, 34

typy

anonimowe, 29, 99

W

dynamiczne, 29

filtrów, 347

W3C, Wide Web Consortium, 311

literałowe, 319

wady

wyliczeniowe, 385, 444, 530

ścieżek nazwanych, 300

Web Forms, 23

wartości

U

domyślne parametrów, 318

zmiennych segmentów, 296

udostępnianie plików, 256

wartość

układ Razor, 114

domyślna dla kontrolera i akcji, 276

ukrycie skryptu, 572

domyślna w ścieżce, 276

ukrywanie elementów <a>, 543

returnUrl, 571

ukrywanie łączy, 543

warunkowe dołączanie w Ninject, 126

ulepszanie URL, 172

WAT, Web Site Administration Tool, 592

uproszczona metoda akcji, 490

WatiN, 87

uruchamianie aplikacji, 151

Web Developer Toolbar, 570

uruchamianie testów, 133

WebPI, Web Platform Installer, 34

usługa

wersje metody ValidationSummary, 485

hostingowa, 37

weryfikowanie przy użyciu Moq, 139

roli ASP.NET, 38

wiązanie witryn

roli Usługa zarządzania, 38

adres IP, 622

zarządzania, 41

nazwa hosta, 622

ustawienie Layout, 115

numer portu, 622

usunięcie

widoczność elementu, 557

atrybutu debug, 611

widok

czasu oczekiwania, 392

AppointmentData.cshtml, 517

wywołania ViewBag, 265

Checkout.cshtml, 202

ChildAction.cshtml, 368

usuwanie

Completed.cshtml, 211

atrybutów, 615

widok

elementów konfiguracji, 614

Edit, 223

produktów, 232, 235

GetLegacyURL, 301

produktów z koszyka, 197

645

Kup książkę

Poleć książkę

SKOROWIDZ

widok

Greeting, 51

Index, 191

HttpContext, 194

Index.cshtml, 220, 516, 537

IsApproved, 439

List.cshtml, 149, 163

Mock.Object, 137

LogOn, 240, 241

ModelState, 207

MakeBooking.cshtml, 480

ModelState.IsValid, 207, 482

Menu, 178

Name, 90

ProductSummary.cshtml, 190

Person.Role, 448

Razor, 108, 109, 401

ProductId, 224

RsvpForm, 57

Products, 163

Summary, 199

Response, 320

Thanks, 60

RouteExistingFiles, 291, 292

widoki

UpdateTargetId na tabledata, 519

beztypowe, 327

ViewBag.Message, 260

częściowe, 169, 428

ViewBag.Title, 114

edytora, 480

ViewData.TemplateInfo, 454

silnie typowane, 54, 327

WillAtend, 53

tylko do odczytu, 441

WillAttend, 61

typowane dynamicznie, 410

włączanie

Windows Server 2008 R2, 37

profili anonimowych, 601

witryna

roli serwera WWW, 37

ASP.NET, 41

usługi zarządzania, 41

IIS, 41

wnioskowanie typów, 98, 99

jQuery, 41

wsparcie dla testów automatycznych, 30

stackoverflow.com, 41

wstrzykiwanie

witryny Web, 621

HTML, 570

właściwości

SQL, 567, 580

automatyczne, 91

wartości do konstruktora, 123

klasy

zależności, 77, 266, 402, 470

ActionExecutedContext, 358

wybieranie bazy danych, 591

ActionExecutingContext, 356

wybór

AuthorizationContext, 350

konfiguracji, 253

AuthorizeAttribute, 351

typu instalacji, 620

ControllerContext, 350

typu projektu, 44

ExceptionContext, 353

wygenerowana klasa C#, 402

HandleErrorAttribute, 355

wyjątek ArgumentNullException, 318

ModelMetadata, 496

wyjątki, 262

obiektu cookie uwierzytelniania, 585, 587

wykrywanie

profilu, 601

błędów, 607

w C#, 89

żądań Ajax, 532

wyszukiwania, 404

wyłączanie

wywołań zwrotnych, 528

kontroli żądań, 573

właściwość

właściwości, 442

AjaxOptions, 519, 520, 527

wymiana szablonu wbudowanego, 453

AjaxOptions.Confirm, 523

wynik zapytania, 105

AjaxOptions.LoadingElementId, 523

wyniki akcji, 50, 320

Category, 96

wyrażenia lambda, 29, 56, 97

Controller.Response, 319

wyróżnianie bieżącej kategorii, 182

CurrentCategory, 172

wyróżnienie elementów, 483

DayOfWeak, 327

wysyłanie

Exception, 353

kodów HTTP, 339

FormattedModelValue, 455

kodu 401, 340

646

Kup książkę

Poleć książkę

SKOROWIDZ

kodu 404, 340

zawartość koszyka, 190

obiektu JSON, 533

zdalna kontrola poprawności, 507, 511

pliku, 337

zdarzenia

tablicy bajtów, 339

JavaScript, 556

zawartości strumienia, 339

jQuery, 555

wyszukiwanie

zgodność pomiędzy przeglądarkami, 30

szablonów, 451

zintegrowane środowisko programistyczne, IDE, 117

widoków, 324

zmiana

wyświetlanie

ciągu połączenia, 611

informacji, 52, 522

elementów konfiguracji, 616

informacji o błędach, 486

lokalizacji wyszukiwania, 405

komunikatów, 229, 486, 487

wrażliwych właściwości, 582

listy produktów, 148

żądania, 373

łączy stron, 158, 163

zmienne

zawartości koszyka, 192

przechwytujące, 284

zdjęć produktów, 247, 249

segmentów, 297

wywołania Ajax, 521

w debugerze, 262

wywołanie @RenderSection, 426

we wzorcu URL, 280

wywołanie zwrotne, 527

własne, 280

wywoływanie

znacznik

akcji podrzędnych, 432

@:, 110, 571

metod akcji, 371

@section, 425

wzorce projektowe, 69

@using, 407

wzorzec

div, 525

A/A/A, arrange/act/assert, 81, 131

inherits, 403

architektury trójwarstwowej, 71

łącza z atrybutami, 297

model-widok, 70

script, 518

MVC, 26, 67

znaczniki deklaratywne, 406

POST-Redirect-GET, 331

znak @, 31, 109, 160

programowania asynchronicznego, 393

znaki =>, 98

Smart UI, 69, 70

znaki cudzysłowu, 160

TDD, 132

zwracanie

URL, 271

błędów, 339

URL z segmentem mieszanym, 278

danych, 333

URL z segmentem statycznym, 277

danych binarnych, 337

danych JSON, 336

Z

danych XML, 336

plików, 337

zachowywanie danych, 334

zakodowany HTML, 408

zalety ASP.NET MVC, 26–29

zaprzyjaźniona klasa metadanych, 446

żądania

zapytania opóźnione, 102

Ajax, 522

zapytanie parametryczne, 581

asynchroniczne, 523

zarządzanie

przesłania pliku statycznego, 290

czasem nieaktywności, 392

żądanie

członkostwem, 592, 593

GET, 58, 311, 568

rolami, 598

HTTP, 570

stanem sesji, 385

POST, 58, 227, 311, 568

zasada czerwone-zielone-refaktoryzacja, 82

REST, 383

zasady biznesowe, 70

zasady kontroli poprawności, 491, 507

647

Kup książkę

Poleć książkę

SKOROWIDZ

648

Kup książkę

Poleć książkę

KSIĄŻKI TEGO AUTORA

ASP.NET MVC 4. Zaawansowane programowanie ASP.NET MVC 3 Framework. Zaawansowane programowanie