ASP.NET MVC 4. Zaawansowane programowanie

ASP.NET MVC 4. Zaawansowane programowanie

Autorzy: Steven Sanderson Adam Freeman

Wydawnictwo: Helion

Kategorie: Informatyka

Typ: e-book

Formaty: EPUB MOBI

Ilość stron: 696

cena od: 79.20 zł



Kompendium wiedzy o platformie ASP.NET MVC 4!





ASP.NET MVC jest rewelacyjną alternatywą dla ASP.NET Web Forms. Pozwala na połączenie efektywności ze schludnością architektury model-widok-kontroler (MVC). Nowa wersja platformy - ASP.NET MVC 4 - to kolejny milowy krok w rozwoju platformy ASP.NET, stworzonej przez giganta z Redmond. Dzięki ASP.NET MVC 4 błyskawicznie stworzysz łatwe w utrzymaniu i rozwojowe aplikacje internetowe.





Lektura tej książki pozwoli Ci zapoznać się z technikami programowania w oparciu o testy (TDD). Przekonasz się, jak działa wzorzec MVC w praktyce. Ponadto uda Ci się szczegółowo poznać całą platformę ASP.NET MVC oraz zauważyć różnice, wady i zalety ASP.NET MVC względem klasycznego ASP.NET. Przekonasz się, jak zastosowanie filtrów może ułatwić Ci życie oraz jak niezwykle istotną kwestią jest zapewnienie bezpieczeństwa Twojej aplikacji. Książka ta jest doskonałym i kompletnym źródłem wiedzy na temat ASP.NET MVC. Obowiązkowa lektura dla każdego programisty tej platformy!





Sięgnij po książkę i sprawdź:





  • jak wykorzystanie architektury MVC może ułatwić Ci pracę


  • jaki wpływ na jakość Twojego kodu ma architektura MVC


  • jak zapewnić bezpieczeństwo Twojej aplikacji


  • w jaki sposób implementowana jest architektura MVC




Lektura obowiązkowa każdego programisty!



Tytuł oryginału: Pro ASP.NET MVC 4

Tłumaczenie: Robert Górczyński

ISBN: 978-83-246-7299-8

Original edition copyright © 2012 by Adam Freeman.

All rights reserved.

Polish edition copyright © 2013 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/aspmv4.zip

Drogi Czytelniku!

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

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

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 treści

O autorze ...............................................................................................................17

O recenzencie technicznym ....................................................................................19

Część I

Wprowadzenie do ASP.NET MVC 4 ..........................................21

Rozdział 1. Zagadnienia ogólne ...............................................................................................23

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

Tradycyjna technologia ASP.NET Web Forms ........................................................................ 23

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

Programowanie witryn WWW — stan obecny .............................................................................. 25

Standardy sieciowe oraz REST .................................................................................................... 26

Programowanie zwinne i sterowane testami ............................................................................ 26

Ruby on Rails ................................................................................................................................. 27

Sinatra ............................................................................................................................................. 27

Node.js ............................................................................................................................................ 28

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

Architektura MVC ........................................................................................................................ 28

Rozszerzalność .............................................................................................................................. 29

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

Łatwość testowania ....................................................................................................................... 30

Zawansowany system routingu .................................................................................................. 30

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

Nowoczesne API ........................................................................................................................... 31

ASP.NET MVC jest open source ................................................................................................ 31

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

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

Migracja z Web Forms do MVC ................................................................................................ 32

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

Porównanie z MonoRail .............................................................................................................. 32

Co nowego w ASP.NET MVC 4? ...................................................................................................... 33

Podsumowanie ..................................................................................................................................... 33

Kup książkę

Poleć książkę

SPIS TREŚCI

Rozdział 2. Pierwsza aplikacja MVC .........................................................................................35

Przygotowanie stacji roboczej ............................................................................................................ 35

Tworzenie nowego projektu ASP.NET MVC ................................................................................. 36

Dodawanie pierwszego kontrolera ............................................................................................. 38

Przedstawiamy ścieżki .................................................................................................................. 40

Generowanie stron WWW ................................................................................................................ 41

Tworzenie i generowanie widoku .............................................................................................. 41

Dynamiczne dodawanie treści .................................................................................................... 43

Tworzenie prostej aplikacji wprowadzania danych ........................................................................ 45

Przygotowanie sceny .................................................................................................................... 45

Projektowanie modelu danych ................................................................................................... 46

Łączenie metod akcji .................................................................................................................... 47

Budowanie formularza ................................................................................................................. 49

Obsługa formularzy ...................................................................................................................... 51

Dodanie kontroli poprawności ................................................................................................... 54

Kończymy ...................................................................................................................................... 60

Podsumowanie ..................................................................................................................................... 61

Rozdział 3. Wzorzec MVC .........................................................................................................63

Historia MVC ....................................................................................................................................... 63

Wprowadzenie do wzorca MVC ....................................................................................................... 64

Budowa modelu domeny ............................................................................................................. 64

Implementacja MVC w ASP.NET .............................................................................................. 65

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

Przedstawiam wzorzec Smart UI ................................................................................................ 65

Modelowanie domeny ......................................................................................................................... 68

Przykładowy model domeny ....................................................................................................... 69

Wspólny język ............................................................................................................................... 69

Agregaty i uproszczenia ............................................................................................................... 70

Definiowanie repozytoriów ......................................................................................................... 71

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

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

Przykład specyficzny dla MVC ................................................................................................... 75

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

Zaczynamy testy automatyczne ......................................................................................................... 76

Zadania testów jednostkowych ................................................................................................... 77

Zadania testów integracyjnych ................................................................................................... 84

Podsumowanie ..................................................................................................................................... 84

Rozdział 4. Najważniejsze cechy języka ...................................................................................85

Utworzenie przykładowego projektu ................................................................................................ 85

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

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

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

Stosowanie metod rozszerzających do interfejsów .................................................................. 93

Tworzenie filtrujących metod rozszerzających ........................................................................ 95

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

Automatyczne wnioskowanie typów .............................................................................................. 100

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

6

Kup książkę

Poleć książkę

SPIS TREŚCI

Wykonywanie zapytań LINQ .......................................................................................................... 102

Opóźnione zapytania LINQ ...................................................................................................... 105

Użycie metod asynchronicznych ..................................................................................................... 107

Użycie słów kluczowych async i await ..................................................................................... 108

Podsumowanie ................................................................................................................................... 109

Rozdział 5. Praca z silnikiem Razor ........................................................................................111

Tworzenie projektu ........................................................................................................................... 111

Definiowanie modelu ................................................................................................................. 111

Definiowanie kontrolera ............................................................................................................ 112

Tworzenie widoku ...................................................................................................................... 113

Korzystanie z obiektów modelu ...................................................................................................... 114

Praca z układami ................................................................................................................................ 116

Tworzenie układu ....................................................................................................................... 116

Stosowanie układu ...................................................................................................................... 118

Użycie pliku ViewStart ............................................................................................................... 119

Użycie układów współdzielonych ............................................................................................ 119

Użycie wyrażeń Razor ....................................................................................................................... 123

Wstawianie wartości danych ..................................................................................................... 124

Przypisanie wartości atrybutu ................................................................................................... 125

Użycie konstrukcji warunkowych ............................................................................................ 127

Wyliczanie tablic i kolekcji ........................................................................................................ 129

Praca z przestrzenią nazw .......................................................................................................... 132

Podsumowanie ................................................................................................................................... 132

Rozdział 6. Ważne narzędzia wspierające MVC .....................................................................133

Tworzenie przykładowego projektu ............................................................................................... 134

Utworzenie klas modelu ............................................................................................................ 134

Dodanie kontrolera .................................................................................................................... 135

Dodanie widoku .......................................................................................................................... 136

Użycie Ninject .................................................................................................................................... 136

Zrozumienie problemu .............................................................................................................. 137

Zaczynamy korzystać z Ninject ................................................................................................ 139

Konfiguracja wstrzykiwania zależności na platformie MVC ............................................... 141

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

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

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

Testy jednostkowe w Visual Studio ................................................................................................. 149

Tworzenie projektu testów jednostkowych ............................................................................ 150

Tworzenie testów jednostkowych ............................................................................................ 151

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

Implementacja funkcji ............................................................................................................... 155

Testowanie i poprawianie kodu ................................................................................................ 156

Użycie Moq ......................................................................................................................................... 157

Zrozumienie problemu .............................................................................................................. 158

Dodawanie Moq do projektu Visual Studio ........................................................................... 159

Dodanie obiektu imitacyjnego do testu jednostkowego ....................................................... 160

Tworzenie obiektu imitacji ........................................................................................................ 161

Tworzenie bardziej skomplikowanych obiektów Mock ....................................................... 163

Podsumowanie ................................................................................................................................... 166

7

Kup książkę

Poleć książkę

SPIS TREŚCI

Rozdział 7. SportsStore — kompletna aplikacja ....................................................................167

Zaczynamy .......................................................................................................................................... 168

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

Dodawanie referencji ................................................................................................................. 169

Konfigurowanie kontenera DI .................................................................................................. 171

Uruchamiamy aplikację ............................................................................................................. 172

Tworzenie modelu domeny ............................................................................................................. 173

Tworzenie abstrakcyjnego repozytorium ................................................................................ 174

Tworzenie imitacji repozytorium ............................................................................................. 174

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

Dodawanie kontrolera ............................................................................................................... 176

Dodawanie widoku ..................................................................................................................... 177

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

Uruchamianie aplikacji .............................................................................................................. 179

Przygotowanie bazy danych ............................................................................................................. 179

Tworzenie bazy danych ............................................................................................................. 180

Definiowanie schematu bazy danych ...................................................................................... 181

Dodawanie danych do bazy ....................................................................................................... 182

Tworzenie kontekstu Entity Framework ................................................................................. 183

Tworzenie repozytorium produktów ...................................................................................... 184

Dodanie stronicowania ..................................................................................................................... 186

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

Ulepszanie adresów URL ........................................................................................................... 195

Dodawanie stylu ................................................................................................................................. 196

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

Dodanie stylów CSS .................................................................................................................... 197

Tworzenie widoku częściowego ............................................................................................... 199

Podsumowanie ................................................................................................................................... 200

Rozdział 8. SportsStore — nawigacja ....................................................................................201

Dodawanie kontrolek nawigacji ...................................................................................................... 201

Filtrowanie listy produktów ...................................................................................................... 201

Ulepszanie schematu URL ......................................................................................................... 203

Budowanie menu nawigacji po kategoriach ........................................................................... 207

Poprawianie licznika stron ........................................................................................................ 214

Budowanie koszyka na zakupy ........................................................................................................ 216

Definiowanie encji koszyka ....................................................................................................... 217

Tworzenie przycisków koszyka ................................................................................................ 221

Implementowanie kontrolera koszyka .................................................................................... 222

Wyświetlanie zawartości koszyka ............................................................................................. 224

Podsumowanie ................................................................................................................................... 227

Rozdział 9. SportsStore — ukończenie koszyka na zakupy ....................................................229

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

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

Kończenie budowania koszyka ........................................................................................................ 234

Usuwanie produktów z koszyka ............................................................................................... 234

Dodawanie podsumowania koszyka ........................................................................................ 234

8

Kup książkę

Poleć książkę

SPIS TREŚCI

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

Rozszerzanie modelu domeny .................................................................................................. 237

Dodawanie procesu zamawiania .............................................................................................. 238

Implementowanie mechanizmu przetwarzania zamówień .................................................. 241

Rejestrowanie implementacji .................................................................................................... 243

Zakończenie pracy nad kontrolerem koszyka ........................................................................ 244

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

Wyświetlanie strony podsumowania ....................................................................................... 249

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

Rozdział 10. SportsStore — administracja ...............................................................................251

Dodajemy zarządzanie katalogiem .................................................................................................. 251

Tworzenie kontrolera CRUD .................................................................................................... 251

Tworzenie nowego pliku układu .............................................................................................. 253

Implementowanie widoku listy ................................................................................................ 255

Edycja produktów ....................................................................................................................... 260

Tworzenie nowych produktów ................................................................................................. 271

Usuwanie produktów ................................................................................................................. 272

Podsumowanie ................................................................................................................................... 275

Rozdział 11. SportsStore — bezpieczeństwo i ostatnie usprawnienia .....................................277

Zabezpieczanie funkcji administracyjnych .................................................................................... 277

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

Tworzenie dostawcy uwierzytelniania ..................................................................................... 280

Tworzenie kontrolera AccountController .............................................................................. 281

Tworzenie widoku ...................................................................................................................... 283

Przesyłanie zdjęć ................................................................................................................................ 286

Rozszerzanie bazy danych ......................................................................................................... 286

Rozszerzanie modelu domeny .................................................................................................. 287

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

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

Implementowanie metody akcji GetImage ............................................................................. 290

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

Podsumowanie ................................................................................................................................... 293

Część II ASP.NET MVC 4 — szczegółowy opis ....................................295

Rozdział 12. Przegląd projektu MVC ........................................................................................297

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

Przedstawienie konwencji MVC .............................................................................................. 301

Debugowanie aplikacji MVC ........................................................................................................... 302

Tworzenie projektu .................................................................................................................... 302

Uruchamianie debugera Visual Studio .................................................................................... 304

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

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

Podsumowanie ................................................................................................................................... 313

Rozdział 13. Routing URL .........................................................................................................315

Tworzenie projektu routingu ........................................................................................................... 316

Wprowadzenie do wzorców URL ................................................................................................... 318

9

Kup książkę

Poleć książkę

SPIS TREŚCI

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

Użycie prostej ścieżki ................................................................................................................. 324

Definiowanie wartości domyślnych ................................................................................................ 325

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

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

Użycie własnych zmiennych jako parametrów metod akcji ................................................ 334

Definiowanie opcjonalnych segmentów URL ........................................................................ 335

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

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

Ograniczenia ścieżek ......................................................................................................................... 342

Ograniczanie ścieżki z użyciem wyrażeń regularnych .......................................................... 342

Ograniczanie ścieżki do zbioru wartości ................................................................................. 343

Ograniczanie ścieżek z użyciem metod HTTP ....................................................................... 343

Definiowanie własnych ograniczeń ......................................................................................... 344

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

Konfiguracja serwera aplikacji .................................................................................................. 347

Definiowanie ścieżek dla plików na dysku .............................................................................. 349

Pomijanie systemu routingu ............................................................................................................ 350

Podsumowanie ................................................................................................................................... 351

Rozdział 14. Zaawansowane funkcje routingu ........................................................................353

Przygotowanie projektu .................................................................................................................... 353

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

Użycie systemu routingu do wygenerowania wychodzącego adresu URL ........................ 354

Użycie innych kontrolerów ....................................................................................................... 357

Przekazywanie dodatkowych parametrów .............................................................................. 358

Definiowanie atrybutów HTML ............................................................................................... 360

Generowanie w pełni kwalifikowanych adresów URL w łączach ........................................ 360

Generowanie adresów URL (nie łączy) ................................................................................... 361

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

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

Dostosowanie systemu routingu ..................................................................................................... 364

Tworzenie własnej implementacji RouteBase ........................................................................ 364

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

Korzystanie z obszarów .................................................................................................................... 369

Tworzenie obszaru ...................................................................................................................... 369

Wypełnianie obszaru .................................................................................................................. 371

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

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

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

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

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

Podsumowanie ................................................................................................................................... 376

Rozdział 15. Kontrolery i akcje .................................................................................................377

Wprowadzenie do kontrolerów ....................................................................................................... 377

Przygotowanie projektu ............................................................................................................. 377

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

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

10

Kup książkę

Poleć książkę

SPIS TREŚCI

Odczytywanie danych wejściowych ................................................................................................ 380

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

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

Tworzenie danych wyjściowych ...................................................................................................... 383

Wyniki akcji ................................................................................................................................. 385

Zwracanie kodu HTML przez generowanie widoku ............................................................. 388

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

Wykonywanie przekierowań .................................................................................................... 394

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

Podsumowanie ................................................................................................................................... 401

Rozdział 16. Filtry ....................................................................................................................403

Użycie filtrów ..................................................................................................................................... 403

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

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

Tworzenie projektu ........................................................................................................................... 406

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

Użycie własnego filtra autoryzacji ............................................................................................ 409

Użycie wbudowanego filtra autoryzacji .................................................................................. 409

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

Tworzenie filtra wyjątku ............................................................................................................ 411

Użycie filtra wyjątków ................................................................................................................ 412

Użycie widoku w celu reakcji na wyjątek ................................................................................ 414

Użycie wbudowanego filtra wyjątków ..................................................................................... 417

Użycie filtrów akcji ............................................................................................................................ 419

Implementacja metody OnActionExecuting .......................................................................... 420

Implementacja metody OnActionExecuted ........................................................................... 421

Używanie filtra wyniku ..................................................................................................................... 423

Użycie wbudowanych klas filtrów akcji i wyniku .................................................................. 424

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

Filtrowanie bez użycia atrybutów ............................................................................................. 426

Użycie filtrów globalnych .......................................................................................................... 427

Określanie kolejności wykonywania filtrów ........................................................................... 429

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

Użycie filtra RequireHttps ......................................................................................................... 432

Użycie filtra OutputCache ......................................................................................................... 432

Podsumowanie ................................................................................................................................... 435

Rozdział 17. Rozszerzanie kontrolerów ....................................................................................437

Tworzenie projektu ........................................................................................................................... 437

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

Przygotowanie kontrolera zapasowego ................................................................................... 441

Utworzenie klasy kontrolera ..................................................................................................... 442

Implementacja innych metod interfejsu ................................................................................. 442

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

Wykorzystanie wbudowanej fabryki kontrolerów ........................................................................ 443

Nadawanie priorytetów przestrzeniom nazw ......................................................................... 444

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

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

11

Kup książkę

Poleć książkę

SPIS TREŚCI

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

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

Selekcja metod akcji .................................................................................................................... 451

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

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

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

Podsumowanie ................................................................................................................................... 463

Rozdział 18. Widoki .................................................................................................................465

Tworzenie własnego silnika widoku ............................................................................................... 465

Tworzenie przykładowego projektu ........................................................................................ 467

Tworzenie własnej implementacji IView ................................................................................ 468

Tworzenie implementacji IViewEngine .................................................................................. 468

Rejestrowanie własnego silnika widoku .................................................................................. 470

Testowanie silnika widoku ........................................................................................................ 470

Korzystanie z silnika Razor .............................................................................................................. 472

Tworzenie przykładowego projektu ........................................................................................ 472

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

Konfigurowanie wyszukiwania lokalizacji widoków ............................................................. 475

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

Zastosowanie sekcji .................................................................................................................... 478

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

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

Podsumowanie ................................................................................................................................... 488

Rozdział 19. Metody pomocnicze ............................................................................................489

Tworzenie przykładowego projektu ............................................................................................... 489

Tworzenie własnej metody pomocniczej ....................................................................................... 491

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

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

Zarządzanie kodowaniem ciągów tekstowych w metodzie pomocniczej .......................... 496

Użycie wbudowanych metod pomocniczych ................................................................................ 500

Przygotowania do obsługi formularzy ..................................................................................... 500

Określenie ścieżki używanej przez formularz ......................................................................... 507

Użycie metod pomocniczych do wprowadzania danych ...................................................... 508

Tworzenie znaczników select .................................................................................................... 513

Podsumowanie ................................................................................................................................... 515

Rozdział 20. Szablonowe metody pomocnicze ........................................................................517

Przegląd przykładowego projektu ................................................................................................... 517

Używanie szablonowych metod pomocniczych ............................................................................ 519

Generowanie etykiety i wyświetlanie elementów ................................................................... 522

Użycie szablonowych metod pomocniczych dla całego modelu ......................................... 525

Użycie metadanych modelu ............................................................................................................. 527

Użycie metadanych do sterowania edycją i widocznością .................................................... 528

Użycie metadanych dla etykiet ................................................................................................. 530

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

Użycie metadanych do wybierania szablonu wyświetlania .................................................. 533

Dodawanie metadanych do klasy zaprzyjaźnionej ................................................................ 535

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

12

Kup książkę

Poleć książkę

SPIS TREŚCI

Dostosowywanie systemu szablonowych metod pomocniczych ................................................ 538

Tworzenie własnego szablonu edytora .................................................................................... 538

Tworzenie szablonu ogólnego .................................................................................................. 539

Wymiana szablonów wbudowanych ....................................................................................... 540

Podsumowanie ................................................................................................................................... 541

Rozdział 21. Metody pomocnicze URL i Ajax ............................................................................543

Przegląd i przygotowanie projektu .................................................................................................. 543

Tworzenie podstawowych łączy i adresów URL ........................................................................... 545

Nieprzeszkadzający Ajax .................................................................................................................. 547

Tworzenie widoku formularza synchronicznego .................................................................. 547

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

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

Przygotowanie kontrolera ......................................................................................................... 550

Tworzenie formularza Ajax ....................................................................................................... 552

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

Ustawianie opcji Ajax ........................................................................................................................ 554

Zapewnienie kontrolowanej degradacji .................................................................................. 554

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

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

Tworzenie łączy Ajax ........................................................................................................................ 558

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

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

Wykorzystanie JSON ......................................................................................................................... 562

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

Przetwarzanie JSON w przeglądarce ........................................................................................ 564

Przygotowanie danych do kodowania ..................................................................................... 565

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

Podsumowanie ................................................................................................................................... 570

Rozdział 22. Dołączanie modelu ..............................................................................................571

Przygotowanie projektu .................................................................................................................... 571

Użycie dołączania modelu ................................................................................................................ 573

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

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

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

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

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

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

Dostosowanie systemu dołączania modelu ................................................................................... 591

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

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

Rejestracja własnego łącznika modelu ..................................................................................... 596

Podsumowanie ................................................................................................................................... 597

Rozdział 23. Kontrola poprawności modelu ............................................................................599

Tworzenie projektu ........................................................................................................................... 599

Jawna kontrola poprawności modelu ............................................................................................. 602

Wyświetlenie użytkownikowi błędów podczas kontroli poprawności ............................... 603

13

Kup książkę

Poleć książkę

SPIS TREŚCI

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

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

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

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

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

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

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

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

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

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

Wykonywanie zdalnej kontroli poprawności ................................................................................ 621

Podsumowanie ................................................................................................................................... 624

Rozdział 24. Paczki i tryby wyświetlania .................................................................................625

Domyślne biblioteki skryptów ......................................................................................................... 625

Tworzenie przykładowej aplikacji ................................................................................................... 627

Zarządzanie skryptami i stylami ...................................................................................................... 630

Profilowanie wczytywania skryptów i arkuszy stylów .......................................................... 630

Używanie paczek stylów i skryptów ................................................................................................ 632

Stosowanie paczek ...................................................................................................................... 635

Używanie sekcji script ................................................................................................................ 637

Profilowanie wprowadzonych zmian ...................................................................................... 638

Przygotowanie aplikacji dla urządzeń mobilnych ........................................................................ 640

Aplikacja standardowa ............................................................................................................... 641

Użycie widoków i układów przeznaczonych dla urządzeń mobilnych .............................. 642

Tworzenie własnych trybów wyświetlania .............................................................................. 643

Podsumowanie ................................................................................................................................... 646

Rozdział 25. Web API ...............................................................................................................647

Zrozumienie Web API ...................................................................................................................... 647

Tworzenie aplikacji Web API .......................................................................................................... 648

Tworzenie modelu i repozytorium .......................................................................................... 648

Tworzenie kontrolera Home ..................................................................................................... 650

Utworzenie widoku i CSS .......................................................................................................... 651

Tworzenie kontrolera API ................................................................................................................ 653

Testowanie kontrolera API ....................................................................................................... 655

Jak działa kontroler API? .................................................................................................................. 656

Jak wybierana jest akcja kontrolera API? ................................................................................ 657

Mapowanie metod HTTP na metody akcji ............................................................................. 657

Tworzenie kodu JavaScript wykorzystującego interfejs Web API ............................................. 658

Tworzenie funkcji podstawowych ............................................................................................ 659

Dodanie obsługi edycji nowych rezerwacji ............................................................................. 661

Dodanie obsługi usuwania rezerwacji ..................................................................................... 663

Dodanie obsługi tworzenia rezerwacji ..................................................................................... 664

Podsumowanie ................................................................................................................................... 665

Rozdział 26. Wdrażanie aplikacji .............................................................................................667

Przygotowanie aplikacji do dystrybucji .......................................................................................... 668

Wykrywanie błędów widoku .................................................................................................... 668

Wyłączanie trybu debugowania ................................................................................................ 670

Usunięcie nieużywanych ciągów tekstowych połączenia ..................................................... 670

14

Kup książkę

Poleć książkę

SPIS TREŚCI

Przygotowanie do użycia Windows Azure .................................................................................... 671

Tworzenie witryny internetowej i bazy danych ..................................................................... 672

Przygotowanie bazy danych do zdalnej administracji .......................................................... 674

Tworzenie schematu bazy danych ........................................................................................... 674

Wdrażanie aplikacji ........................................................................................................................... 676

Podsumowanie ................................................................................................................................... 680

Skorowidz ............................................................................................................681

15

Kup książkę

Poleć książkę

SPIS TREŚCI

16

Kup książkę

Poleć książkę

R O Z D Z I A 1 3 .

„ „ „

Routing URL

Przed wprowadzeniem platformy MVC założono w ASP.NET, że istnieje bezpośrednia relacja pomiędzy adresem URL żądania a plikiem na dysku serwera. Zadaniem serwera było odczytanie żądania wysłanego przez przeglądarkę i dostarczenie wyniku z odpowiedniego pliku.

dany URL

Odpowiadajcy mu plik

http://witryna.pl/default.aspx

e:\webroot\default.aspx

http://witryna.pl/admin/login.aspx

e:\webroot\admin\login.aspx

http://witryna.pl/articles/AnnualReview

Plik nie został znaleziony! Wygeneruj błąd 404.

Podejście to działa świetnie dla Web Forms, gdzie każda strona ASPX jest plikiem i zawiera odpowiedź

na żądanie. Nie ma to sensu dla aplikacji MVC, w których żądania są przetwarzane przez metody akcji w klasach kontrolera i nie ma bezpośredniej korelacji z plikami na dysku.

Aby obsługiwać adresy URL MVC, platforma ASP.NET korzysta z systemu routingu. W tym rozdziale pokażę, jak konfigurować i wykorzystywać routing w celu utworzenia zaawansowanego i elastycznego systemu obsługi adresów URL dla naszych projektów. Jak się przekonasz, system routingu oferuje możliwość tworzenia dowolnych wzorców URL i opisywania ich w jasny i spójny sposób. System routingu ma dwie funkcje: x Analiza przychodzącego żądania URL i określenie kontrolera i akcji przeznaczonych dla tego żądania.

Jak można się spodziewać, jest to oczekiwana akcja w przypadku otrzymania żądania klienta.

x Generowanie wychodzących adresów URL. Są to adresy URL pojawiające się w stronach HTML

generowanych na podstawie naszych widoków, dzięki czemu po kliknięciu łącza przez użytkownika generowane są odpowiednie akcje (i stają się ponownie przychodzącymi żądaniami URL).

W pierwszej części tego rozdziału skupimy się na definiowaniu ścieżek i korzystaniu z nich do przetwarzania przychodzących adresów URL, dzięki którym użytkownik wywołuje nasze kontrolery i akcje. Następnie pokażę, w jaki sposób korzystać z tych samych ścieżek do wygenerowania wychodzących adresów URL, które musimy dołączać do widoków. Dowiesz się również, jak system routingu dostosować do własnych potrzeb i jak używać funkcji o nazwie obszary.

Kup książkę

Poleć książkę

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

Tworzenie projektu routingu

Aby zademonstrować działanie systemu routingu, potrzebujemy projektu, w którym możemy dodawać ścieżki.

Na potrzeby tego rozdziału tworzymy aplikację MVC z wykorzystaniem szablonu Podstawowe i nadajemy jej nazwę UrlsAndRoutes.

„ Wskazówka W tym rozdziale znajdziesz wiele rónych testów jednostkowych. Jeeli chcesz je wykorzysta ,

to podczas tworzenia nowego projektu musisz zaznaczy pole wyboru Utwórz projekt testu jednostki,

a nastpnie uy menedera pakietów NuGet w celu dodania biblioteki Moq do projektu.

W celu zademonstrowania funkcji routingu konieczne jest dodanie kilku prostych kontrolerów do utworzonej przed chwilą aplikacji. W rozdziale koncentrujemy się jedynie na sposobie interpretacji adresów URL w celu wywołania metod akcji. Jako modeli widoków będziemy więc używać ciągów tekstowych zdefiniowanych w ViewBag, które podają nazwę kontrolera i metody akcji. Jako pierwszy utwórz kontroler HomeController i umieść w nim kod przedstawiony na listingu 13.1.

Listing 13.1. Kod kontrolera HomeController

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

namespace UrlsAndRoutes.Controllers {

public class HomeController : Controller {

public ActionResult Index() {

ViewBag.Controller = "Home";

ViewBag.Action = "Index";

return View("ActionName");

}

}

}

Następnie utwórz kontroler CustomerController i umieść w nim kod przedstawiony na listingu 13.2.

Listing 13.2. Kod kontrolera CustomerController

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

namespace UrlsAndRoutes.Controllers {

public class CustomerController : Controller {

public ActionResult Index() {

ViewBag.Controller = "Customer";

ViewBag.Action = "Index";

return View("ActionName");

}

316

Kup książkę

Poleć książkę

ROZDZIA 13. „ ROUTING URL

public ActionResult List() {

ViewBag.Controller = "Customer";

ViewBag.Action = "List";

return View("ActionName");

}

}

}

Utwórz kolejny kontroler i nadaj mu nazwę AdminController, a następnie umieść w nim kod przedstawiony na listingu 13.3.

Listing 13.3. Kod kontrolera AdminController

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

namespace UrlsAndRoutes.Controllers {

public class AdminController : Controller {

public ActionResult Index() {

ViewBag.Controller = "Admin";

ViewBag.Action = "Index";

return View("ActionName");

}

}

}

We wszystkich metodach akcji utworzonych kontrolerów został użyty widok ActionName, który pozwala na zdefiniowanie jednego widoku i jego użycie w całej aplikacji. Do katalogu /Views/Shared projektu dodaj więc widok o nazwie ActionName.cshtml i umieść w nim kod przedstawiony na listingu 13.4.

Listing 13.4. Kod widoku ActionName.cshtml

@{

Layout = null;

}

<!DOCTYPE html>

<html>

<head>

<meta name="viewport" content="width=device-width" />

<title>ActionName</title>

</head>

<body>

<div>Nazwa kontrolera: @ViewBag.Controller</div>

<div>Nazwa akcji: @ViewBag.Action</div>

</body>

</html>

Po uruchomieniu aplikacji otrzymasz komunikaty widoczne na rysunku 13.1.

317

Kup książkę

Poleć książkę

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

Rysunek 13.1. Efekt uruchomienia przykładowej aplikacji

Wprowadzenie do wzorców URL

System routingu działa dzięki wykorzystaniu zbioru ścieżek. Ścieżki te są nazywane schematem URL dla aplikacji i definiują zbiór adresów URL, jakie aplikacja rozpoznaje i na jakie odpowiada.

Nie musimy ręcznie wpisywać wszystkich adresów URL, jakie chcemy obsługiwać. Zamiast tego każda ścieżka zawiera wzorzec URL, który jest porównywany z przychodzącym adresem URL. Jeżeli wzorzec pasuje do adresu, jest używany do przetworzenia tego adresu URL. Zacznijmy od przykładowego adresu URL

aplikacji utworzonej w rozdziale:

http://witryna.pl/Admin/Index

Adresy URL mogą być podzielone na segmenty. Są to te części adresu URL, które są rozdzielane znakiem /

z pominięciem nazwy hosta oraz ciągu zapytania. W przykładowym adresie URL występują dwa segmenty, jak pokazano na rysunku 13.2.

Rysunek 13.2. Segmenty przykładowego adresu URL

Pierwszy segment zawiera słowo Admin, a drugi słowo Index. Dla ludzkiego oka jest oczywiste, że pierwszy argument odnosi się do kontrolera, a drugi do akcji. Jasne jest, że musimy wyrazić tę relację w sposób zrozumiały dla systemu routingu. Wzorzec URL realizujący to zadanie wygląda następująco:

{controller}/{action}

W czasie przetwarzania przychodzącego adresu URL zadaniem systemu routingu jest dopasowanie adresu URL do wzorca oraz pobranie wartości do zmiennych segmentu zdefiniowanych we wzorcu. Zmienne segmentu są zapisywane z użyciem nawiasów klamrowych (znaków { oraz }). Przykładowy wzorzec zawiera dwie zmienne segmentu, o nazwach controller i action. Dlatego też wartością zmiennej segmentu controller jest Admin, natomiast wartością zmiennej segmentu action jest Index.

Mówimy o dopasowaniu wzorca, ponieważ aplikacja MVC zwykle zawiera kilka ścieżek, a system routingu będzie dopasowywał przychodzący adres URL do wzorca kolejnych ścieżek do momentu znalezienia dopasowania.

„ Uwaga System routingu nie posiada adnych informacji na temat kontrolerów i akcji. Po prostu pobiera wartoci do zmiennych segmentów i przekazuje je do potoku dania. W dalszej czci potoku, gdy danie trafi do platformy MVC, s one wizane ze zmiennymi kontrolera i akcji. Dziki temu system routingu moe by uywany w Web Forms

i Web API (interfejs Web API zostanie omówiony w rozdziale 25.).

318

Kup książkę

Poleć książkę

ROZDZIA 13. „ ROUTING URL

Domyślnie wzorce URL są dopasowywane do dowolnego adresu URL mającego właściwą liczbę segmentów.

Wzorzec {controller}/{action} jest dopasowywany do dowolnego adresu URL z dwoma segmentami, jak pokazano w tabeli 13.1.

Tabela 13.1. Dopasowanie adresów URL

dany URL

Zmienne segmentu

http://witryna.pl/Admin/Index

controller = Admin

action = Index

http://witryna.pl/Index/Admin

controller = Index

action = Admin

http://witryna.pl/Apples/Oranges

controller = Apples

action = Oranges

http://witryna.pl/Admin

Brak dopasowania — za mało segmentów

http://witryna.pl/Admin/Index/Apples

Brak dopasowania — za dużo segmentów

W tabeli 13.1 przedstawione są dwie kluczowe cechy wzorców URL:

x Wzorce URL są konserwatywne i pasują wyłącznie do adresów, które mają taką samą liczbę segmentów jak wzorzec. Można to zauważyć w czwartym i piątym przykładzie z tabeli.

x Wzorce URL są liberalne. Jeżeli adres URL posiada prawidłową liczbę segmentów, zostanie pobrana wartość zmiennej segmentu, niezależnie od tego, jaka ta wartość jest.

Są to kluczowe zależności, które trzeba znać, aby zrozumieć sposób domyślnego działania wzorców URL.

W dalszej części rozdziału wyjaśnimy, jak zmienić to domyślne działanie.

Jak wspomniałem, system routingu nie ma żadnych informacji na temat aplikacji MVC, dlatego wzorce URL będą dopasowywane nawet w przypadku, gdy nie ma kontrolera lub akcji pasującej do wartości pobranych z adresu URL. Jest to pokazane w drugim przykładzie z tabeli 13.1. Zamieniliśmy w nim segmenty Admin i Index, przez co również wartości pobrane z URL są zamienione, pomimo że w omawianym projekcie nie ma kontrolera Index.

Tworzenie i rejestrowanie prostej cieki

Po zapoznaniu się z wzorcami URL możemy użyć ich do zdefiniowania ścieżki. Ścieżki są definiowane w pliku RouteConfig.cs, który znajduje się w katalogu App_Start projektu. Początkowy kod wspomnianego pliku wygenerowany przez Visual Studio przedstawiono na listingu 13.5.

Listing 13.5. Domyślny kod w pliku RouteConfig.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

using System.Web.Routing;

namespace UrlsAndRoutes {

public class RouteConfig {

public static void RegisterRoutes(RouteCollection routes) {

routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

routes.MapRoute(

name: "Default",

319

Kup książkę

Poleć książkę

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

url: "{controller}/{action}/{id}",

defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }

);

}

}

}

Zdefiniowana w pliku RouteConfig.cs metoda statyczna RegisterRoutes jest wywoływana z pliku Global.asax.cs, który konfiguruje podstawowe komponenty platformy MVC podczas uruchamiania aplikacji.

Domyślna zawartość pliku Global.asax.cs została przedstawiona na listingu 13.6, a wywołanie metody RouteConfig.RegisterRoutes z metody Application_Start oznaczono pogrubioną czcionką.

Listing 13.6. Domyślna zawartość pliku Global.asax.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Http;

using System.Web.Mvc;

using System.Web.Optimization;

using System.Web.Routing;

namespace UrlsAndRoutes {

public class MvcApplication : System.Web.HttpApplication {

protected void Application_Start() {

AreaRegistration.RegisterAllAreas();

WebApiConfig.Register(GlobalConfiguration.Configuration);

FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);

RouteConfig.RegisterRoutes(RouteTable.Routes);

BundleConfig.RegisterBundles(BundleTable.Bundles);

}

}

}

Metoda Application_Start jest wywoływana przez platformę ASP.NET w trakcie pierwszego uruchomienia aplikacji MVC, co prowadzi do wywołania metody RouteConfig.RegisterRoutes.

Parametrem metody jest wartość właściwości statycznej RouteTable.Routes, która jest egzemplarzem klasy RouteCollection (funkcje wymienionej klasy zostaną wkrótce przedstawione).

„ Wskazówka Pozosta e wywo ania w metodzie Application_Start zostan omówione w innych rozdzia ach.

Wywo anie metody AreaRegistration.RegisterAllAreas przedstawi em w rozdziale 14., metody WebApiConfig.Register w rozdziale 25., metody FilterConfig.RegisterGlobalFilters w rozdziale 16., natomiast metody BundleConfig.RegisterBundles w rozdziale 24.

Na listingu 13.7 pokazałem, w jaki sposób możemy utworzyć ścieżkę w metodzie RegisterRoutes z pliku RouteConfig.cs za pomocą przykładowego wzorca URL z poprzedniego punktu. (Pozostałe polecenia w metodzie zostały usunięte, aby umożliwić Ci skoncentrowanie się na przykładzie).

Listing 13.7. Rejestrowanie ścieżki

using System;

using System.Collections.Generic;

using System.Linq;

320

Kup książkę

Poleć książkę

ROZDZIA 13. „ ROUTING URL

using System.Web;

using System.Web.Mvc;

using System.Web.Routing;

namespace UrlsAndRoutes {

public class RouteConfig {

public static void RegisterRoutes(RouteCollection routes) {

Route myRoute = new Route("{controller}/{action}",

new MvcRouteHandler());

routes.Add("MyRoute", myRoute);

}

}

}

Tworzymy tu nowy obiekt ścieżki, przekazując do konstruktora wzorzec URL jako parametr. Przekazaliśmy do niego również obiekt MvcRouteHendler. Różne technologie ASP.NET zawierają różne klasy do obsługi routingu; w aplikacjach ASP.NET MVC będziemy używać właśnie tej klasy. Utworzoną ścieżkę dodajemy do obiektu RouteCollection za pomocą metody Add — przekazujemy nazwę, pod jaką powinna być zarejestrowana ścieżka, oraz samą ścieżkę.

„ Wskazówka Nazywanie cieek jest opcjonalne i podnoszone s argumenty, e w ten sposób powica si czyst

separacj zada, któr mona uzyska przy uyciu systemu routingu. Osobicie nie przywizuj wielkiej wagi

do kwestii nazywania cieek, ale na wszelki wypadek przedstawiam zwizane z tym problemy w punkcie

„Generowanie adresu URL na podstawie wybranej cieki”, w dalszej czci rozdzia u.

Wygodniejszą metodą rejestrowania ścieżek jest użycie metody MapRoute, zdefiniowanej w klasie RouteCollection. Na listingu 13.8 przedstawione jest zastosowanie tej metody do zarejestrowania naszej ścieżki.

Otrzymany efekt jest dokładnie taki sam jak w poprzednim przykładzie, ale sama składnia jest bardziej przejrzysta.

Listing 13.8. Rejestrowanie ścieżki za pomocą metody MapRoute

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

using System.Web.Routing;

namespace UrlsAndRoutes {

public class RouteConfig {

public static void RegisterRoutes(RouteCollection routes) {

routes.MapRoute("MyRoute", "{controller}/{action}");

}

}

}

Podejście takie jest nieco bardziej zwięzłe, głównie dlatego, że nie trzeba tworzyć obiektu klasy MvcRouteHandler.

Metoda MapRoute jest przeznaczona wyłącznie dla aplikacji MVC. Aplikacje ASP.NET Web Forms mogą korzystać z metody MapPageRoute, zdefiniowanej również w klasie RouteCollection.

321

Kup książkę

Poleć książkę

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

Test jednostkowy — testowanie przychodzcych adresów URL

Zalecam, aby nawet w przypadku, gdy nie tworzymy testów jednostkowych dla reszty aplikacji, tworzy testy

jednostkowe dla cieek, dziki czemu mona si upewni , e przetwarzanie przychodzcych adresów URL dzia a

w oczekiwany sposób. Schematy URL mog by dosy rozbudowane w duych aplikacjach, wic atwo jest utworzy

co, co bdzie dawa o nieoczekiwane wyniki.

W poprzednich rozdzia ach unika em tworzenia metod pomocniczych, wspó dzielonych przez wiele testów, aby kady test by niezaleny. W tym rozdziale przyjmiemy inne podejcie. Testowanie schematu routingu dla aplikacji bdzie realizowane w najbardziej czytelny sposób, gdy po czymy kilka testów w jedn metod.

Naj atwiej moemy to zrealizowa przy uyciu metod pomocniczych.

Aby testowa cieki, musimy utworzy imitacje trzech klas: HttpRequestBase, HttpContextBase oraz

HttpResponseBase (ostatnia z nich jest potrzebna do testowania wychodzcych adresów URL, które przedstawi

w nastpnym rozdziale). Klasy te pozwalaj odtworzy fragment infrastruktury MVC obs ugujcej system routingu.

Do projektu testowego dodajemy nowy plik testów jednostkowych o nazwie RouteTests.cs. Poniej zamieszczona jest metoda pomocnicza tworzca imitacje obiektów HttpContextBase:

using System;

using Microsoft.VisualStudio.TestTools.UnitTesting;

using System.Web;

using System.Web.Routing;

using Moq;

using System.Reflection;

namespace UrlsAndRoutes.Tests {

[TestClass]

public class RouteTests {

private HttpContextBase CreateHttpContext(string targetUrl = null,

string httpMethod = "GET") {

// tworzenie imitacji żądania

Mock<HttpRequestBase> mockRequest = new Mock<HttpRequestBase>();

mockRequest.Setup(m => m.AppRelativeCurrentExecutionFilePath)

.Returns(targetUrl);

mockRequest.Setup(m => m.HttpMethod).Returns(httpMethod);

// tworzenie imitacji odpowiedzi

Mock<HttpResponseBase> mockResponse = new Mock<HttpResponseBase>(); mockResponse.Setup(m => m.ApplyAppPathModifier(

It.IsAny<string>())).Returns<string>(s => s);

// tworzenie imitacji kontekstu z użyciem żądania i odpowiedzi

Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>();

mockContext.Setup(m => m.Request).Returns(mockRequest.Object);

mockContext.Setup(m => m.Response).Returns(mockResponse.Object);

// zwraca imitację kontekstu

return mockContext.Object;

}

}

}

Konfiguracja jest prostsza, ni si wydaje. Udostpniamy URL do testowania poprzez w aciwo AppRelativeCurrentExecutionFilePath klasy HttpRequestBase; udostpniamy take HttpRequestBase poprzez w aciwo Request imitacji klasy HttpContextBase.

322

Kup książkę

Poleć książkę

ROZDZIA 13. „ ROUTING URL

Nasza nastpna metoda pomocnicza pozwala testowa ciek:

...

private void TestRouteMatch(string url, string controller, string action,

object routeProperties = null, string httpMethod = "GET") {

// przygotowanie

RouteCollection routes = new RouteCollection();

RouteConfig.RegisterRoutes(routes);

// działanie — przetwarzanie ścieżki

RouteData result = routes.GetRouteData(CreateHttpContext(url, httpMethod));

// asercje

Assert.IsNotNull(result);

Assert.IsTrue(TestIncomingRouteResult(result, controller,

action, routeProperties));

}

...

Parametr tej metody pozwala nam okreli adres URL do testowania, oczekiwane wartoci dla zmiennych

segmentów kontrolera i akcji oraz obiekt zawierajcy oczekiwane wartoci dowolnych innych zdefiniowanych zmiennych. Sposób tworzenia takich zmiennych poka w dalszej czci rozdzia u. Zdefiniowalimy równie

parametr dla metody HTTP, którego uyjemy w punkcie „Ograniczanie cieek”.

Metoda TestRouteMatch bazuje na innej metodzie, TestIncomingRouteResult, która porównuje wyniki uzyskane z systemu routingu z oczekiwanymi wartociami zmiennych segmentów. Metody te korzystaj z refleksji

.NET, dziki czemu moemy uywa typów anonimowych do definiowania dodatkowych zmiennych segmentów.

Jeeli to, co tu napisa em, nie ma dla Ciebie sensu, nie przejmuj si, nie jest to wymagane do zrozumienia mechanizmów MVC, lecz jedynie u atwia testowanie. Poniej zamieszczona jest metoda TestIncommingRouteResult:

...

private bool TestIncomingRouteResult(RouteData routeResult, string controller, string action, object propertySet = null) {

Func<object, object, bool> valCompare = (v1, v2) => {

return StringComparer.InvariantCultureIgnoreCase.Compare(v1, v2) == 0;

};

bool result = valCompare(routeResult.Values["controller"], controller)

&& valCompare(routeResult.Values["action"], action);

if (propertySet != null) {

PropertyInfo[] propInfo = propertySet.GetType().GetProperties();

foreach (PropertyInfo pi in propInfo) {

if (!(routeResult.Values.ContainsKey(pi.Name)

&& valCompare(routeResult.Values[pi.Name],

pi.GetValue(propertySet, null)))) {

result = false;

break;

}

}

}

return result;

}

...

323

Kup książkę

Poleć książkę

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

Potrzebujemy równie sprawdzi niedzia ajcy adres URL. Jak poka, moe to by wana cz definiowania

schematu URL.

...

private void TestRouteFail(string url) {

// przygotowanie

RouteCollection routes = new RouteCollection();

RouteConfig.RegisterRoutes(routes);

// działanie — przetwarzanie ścieżki

RouteData result = routes.GetRouteData(CreateHttpContext(url));

// asercje

Assert.IsTrue(result == null || result.Route == null);

}

...

Metody TestRouteMatch oraz TestRouteFail zawieraj wywo ania metody Assert, która zg asza wyjtek, jeeli asercja si nie powiedzie. Poniewa wyjtki C# s propagowane w gór stosu, moemy utworzy prost

metod testow, która pozwoli sprawdzi zestaw adresów URL. Poniej znajduje si metoda testujca ciek

zdefiniowan na listingu 13.8.

...

[TestMethod]

public void TestIncomingRoutes() {

// sprawdzenie, czy otrzymamy adres URL, jakiego oczekiwaliśmy

TestRouteMatch("~/Admin/Index", "Admin", "Index");

// sprawdzenie wartości uzyskanych z segmentów

TestRouteMatch("~/One/Two", "One", "Two");

// upewnienie się, że za mało lub za dużo segmentów spowoduje błąd dopasowania TestRouteFail("~/Admin/Index/Segment");

TestRouteFail("~/Admin");

}

...

Test ten korzysta z metody TestRouteMatch do sprawdzenia oczekiwanego adresu URL, a take do sprawdzenia adresu w tym samym formacie, aby mona by o si upewni , e wartoci kontrolera i akcji

s pozyskiwane w prawid owych segmentach URL. Wykorzystalimy równie metod TestRouteFail w celu upewnienia si, e nasza aplikacja nie zaakceptuje adresów URL majcych inn liczb segmentów. Przy testowaniu musimy poprzedzi adres URL znakiem tyldy (~), poniewa w taki sposób platforma ASP.NET

prezentuje adresy URL systemowi routingu.

Zwró uwag, e nie musimy definiowa cieek w metodach testowych. adujemy tu cieki bezporednio

z metody RegisterRoutes, zdefiniowanej w klasie RouteConfig.

Użycie prostej ścieżki

Możemy zobaczyć efekt działania utworzonych ścieżek przez uruchomienie aplikacji. Gdy przeglądarka zażąda głównego adresu URL, aplikacja zwróci błąd. Jeżeli jednak podasz ścieżkę dopasowaną do wzorca

{controller}/{action}, wówczas otrzymasz wynik pokazany na rysunku 13.3. Na wspomnianym rysunku pokazano efekt przejścia w aplikacji do adresu URL /Admin/Index.

324

Kup książkę

Poleć książkę

ROZDZIA 13. „ ROUTING URL

Rysunek 13.3. Nawigacja za pomocą prostej ścieżki

Nasza prosta ścieżka nie informuje platformy MVC, w jaki sposób ma odpowiadać na żądania dotyczące głównego adresu URL, i obsługuje tylko jeden, konkretny wzorzec URL. Tymczasowo wykonaliśmy więc krok wstecz względem funkcjonalności zdefiniowanej przez Visual Studio w pliku RouteConfig.cs podczas tworzenia projektu MVC. W dalszej części rozdziału pokażę, jak tworzyć bardziej złożone ścieżki i wzorce.

Definiowanie wartoci domylnych

Powodem pojawienia się błędu w przypadku domyślnego adresu URL dla aplikacji jest brak dopasowania do zdefiniowanej przez nas ścieżki. Domyślny adres URL jest przedstawiany systemowi routingu jako ~/, więc nie ma w nim segmentów, które mogłyby być dopasowane do zmiennych controller oraz action.

Jak wcześniej wyjaśniłem, wzorce URL są konserwatywne, więc pasują wyłącznie do adresów URL

o zdefiniowanej liczbie segmentów. Wspominałem również, że jest to domyślne zachowanie. Jednym ze sposobów zmiany tego zachowania jest użycie wartości domyślnych. Wartości domyślne są stosowane, gdy adres URL

nie zawiera segmentu, który można dopasować do wartości. Na listingu 13.9 zamieściłem przykład ścieżki zawierającej wartość domyślną.

„ Uwaga Od tej chwili, gdy pokazuj jakkolwiek now konfiguracj routingu, wszelkie zmiany musisz wprowadza w metodzie RegisterRoutes klasy RouteConfig.

Listing 13.9. Określanie wartości domyślnej w ścieżce

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

using System.Web.Routing;

namespace UrlsAndRoutes {

public class RouteConfig {

public static void RegisterRoutes(RouteCollection routes) {

routes.MapRoute("MyRoute", "{controller}/{action}", new { action = "Index" });

}

}

}

Wartości domyślne są dostarczane jako właściwości w typie anonimowym. Na listingu 13.9 zdefiniowaliśmy wartość domyślną Index dla zmiennej action. Ścieżka ta będzie dopasowywana do wszystkich dwusegmentowych adresów URL, tak jak poprzednio. Gdy zażądamy na przykład adresu URL http://witryna.pl/Home/Index, ścieżka pobierze Home jako wartość dla controller oraz Index jako wartość action.

325

Kup książkę

Poleć książkę

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

Teraz mamy jednak przekazaną wartość domyślną dla segmentu action, więc ścieżka będzie dopasowywana również dla jednosegmentowych adresów URL. Przetwarzając adres URL, system routingu pobierze wartość zmiennej controller z jedynego segmentu adresu URL oraz użyje wartości domyślnej dla zmiennej action.

Zatem gdy zażądamy adresu URL http://witryna.pl/Home, zostanie wywołana metoda akcji Index z kontrolera Home.

Możemy pójść dalej i zdefiniować adresy URL niezawierające żadnych zmiennych segmentów, bazując przy identyfikowaniu kontrolera i akcji wyłącznie na wartościach domyślnych. Możemy w ten sposób zdefiniować domyślny URL, korzystając z wartości domyślnych dla obu zmiennych, jak pokazano na listingu 13.10.

Listing 13.10. Określanie domyślnych wartości dla kontrolera i akcji using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

using System.Web.Routing;

namespace UrlsAndRoutes {

public class RouteConfig {

public static void RegisterRoutes(RouteCollection routes) {

routes.MapRoute("MyRoute", "{controller}/{action}",

new { controller = "Home", action = "Index" });

}

}

}

Definiując wartości domyślne dla zmiennych controller i action, utworzyliśmy ścieżkę, która pasuje do adresów URL mających zero, jeden lub dwa segmenty, co jest pokazane w tabeli 13.2.

Tabela 13.2. Dopasowanie adresów URL

Liczba segmentów

Przykad

Odwzorowany na

0

witryna.pl

controller = Home

action = Index

1

witryna.pl/Customer

controller = Customer

action = Index

2

witryna.pl/Customer/List

controller = Customer

action = List

3

witryna.pl/Customer/List/All

Brak dopasowania — za dużo segmentów

Im mniej segmentów otrzymamy w przychodzącym adresie URL, tym bardziej polegamy na wartościach domyślnych aż do otrzymania adresu URL pozbawionego segmentów — w takim przypadku będą użyte jedynie wartości domyślne. Efekt zdefiniowania wartości domyślnych możesz zobaczyć po ponownym uruchomieniu aplikacji. Przeglądarka ponownie zażąda domyślnego adresu URL, ale tym razem nasza nowa ścieżka doda nasze domyślne wartości dla kontrolera i akcji, dzięki czemu przychodzący adres URL zostanie odwzorowany na akcję Index w kontrolerze Home, jak pokazano na rysunku 13.4.

326

Kup książkę

Poleć książkę

ROZDZIA 13. „ ROUTING URL

Rysunek 13.4. Efekt użycia wartości domyślnych w celu rozszerzenia zasięgu ścieżki Testy jednostkowe — wartoci domylne

Nie musimy wykonywa adnych specjalnych akcji, jeeli uyjemy naszych metod pomocniczych do definiowania cieek korzystajcych z wartoci domylnych. Poniej zamieszczona jest uaktualniona metoda TestIncomingRoutes z pliku RouteTests.cs dla cieek z listingu 13.10:

...

[TestMethod]

public void TestIncomingRoutes() {

TestRouteMatch("~/", "Home", "Index");

TestRouteMatch("~/Customer", "Customer", "Index"); TestRouteMatch("~/Customer/List", "Customer", "List"); TestRouteFail("~/Customer/List/All");

}

...

Trzeba tylko pamita o podawaniu domylnego adresu URL jako ~/, poniewa ASP.NET w taki sposób prezentuje adresy URL systemowi routingu. Jeeli podamy pusty cig ("") lub /, system routingu zg osi wyjtek i test si nie powiedzie.

Uycie statycznych segmentów adresu URL

Nie wszystkie segmenty we wzorcu URL muszą być zmiennymi. Można również tworzyć wzorce mające segmenty statyczne. Załóżmy, że chcemy dopasować poniższy adres URL w celu obsługi adresów URL poprzedzonych słowem Public:

http://witryna.pl/Public/Home/Index

Możemy zrobić to przez użycie wzorca zamieszczonego na listingu 13.11.

Listing 13.11. Wzorzec URL z segmentem statycznym

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

using System.Web.Routing;

namespace UrlsAndRoutes {

public class RouteConfig {

public static void RegisterRoutes(RouteCollection routes) {

327

Kup książkę

Poleć książkę

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

routes.MapRoute("MyRoute", "{controller}/{action}",

new { controller = "Home", action = "Index" });

routes.MapRoute("", "Public/{controller}/{action}", new { controller = "Home", action = "Index" });

}

}

}

Wzorzec ten pasuje wyłącznie do adresów URL posiadających trzy segmenty, z których pierwszym musi być Public. Pozostałe dwa segmenty mogą zawierać dowolną wartość i będą używane dla zmiennych controller oraz action. Jeżeli dwa ostatnie segmenty zostaną pominięte, wtedy użyte będą wartości domyślne.

Możemy również tworzyć wzorce URL mające segmenty zawierające zarówno elementy statyczne, jak i zmienne (listing 13.12).

Listing 13.12. Wzorzec URL z segmentem mieszanym

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

using System.Web.Routing;

namespace UrlsAndRoutes {

public class RouteConfig {

public static void RegisterRoutes(RouteCollection routes) {

routes.MapRoute("", "X{controller}/{action}");

routes.MapRoute("MyRoute", "{controller}/{action}",

new { controller = "Home", action = "Index" });

routes.MapRoute("", "Public/{controller}/{action}",

new { controller = "Home", action = "Index" });

}

}

}

Wzorzec w tej ścieżce pasuje do dowolnego dwusegmentowego adresu URL, w którym pierwszy segment zaczyna się od litery X. Wartość zmiennej controller jest pobierana z pierwszego segmentu, poza początkową literą X. Wartość zmiennej action jest pobierana z drugiego segmentu. Efekt działania tego rodzaju ścieżki możesz zobaczyć po uruchomieniu aplikacji i przejściu do adresu URL /XHome/Index, co zostało pokazane na rysunku 13.5.

Rysunek 13.5. Połączenie statycznych i zmiennych elementów w pojedynczym segmencie Możemy połączyć statyczne segmenty URL oraz wartości domyślne w celu utworzenia aliasów dla wybranych adresów URL. Jest to przydatne, jeżeli opublikowaliśmy schemat URL w postaci kontraktu dla użytkownika.

328

Kup książkę

Poleć książkę

ROZDZIA 13. „ ROUTING URL

Jeżeli zrefaktoryzujesz w takiej sytuacji aplikację, powinieneś zachować poprzedni format adresów URL, aby nadal działały adresy dodane przez użytkownika do ulubionych lub przygotowane przez niego makra. Wyobraźmy sobie, że mieliśmy kontroler o nazwie Shop, który został zastąpiony przez kontroler Home. Na listingu 13.13 pokazany jest sposób tworzenia ścieżek pozwalających na zachowanie starego schematu URL.

Listing 13.13. Łączenie statycznych segmentów URL oraz wartości domyślnych using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

using System.Web.Routing;

namespace UrlsAndRoutes {

public class RouteConfig {

public static void RegisterRoutes(RouteCollection routes) {

routes.MapRoute("ShopSchema", "Shop/{action}",

new { controller = "Home" });

routes.MapRoute("", "X{controller}/{action}");

routes.MapRoute("MyRoute", "{controller}/{action}",

new { controller = "Home", action = "Index" });

routes.MapRoute("", "Public/{controller}/{action}",

new { controller = "Home", action = "Index" });

}

}

}

Dodana przez nas ścieżka pasuje do wszystkich dwusegmentowych adresów URL, w których pierwszym segmentem jest Shop. Wartość zmiennej action jest pobierana z drugiego segmentu. Wzorzec URL nie zawiera zmiennej segmentu o nazwie controller, więc użyta jest podana przez nas wartość domyślna. Oznacza to, że żądanie wykonania akcji na kontrolerze Shop jest przekształcane w żądanie dla kontrolera Home.

Efekt działania ścieżki można zobaczyć po uruchomieniu aplikacji i przejściu do adresu URL /Shop/Index.

Jak pokazano na rysunku 13.6, dodana ścieżka spowodowała, że platforma MVC wywołuje metodę akcji Index kontrolera Home.

Rysunek 13.6. Utworzenie aliasu w celu zachowania schematu URL

Możemy również pójść o krok dalej i utworzyć aliasy dla metod akcji, które zostały zrefaktoryzowane i nie występują już w kontrolerze. W tym celu należy utworzyć statyczny URL i dostarczyć wartości dla controller oraz action w postaci wartości domyślnych, jak pokazano na listingu 13.14.

329

Kup książkę

Poleć książkę

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

Listing 13.14. Aliasy dla kontrolera i akcji

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

using System.Web.Routing;

namespace UrlsAndRoutes {

public class RouteConfig {

public static void RegisterRoutes(RouteCollection routes) {

routes.MapRoute("ShopSchema2", "Shop/OldAction",

new { controller = "Home", action = "Index" }); routes.MapRoute("ShopSchema", "Shop/{action}",

new { controller = "Home" });

routes.MapRoute("", "X{controller}/{action}");

routes.MapRoute("MyRoute", "{controller}/{action}",

new { controller = "Home", action = "Index" });

routes.MapRoute("", "Public/{controller}/{action}",

new { controller = "Home", action = "Index" });

}

}

}

Zwróć uwagę, że kolejny raz umieściliśmy naszą nową ścieżkę jako pierwszą. Jest ona bardziej szczegółowa niż wszystkie kolejne. Jeżeli żądanie otwarcia adresu /Shop/OldAction byłoby przetworzone przez drugą z kolei ścieżkę, otrzymalibyśmy inny wynik, niż oczekiwaliśmy. Żądanie takie zostałoby obsłużone przez zwrócenie informacji o błędzie 404, a nie przez przekształcenie pozwalające zachować istniejący schemat URL.

Kolejno cieek

Na listingu 13.12 zdefiniowalimy now ciek i umiecilimy j w metodzie RegisterRoutes przed wszystkimi innymi. Zrobilimy to, poniewa cieki s stosowane w kolejnoci, w jakiej wystpuj w obiekcie RouteCollection.

Metoda MapRoute dodaje ciek na koniec kolekcji, co oznacza, e cieki s zwykle przetwarzane w kolejnoci dodawania. Uy em s owa „zwykle”, poniewa istniej metody pozwalajce na wstawianie cieek w wybranym miejscu. Zazwyczaj nie korzystam z tych metod, gdy uporzdkowanie cieek w kolejnoci ich wykonywania pozwala atwiej zrozumie routing w aplikacji.

System routingu próbuje dopasowa przychodzcy adres URL do wzorca URL cieki zdefiniowanej jako pierwsza

i jeeli si to nie uda, przechodzi do nastpnej. cieki s wypróbowywane po kolei, a do wyczerpania ich zbioru.

W konsekwencji musimy definiowa najbardziej szczegó owe cieki jako pierwsze. cieka dodana na listingu 13.12

jest bardziej szczegó owa ni nastpna. Za ómy, e odwrócimy kolejno w poniszy sposób:

...

routes.MapRoute("MyRoute", "{controller}/{action}",

new { controller = "Home", action = "Index" });

routes.MapRoute("", "X{controller}/{action}");

...

330

Kup książkę

Poleć książkę

ROZDZIA 13. „ ROUTING URL

Teraz pierwsz uyt ciek bdzie ta, która pasuje do kadego adresu URL posiadajcego zero segmentów, jeden segment lub dwa segmenty. Bardziej szczegó owa cieka, znajdujca si na licie jako druga, nie bdzie nigdy wykorzystana. Nowa cieka powoduje usunicie pocztkowego X z adresu URL, co nie jest realizowane we wczeniejszej ciece. Z tego powodu poniszy adres URL:

http://witryna.pl/XHome/Index

zostanie skierowany do nieistniejcego kontrolera o nazwie XHome, wskutek czego nastpi wygenerowanie uytkownikowi informacji o b dzie 404.

Jeeli nie przeczyta e tekstu z ramki na temat testowania jednostkowego przychodzcych adresów URL, sugeruj powrót do niego. Jeli testy jednostkowe maj obejmowa tylko jedn cz aplikacji MVC, powinien to

by schemat adresów URL.

Test jednostkowy — testowanie segmentów statycznych

Kolejny raz uyjemy naszych metod pomocniczych do przetestowania cieek, których wzorzec URL zawiera segmenty statyczne. Poniej przedstawiono zmiany wprowadzone w metodzie TestIncomingRoutes w celu przetestowania cieki dodanej na listingu 13.14:

...

[TestMethod]

public void TestIncomingRoutes() {

TestRouteMatch("~/", "Home", "Index");

TestRouteMatch("~/Customer", "Customer", "Index"); TestRouteMatch("~/Shop/Index", "Home", "Index"); TestRouteMatch("~/Customer/List", "Customer", "List"); TestRouteFail("~/Customer/List/All");

}

...

Definiowanie wasnych zmiennych segmentów

Zmienne segmentu controller i action mają specjalne znaczenie na platformie MVC i — co oczywiste —

odpowiadają kontrolerowi i metodzie akcji, które będą użyte do obsługi danego żądania. Nie jesteśmy ograniczeni wyłącznie do zmiennych controller i action. Możemy również definiować własne zmienne w sposób pokazany na listingu 13.15. (Istniejące trasy z poprzednich sekcji zostały usunięte).

Listing 13.15. Definiowanie nowych zmiennych we wzorcu URL

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

using System.Web.Routing;

namespace UrlsAndRoutes {

public class RouteConfig {

public static void RegisterRoutes(RouteCollection routes) {

routes.MapRoute("MyRoute", "{controller}/{action}/{id}", 331

Kup książkę

Poleć książkę

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

new { controller = "Home", action = "Index", id = "DefaultId" });

}

}

}

Wzorzec ścieżki URL definiuje typowe zmienne controller oraz action, jak również własną zmienną o nazwie id. Ścieżka ta pozwala dopasować adresy URL o długości od zera do trzech segmentów. Zawartość trzeciego segmentu jest przypisywana do zmiennej id, a jeżeli nie wystąpi trzeci segment, użyta zostanie wartość domyślna.

„ Ostrzeenie Niektóre nazwy s zarezerwowane i nie s dostpne dla nazw zmiennych w asnych segmentów.

Nazwami tymi s controller, action oraz area. Znaczenie pierwszych dwóch jest oczywiste, a rol trzeciej wyjani w nastpnym rozdziale.

W metodzie akcji możemy odczytać każdą ze zmiennych segmentów, korzystając z właściwości RouteData.Values. Aby to zademonstrować, trzeba dodać do klasy HomeController metodę CustomVariable (listing 13.16).

Listing 13.16. Dostęp do własnej zmiennej segmentu w metodzie akcji using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

namespace UrlsAndRoutes.Controllers {

public class HomeController : Controller {

public ActionResult Index() {

ViewBag.Controller = "Home";

ViewBag.Action = "Index";

return View("ActionName");

}

public ActionResult CustomVariable() {

ViewBag.Controller = "Home";

ViewBag.Action = "CustomVariable";

ViewBag.CustomVariable = RouteData.Values["id"];

return View();

}

}

}

Metoda ta pozyskuje wartość zmiennej z wzorca ścieżki i przekazuje ją do widoku poprzez ViewBag.

Kliknij prawym przyciskiem myszy nową metodę akcji w edytorze kodu i wybierz opcję Dodaj widok…

z menu kontekstowego. Widokowi nadaj nazwę CustomVariable i kliknij przycisk Dodaj. Visual Studio utworzy nowy plik widoku CustomVariable.cshtml w katalogu /Views/Home. Kod widoku zmodyfikuj tak, aby odpowiadał przedstawionemu na listingu 13.17.

Listing 13.17. Wyświetlanie wartości zmiennej własnego segmentu

@{

Layout = null;

}

332

Kup książkę

Poleć książkę

ROZDZIA 13. „ ROUTING URL

<!DOCTYPE html>

<html>

<head>

<meta name="viewport" content="width=device-width" />

<title>CustomVariable</title>

</head>

<body>

<div>Nazwa kontrolera: @ViewBag.Controller</div>

<div>Nazwa akcji: @ViewBag.Action</div>

<div>Nazwa wasnej zmiennej: @ViewBag.CustomVariable</div>

</body>

</html>

Aby zobaczyć efekt zdefiniowania zmiennej własnego segmentu, uruchom aplikację i przejdź do adresu URL /Home/CustomVariable/Halo. Zostanie wywołana akcja CustomVariable z kontrolera Home, a wartość zmiennej naszego segmentu będzie pobrana z ViewBag i wyświetlona na stronie, jak pokazano na rysunku 13.7.

Rysunek 13.7. Wyświetlanie wartości zmiennej własnego segmentu

Zmiennej segmentu przypisaliśmy wartość domyślną, co oznacza, że po przejściu do adresu URL

/Home/CustomVariable otrzymasz wynik pokazany na rysunku 13.8.

Rysunek 13.8. Wyświetlanie wartości domyślnej zmiennej własnego segmentu Test jednostkowy — testowanie zmiennych wasnych segmentów

W naszych metodach pomocniczych testów dodalimy obs ug testowania zmiennych w asnych segmentów.

Metoda TestRouteMatch posiada opcjonalny parametr, który akceptuje typ anonimowy zawierajcy nazwy zmiennych, jakie chcemy testowa , oraz oczekiwane wartoci. Poniej przedstawiono zmodyfikowan wersj

metody TestIncomingRoutes w celu przetestowania cieki zdefiniowanej na listingu 13.15.

...

[TestMethod]

public void TestIncomingRoutes() {

TestRouteMatch("~/", "Home", "Index", new {id = "DefaultId"}); TestRouteMatch("~/Customer", "Customer", "index", new { id = "DefaultId" }); TestRouteMatch("~/Customer/List", "Customer", "List", new { id = "DefaultId" }); 333

Kup książkę

Poleć książkę

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

TestRouteMatch("~/Customer/List/All", "Customer", "List", new { id = "All" }); TestRouteFail("~/Customer/List/All/Delete");

}

...

Użycie własnych zmiennych jako parametrów metod akcji

Użycie właściwości RouteData.Values jest jedynie pierwszym ze sposobów na dostęp do zmiennych własnych segmentów. Inny sposób jest znacznie elegantszy. Jeżeli zdefiniujemy parametr metody akcji o nazwie pasującej do zmiennej z wzorca URL, platforma MVC przekaże wartość pobraną z URL do tego parametru metody akcji. Na przykład własna zmienna zdefiniowana w ścieżce z listingu 13.15 ma nazwę id. Możemy zmodyfikować metodę akcji CustomVariable w taki sposób, aby posiadała analogiczny parametr, jak pokazano na listingu 13.18.

Listing 13.18. Mapowanie zmiennej własnego segmentu URL na parametr metody akcji using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

namespace UrlsAndRoutes.Controllers {

public class HomeController : Controller {

public ActionResult Index() {

ViewBag.Controller = "Home";

ViewBag.Action = "Index";

return View("ActionName");

}

public ActionResult CustomVariable(string id) {

ViewBag.Controller = "Home";

ViewBag.Action = "CustomVariable";

ViewBag.CustomVariable = id;

return View();

}

}

}

Gdy system routingu dopasuje URL do ścieżki zdefiniowanej na listingu 13.15, wartość trzeciego segmentu w adresie URL zostanie przypisana do zmiennej id. Platforma MVC porówna listę zmiennych segmentów z listą parametrów metody akcji i jeżeli zostaną znalezione pasujące nazwy, wartości z adresu URL będą przekazane do metody.

Parametr id zdefiniowaliśmy jako string, ale platforma MVC będzie próbowała skonwertować wartość z URL

na dowolny zdefiniowany przez nas typ. Jeżeli zadeklarujemy parametr id jako int lub DateTime, otrzymamy wartość z URL w postaci obiektu właściwego typu. Jest to elegancka i przydatna funkcja, która pozwala uniknąć samodzielnej realizacji konwersji.

„ Uwaga Przy konwersji wartoci znajdujcych si w adresie URL na typy .NET platforma MVC korzysta z systemu do czania obiektu, który jest w stanie obs uy sytuacje znacznie bardziej skomplikowane ni pokazane w tym

przyk adzie. Do czanie modelu przedstawi w rozdziale 22.

334

Kup książkę

Poleć książkę

ROZDZIA 13. „ ROUTING URL

Definiowanie opcjonalnych segmentów URL

Opcjonalny segment URL to taki, który nie musi być specyfikowany przez użytkownika, ale dla którego nie są podane wartości domyślne. Na listingu 13.19 pokazany jest przykład. Opcjonalność zmiennej segmentu zaznaczyliśmy przez ustawienie domyślnej wartości parametru UrlParameter.Optional, co zostało oznaczone czcionką pogrubioną.

Listing 13.19. Określanie opcjonalnego segmentu URL

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

using System.Web.Routing;

namespace UrlsAndRoutes {

public class RouteConfig {

public static void RegisterRoutes(RouteCollection routes) {

routes.MapRoute("MyRoute", "{controller}/{action}/{id}",

new { controller = "Home", action = "Index",

id = UrlParameter.Optional });

}

}

}

Ścieżka ta będzie dopasowana do adresów URL niezależnie od tego, czy zostanie podany segment id.

W tabeli 13.3 pokazane jest działanie tego mechanizmu dla różnych adresów URL.

Tabela 13.3. Dopasowanie adresów URL z opcjonalną zmienną segmentu Liczba segmentów

Przykadowy URL

Odwzorowany na

0

witryna.pl

controller = Home

action = Index

1

witryna.pl/Customer

controller = Customer

action = Index

2

witryna.pl/Customer/List

controller = Customer

action = List

3

witryna.pl/Customer/List/All

controller = Customer

action = List

id = All

4

witryna.pl/Customer/List/All/Delete

Brak dopasowania — za dużo segmentów

Jak można zauważyć w tabeli, zmienna id jest dodawana do zbioru zmiennych tylko w przypadku, gdy odpowiedni segment znajduje się w przychodzącym adresie URL. Funkcja ta jest przydatna, gdy musimy wiedzieć, czy użytkownik podał wartość. Jeżeli dla opcjonalnej zmiennej segmentu nie zostanie podana żadna wartość, wówczas wartością odpowiadającego jej parametru będzie null. Na listingu 13.20

pokazano uaktualnioną wersję kontrolera, który odpowiada, gdy nie zostanie podana żadna wartość dla zmiennej id segmentu.

Listing 13.20. Sprawdzenie, czy opcjonalnej zmiennej segmentu została przypisana wartość using System;

using System.Collections.Generic;

using System.Linq;

335

Kup książkę

Poleć książkę

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

using System.Web;

using System.Web.Mvc;

namespace UrlsAndRoutes.Controllers {

public class HomeController : Controller {

public ActionResult Index() {

ViewBag.Controller = "Home";

ViewBag.Action = "Index";

return View("ActionName");

}

public ActionResult CustomVariable(string id) {

ViewBag.Controller = "Home";

ViewBag.Action = "CustomVariable";

ViewBag.CustomVariable = id == null ? "<brak wartoci>" : id; return View();

}

}

}

Po uruchomieniu aplikacji i przejściu do adresu URL /Home/CustomVariable (który nie posiada zdefiniowanej wartości domyślnej dla zmiennej id segmentu) otrzymasz wynik pokazany na rysunku 13.9.

Rysunek 13.9. Aplikacja wykryła, że adres URL nie zawiera wartości dla opcjonalnej zmiennej segmentu Uycie opcjonalnych segmentów URL w celu wymuszenia separacji zada

Niektórzy programiści bardzo mocno koncentrują się na separacji zadań na platformie MVC i nie lubią umieszczania wartości domyślnych zmiennych segmentu w ścieżkach aplikacji. Jeżeli jest to problemem również dla Ciebie, możesz użyć funkcji parametrów opcjonalnych w C# wraz z opcjonalną zmienną segmentu w trasie w celu zdefiniowania wartości domyślnych dla parametrów metod akcji. Jak pokazano na listingu 13.21, należy zmodyfikować metodę akcji CustomVariable i zdefiniować wartość domyślną dla parametru id, która będzie używana, jeśli adres URL nie będzie zawierał wartości dla wspomnianego parametru.

Listing 13.21. Definiowanie wartości domyślnej dla parametru metody akcji

...

public ViewResult CustomVariable(string id = "DefaultId" ) {

ViewBag.Controller = "Home";

ViewBag.Action = "CustomVariable";

ViewBag.CustomVariable = id;

return View();

}

...

W ten sposób zapewnimy wartość dla parametru id (albo pochodzącą z adresu URL, albo domyślną), więc możemy usunąć kod odpowiedzialny za obsługę wartości null. Ta metoda akcji, w połączeniu ze ścieżką zdefiniowaną na listingu 13.19, ma taką samą funkcjonalność jak ścieżka zdefiniowana na listingu 13.15: 336

Kup książkę

Poleć książkę

ROZDZIA 13. „ ROUTING URL

...

routes.MapRoute("MyRoute", "{controller}/{action}/{id}",

new { controller = "Home", action = "Index", id = "DefaultId" });

...

Różnica polega na tym, że wartość domyślna dla zmiennej id segmentu jest zdefiniowana w kodzie kontrolera, a nie w definicji ścieżki.

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

Innym sposobem na zmianę domyślnego konserwatyzmu ścieżek URL jest akceptowanie zmiennej liczby segmentów URL. Pozwala to na obsługiwanie adresów URL o dowolnej długości przy zastosowaniu jednej definicji ścieżki. Obsługę zmiennej liczby segmentów realizuje się przez wyznaczenie jednej ze zmiennych segmentów jako zmiennej przechwytującej, co jest realizowane przez poprzedzenie jej znakiem gwiazdki (*), jak pokazano na listingu 13.22.

Listing 13.22. Wyznaczanie zmiennej przechwytującej

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

using System.Web.Routing;

namespace UrlsAndRoutes {

public class RouteConfig {

public static void RegisterRoutes(RouteCollection routes) {

routes.MapRoute("MyRoute", "{controller}/{action}/{id}/{*catchall}", new { controller = "Home", action = "Index",

id = UrlParameter.Optional });

}

}

}

Testy jednostkowe — opcjonalne segmenty URL

Jedynym problemem, na który musimy zwróci uwag przy testowaniu opcjonalnych segmentów URL jest

to, czy zmienna segmentu nie zostanie dodana do kolekcji RouteData.Values, gdy warto nie zostanie znaleziona

w adresie URL. Oznacza to, e nie powinnimy do cza zmiennej w typie anonimowym, o ile nie testujemy adresu

URL zawierajcego opcjonalny segment. Poniej przedstawiono zmiany, jakie trzeba wprowadzi w metodzie

TestIncomingRoutes, aby przetestowa ciek zdefiniowan na listingu 13.19.

...

[TestMethod]

public void TestIncomingRoutes() {

TestRouteMatch("~/", "Home", "Index");

TestRouteMatch("~/Customer", "Customer", "index"); TestRouteMatch("~/Customer/List", "Customer", "List"); TestRouteMatch("~/Customer/List/All", "Customer", "List", new { id = "All" }); TestRouteFail("~/Customer/List/All/Delete");

}

...

337

Kup książkę

Poleć książkę

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

Rozszerzyliśmy ścieżkę z poprzedniego przykładu o dodatkową zmienną segmentu przechwytującego, o nazwie catchall. Ścieżka ta pasuje teraz do dowolnego adresu URL, niezależnie od liczby segmentów lub wartości któregokolwiek z nich. Pierwsze trzy segmenty są wykorzystywane do skonfigurowania wartości zmiennych controller, action oraz id. Jeżeli adres URL będzie zawierał kolejne segmenty, zostaną one przypisane do zmiennej catchall w sposób pokazany w tabeli 13.4.

Tabela 13.4. Dopasowanie adresów URL ze zmienną przechwytującą segmentu Liczba segmentów

Przykadowy URL

Odwzorowany na

0

witryna.pl

controller = Home

action = Index

1

witryna.pl/Customer

controller = Customer

action = Index

2

witryna.pl/Customer/List

controller = Customer

action = List

3

witryna.pl/Customer/List/All

controller = Customer

action = List

id = All

4

witryna.pl/Customer/List/All/Delete

controller = Customer

action = List

id = All

catchall = Delete

5

witryna.pl/Customer/List/All/Delete/Perm

controller = Customer

action = List

id = All

catchall = Delete/Perm

Nie istnieje górna granica liczby segmentów możliwych do dopasowania przez wzorzec URL. Zwróć uwagę, że segmenty w zmiennej przechwytującej są prezentowane w postaci segment/ segment/ segment. To my jesteśmy odpowiedzialni za przetworzenie tego ciągu znaków i jego podział na pojedyncze segmenty.

Test jednostkowy — testowanie zmiennych segmentów przechwytujcych

Zmienn przechwytujc moemy potraktowa jak kad inn zmienn. Jedyna rónica polega na tym, e musimy

oczekiwa otrzymania wartoci wielu segmentów po czonych w jedn warto , na przyk ad segment/segment/

segment. Zwró uwag, e nie otrzymamy pocztkowego ani kocowego znaku /. Poniej przedstawiono zmiany, jakie trzeba wprowadzi w metodzie TestIncomingRoutes, aby przetestowa ciek zdefiniowan na

listingu 13.22 oraz adresy URL z tabeli 13.4:

...

[TestMethod]

public void TestIncomingRoutes() {

TestRouteMatch("~/", "Home", "Index");

TestRouteMatch("~/Customer", "Customer", "Index"); TestRouteMatch("~/Customer/List", "Customer", "List"); TestRouteMatch("~/Customer/List/All", "Customer", "List", new { id = "All" }); TestRouteMatch("~/Customer/List/All/Delete", "Customer", "List", new { id = "All", catchall = "Delete" });

TestRouteMatch("~/Customer/List/All/Delete/Perm", "Customer", "List", new { id = "All", catchall = "Delete/Perm" });

}

...

338

Kup książkę

Poleć książkę

ROZDZIA 13. „ ROUTING URL

Definiowanie priorytetów kontrolerów na podstawie przestrzeni nazw

Gdy przychodzący adres URL zostanie dopasowany do ścieżki, platforma MVC odczytuje nazwę zmiennej controller i szuka klasy o odpowiedniej nazwie. Jeżeli na przykład wartością zmiennej controller jest Home, platforma MVC poszukuje klasy o nazwie HomeController. Jest to niekwalifikowana nazwa klasy, co oznacza, że w przypadku znalezienia co najmniej dwóch klas o nazwie HomeController w różnych przestrzeniach nazw platforma nie będzie „wiedziała”, którą z nich należy wybrać.

Aby zademonstrować ten problem, utwórz nowy podkatalog w katalogu głównym projektu i nadaj mu nazwę AdditionalControllers. Następnie umieść w nim nowy kontroler HomeController, którego kod przedstawiono na listingu 13.23.

Listing 13.23. Dodanie drugiego kontrolera HomeController do omawianego projektu using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

namespace UrlsAndRoutes.AdditionalControllers

{

public class HomeController : Controller

{

public ActionResult Index()

{

ViewBag.Controller = "Additional Controllers - Home";

ViewBag.Action = "Index";

return View("ActionName");

}

}

}

Po uruchomieniu aplikacji zobaczysz błąd pokazany na rysunku 13.10.

Rysunek 13.10. Błąd występujący w przypadku niejednoznaczności klas kontrolerów Platforma MVC szukała klasy HomeController i znalazła dwie: pierwszą w katalogu AdditionalControllers i drugą w katalogu Controllers. Jeżeli wczytasz się w tekst komunikatu pokazanego na rysunku 13.10, to dowiesz się, które klasy zostały znalezione przez platformę MVC.

339

Kup książkę

Poleć książkę

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

Problem ten pojawia się częściej, niż można się tego spodziewać, szczególnie jeżeli pracujemy nad dużym projektem MVC, który korzysta z bibliotek kontrolerów pochodzących od różnych zespołów lub zewnętrznych dostawców. Naturalne jest nazywanie kontrolera związanego z kontami użytkowników ciągiem AccountController, a jest to tylko jeden z przypadków, gdy napotkamy konflikty nazw.

Aby rozwiązać ten problem, możemy określić przestrzenie nazw, które powinny mieć wyższy priorytet przy wyborze nazwy klasy kontrolera (listing 13.24).

Listing 13.24. Określanie kolejności wykorzystania przestrzeni nazw using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

using System.Web.Routing;

namespace UrlsAndRoutes {

public class RouteConfig {

public static void RegisterRoutes(RouteCollection routes) {

routes.MapRoute("MyRoute", "{controller}/{action}/{id}/{*catchall}", new { controller = "Home", action = "Index",

id = UrlParameter.Optional

},

new[] { "UrlsAndRoutes.AdditionalControllers"});

}

}

}

Przestrzenie nazw zapisujemy jako tablicę ciągów znakowych. W kodzie zamieszczonym na powyższym listingu informujemy platformę MVC, aby przeszukiwała przestrzeń nazw

UrlsAndRoutes.AdditionalControllers jako pierwszą.

Jeżeli w podanej przestrzeni nazw nie zostanie znaleziony odpowiedni kontroler, platforma MVC wróci do standardowego działania i przeszuka wszystkie dostępne przestrzenie nazw. Po uruchomieniu aplikacji na tym etapie otrzymasz wynik pokazany na rysunku 13.11. Na wymienionym rysunku pokazano, że żądanie skierowane do adresu głównego aplikacji, które jest przetwarzane przez metodę akcji Index kontrolera Home, zostało przekazane kontrolerowi zdefiniowanemu w przestrzeni nazw AdditionalControllers.

Rysunek 13.11. Nadanie priorytetu kontrolerom we wskazanej przestrzeni nazw Przestrzenie nazw dodawane do ścieżki mają identyczny priorytet. Platforma MVC nie sprawdza pierwszej przestrzeni nazw, potem przechodzi do następnej itd. Dodajmy do ścieżki na przykład obie nasze przestrzenie nazw w poniższy sposób:

...

routes.MapRoute("MyRoute", "{controller}/{action}/{id}/{*catchall}", new { controller = "Home", action = "Index",

340

Kup książkę

Poleć książkę

ROZDZIA 13. „ ROUTING URL

id = UrlParameter.Optional

},

new[] { "UrlsAndRoutes.AdditionalControllers", " UrlsAndRoutes.Controllers"});

...

Ponownie zobaczymy informacje o błędzie pokazane na rysunku 13.10, ponieważ platforma MVC

próbuje znaleźć klasę kontrolera we wszystkich przestrzeniach nazw dodanych do ścieżki. Jeżeli chcemy zwiększyć priorytet kontrolera z jednej przestrzeni nazw, a wszystkie inne kontrolery wyszukiwać w innej przestrzeni, musimy utworzyć wiele ścieżek, jak pokazano na listingu 13.25.

Listing 13.25. Użycie wielu ścieżek do sterowania przeszukiwaniem przestrzeni nazw using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

using System.Web.Routing;

namespace UrlsAndRoutes {

public class RouteConfig {

public static void RegisterRoutes(RouteCollection routes) {

routes.MapRoute("AddContollerRoute", "Home/{action}/{id}/{*catchall}",

new { controller = "Home", action = "Index", id = UrlParameter.Optional },

new[] { "UrlsAndRoutes.AdditionalControllers" });

routes.MapRoute("MyRoute", "{controller}/{action}/{id}/{*catchall}", new { controller = "Home", action = "Index",

id = UrlParameter.Optional },

new[] { "UrlsAndRoutes.Controllers"});

}

}

}

Pierwsza ścieżka zostanie użyta, kiedy użytkownik wyraźnie wskaże adres URL, którego pierwszym segmentem jest Home. W takim przypadku żądanie będzie skierowane do kontrolera HomeController w katalogu AdditionalControllers. Wszystkie pozostałe żądania, łącznie z tymi, w których nie zdefiniowano pierwszego segmentu, zostaną obsłużone przez kontrolery znajdujące się w katalogu Controllers.

Możemy również zmusić platformę MVC, aby szukała wyłącznie w podanych przez nas przestrzeniach nazw. Jeżeli nie zostanie znaleziony odpowiedni kontroler, biblioteka nie będzie szukała go w innych przestrzeniach.

Na listingu 13.26 przedstawiony jest sposób użycia tej funkcji.

Listing 13.26. Wyłączenie domyślnego przeszukiwania przestrzeni nazw using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

using System.Web.Routing;

namespace UrlsAndRoutes {

public class RouteConfig {

public static void RegisterRoutes(RouteCollection routes) {

Route myRoute = routes.MapRoute("AddContollerRoute",

"Home/{action}/{id}/{*catchall}",

341

Kup książkę

Poleć książkę

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

new { controller = "Home", action = "Index",

id = UrlParameter.Optional },

new[] { "UrlsAndRoutes.AdditionalControllers" });

myRoute.DataTokens["UseNamespaceFallback"] = false;

}

}

}

Metoda MapRoute zwraca obiekt Route. Do tej pory nie korzystaliśmy z tej metody, ponieważ nie potrzebowaliśmy wprowadzać żadnych korekt do tworzonych ścieżek. Aby wyłączyć przeszukiwanie kontrolerów w innych przestrzeniach nazw, musimy pobrać obiekt Route i przypisać kluczowi UseNamespaceFallback w kolekcji DataTokens wartość false.

Ustawienie to zostanie przekazane do komponentu odpowiedzialnego za wyszukiwanie kontrolerów, nazywanego fabryką kontrolerów, który przedstawię szczegółowo w rozdziale 17. Efektem wprowadzonej zmiany jest to, że żądania, które nie mogą być obsłużone przez kontroler Home z katalogu AdditionalControllers, zakończą się niepowodzeniem.

Ograniczenia cieek

Na początku rozdziału napisałem, że wzorce URL są konserwatywne przy dopasowywaniu segmentów i liberalne przy dopasowywaniu zawartości tych segmentów. W kilku poprzednich punktach przedstawiłem różne techniki kontrolowania poziomu konserwatyzmu — tworzenia ścieżek pasujących do większej lub mniejszej liczby segmentów przez użycie wartości domyślnych, zmiennych opcjonalnych itd.

Teraz czas zająć się sposobami kontrolowania liberalizmu przy dostosowywaniu zawartości segmentów URL

— możliwościami ograniczenia zbioru adresów URL — do której będzie pasowała ścieżka. Ponieważ mamy kontrolę nad oboma tymi aspektami ścieżki, możemy tworzyć schematy URL, które działają z laserową precyzją.

Ograniczanie ścieżki z użyciem wyrażeń regularnych

Pierwszą techniką, jaką się zajmiemy, jest ograniczanie ścieżek z użyciem wyrażeń regularnych. Na listingu 13.27

pokazany jest przykład.

Listing 13.27. Użycie wyrażeń regularnych do ograniczania ścieżki

...

public static void RegisterRoutes(RouteCollection routes) {

routes.MapRoute("MyRoute", "{controller}/{action}/{id}/{*catchall}", new { controller = "Home", action = "Index", id = UrlParameter.Optional }, new { controller = "^H.*"},

new[] { "UrlsAndRoutes.Controllers"});

}

...

Ograniczenia definiujemy przez przekazanie ich jako parametru do metody MapRoute. Podobnie jak w przypadku wartości domyślnych, ograniczenia są zapisywane w postaci typu anonimowego, którego właściwości odpowiadają nazwom zmiennych segmentów, które chcemy ograniczyć.

W zamieszczonym przykładzie użyliśmy stałej z wyrażeniem regularnym pasującym do adresu URL tylko wtedy, gdy wartość zmiennej kontrolera zaczyna się od litery H.

342

Kup książkę

Poleć książkę

ROZDZIA 13. „ ROUTING URL

„ Uwaga Wartoci domylne s uywane przed sprawdzeniem ogranicze. Jeeli zatem otworzymy URL /, zostanie zastosowana domylna warto dla zmiennej controller, czyli w tym przypadku Home. Nastpnie s sprawdzane

ograniczenia, a poniewa warto zmiennej controller zaczyna si od H, domylny URL bdzie pasowa do tej cieki.

Ograniczanie ścieżki do zbioru wartości

Wyrażenia regularne możemy wykorzystać do definiowania ścieżki pasującej wyłącznie do specyficznych wartości segmentu. W tym celu zastosujemy znak |, jak pokazano na listingu 13.28.

Listing 13.28. Ograniczanie ścieżki do zbioru wartości zmiennej segmentu

...

public static void RegisterRoutes(RouteCollection routes) {

routes.MapRoute("MyRoute", "{controller}/{action}/{id}/{*catchall}", new { controller = "Home", action = "Index", id = UrlParameter.Optional }, new { controller = "^H.*", action = "^Index$|^About$" }, new[] { "UrlsAndRoutes.Controllers"});

}

...

Ograniczenie to powoduje, że ścieżka pasuje wyłącznie do adresów URL, których wartość segmentu action jest Index lub About. Ograniczenia są stosowane jednocześnie, więc ograniczenia nałożone na wartości zmiennej action są łączone z tymi, które są nałożone na zmienną controller. Oznacza to, że ścieżka z listingu 13.28

będzie pasowała wyłącznie do adresów URL, których zmienna controller zaczyna się od litery H, a zmienna action ma wartość Index lub About. Teraz wiesz już, co miałem na myśli, pisząc o bardzo precyzyjnych ścieżkach.

Ograniczanie ścieżek z użyciem metod HTTP

Możliwe jest ograniczanie ścieżek w taki sposób, aby dopasowywały wyłącznie adresy URL w momencie, gdy żądanie korzysta z wybranej metody HTTP, jak pokazano na listingu 13.29.

Listing 13.29. Ograniczanie ścieżek bazujące na metodzie HTTP

...

public static void RegisterRoutes(RouteCollection routes) {

routes.MapRoute("MyRoute", "{controller}/{action}/{id}/{*catchall}", new { controller = "Home", action = "Index", id = UrlParameter.Optional }, new { controller = "^H.*", action = "Index|About",

httpMethod = new HttpMethodConstraint("GET") },

new[] { "UrlsAndRoutes.Controllers" });

}

...

Format definiowania metody HTTP jest trochę dziwny. Nazwa nadana właściwości nie ma znaczenia

— wystarczy, że będzie egzemplarzem klasy HttpMethodConstraint. W powyższym listingu nazwaliśmy ją httpMethod, aby pomóc odróżnić ją od wcześniej zdefiniowanych ograniczeń wartościowych.

343

Kup książkę

Poleć książkę

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

„ Uwaga Moliwo ograniczania cieek za pomoc metod HTTP nie jest zwizana z moliwoci ograniczania metod akcji za pomoc takich atrybutów jak HttpGet czy HttpPost. Ograniczenia cieek s przetwarzane znacznie wczeniej w potoku obs ugi dania i wyznaczaj nazw kontrolera i akcji wymaganej do przetworzenia dania. Atrybuty metod akcji s uywane do wybrania wersji metody akcji stosowanej do obs ugi dania przez kontroler. Wicej informacji na temat obs ugi rónych rodzajów metod HTTP (w tym równie rzadziej stosowanych, takich jak PUT

i DELETE) przedstawi w rozdziale 14.

Do konstruktora klasy HttpMethodConstraint przekazujemy nazwy metod HTTP, które chcemy obsługiwać.

Na wcześniejszym listingu ograniczyliśmy ścieżkę wyłącznie do żądań GET, ale możemy łatwo dodać obsługę innych metod:

...

httpMethod = new HttpMethodConstraint("GET", "POST") },

...

Testy jednostkowe — ograniczenia cieek

Przy testowaniu ogranicze cieek wane jest, aby sprawdzi zarówno niepasujce adresy URL, jak i adresy,

które próbujemy wykluczy , co moemy zrealizowa przez wykorzystanie metod pomocniczych wprowadzonych

na pocztku tego rozdzia u. Poniej przedstawiono zmodyfikowan metod testow TestIncomingRoutes, której uyjemy do przetestowania cieek zdefiniowanych na listingu 13.29:

...

[TestMethod]

public void TestIncomingRoutes() {

TestRouteMatch("~/", "Home", "Index");

TestRouteMatch("~/Home", "Home", "Index");

TestRouteMatch("~/Home/Index", "Home", "Index"); TestRouteMatch("~/Home/About", "Home", "About"); TestRouteMatch("~/Home/About/MyId", "Home", "About", new { id = "MyId" }); TestRouteMatch("~/Home/About/MyId/More/Segments", "Home", "About", new {

id = "MyId",

catchall = "More/Segments"

});

TestRouteFail("~/Home/OtherAction");

TestRouteFail("~/Account/Index");

TestRouteFail("~/Account/About");

}

...

Definiowanie własnych ograniczeń

Jeżeli standardowe ograniczenia nie są wystarczające do naszych potrzeb, możemy zdefiniować własne ograniczenia przez zaimplementowanie interfejsu IRouteConstraint. Aby zademonstrować tę funkcję, do projektu dodajemy katalog Infrastructure, w którym następnie tworzymy nowy plik klasy o nazwie UserAgentConstraint.cs i umieszczamy w niej kod przedstawiony na listingu 13.30.

344

Kup książkę

Poleć książkę

ROZDZIA 13. „ ROUTING URL

Listing 13.30. Tworzenie własnego ograniczenia ścieżki

using System.Web;

using System.Web.Routing;

namespace UrlsAndRoutes.Infrastructure {

public class UserAgentConstraint : IRouteConstraint {

private string requiredUserAgent;

public UserAgentConstraint(string agentParam) {

requiredUserAgent = agentParam;

}

public bool Match(HttpContextBase httpContext, Route route,

string parameterName, RouteValueDictionary values,

RouteDirection routeDirection) {

return httpContext.Request.UserAgent != null &&

httpContext.Request.UserAgent.Contains(requiredUserAgent);

}

}

}

Interfejs IRouteConstraint definiuje metodę Match, której implementacja wskazuje systemowi routingu, czy ograniczenie jest spełnione. Parametry metody Match zapewniają dostęp do żądania od klienta, do kontrolowanej ścieżki, do zmiennych segmentów pobranych z adresu URL oraz do informacji, czy żądanie dotyczy przychodzącego, czy wychodzącego adresu URL. W naszym przykładzie sprawdzamy, czy wartość właściwości UserAgent w żądaniu klienta jest taka sama jak wartość przekazana do konstruktora. Na listingu 13.31

pokazane jest nasze ograniczenie użyte w ścieżce.

Listing 13.31. Użycie niestandardowego ograniczenia w ścieżce

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

using System.Web.Routing;

using UrlsAndRoutes.Infrastructure;

namespace UrlsAndRoutes {

public class RouteConfig {

public static void RegisterRoutes(RouteCollection routes) {

routes.MapRoute("ChromeRoute", "{*catchall}",

new { controller = "Home", action = "Index" },

new {

customConstraint = new UserAgentConstraint("Chrome")

},

new[] { "UrlsAndRoutes.AdditionalControllers" });

routes.MapRoute("MyRoute", "{controller}/{action}/{id}/{*catchall}", new { controller = "Home", action = "Index",

id = UrlParameter.Optional },

new[] { "UrlsAndRoutes.Controllers" });

}

}

}

345

Kup książkę

Poleć książkę

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

Na listingu mamy zdefiniowane ograniczenie ścieżki pozwalające na dopasowanie wyłącznie żądań wykonywanych z przeglądarek, których nagłówek user-agent zawiera Chrome. Jeżeli ścieżka zostanie dopasowana, wówczas żądanie będzie skierowane do metody akcji Index w kontrolerze HomeController zdefiniowanym w katalogu AdditionalControllers bez względu na strukturę i treść żądanego adresu URL.

Nasz wzorzec URL składa się ze zmiennej catchall segmentu, co oznacza, że wartości zmiennych controller i action segmentu zawsze będą wartościami domyślnymi, a nie pobranymi z adresu URL.

Druga ścieżka spowoduje dopasowanie wszystkich żądań i kontrolerów docelowych w katalogu Controllers. Efektem zastosowania omówionych ścieżek jest to, że jedna z przeglądarek zawsze będzie przechodziła do tego samego miejsca w aplikacji, co możesz zobaczyć na rysunku 13.12. Na wymienionym rysunku pokazano efekt uruchomienia aplikacji w przeglądarce Google Chrome.

Rysunek 13.12. Aplikacja uruchomiona w przeglądarce Google Chrome

Z kolei na rysunku 13.13 pokazano wynik uruchomienia tej samej aplikacji w przeglądarce Internet Explorer.

Rysunek 13.13. Aplikacja uruchomiona w przeglądarce Internet Explorer

„ Uwaga Chc postawi spraw jasno — nie sugeruj, aby ogranicza aplikacj do obs ugi przegldarki tylko jednego typu. Uy em nag ówka user-agent wy cznie w celu zademonstrowania w asnych ogranicze cieki, poniewa wierz w równe szanse wszystkich przegldarek. Naprawd nie znosz witryn, które wymuszaj na uytkownikach wybór przegldarki.

Routing da dla plików dyskowych

Nie wszystkie żądania do aplikacji MVC odnoszą się do kontrolerów i akcji. Nadal musimy udostępniać takie dane, jak zdjęcia, statyczne pliki HTML, biblioteki JavaScript itd. Na przykład w naszej aplikacji MVC utworzymy w katalogu Content plik o nazwie StaticContent.html. Zawartość tego pliku znajduje się na listingu 13.32.

346

Kup książkę

Poleć książkę

ROZDZIA 13. „ ROUTING URL

Listing 13.32. Plik StaticContent.html

<!DOCTYPE html>

<html xmlns="http://www.w3.org/1999/xhtml">

<head><title>Statyczny plik HTML</title></head>

<body>

To jest statyczny plik html (~/Content/StaticContent.html)

</body>

</html>

System routingu zawiera zintegrowaną obsługę tego typu treści. Jeżeli uruchomisz aplikację i użyjesz adresu URL /Content/StaticContent.html, zobaczysz w przeglądarce zawartość tego prostego pliku HTML

(rysunek 13.14).

Rysunek 13.14. Żądanie przesłania pliku statycznego

Domyślnie system routingu sprawdza, czy adres URL pasuje do pliku na dysku, zanim zacznie przetwarzać ścieżki aplikacji. Dlatego też nie trzeba definiować ścieżki, aby otrzymać efekt pokazany na rysunku 13.14.

Jeżeli zostanie znalezione dopasowanie, plik z dysku jest udostępniany przeglądarce, a ścieżki nie są przetwarzane. Możemy odwrócić ten sposób działania, aby nasze ścieżki były przetwarzane przed sprawdzaniem plików na dysku — zmienić właściwość RouteExistingFiles w obiekcie RouteCollection na true (listing 13.33).

Listing 13.33. Aktywowanie przetwarzania ścieżek przed kontrolą plików public static void RegisterRoutes(RouteCollection routes) {

routes.RouteExistingFiles = true;

routes.MapRoute("ChromeRoute", "{*catchall}",

new { controller = "Home", action = "Index" },

new {

customConstraint = new UserAgentConstraint("Chrome")

},

new[] { "UrlsAndRoutes.AdditionalControllers" });

routes.MapRoute("MyRoute", "{controller}/{action}/{id}/{*catchall}", new { controller = "Home", action = "Index",

id = UrlParameter.Optional },

new[] { "UrlsAndRoutes.Controllers" });

}

Zgodnie z konwencją instrukcja ta powinna znajdować się blisko początku metody RegisterRoutes, choć będzie działała nawet wtedy, gdy zostanie ustawiona po zdefiniowaniu ścieżek.

Konfiguracja serwera aplikacji

Visual Studio 2012 używa IIS Express jako serwera aplikacji dla projektów MVC. Nie tylko powinniśmy ustawić wartość true właściwości RouteExistingFiles w metodzie RegisterRoutes, ale również poinformować serwer IIS Express, aby nie przechwytywał żądań do plików na dysku, zanim nie zostaną one przekazane systemowi routingu MVC.

347

Kup książkę

Poleć książkę

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

Przede wszystkim uruchom IIS Express. Najłatwiejszym sposobem jest uruchomienie aplikacji MVC

w Visual Studio, co spowoduje wyświetlenie ikony IIS Express na pasku zadań. Kliknij tę ikonę prawym przyciskiem myszy i z menu kontekstowego wybierz opcję Pokaż wszystkie aplikacje. Kliknij UrlsAndRoutes w kolumnie Nazwa witryny, aby w ten sposób wyświetlić informacje konfiguracyjne, jak pokazano na rysunku 13.15.

Rysunek 13.15. Informacje konfiguracyjne serwera IIS Express

Kliknij łącze Konfiguracja znajdujące się na dole okna, co spowoduje wyświetlenie w Visual Studio pliku konfiguracyjnego IIS Express. Teraz naciśnij klawisze Ctrl+F i wyszukaj UrlRoutingModule-4.0. Odpowiedni wpis znajduje się w sekcji modules pliku konfiguracyjnego. Naszym celem jest ustawienie atrybutowi preCondition pustego ciągu tekstowego, np.:

<add name="UrlRoutingModule-4.0" type="System.Web.Routing.UrlRoutingModule"

preCondition="" />

Teraz ponownie uruchom aplikację w Visual Studio, aby zmodyfikowane ustawienia zostały uwzględnione, a następnie przejdź do strony pod adresem /Content/StaticContent.html. Zamiast zobaczyć zawartość pliku, w oknie przeglądarki internetowej zostanie wyświetlony komunikat błędu widoczny na rysunku 13.16. Błąd wynika z tego, że żądanie pliku HTML zostało przekazane do systemu routingu MVC, ale ścieżka dopasowująca adres URL przekierowuje żądanie do nieistniejącego kontrolera Content.

Rysunek 13.16. Żądanie pliku statycznego obsłużone przez system routingu 348

Kup książkę

Poleć książkę

ROZDZIA 13. „ ROUTING URL

„ Wskazówka Innym rozwizaniem jest uycie serwera Visual Studio, który moesz aktywowa w sekcji Sie Web

konfiguracji projektu wywietlanej po wybraniu opcji W aciwoci UrlsAndRoutes... w menu Projekt w Visual Studio. Serwer Visual Studio jest ca kiem prost, a nie okrojon wersj IIS tak jak IIS Express, wic nie przechwytuje da w ten sam sposób.

Definiowanie ścieżek dla plików na dysku

Gdy właściwości RouteExistingFiles została przypisana wartość true, możemy zdefiniować ścieżki odpowiadające adresom URL dla plików na dysku, takie jak na listingu 13.34.

Listing 13.34. Ścieżka, której wzorzec URL odpowiada plikowi na dysku

...

public static void RegisterRoutes(RouteCollection routes) {

routes.RouteExistingFiles = true;

routes.MapRoute("DiskFile", "Content/StaticContent.html", new {

controller = "Customer", action = "List",

});

routes.MapRoute("ChromeRoute", "{*catchall}",

new { controller = "Home", action = "Index" },

new {

customConstraint = new UserAgentConstraint("Chrome")

},

new[] { "UrlsAndRoutes.AdditionalControllers" });

routes.MapRoute("MyRoute", "{controller}/{action}/{id}/{*catchall}", new { controller = "Home", action = "Index", id = UrlParameter.Optional }, new[] { "UrlsAndRoutes.Controllers" });

}

...

Powyższa ścieżka powoduje mapowanie żądań adresu URL /Content/StaticContent.html na akcję List kontrolera Customer. Działające mapowanie pokazano na rysunku 13.17. Pokazany na rysunku efekt otrzymasz po uruchomieniu aplikacji i przejściu do adresu URL /Content/StaticContent.html.

Rysunek 13.17. Przechwytywanie żądania pliku dyskowego z użyciem ścieżki Routing żądań przeznaczonych dla plików dyskowych wymaga dokładnego przemyślenia, ponieważ wzorce URL będą dopasowywać adresy tego typu równie chętnie, jak wszystkie inne. Na przykład żądanie dla

/Content/StaticContent.html może być dopasowane do wzorca URL takiego jak {controller}/{action}. Jeżeli nie będziesz ostrożny, może się to skończyć bardzo dziwnymi wynikami i obniżoną wydajnością. Dlatego wykorzystanie tej opcji powinno być ostatecznością.

349

Kup książkę

Poleć książkę

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

Pomijanie systemu routingu

Użycie właściwości RouteExistingFiles, przedstawionej w poprzednim punkcie, powoduje, że system routingu zaczyna obsługiwać więcej żądań. Żądania, które normalnie pomijały system routingu, są teraz dopasowywane do zdefiniowanych ścieżek.

Przeciwieństwem tej funkcji jest możliwość ograniczenia liczby adresów URL dopasowanych do naszych ścieżek. Realizujemy to przez użycie metody IgnoreRoute z klasy RouteCollection, która jest pokazana na listingu 13.35.

Listing 13.35. Użycie metody IgnoreRoute

...

public static void RegisterRoutes(RouteCollection routes) {

routes.RouteExistingFiles = true;

routes.IgnoreRoute("Content/{filename}.html");

routes.MapRoute("DiskFile", "Content/StaticContent.html", new {

controller = "Customer", action = "List",

});

routes.MapRoute("ChromeRoute", "{*catchall}",

new { controller = "Home", action = "Index" },

new {

customConstraint = new UserAgentConstraint("Chrome")

},

new[] { "UrlsAndRoutes.AdditionalControllers" });

routes.MapRoute("MyRoute", "{controller}/{action}/{id}/{*catchall}", new { controller = "Home", action = "Index", id = UrlParameter.Optional }, new[] { "UrlsAndRoutes.Controllers" });

}

...

Do dopasowania zakresów adresów URL możemy użyć zmiennych segmentu, takich jak {filename}.

W tym przypadku wzorzec URL będzie dopasowywał dowolne trójsegmentowe adresy URL, których pierwszym segmentem jest Content; drugi segment ma rozszerzenie .html.

Metoda IgnoreRoute tworzy wpis w RouteCollection, w której obiekt zarządzania ścieżki jest typu StopRoutingHandler zamiast MvcRouteHandler. System routingu ma wbudowany kod rozpoznający ten obiekt obsługi. Jeżeli wzorzec URL przekazany do metody IgnoreRoute zostanie dopasowany, to nie będą analizowane kolejne ścieżki, tak jak w przypadku dopasowania ścieżki standardowej. Z tego powodu ważne jest również miejsce, w którym umieszczone jest wywołanie metody IgnoreRoute. Jeżeli uruchomisz aplikację i ponownie przejdziesz do adresu URL /Content/StaticContent.html, będziesz mógł zobaczyć zawartość wskazanego pliku HTML. Wynika to z faktu przetworzenia obiektu StopRoutingHandler, zanim jakakolwiek ścieżka będzie mogła dopasować adres URL.

350

Kup książkę

Poleć książkę

ROZDZIA 13. „ ROUTING URL

Podsumowanie

W tym rozdziale przedstawiłem szczegółowo system routingu. Pokazałem, jak są dopasowywane i obsługiwane przychodzące żądania URL, jak dostosować ścieżki do własnych potrzeb przez zmianę sposobu dopasowywania segmentów URL i przez używanie wartości domyślnych oraz segmentów opcjonalnych. Zademonstrowałem także sposób ograniczania ścieżek w wyniku zmniejszania zakresu dopasowywanych żądań i pokazałem, jak obsługiwać żądania treści statycznej.

W następnym rozdziale pokażę, jak generować wychodzące żądania URL ze ścieżek w widokach oraz jak korzystać z funkcji obszarów na platformie MVC. Wspomniana funkcja opiera się na systemie routingu i można ją wykorzystać do zarządzania ogromnymi i skomplikowanymi aplikacjami opartymi na technologii ASP.NET MVC.

351

Kup książkę

Poleć książkę

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

352

Kup książkę

Poleć książkę

Skorowidz

A

akcja, 448

kontrolera API, 657

Active Server Pages, 24

metoda, Patrz: metoda akcji

adres

nazwa, 450, 451, 455

URL, 30, 38, 40, 144, 188, 203, 223, 316, 396, 545,

podrzędna, 477, 486, 487, 496

546, 573, 655

potomna, 207

domyślny, 325, 326, 327

testowanie, 386

generowanie, 361, 362, 363

użytkownika, 63

generowany na podstawie schematu, 354

wynik, 379, 385, 387, 405, 424

ograniczenia, 342

buforowanie, 433

przychodzący, 315, 318, 322, 326, 330, 335,

wywołanie, 447, 448, 449

339, 345, 365

aktywator kontrolerów, Patrz: kontroler aktywator

przyjazny dla użytkownika, 375

Amazon Kindle Fire, 643

segment, 318, 331, 337, 343, 356

antywzorzec, 66

segment opcjonalny, 335, 336, 337, 338

API, 31, 298, 318, 494, 633, 647, 648, 658

segment statyczny, 327, 331

format danych, 656

segment zmienny, 359

aplikacja, 167, 168

składany, 195

dla urządzeń mobilnych, 640, 641

skojarzony z metodą akcji, 65

domena, 46

w pełni kwalifikowany, 360

dystrybucja, 668

wychodzący, 206, 315, 345, 353, 356,

kompilowanie, 48

357, 358, 367

sieciowa, 625

żądania, 315

wdrażanie, 667, 676

względny, 361

architektura

agregat, 70, 71

model-widok, 66

Ajax, 24, 25, 26, 28, 543, 547, 626

model-widok-kontroler, Patrz: MVC

formularz nieprzeszkadzający, 550

model-widok-prezenter, Patrz: MVP

łącza, 558

model-widok-widok-model, Patrz: MVVM

opcje, 554

MVC, Patrz: MVC

wykrywanie żądań, 567

obsługująca intensywne testowanie, 133

wywołanie

trójwarstwowa, 67

nieprzeszkadzające, 547, 549, 550, 553, 554, 555

arkusz stylów, Patrz: CSS

zwrotne, 560

ASP, Patrz: Active Server Pages

ASPX, 37, 465, 472

Kup książkę

Poleć książkę

SKOROWIDZ

asynchroniczność, 28

cookie, 223, 280

atak, 497

CouchDB, 28

AutoFac, 27

CRUD, 167, 251

Azure, Patrz: Windows Azure

Cruise Control, 27

CSS, 25, 26, 29, 58, 196, 211, 262, 299, 632

B

członkostwo, 30

baza

D

danych, 50

administracja zdalna, 674

DAL, 67

konfiguracja połączenia, 670

DDD, 68, 70

kontrola wersji, 32

debugowanie, 38, 169, 172, 302, 304, 306, 307, 309,

migracja, 32

310, 566, 626, 670

na podstawie klas modelu, 183

widoków Razor, 309

nierelacyjna, 28

delegat, 97, 100

obiektowa, 71

DI, 74, 75, 78, 136, 171, 241

relacyjna, 70, 71, 179

domena

SQL Server, 35, 179

klasa, Patrz: klasa domeny

zapisywanie zdjęć, 289

model, Patrz: model domeny

dokumentów, 70, 71

modelowanie, 68

BDD, Patrz: programowanie sterowane

typ, 64

zachowaniami

dostawca wartości, 382

bezpieczeństwo, 496, 497, 555, 564

bezstanowość, 23, 32, 63

E

biblioteka

GUI, 67

Edit and Continue, Patrz: Visual Studio Edit

imitacyjna, 161

and Continue

JavaScript, Patrz: JavaScript

edytor kodu, 35, 307

jQuery, Patrz: jQuery

e-mail, 241

jQuery Mobile, Patrz: jQuery Mobile

encja, 64, 69, 169, 174

jQuery UI, Patrz: jQuery UI

główna, 70

Knockout, Patrz: Knockout

koszyka, 217

kolekcji generycznych, 91

Entity Framework, 106, 179, 265, 535

LINQ, 102

kontekstu, 183

Modernizr, Patrz: Modernizr

etykieta, 530

Moq, Patrz: Moq

narzędziowa, 169

F

ORM, 65

skryptów, 625

Fiddler, 566, 631

błąd, 399, 603, 608

filtr, 278, 379, 403, 405, 427, 429

usuwanie, 35

Action, 405

akcji, 420, 430, 433

C

Authorization, 405

Authorize, 278, 279

CDN, 29

autoryzacji, 407, 408, 409, 410, 430, 433

CGI, Patrz: Common Gateway Interface

własny, 409

chmura, 667

bez atrybutów, 427

Chrome, 604

Exception, 405

Common Gateway Interface, 24

globalny, 429, 430, 433

682

Kup książkę

Poleć książkę

SKOROWIDZ

kolejność wykonywania, 430, 433

intencja

kontrolera, 279

definiowanie, 385

OutputCache, 433, 434

wykonywanie, 385

RequireHttps, 433

interfejs, 93

Result, 405

.NET, 29

stos, 432

C#, 137

uwierzytelniania, 278

dostawcy uwierzytelniania, 280

wbudowany, 433

edycji, 261

wyjątków, 411, 413, 415, 433

IActionFilter, 405, 426, 427

wbudowany, 418, 419

IActionInvoker, 466

wyniku, 424, 430

IAuthorizationFilter, 407, 409, 427

filtrowanie według kategorii, 203, 205

IController, 378, 441, 447, 654

Firefox, 38, 84, 604

IControllerFactory, 301

formularz, 51, 380, 433, 500, 502

IDiscountHelper, 162, 163

Ajax, 552

IExceptionFilter, 418

nieprzeszkadzający, 550

IExecutionFilter, 427

obsługujący, 628

IHttpHandler, 368

HTML, 222, 625

implementacja, 133

znacznik, 50

IOrderProcessor, 241, 243

synchroniczny, 547, 548, 552

IProductRepository, 174

tworzenie, 504

IQueryable, 106

ukryte pole, 528

IResultFilter, 405, 426, 427

uwierzytelnianie, 277, 280

IRouteConstraint, 344

funkcja

IRouteHandler, 368

code-first, 183

IViewEngine, 465

SQL Server, 180

Ninject.IKernel, 140

uwierzytelniania formularzy, 277

repozytorium, 649

użytkownika, 23, 55, 64, 65, 68, 169

G

automatyzacja, 84

do przesyłania plików, 288

getter, 89

graficzny, 23

Google Web Accelerator, 376

prototypowanie, 66

GridView, 194

Web API, Patrz: API

GUI, Patrz: interfejs użytkownika graficzny

internacjonalizacja, 30

Guthrie Scott, 28

Internet Explorer, 38, 84, 144, 172, 630, 631

inversion of control, Patrz: IoC

H

IoC, 74, Patrz też: DI

hasło, 277, 278, 299

HTML, 23, 25, 26, 29, 31, 47, 63, 188, 477, 489, 492

J

generowanie kodu, 388

JavaScript, 25, 26, 28, 169, 269, 299, 300, 346, 625

HTML5, 26

V8, 28

HTTP, 23, 25, 31, 221, 343

wyłączona obsługa, 555, 559

kody, 399, 400

jQuery, 26, 28, 29, 169, 299, 543, 547, 550, 625, 626,

637, 658

I

jQuery Mobile, 26, 169, 625, 640

IDC, Patrz: Microsoft Internet Database Connector

jQuery UI, 26, 169, 625

IDE, 133, 149

jQuery Validation, 621, 625, 626

IIS, 667

JSON, 26, 562, 647

IntelliSense, 381, 392, 634

wyświetlenie danych, 566

683

Kup książkę

Poleć książkę

SKOROWIDZ

K

obsługi trwałości, 67

wbudowany, 477

kalendarz, 29

kolekcja, 90, 129, 130, 251, 586, 587, 588

klasa, 38, 46, 88, 93, 137

filtrowanie, 95

abstrakcyjna, 29

generyczna, 91, 95

ActionFilterAttribute, 405, 426

obiektów, 134

ActionMethodSelectorAttribute, 453

kompilacja, 173

AjaxOptions, 553, 560

kompilator, 35, 109

ApiController, 657

komunikat, 267, 268, 557

Assert, 152, 153

błędu, 417

AuthorizeAttribute, 410, 411

kontroli poprawności, 604, 608

ControllerActionInvoker, 466

o błędach, 399

ControllerContext, 230, 411

konstruktor, 245

CSS, 197

konfiguracja parametrów, 76

DefaultControllerFactory, 443

oczekujący, 176

domeny, 111

kontener

ExceptionContext, 412

DI, 75, 76, 133, 136, 171, 241

fabryki kontrolerów, 443

IoC, Patrz: kontener DI

FilterAttribute, 413

kontrola

FormsAuthentication, 280

poprawności, 54, 57, 68, 248, 269, 595, 599, 604,

HandleErrorAttribute, 419

608, 616

HttpStatusCodeResult, 400

jawna, 602

imitacja, 322

jQuery, 621

implementacja, 146

nieprzeszkadzająca, 618

It, 162

po stronie klienta, 269, 271, 284, 618, 619,

kontrolerów, 299

620, 621

modelu, 68, 134, 177

w łączniku modelu, 609

częściowa, 535

zasady poprawności, 610, 612, 613, 614

domeny, 299

zdalna, 621

generowana automatycznie, 535

wersji bazy danych, 32

widoku, 299

kontroler, 27, 29, 38, 40, 43, 64, 68, 85, 135, 142, 169,

nazwa niekwalifikowana, 339

299, 301, 315, 368, 371, 377, 405, 406, 429, 650

NinjectControllerFactory, 171

aktywator, 445, 446

osłonowa, 91

API, 647, 648, 650, 655, 656

RangeExceptionAttribute, 413

akcja, 657

RouteBase, Patrz: RouteBase

tworzenie, 653

RouteCollection, 320

asynchroniczny, 28, 458, 459, 461

System.Mvc.Web.Html.InputExtensions, 604

System.Web.Http.ApiController, 654

tworzenie, 461

System.Web.Mvc.Controller, 379, 654

bezstanowy, 456, 457

System.Web.Security.FormsAuthentication, 280

CRUD, 251

testowanie, 158

fabryka, 437, 441, 446, 447, 466

ViewContext, 493

domyślna, 441

ViewEngineResult, 467

tworzenie, 439, 442, 445

zaprzyjaźniona, 535, 536

wbudowana, 443, 457

klucz główny, 182

koszyka na zakupy, 222

Knockout, 169, 625, 626

nawigacji, 207

kod

niejednoznaczność, 373

HTML, 388

poprawiający wydajność, 456

HTTP, 399, 400

priorytet, 339

684

Kup książkę

Poleć książkę

SKOROWIDZ

rozszerzanie, 437

rozwiązywania zależności, Patrz: zależność

testowanie, 386

stanu sesji, 223

tworzenie, 378, 379, 380, 445

ViewBag, 212

zapasowy, 441

wstrzykiwania zależności, Patrz: DI

kontrolka, 23, 47, 625

menu

GridView, 194

kaskadowe, 29

nawigacji, 201

nawigacji, 207

serwerowa, 31

metadane, 527, 530, 531, 533, 535, 538, 610, 614

UI, 32

metoda, 448

użytkownika

.ToString, 178

dla urządzeń mobilnych, 625

@RenderSection, 478

wprowadzania danych

Action, 208

silnie typowana, 512

ActionLink, 47, 211, 484

kontynuacja, 108

AddBindings, 171

konwencja

Ajax.BeginForm, 554

dla klas kontrolerów, 301

akcji, 38, 41, 43, 65, 113, 120, 123, 178, 229, 260,

dla układów, 302

282, 300, 316, 362, 368, 379, 388, 390, 405, 424,

dla widoków, 301

455, 573, Patrz: metoda publiczna

koszyk na zakupy, 216, 222, 224, 232, 234, 244

alias, 329

kreator projektów testów, 30

niejednoznaczność, 455

parametry, 380, 382, 383

L

przekazywanie danych do widoku, 391

selektor, 453

Language Integrated Query, Patrz: LINQ

tworzenie, 48

LINQ, 31, 83, 102, 106, 162, 179

wywoływana z widoku, 486

Parallel, 106

AreaRegistration.RegisterAllAreas, 320, 371

to Entities, 106

AreEqual, 152

to Objects, 106

AreNotEqual, 152

to XML, 106

AsQueryable, 175

lista, 47

Assert.AreEqual, 152

kategorii, 208

asynchroniczna, 107, 108, 109, 461

posortowana alfabetycznie, 209

Authenicate, 280

rozwijana, 57

AuthorizeCore, 408, 410

LocalDB, 180

BeginForm, 50, 51, 221, 554, Patrz też: metoda

logika

Html.BeginForm

aplikacji, 377

BeginRouteForm, 507, 508

biznesowa, 66, 123, 169

Bind, 140, 142

BundleConfig.RegisterBundles, 320

C#, 573

CanChangeLoginName, 78

łańcuch zależności, 76

CRUD, 252

łącznik modelu, Patrz: model łącznik

DefaultControllerFactory, 447

DisplayForModel, 536

M

EditorForModel, 261, 530, 536, Patrz też: metoda

Html.EditorForModel

Mac OS X, 32

Execute, 378, 379

mapowanie obiektowo-relacyjne, 27, 179

ExecuteResult, 385

mechanizm

FilterConfig.RegisterGlobalFilters, 320

dołączania modelu, Patrz: model dołączanie

formatująca, 178

685

Kup książkę

Poleć książkę

SKOROWIDZ

metoda

tworzenie, 491

GetControllerSessionBehavior, 442

wbudowana, 500

GetImage, 290

wewnętrzna, 491, 492, 495

GetModelStateValue, 604

widoku szablonowego, 240

GetRouteData, 366

własna, 495

GetService, 142

wprowadzanie danych, 508, 509

GetServices, 142

zewnętrzna, 493

HandleNonHttpsRequest, 433

POST, 221

Html.ActionLink, 354, 362

publiczna, Patrz: metoda akcji

Html.BeginForm, 504, 506, 507

Redirect, 395, 396

Html.Editor, 519

RedirectToAction, 362

Html.EditorFor, 240, 519

RegisterGlobalFilters, 429

Html.EditorForModel, 241, 269, 536

ReleaseController, 442

Html.EndForm, 504

RenderAction, 208

Html.HiddenFor, 234

RenderPartial, 200, 208

Html.HttpMethodOverride, 664

Response.Write, 383

Html.TextBoxFor, 240

Returns, 162

Html.ValidationSummary, 605, 606

RouteConfig.RegisterRoutes, 320

HTML, 188, 189, 477

RouteLink, 211, 213

HTTP, 343, 344

rozszerzająca, 91, 92, 93, 103, 104

IsAny, 162

filtrująca, 95

IsInRange, 165

LINQ, 104, 105

It.Is, 165

SetAuthCookie, 280

Label, 530

Setup, 162

LabelFor, 530

statyczna, 152, 153, 162, 280

LabelForModel, 530

string.IsNullOrEmpty, 602

List, 301

synchroniczna, 461

łańcuch wywołań, 147

TestIncomingRouteResult, 323

łączenie warunkowe, 148

TextBoxFor, 50, Patrz też: metoda

MapPageRoute, 321

Html.TextBoxFor

MapRoute, 321

To, 140, 142

ModelState.AddModelError, 602

ToConstant, 175

Ninject, 244

Url.Action, 362

obsługi zdarzeń, 65

UrlHelper.GenerateURL, 357

OnAuthorization, 409

View, 41, 391, 603

OnException, 411

WebApiConfig.Register, 320

opóźniona, 105, 106

widoku, 120

pomocnicza, 47, 200, 221, 234, 322, 489, 492, 496,

WithConstructorArgument, 244

530

WithPropertyValue, 146

generująca adresy URL, 545, 546

metodologia zwinna, Patrz: programowanie zwinne

kodowanie ciągów tekstowych, 496

Microsoft Internet Database Connector, 24

kodowanie treści, 498

Microsoft’s Entity Framework, 32

obsługująca formularze, 500

model, 46, 64, 113, 371

obsługująca kontrolę poprawności, 604

dołączanie, 53, 57, 68, 229, 380, 571, 573, 579,

rusztowanie, Patrz: rusztowanie

591, 609

silnie typowana, 512

kolekcji, 584, 586

szablonowa, 240, 517, 519, 522, 525, 527, 533,

obsługa błędów, 590

538, 539, 603

selektywne właściwości, 583

tworząca znacznik select, 513

tablic, 584

wywołanie jawne, 589

686

Kup książkę

Poleć książkę

SKOROWIDZ

domeny, 46, 55, 64, 66, 67, 69, 111, 123, 168, 173,

NHibernate, 27, 32

230, 269, 299, 377

Ninject, 27, 76, 133, 136, 138, 139, 141, 144, 148, 241

implementacja, 65

Node.js, 28

trwały, 64

notacja kropki, 103

klasa, Patrz: klasa modelu

NuGet, 138, 139, 159, 640

kojarzenie z bazą danych, 184

NUnit, 27, 30, 133, 149

kontrola poprawności, Patrz: kontrola

poprawności

O

łącznik, 229, 232, 265, 282, 382, 502, 574, 581, 594,

595, 596, 609

obiekt, 70

domyślny, 575

AuthorizationContext, 409

metadane, 68, 262, 527

C#, 229

obiekt, 115

ControllerContext, 380

samokontrolujący, 616

cykl życia, 223

typ, 115

czas życia, 76

widoku, 64, 68, 299, 309, 316, 392

dołączanie, 334

właściwość, 50

dynamiczny, 44

wyświetlanie danych, 531

filtrowanie kolekcji, 95

ModelState, 383

HttpContextBase, 409

Modernizr, 169, 626

imitacyjny, 160, 175

Mongo, 28

tworzenie, 161

MonoRail, 32

inicjalizator, 90, 93, 100

Moq, 27, 133, 157, 158, 159, 163, 280

kernel Ninject, 140

MSTest, 30

kolekcja, Patrz: kolekcja obiektów

MVC, 27, 28, 29, 30, 31, 38, 46, 65, 68, 133, 159, 167,

kontekstu, 380, 381

229, 297, 625

ModelState, 383

aplikacja, 35, 299

modelu domeny, 123, 230

wprowadzania danych, 45

modelu widoku, 392

bezpieczeństwo, 278

obsługi ścieżki, 368

elementy projektu, 299, 300

RedirectToRouteResult, 362

konwencja, 301

stanu sesji, 223

migracja z Web Forms, 32

tworzenie, 89

odmiany, 67

ViewBag, 43, 213, 394

programowanie po stronie klienta, 628

wywołujący akcje, 437

wzorzec projektowy, Patrz: wzorzec MVC

zarządzanie czasem życia, 76

MVC 4, 298

obsługa stanu, 32

MVP, 67

obsługa łańcucha zależności, 76

MVVM, 68

obszar, 300, 369, 371

tworzenie, 369

N

odwrócenie kontroli, 74, Patrz też: DI

Open Source Initiative, Patrz: OSI

narzędzie

Opera, 84

F12, 630, 631

Opera Mobile, 643

imitujące, 79, 133

Opera Mobile Emulator, 641, 643

National Center for Supercomputing Applications, 24

operacja, 69

nawigacja, 207

optymalizacja, 630, 631, 640

nazwa kwalifikowana, 55

ORM, Patrz: mapowanie obiektowo-relacyjne

NCSA, 24

OSI, 31

687

Kup książkę

Poleć książkę

SKOROWIDZ

P

przycisk, 221, 222

pula wątków roboczych, 458, 459

paczka, 625, 632, 635, 670

punkt

arkuszy stylów, 633

przerwania, 306, 307, 309

skryptów, 633

zatrzymania, 306

ścieżka dostępu, 633

Python, 32

platforma ORM, 179

plik

R

.cshtml, 42

IntelliSense, 634

Rails, Patrz: Ruby on Rails

konfiguracyjny, 300

Razor, 33, 37, 54, 65, 111, 120, 126, 177, 389, 465,

skryptów, 632

472, 473, 475, 478, 484

ViewStart, 119

blok kodu, 116

widoku, 122

instrukcja, 114

zminimalizowany, 626, 627, 634

konstrukcje warunkowe, 127, 129

poczta elektroniczna, 241

składnia, 111

pole

wyrażenia, 123

prywatne, 88

refaktoring, 199, 329

tekstowe, 47, 57, 604

kontrolera, 142

wyboru, 47, 604

relacja, 69

powiązanie luźne, 73

repozytorium, 71, 179, 649

prefiks, 580, 581

imitacja, 175, 179

prezenter, 67, 68

magazynów dokumentów, 179

profil, 30

obiektów, 179

profilowanie, 638

tworzenie, 184

programowanie

wzorzec, 174

równoległe, 107, 108

Representational State Transfer, Patrz: REST

sieciowe, 26

REST, 26, 30, 657

sterowane domeną, Patrz: DDD

Rhino Mock, 27, 133

sterowane testami, 26, 76, 79, 83

rola, 30

sterowane zachowaniami, 26

RouteBase, 364

zwinne, 26

routing, 27, 29, 30, 40, 195, 206, 299, 315, 318, 330,

protokół

356, 369, 396, 409, 544

HTTP, Patrz: HTTP

dostosowanie, 364

konfiguracja, 40, 175, 300, 355, 546

HTTPS, 433

pomijanie, 350

przeglądarka

tworzenie projektu, 316

automatyzacja, 84

żądań dla plików dyskowych, 346

internetowa, 38, 144, 300, 643, 655

Ruby on Rails, 27, 28, 29, 32, 301

symulowanie, 84

rusztowanie, 525, 526, 536

przekierowanie, 395, 396, 397, 398

wyłączanie właściwości, 530

trwałe, 395, 397

tymczasowe, 395, 397

przerwanie, 306

S

przestrzeń nazw, 132, 339, 341, 536

Safari, 84

domyślna, 371

Sanderson Steve, 626

MyProject, 445

Sanderson Steven, 169

priorytet, 340, 444

schemat URL

System.ComponentModel.DataAnnotations, 262

w postaci kontraktu dla użytkownika, 328

System.Web.Mvc, 378

dla aplikacji, 318

688

Kup książkę

Poleć książkę

SKOROWIDZ

sekcja, 477, 478, 479, 481

ogólny, 539

opcjonalna, 481

wbudowany, 540

Selenium RC, 84

serwer

aplikacji, 347

Content Delivery Network, Patrz: CDN

ścieżka, 40, 195, 196, 205, 206, 301, 315, 339, 507

Internet Information Services, Patrz: IIS

definiowanie, 319

SMTP, 243

domyślna, 40, 178

Visual Studio, 349

dopasowanie, 356

sesja, 223

generowanie adresu URL, 363

stan, 456, 457

kolejność, 330

wyłączony, 458

nazwa, 321, 332, 363, 370

setter, 89

ograniczenia, 342, 344

silnik

metody HTTP, 343, 344

ASPX, Patrz: ASPX

własne, 344

Razor, Patrz: Razor

wyrażenia regularne, 342

widoku, 37, 379, 465, 470

zbiór wartości, 343

tworzenie, 467, 468, 470

pliku na dysku, 349

Silverlight, 26, 68, 674

prosta, 324, 325

Sinatra, 27, 28

rejestrowanie, 321

składnia <% %>, 111

własny obiekt obsługi, 368

skrypt, 630, 632, 637

wzorzec, Patrz: wzorzec ścieżki

słowo kluczowe

zbiór, 318

async, 108, 109

śledzenie, 139

await, 108, 109

foreach, 492

T

model, 392

return, 108

tabela, 32, 675

select, 103

tablica, 90, 129, 130, 131, 584, 587

this, 92

Request.Form, 53

using, 104, 152

Request.QueryString, 53

var, 100, 101

TDD, 167, Patrz: programowanie sterowane testami

yield, 95

TeamCity, 27

zarezerwowane, 360

test, 26

Smalltalk, 28, 63

testowanie, 30, 154

SMTP, 241

automatyczne, 25, 27, 30, 32, 76

SOAP, 26

integracyjne, 76, 84

SQL, 102

jednostkowe, 25, 26, 27, 30, 67, 76, 77, 79, 83, 84,

skrypt, 182

133, 149, 151, 156, 158, 159, 160, 163, 167, 168,

SQL Server, 180

169, 203, 344

standard sieciowy, 26

generowanie metod testowych, 151

stoper, 423

nazewnictwo, 152

strona wzorcowa, 30

routingu, 316, 322, 327

stronicowanie, 186, 187

tworzenie projektu, 150

Subsonic, 27, 32

trwałość, 71

system wyników akcji, 379, 385

tryb wyświetlania, 625

System.Linq, 104

typ

System.Web.Routing, 30

anonimowy, 101

szablon, Patrz: metoda pomocnicza szablonowa

złożony, 536

kolejność wyszukiwania, 539

typowanie niejawne, Patrz: wnioskowanie typów

689

Kup książkę

Poleć książkę

SKOROWIDZ

U

widok, 27, 29, 33, 41, 43, 53, 64, 68, 114, 117, 123,

136, 169, 177, 300, 301, 309, 362, 363, 368, 371,

UI, Patrz: interfejs użytkownika

377, 390, 415, 465, 473, 477, 625, 635

układ, 117, 119, 300, 302, 417, 478, 481, 549

aktualizacja, 63

stosowanie, 118

bezstanowość, 63

tworzenie, 116, 253

beztypowy, 392

wersja mobilna, 642

C#, 42

współdzielony, 119

częściowy, 199, 209, 300, 301, 477, 483, 484, 487, 496

Unity, 76, 133

tworzenie, 483

URI, 26

typ, 485

URL, 27

generowanie, 389

urządzenie przenośne, 298

z użyciem ścieżki, 391

usługa RESTful, 657, 664

kompilacja, 668

ustawienia regionalne, 178, 577

niezależny, 116

uwierzytelnianie, 30, 284, 298, 299, 403, 411, 640

przekazywanie danych z metody akcji, 391

formularzy, Patrz: formularz uwierzytelnianie

rusztowania, 256, 257, 260

systemu Windows, 277

silnik, Patrz: silnik widoku

z użyciem filtrów, 278

słabo typowany, Patrz: widok beztypowy

użytkownik, 277, 278, 280, 299

szablon wbudowany, 534

dane, 612

ściśle określonego typu, 48

treści dynamiczne, 477

V

treści statyczne, 477

tworzenie, 113

ViewBag, 212, 266, 282, 316, 332, 393, 394, 458, 489

wersja mobilna, 642

ViewData, 458

wykrywanie błędów, 668

ViewState, 25, 31

wyszukiwanie, 475

Visual Studio, 30, 35, 36, 46, 85, 111, 133, 138, 149,

Windows Azure, 667, 671

151, 180, 297, 299, 536, 626

Windows Presentation Foundation, Patrz: WPF

błędy, 115

właściwość

debuger, 172, 304

AppRelativeCurrentExecutionFilePath, 322

Edit and Continue, 310, 312

automatyczna, Patrz: właściwość automatycznie

IntelliSense, 50, 65

implementowana

okno, 308

automatycznie implementowana, 88

Call Stack, 308, 309

Canceled, 423

Locals, 308, 309

class, 360

serwer, 349

controller, 178

Controller.ActionInvoker, 448

W

Controller.ControllerContext, 380

Controller.ViewBag, 393

warstwa dostępu do danych, Patrz: DAL

Date, 393

WatiN, 84

dynamiczna, 491

wątek

EmailSettings.WriteAsFile, 243

roboczy, 458

Exception, 423

tła, 459

ExceptionHandled, 423

Web API, Patrz: API

Greeting, 44

Web Forms, 23, 24, 25, 26, 27, 28, 29, 31, 65, 67, 167,

HttpContext, 230, 380

194, 300, 315

IDENTITY, 182

migracja do MVC, 32

Layout, 119

Message, 393

690

Kup książkę

Poleć książkę

SKOROWIDZ

ModelState.IsValid, 266

repozytorium, Patrz: repozytorium wzorzec

Request, 380

Smart UI, 64, 65, 66

Response, 380

ścieżki, 332

RouteData, 380

URL, 27, 318, 330

RouteData.Values, 334

konserwatywny, 319

RouteExistingFiles, 349

liberalny, 319

RouteTable.Routes, 320

Server, 380

X

Server.MachineName, 384

statyczna, 320

XML, 26

ukrywanie, 529

xUnit, 27, 30

ułatwiająca, 380

ViewBag.ProductCount, 128

Y

ViewContext, 493

ViewResult.ViewData.Model, 392

Yahoo! UI Library, 29

wartość, 146

WillAttend, 46, 55

Z

wyłączanie, 530

wnioskowanie typów, 100

zachowanie oczekiwane, 26

WPF, 68

zadanie

wstrzykiwanie, 176

przekrojowe, 403

implementacji, 148

separacja, 63, 73, 336

konstruktora, 144

zależność, 139, 141, 142, 144, 170, 171, 446

wartości do konstruktora, 147

łańcuch, 144

za pomocą konstruktora, 74

wstrzykiwanie, Patrz: wstrzykiwanie zależności

za pomocą settera, 74

zapytanie, 380

zależności, 141, 144, 176, 442

LINQ, 102

wyjątek, 306, 309, 415

opóźnione, 105

nieobsłużony, 411, 430

składnia, 103

obsłużony, 309

zasada

wyrażenie

czerwone-zielone-refaktoryzacja, 79

@Model, 124, 136

konwencja przed konfiguracją, 301, 444

@using, 132

zbiór

@ViewBag, 124

ścieżek, Patrz: ścieżka zbiór

lambda, 50, 83, 97, 98, 99, 100, 108, 162, 512

zasobów, Patrz: URI

Razor, Patrz: Razor wyrażenia

zdarzenie

regularne, 445

klienckie, 23

wywołanie

obsługa, 65

postback, 31

zdjęcia, 286, 290, 346

zwrotne, 28

wyświetlanie, 292

wzorzec

zintegrowane środowisko programistyczne, Patrz: IDE

architektury oprogramowania, 65

zmienna przechwytująca, 337, 338

DI, Patrz: DI

znacznik, 65

konwencja przed konfiguracją, Patrz: zasada

formularza HTML, 50

konwencja przed konfiguracją

HTML, 25, 504, 533

MVC, 63, 64

łącza (<a>), 360

POST-Redirect-GET, 395

select, 513

691

Kup książkę

Poleć książkę

SKOROWIDZ

żądanie, 23, 28, 318, 383, 441

Ajax, 647

GET, 52, 221, 376, 395, 433, 564, 657

HTTP, 229, 451, 573

klienta, 64

POST, 52, 244, 265, 273, 376, 395, 433, 564

przechwytywanie, 446

przychodzące, 206, 315, 377

sieciowe profilowanie, 631

692

Kup książkę

Poleć książkę

KSIĄŻKI TEGO AUTORA

ASP.NET MVC 4. Zaawansowane programowanie ASP.NET MVC 3 Framework. Zaawansowane programowanie