Darmowy fragment publikacji:
Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej
publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną,
fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym
powoduje naruszenie praw autorskich niniejszej publikacji.
Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi
ich właścicieli.
Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte
w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności
ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub
autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności
za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce.
Redaktor prowadzący: Ewelina Burska
Projekt okładki: ULABUKA
Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock.
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)
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie?aspm4w
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Materiały do książki można znaleźć pod adresem:
ftp://ftp.helion.pl/przyklady/aspm4w.zip
ISBN: 978-83-246-6534-1
Copyright © Helion 2013
Printed in Poland.
• Kup książkę
• Poleć książkę
• Oceń książkę
• Księgarnia internetowa
• Lubię to! » Nasza społeczność
Spis treĈci
Wstöp .............................................................................................. 7
Rozdziaä 1. Model-Widok-Kontroler ................................................................... 11
1.1. Krótka historia MVC ............................................................................................... 11
1.2. Klasyczna postaü wzorca MVC ............................................................................... 12
1.3. MVC jako wzorzec záoĪony .................................................................................... 14
1.3.1. Obserwator ..................................................................................................... 15
1.3.2. Strategia .......................................................................................................... 15
1.3.3. Kompozyt ....................................................................................................... 16
1.4. MVC dla aplikacji webowych ................................................................................. 17
1.5. Warianty MVC ........................................................................................................ 18
1.5.1. Wzorzec Model-Widok-Prezenter (MVP) ...................................................... 18
1.5.2. Wzorzec Prezentacja-Abstrakcja-Kontrola (PAC) ......................................... 19
1.5.3. Wzorzec Model-Widok-Widok Modelu (MVVM) ......................................... 19
1.6. Implementacja MVC w jĊzykach programowania ................................................... 19
1.6.1. Ruby: Ruby on Rails ...................................................................................... 19
1.6.2. Python: Django ............................................................................................... 20
1.6.3. Java: Spring, Struts ......................................................................................... 20
1.6.4. PHP: Zend Framework ................................................................................... 20
1.7. Podsumowanie ......................................................................................................... 20
Rozdziaä 2. Framework ASP.NET MVC 4 ........................................................... 23
2.1. ZaáoĪenia projektowe frameworku ASP.NET MVC ............................................... 25
2.1.1. RozszerzalnoĞü ............................................................................................... 26
2.1.2. Konwencja nad konfiguracją .......................................................................... 26
2.1.3. Peána kontrola nad HTML i HTTP ................................................................. 26
2.1.4. TestowalnoĞü .................................................................................................. 27
2.1.5. Elastyczny mechanizm routingu ..................................................................... 27
2.1.6. DostĊpnoĞü sprawdzonych funkcji i elementów frameworku ASP.NET ........ 27
2.1.7. Nowoczesne API ............................................................................................ 27
2.1.8. DostĊp do kodu Ĩródáowego ........................................................................... 28
2.2. Wersje i usprawnienia frameworku ASP.NET MVC .............................................. 28
2.3. Routing URL ........................................................................................................... 29
2.4. Testowanie ............................................................................................................... 30
2.4.1. Testowanie zwróconego widoku .................................................................... 31
2.4.2. Testowanie zwróconych danych ..................................................................... 31
2.4.3. Testowanie zwróconego rezultatu .................................................................. 32
2.5. Struktura aplikacji w ASP.NET MVC 4 ..................................................................... 33
2.6. Podsumowanie ......................................................................................................... 37
Kup książkęPoleć książkę 4
ASP.NET MVC 4. Programowanie aplikacji webowych
Rozdziaä 3. Kontrolery ...................................................................................... 39
3.1. Akcje i parametry .................................................................................................... 41
3.2. Model binding ......................................................................................................... 44
3.3. Filtry ........................................................................................................................ 46
3.4. Wbudowane atrybuty ............................................................................................... 49
3.4.1. NonAction ...................................................................................................... 49
3.4.2. Atrybut ActionNameAttribute ........................................................................ 49
3.4.3. Atrybut AcceptVerbsAttribute ....................................................................... 50
3.5. Podsumowanie ......................................................................................................... 50
Rozdziaä 4. Widoki ........................................................................................... 53
4.1. Przekazywanie danych do widoków .......................................................................... 54
4.2. Silniki widoków: Razor i ASPX .............................................................................. 57
4.3. Definicja szablonu widoku ...................................................................................... 60
4.4. Metody pomocnicze HTML .................................................................................... 61
4.5. Helpery Razor .......................................................................................................... 63
4.6. Podsumowanie ......................................................................................................... 63
Rozdziaä 5. Modele .......................................................................................... 65
5.1. Entity Framework .................................................................................................... 66
5.1.1. Konwencje i klasa kontekstowa w Code First ................................................ 67
5.2. Walidacja i adnotacje danych .................................................................................. 68
5.3. Asocjacje (związki) ................................................................................................. 70
5.3.1. Związek jeden-do-jednego ............................................................................. 70
5.3.2. Związek jeden-do-wielu (opcjonalny)
i związek jeden-do-wielu (obligatoryjny) ....................................................... 71
5.3.3. Związek wiele-do-wielu ................................................................................. 71
5.3.4. Związek wiele-do-wielu, klasa asocjacyjna z dodatkowymi atrybutami ........ 72
5.3.5. Generalizacja .................................................................................................. 72
5.4. Podsumowanie ......................................................................................................... 73
Rozdziaä 6. Zagadnienia zaawansowane ........................................................... 75
6.1. Routing, czyli przekierowania ................................................................................. 75
6.1.1. Deklaracja tras ................................................................................................ 76
6.1.2. Przykáad deklaracji wáasnej trasy ................................................................... 77
6.1.3. UĪywanie trasowania do generowania linków ............................................... 79
6.2. AJAX ....................................................................................................................... 80
6.2.1. AJAX Helpers ................................................................................................ 80
6.3. Entity Framework + Database Migrations ............................................................... 83
6.3.1. PodejĞcie Code First ....................................................................................... 84
6.3.2. Database Migrations ....................................................................................... 87
6.4. Mechanizm grupowania i minimalizacji .................................................................. 90
6.4.1. Wpáyw grupowania i minimalizacji ................................................................ 91
6.4.2. Kontrola i konfiguracja w projekcie MVC 4 .................................................. 92
6.5. Podsumowanie ......................................................................................................... 94
Rozdziaä 7. Studium przypadku: serwis Subskrypcja .......................................... 95
7.1. Biznesowa wizja systemu ........................................................................................ 95
7.2. Projektowa wizja systemu ....................................................................................... 96
7.3. Przygotowanie projektu ........................................................................................... 97
7.4. Przygotowanie bazy danych .................................................................................... 99
7.5. Dodanie modelu ..................................................................................................... 101
7.6. Utworzenie kontrolera Subscriber ......................................................................... 104
7.7. Dodanie widoków dla kontrolera Subscriber ......................................................... 109
7.8. Modyfikacja routingu oraz dostosowanie strony wzorcowej ................................. 119
Kup książkęPoleć książkę Spis treĈci
5
7.9. Dodanie modelu Newsletter ................................................................................... 121
7.10. Utworzenie kontrolera Newsletter ....................................................................... 122
7.11. Dodanie widoków dla kontrolera Newsletter ....................................................... 125
7.12. Utworzenie uĪytkownika Administrator .............................................................. 127
7.13. Utworzenie modelu Administrator ...................................................................... 130
7.14. Utworzenie kontrolera Administrator .................................................................. 130
7.15. Dodanie widoków dla kontrolera Administrator .................................................. 132
7.16. Instalacja aplikacji na serwerze WWW ............................................................... 136
7.17. Podsumowanie ..................................................................................................... 137
Rozdziaä 8. Studium przypadku: serwis Portal Usäug ......................................... 139
8.1. Biznesowa wizja systemu ...................................................................................... 139
8.2. Projektowa wizja systemu ..................................................................................... 140
8.3. Projekt aplikacji ..................................................................................................... 142
8.3.1. Projektowanie modelu .................................................................................. 142
8.3.2. Projektowanie kontrolerów ........................................................................... 145
8.4. Przygotowywanie projektu .................................................................................... 146
8.5. Przygotowywanie bazy danych ............................................................................. 146
8.6. Przygotowywanie modelu ..................................................................................... 147
8.7. Przygotowywanie repozytorium ............................................................................ 156
8.8. Rejestrowanie uĪytkowników ................................................................................ 169
8.8.1. Zmiana kontrolera Account .......................................................................... 171
8.8.2. Zmiana widoków kontrolera Account .......................................................... 182
8.8.3. Dodanie komponentu CAPTCHA ................................................................ 189
8.8.4. Implementacja mechanizmu komunikatów .................................................. 193
8.9. FunkcjonalnoĞü dodawania i edycji kategorii usáug i kategorii komentarzy .......... 194
8.9.1. Dodawanie i edycja kategorii usáug .............................................................. 194
8.9.2. Dodawanie i edycja kategorii komentarzy .................................................... 201
8.10. FunkcjonalnoĞü wysyáania newslettera ................................................................ 204
8.11. Utworzenie uĪytkownika Administrator .............................................................. 208
8.12. Implementacja menu ............................................................................................ 209
8.13. FunkcjonalnoĞü usáugobiorcy .............................................................................. 214
8.13.1. Lista usáugobiorców ................................................................................... 216
8.13.2. Edycja usáugobiorców ................................................................................ 225
8.13.3. Usuwanie usáugobiorców ........................................................................... 229
8.14. FunkcjonalnoĞü usáugodawcy .............................................................................. 232
8.14.1. Lista usáugodawców ................................................................................... 235
8.14.2. Edycja usáugodawców ................................................................................ 239
8.14.3. Usuwanie usáugodawców ........................................................................... 242
8.15. FunkcjonalnoĞü usáug i komentarzy ..................................................................... 245
8.15.1. Dodawanie usáug ........................................................................................ 246
8.15.2. Lista usáug .................................................................................................. 251
8.15.3. Edycja usáug ............................................................................................... 260
8.15.4. Usuwanie usáug .......................................................................................... 264
8.15.5. Szczegóáy usáug .......................................................................................... 267
8.15.6. Dodawanie komentarzy .............................................................................. 275
8.15.7. Edycja i usuwanie komentarzy ................................................................... 279
8.16. Szczegóáy usáugodawców .................................................................................... 282
8.17. Modyfikacja strony gáównej ................................................................................ 289
8.18. Implementacja widoków mobilnych .................................................................... 291
8.18.1. Dostosowanie strony wzorcowej ................................................................ 292
8.18.2. Widoki mobilne dla usáug ........................................................................... 294
8.18.3. Widoki mobilne dla wysyáania newslettera ................................................ 296
8.19. Instalacja aplikacji na serwerze WWW ............................................................... 297
8.20. Podsumowanie ..................................................................................................... 298
Kup książkęPoleć książkę 6
ASP.NET MVC 4. Programowanie aplikacji webowych
Rozdziaä 9. Studium przypadku: serwis Moje Zdjöcia w Windows Azure ........... 301
9.1. Biznesowa wizja systemu ...................................................................................... 302
9.2. Projektowa wizja systemu ..................................................................................... 302
9.3. Moje ZdjĊcia — wersja lokalna ............................................................................. 304
9.3.1. Tworzenie projektu ....................................................................................... 304
9.3.2. Dodanie modelu ........................................................................................... 306
9.3.3. Wygenerowanie kontrolera i widoków ......................................................... 308
9.3.4. Modyfikacja kontrolera ................................................................................ 309
9.3.5. Modyfikacje widoków .................................................................................. 320
9.3.6. Dodanie metody-akcji i widoku Wyszukaj ................................................... 328
9.3.7. Dodanie mechanizmu autouzupeániania ....................................................... 332
9.3.8. Pliki konfiguracyjne Windows Azure ........................................................... 335
9.4. Moje ZdjĊcia — wersja w chmurze ....................................................................... 337
9.4.1. Zakáadanie subskrypcji Windows Azure ...................................................... 337
9.4.2. Zakáadanie usáug Cloud Service, Azure Storage i bazy SQL ....................... 340
9.4.3. Pobranie poĞwiadczeĔ do bazy SQL i Azure Storage ................................... 342
9.4.4. Modyfikacja plików konfiguracyjnych ......................................................... 343
9.4.5. WdroĪenie serwisu do chmury ..................................................................... 344
9.5. Podsumowanie ....................................................................................................... 346
Rozdziaä 10. Studium przypadku: serwis Planner ............................................... 349
10.1. WáasnoĞci ASP.NET Web API ............................................................................ 349
10.2. Tworzenie projektu ASP.NET Web API ............................................................. 351
10.2.1. Biznesowa wizja systemu ........................................................................... 351
10.2.2. Przygotowanie projektu .............................................................................. 351
10.2.3. Struktura projektu ASP.NET Web API ...................................................... 353
10.2.4. Implementacja modelu Task i bazy danych ................................................ 355
10.2.5. Implementacja repozytorium ...................................................................... 357
10.2.6. Implementacja kontrolera Tasks ................................................................. 359
10.2.7. Testowanie akcji kontrolera Tasks ............................................................. 362
10.2.8. Implementacja interfejsu uĪytkownika ....................................................... 366
10.3. Instalacja aplikacji na serwerze WWW ............................................................. 377
10.4. Podsumowanie ..................................................................................................... 378
Rozdziaä 11. Podsumowanie ............................................................................ 379
Dodatek A. Bibliografia .................................................................................. 381
KsiąĪki .......................................................................................................................... 381
Zasoby internetowe ...................................................................................................... 381
Skorowidz ..................................................................................... 383
Kup książkęPoleć książkę Rozdziaä 3.
Kontrolery
Kontroler to zasadniczo poĞrednik pomiĊdzy dziaáaniami uĪytkownika a danymi zawar-
tymi w modelu. PoĞrednik, który obsáugując Īądania HTTP, moĪe dokonywaü zmian
w modelu i uruchamiaü odpowiedni widok z prezentacją danego fragmentu modelu.
Zgodnie z konwencją obowiązującą w ASP.NET MVC klasa, która jest kontrolerem,
musi mieü nazwĊ zakoĔczoną przyrostkiem Controller oraz implementowaü przynajm-
niej interfejs IController — listing 3.1.
Listing 3.1. Interfejs IController
public interface IController
{
void Execute(RequestContext requestContext);
}
Interfejs IController jest bardzo prosty i zawiera tylko jedną metodĊ Execute. Wewnątrz
tej metody moĪna dostaü siĊ do obiektów takich jak HttpContext, Request czy Response.
Taki sposób definiowania kontrolera jest rzadko uĪyteczny, bo w ten sposób pomija siĊ
wszystkie udogodnienia frameworka związane np. z bezpieczeĔstwem, wiązaniem mo-
delu (ang. model binding) czy teĪ wynikami akcji. Traci siĊ takĪe moĪliwoĞü definiowania
metod akcji — wszystkie Īądania przychodzące do tego kontrolera są obsáugiwane cen-
tralnie przez metodĊ Execute. Z tych powodów w praktyce nigdy nie implementuje siĊ
bezpoĞrednio interfejsu IController. PodejĞcie praktyczne to dziedziczenie z jednej
z dwóch klas bazowych — ControllerBase i Controller.
Framework ASP.NET MVC 4 posiada abstrakcyjną klasĊ, która jest klasą bazową dla
wszystkich kontrolerów MVC. Klasa ControllerBase bezpoĞrednio implementuje inter-
fejs IController oraz dostarcza dodatkowe funkcjonalnoĞci, np. odpowiada za tworzenie
obiektu ControllerContext, dostarcza wáaĞciwoĞü ViewData etc. ControllerBase nie do-
starcza jednak innych wysoce poĪądanych funkcjonalnoĞci, takich jak np. metody akcji.
Te i inne funkcjonalnoĞci zawiera dopiero abstrakcyjna klasa Controller. Dostarcza
ona trzy kluczowe funkcje: akcje (ang. Action Methods), wyniki akcji (ang. Action
Results) oraz filtry (ang. Filters).
Kup książkęPoleć książkę 40
ASP.NET MVC 4. Programowanie aplikacji webowych
Akcje umoĪliwiają rozszerzenie zachowania kontrolera. Stosowanie pojedynczej akcji
Execute, którą oferuje interfejs IController, jest maáo wygodne. Przy zaimplemento-
waniu klasy kontrolera dziedziczącego po Controller kaĪda akcja jest ĞciĞle powiąza-
na z adresem URL oraz parametrami przekazywanymi do niej, a wydobytymi z przy-
chodzącego Īądania.
Wyniki akcji umoĪliwiają zwracanie róĪnych bytów z poziomu wykonywanej akcji,
np. wygenerowanie widoku, przekierowanie do innej akcji czy zwrócenie jakiegoĞ
pliku. Taka jawna separacja wyników zwracanych przez akcjĊ upraszcza przeprowa-
dzanie testów jednostkowych.
W praktyce wáaĞnie na podstawie klasy Controller tworzone są wszystkie klasy kon-
trolerów uĪywanych w aplikacjach opartych na frameworku ASP.NET MVC 4.
Podczas projektowania aplikacji zachodzi zwykle koniecznoĞü ustalenia ziarnistoĞci
kontrolerów. W tym procesie wszystko zaleĪy od projektanta. JeĪeli projektant przewidzi
w aplikacji jeden kontroler, odpowiednio organizując w nim akcje, to aplikacja moĪe
dziaáaü prawidáowo. Wadą takiego podejĞcia jest jednak zwykle duĪy przyrost akcji oraz
metod, które bĊdą musiaáy obsáugiwaü Īądania z szerokiej grupy klas biznesowych.
Bardziej wskazanym podejĞciem jest utworzenie kontrolerów w liczbie wystĊpujących
w systemie klas biznesowych, które wymagają bezpoĞrednich operacji na danych. Wtedy
w kaĪdym z tych kontrolerów tworzy siĊ zestaw akcji, które umoĪliwiają utworzenie,
odczyt, modyfikacjĊ oraz usuniĊcie danych dla konkretnej klasy biznesowej.
Na listingu 3.2 przedstawiono fragment kodu, za pomocą którego utworzono kontroler
Product.
Listing 3.2. Przykáadowy kontroler
public class ProductController : Controller
{
public void Show()
{
Response.Write( Product info! );
}
}
W klasie kontrolera Product dodano metodĊ Show, której wynikiem wykonania jest wy-
Ğwietlenie napisu Product info. Na rysunku 3.1 przedstawiono sposób, w jaki odbywa siĊ
wykonanie akcji Show w kontrolerze Product. W pierwszym kroku uĪytkownik aplikacji
— poprzez interakcjĊ z widokiem — przekazuje do aplikacji Īądanie /Product/Show.
System dopasowuje otrzymane Īądanie do wzorca ĞcieĪki przy uĪyciu mechanizmu
routingu. W trzecim kroku, kiedy ĞcieĪka zostaáa dopasowana, system tworzy instancjĊ
kontrolera ProductController (odczytanego z Īądania), po czym wykonuje akcjĊ (poprzez
uruchomienie metody) Show, która równieĪ odczytana zostaáa z Īądania HTTP. Ostatnim
krokiem jest wyĞwietlenie tekstu.
Kup książkęPoleć książkę Rozdziaä 3. i Kontrolery
Rysunek 3.1.
Tworzenie
kontrolera
i uruchamianie akcji
41
3.1. Akcje i parametry
DomyĞlnie w aplikacji ASP.NET MVC ĞcieĪka URL rozbijana jest — przy uĪyciu
mechanizmu routingu — na trzy gáówne elementy: /{controller}/{action}/{id}, gdzie
controller to nazwa kontrolera, action oznacza nazwĊ akcji, a id to parametr dla akcji.
W kontrolerze moĪe znajdowaü siĊ wiele akcji (metod publicznych), z których kaĪda
moĪe (ale nie musi) przyjmowaü parametry.
Listing 3.3 przedstawia zmodyfikowaną wersjĊ kontrolera z poprzedniego przykáadu
(listing 3.2), która zawiera jeden parametr id.
Listing 3.3. Akcja i parametr
public class ProductController : Controller
{
public void Show(string id)
{
Response.Write( Product + id + info! );
}
}
Teraz gdy nastąpi Īądanie: /Product/Show/TVsets, w odpowiedzi wyĞwietlony zostanie
napis: Product TVsets info!. Taki sam rezultat zostanie osiągniĊty, jeĞli Īądanie bĊdzie
wyglądaáo tak: /Product/Show?id=TVsets. àatwo zauwaĪyü, Īe pierwszy sposób jest
wygodniejszy dla uĪytkownika. Takie przekazywanie parametru moĪliwe jest dziĊki od-
powiednio skonfigurowanemu mechanizmowi routingu, który sam zajmuje siĊ przekazy-
waniem metodzie parametru odczytanego z adresu.
OczywiĞcie jest moĪliwoĞü przekazywania wiĊkszej liczby parametrów. Ilustracją jest
zmodyfikowany kontroler z poprzedniego przykáadu — listing 3.4.
Listing 3.4. Akcja i wiĊksza liczba parametrów
public class ProductController : Controller
{
Kup książkęPoleć książkę 42
ASP.NET MVC 4. Programowanie aplikacji webowych
public void Show(String p1, String p2, int p3)
{
Response.Write( [id: + p3 + ] name: + p1 + info + p2);
}
}
JeĞli teraz do aplikacji trafi Īądanie: /Product/Show?p1=TVsets p2=test p3=1, wów-
czas wyĞwietlony zostanie tekst: [id:1] name: TVsets info test. Aby adres mógá byü
bardziej czytelny dla uĪytkownika, naleĪy zdefiniowaü odpowiednią ĞcieĪkĊ w mechani-
zmie routingu — szczegóáy przedstawia listing 3.5.
Listing 3.5. Przykáadowa ĞcieĪka z kilkoma parametrami
routes.MapRoute(
productInfo , Product/Show/{p1}/{p2},{p3} ,
new { Controller = Product , action = Show }
)
Przy tak zdefiniowanej ĞcieĪce jak na listingu 3.5 moĪna uĪyü bardziej przyjaznej dla
uĪytkownika wersji adresu URL, w postaci: /Product/Show/TVsets/test,1.
W prezentowanych wczeĞniej przykáadach zastosowano tymczasowo metodĊ Response.
Write, która umoĪliwiaáa wyĞwietlenie tekstu. UĪycie tej metody w znacznym stopniu na-
ruszyáo jednak zasadĊ rozdziaáu kompetencji ról poszczególnych warstw wzorca MVC.
Kontrolery nie mogą zajmowaü siĊ widokiem danych; dane prezentowane są w bytach
zwanych widokami.
Aby zapewniü zgodnoĞü z konwencją, akcje w kontrolerach zwracają róĪnego rodzaju
wyniki. W ASP.NET MVC 4 realizacja takiego podejĞcia nastĊpuje przy wykorzystaniu
obiektów klasy ActionResult — listing 3.6.
Listing 3.6. Klasa ActionResult
public abstract class ActionResult
{
protected ActionResult()
{
}
public abstract void ExecuteResult(ControllerContext context);
}
Akcja w kontrolerze zwraca obiekt typu ActionResult, jednak nie sáuĪy on jako kontener
dla danych. ActionResult jest abstrakcyjną klasą oferującą wspólny interfejs, który wyko-
nuje pewne dalsze dziaáania w imieniu akcji. Poprzez nadpisanie metody ExecuteResult
pochodna klasy uzyskuje dostĊp do wszelkich danych dostarczonych przez wykonanie
akcji i wyzwala jakąĞ póĨniejszą akcjĊ. Są to kolejne dziaáania związane z wytworze-
niem odpowiedzi dla przeglądarki.
PoniewaĪ klasa ActionResult jest abstrakcyjna, kaĪda akcja zdefiniowana w kontrolerze
moĪe zwróciü jeden z predefiniowanych typów ActionResult — tabela 3.1.
Kup książkęPoleć książkę Rozdziaä 3. i Kontrolery
Tabela 3.1. Typy ActionResult
Typ
ContentResult
EmptyResult
FileContentResult
FilePathResult
FileStreamResult
HttpNotFoundResult
HttpUnauthorizedResult
JavaScriptResult
JsonResult
PartialViewResult
RedirectResult
RedirectToRouteResult
ViewResult
43
Opis
Zwraca bezpoĞrednio podaną treĞü (niekoniecznie HTML) do
przeglądarki. Metoda ExecuteResult serializuje przekazywaną treĞü.
Nie zwraca niczego do przeglądarki. Metoda ExecuteResult nic nie robi.
Zwraca zawartoĞü pliku do przeglądarki. ZawartoĞü pliku wyraĪona
jest jako tablica bajtów. Metoda ExecuteResult przekazuje zawartoĞü
do strumienia wyjĞciowego.
Zwraca zawartoĞü pliku do przeglądarki. Plik identyfikowany jest
poprzez ĞcieĪkĊ. Metoda ExecuteResult przekierowuje przeglądarkĊ
bezpoĞrednio do pliku.
Zwraca zawartoĞü pliku do przeglądarki. ZawartoĞü pliku reprezentowana
jest przez obiekt Stream. Metoda ExecuteResult kopiuje zawartoĞü
pliku z dostarczonego strumienia do strumienia wyjĞciowego.
Zwraca kod HTTP 404 do przeglądarki. Podany kod identyfikuje
Īądanie jako niepowodzenie — Īądany zasób nie zostaá odnaleziony.
Zwraca kod HTTP 401 do przeglądarki. Podany kod wskazuje
nieuprawnione Īądanie. W efekcie mechanizm uwierzytelniania prosi
o zalogowanie.
Zwraca kod JavaScript do przeglądarki. Metoda ExecuteResult
zwraca skrypt i ustawia odpowiedni typ. Skrypt bĊdzie wykonany
po stronie klienta.
Serializuje obiekty .NET do formatu JSON i wysyáa jako odpowiedĨ
do przeglądarki. Metoda ExecuteResult okreĞla typ obiektu, który ma
zostaü zwrócony, oraz wywoáuje klasĊ JavaScriptSerializer w celu
dokonania serializacji dostarczonego obiektu do formatu JSON.
Zwraca zawartoĞü HTML do przeglądarki; zwracana zawartoĞü
reprezentuje fragment widoku strony.
Zwraca kod HTTP 302 do przeglądarki w celu jej przekierowania
na inny adres URL. Metoda ExecuteResult wywoáuje po prostu
Response.Redirect.
Dziaáa podobnie jak RedirectResult; w tym przypadku
przekierowuje uĪytkownika na adres URL okreĞlony w parametrach
routingu.
Zwraca zawartoĞü HTML do przeglądarki; zawartoĞü reprezentuje
peány widok strony.
W tabeli 3.1 moĪna odnaleĨü typy do obsáugi kodów HTTP, moĪliwoĞci zwracania pli-
ków, przekierowania i wsparcia dla JavaScriptu. MoĪna teĪ uzyskaü asynchroniczne
przekazywanie danych w formie serializowanej do formatu JSON.
Kup książkęPoleć książkę 44
ASP.NET MVC 4. Programowanie aplikacji webowych
3.2. Model binding
Model binding (wiązanie modelu) to mechanizm odwzorowywania danych przycho-
dzących w Īądaniu HTTP bezpoĞrednio na parametry akcji i obiekty .NET (model).
Mechanizm jest wykorzystywany w tzw. modelu wejĞciowym danych, czyli takim,
który opisuje dane przychodzące do aplikacji. KaĪde przychodzące Īądanie jest rozpatry-
wane pod kątem kontrolera i akcji, której rezultat jest odpowiedzią na Īądanie. Naj-
pierw rozpoznawany jest kontroler, póĨniej akcja. JeĞli oba elementy zostaną odnalezione,
to odszukiwane są dane oczekiwane przez akcjĊ, a zdefiniowane jako parametry tej akcji.
Dziaáanie mechanizmu model binding stanie siĊ jasne, gdy najpierw przeanalizowany
zostanie sposób pobierania danych z przychodzącego Īądania HTTP. Na listingu 3.7
przedstawiono przykáadowy model wraz z akcją Create. Akcja ma za zadanie utworzyü
nową usáugĊ i dodaü ją do systemu.
Listing 3.7. Pobieranie danych z Īądania
public class Service
{
public int ID { get; set; }
public String Name { get; set; }
public String Content { get; set; }
public DateTime PostedDate { get; set; }
}
public ActionResult Create()
{
var service = new Service(){
Name = Request[ name ],
Content = Request[ content ],
PostedDate = DateTime.Parse(Request[ postedDate ])
};
// ...
}
W przykáadzie przedstawionym na listingu 3.7 akcja Create tworzy nowy obiekt Service
i wypeánia go danymi bezpoĞrednio pobranymi z Īądania. PoniewaĪ dane odczytywane
z Īądania są ciągiem znaków, to dla kaĪdego pola z modelu Service, który nie jest
typu string, naleĪy pobraną wartoĞü przeksztaáciü na odpowiedni typ (jak w przy-
padku pola PostedDate).
Tworzenie akcji w taki sposób jest bardzo káopotliwe i nieefektywne. W przypadku
wykorzystania w akcji obiektu, który bĊdzie miaá wiele pól róĪnych typów, samo tworze-
nie obiektu bĊdzie bardzo skomplikowane i przesáoni gáówny cel akcji, jakim jest
— w powyĪszym przykáadzie — dodanie nowej usáugi do systemu.
W celu unikniĊcia takich maáo efektywnych metod moĪna tworzyü akcje inaczej. Za-
miast pobieraü dane bezpoĞrednio z Īądania moĪna deklarowaü je jako parametry akcji
— listing 3.8.
Kup książkęPoleć książkę Rozdziaä 3. i Kontrolery
45
Listing 3.8. Pobieranie danych z parametrów akcji — typy proste
public ActionResult Create(string title, string content, DateTime postedDate)
{
var service = new Service(){
Title = title,
Content = content
PostedDate = postedDate
};
// ...
}
W przypadku akcji Create z listingu 3.8 zadziaáa mechanizm model binding. Przed
uruchomieniem akcji Create dwa waĪne elementy, ValueProviderDictionary oraz
DefaultModelBinder, wykonają pewną pracĊ. ValueProviderDictionary pobierze wartoĞci
z Īądania HTTP i zapisze je jako ciągi znaków. Pobieranie odbywa siĊ kolejno z na-
stĊpujących miejsc (na przykáadzie parametru string title):
Request.Form[ title ]; jeĞli element nie istnieje, to:
RouteData.Values[ title ]; jeĞli element nie istnieje, to:
Request.Querystring[ title ]; jeĞli element nie istnieje, to zwraca null.
Po pobraniu z Īądania odpowiednich wartoĞci przez ValueProviderDictionary klasa
DefaultModelBinder bierze na siebie odpowiedzialnoĞü przeksztaácenia tych ciągów
znaków na odpowiednie obiekty .NET.
Tak siĊ dzieje, jeĞli parametry oparte są o typy proste. Sytuacja siĊ nieco komplikuje,
gdy parametrem jest obiekt záoĪony (model), tak jak na listingu 3.9. Wtedy z pomocą
przychodzi mechanizm refleksji (ang. reflection). Przy udziale refleksji wpisywane są
— do wszystkich publicznych wáasnoĞci typu záoĪonego — wartoĞci pobrane przez
klasĊ ValueProviderDictionary. Warto wspomnieü równieĪ o tym, Īe wszystkie publiczne
wáasnoĞci typu záoĪonego, które równieĪ są typem záoĪonym, w ten sam sposób otrzy-
mają wartoĞü.
Listing 3.9. Pobieranie danych z parametrów akcji — typ záoĪony
public ActionResult Create(Service service)
{
// ...
}
Czasami zachodzi potrzeba, aby niektóre pola záoĪonego typu (modelu) wyáączyü z me-
chanizmu model binding. Do tego celu sáuĪy atrybut Bind. MoĪna go wykorzystaü na dwa
sposoby: lokalnie w akcji — listing 3.10 lub globalnie w klasie modelu — listing 3.11.
Przy wykorzystaniu atrybutu Bind moĪna uĪyü dwóch parametrów Include lub Exclude,
które odpowiednio wáączają wymienione wáaĞciwoĞci modelu do mechanizmu model
binding lub wyáączają wáaĞciwoĞci modelu z tego mechanizmu.
Kup książkęPoleć książkę 46
ASP.NET MVC 4. Programowanie aplikacji webowych
Listing 3.10. Lokalny sposób uĪycia atrybutu Bind
public ActionResult Create([Bind(Include = Title,Content,PostedDate )] Service service)
{ // Mechanizm model binding zadziaáa tylko dla wáaĞciwoĞci Title, Content i PostedDate
// ...
}
// lub
public ActionResult Create([Bind(Exclude = ID, PostedDate )] Service service)
{ // mechanizm model binding nie zadziaáa dla wáaĞciwoĞci ID.
// ...
}
Listing 3.11. Globalny sposób uĪycia atrybutu Bind
[Bind(Include = Name,Content,PostedDate )]
public class Service
{
public int ID { get; set; }
public String Name { get; set; }
public String Content { get; set; }
public DateTime PostedDate { get; set; }
}
// lub
[Bind(Exclude = ID )]
public class Service
{
public int ID { get; set; }
public String Name { get; set; }
public String Content { get; set; }
public DateTime PostedDate { get; set; }
}
Podane przykáady uĪycia mechanizmu model binding pokazują, Īe wykorzystanie tego
narzĊdzia pozwala na tworzenie bardziej czytelnego kodu aplikacji, a takĪe na jego znacz-
ne skrócenie.
3.3. Filtry
Mechanizm filtrów w ASP.NET MVC 4 umoĪliwia wstrzykniĊcie dodatkowej logiki
do potoku przetwarzania Īądania. UmoĪliwia to prosty i elegancki sposób realizacji prze-
krojowych problemów dotyczących logowania, autoryzacji czy buforowania. Na li-
stingu 3.12 przedstawiono fragment definicji kontrolera zawierającego filtry.
Listing 3.12. Przykáadowy kontroler z filtrami
[Authorize(Roles = role )]
public class ExampleController : Controller
{
[ShowMessage]
[OutputCache(Duration = 60)]
Kup książkęPoleć książkę Rozdziaä 3. i Kontrolery
47
public ActionResult Index()
{
// ... ... ...
}
}
Filtry zapisuje siĊ w formie atrybutów (pochodzą z przestrzeni nazw System.Attribute)
i mogą byü doáączane do innych elementów kodu, w tym klas, metod, wáaĞciwoĞci i pól.
Celem ich uĪycia jest dostarczenie dodatkowych informacji do skompilowanego kodu.
W jĊzyku C# elementy te umieszcza siĊ w nawiasach kwadratowych, które dodatkowo
mogą zawieraü parametry, np. [MyAttribute(SomeProperty = value)].
Przykáad z listingu 3.12 zawiera kilka filtrów. Pierwszy w postaci [Authorize(Roles
= role )] oznacza, Īe uĪytkownik, który moĪe korzystaü z tego kontrolera, musi byü
autoryzowany i dodatkowo musi wystĊpowaü w roli role. Ten filtr obejmuje caáy kon-
troler wraz ze wszystkimi akcjami.
Filtr zapisany w postaci [OutputCache(Duration = 60)] dotyczy tylko akcji Index
i oznacza uruchomienie buforowania wyników tej akcji przez okres czasu wyraĪony
w sekundach i podany w parametrze Duration. DomyĞlnie dane przechowywane są
w trzech miejscach: na serwerze WWW, na wszystkich serwerach proxy oraz w przeglą-
darce internetowej.
Framework ASP.NET MVC 4 obsáuguje róĪne rodzaje filtrów:
Filtry zezwoleĔ (Authorization) — filtr implementuje interfejs
IAuthorizationFilter i sáuĪy do ograniczania dostĊpu do kontrolerów i akcji
kontrolerów. Przykáadami tego filtra są klasy AuthorizeAttribute oraz
RequireHttpsAttribute. Filtr Authorization dziaáa przed wszystkimi
innymi filtrami.
Filtry akcji (Action) — filtr implementuje interfejs IActionFilter
i „opakowuje” dziaáanie akcji kontrolera. Interfejs IActionFilter deklaruje
dwie metody: OnActionExecuting i OnActionExecuted. OnActionExecuting
uruchamiana jest przed wykonaniem akcji i moĪe dostarczaü akcji dodatkowych
danych lub sprawdzaü poprawnoĞü wprowadzanych danych. Metoda
OnActionExecuted uruchamiana jest natomiast po wykonaniu akcji i moĪe
sáuĪyü do kontroli danych wynikowych lub anulowania wykonywania
rezultatu akcji. Przykáadem takiego filtru jest klasa ActionFilterAttribute.
Filtry rezultatu (Result) — filtr implementuje interfejs IResultFilter
i „opakowuje” obiekt wyniku dziaáania akcji — ActionResult. Interfejs
IResultFilter deklaruje dwie metody: OnResultExecuting i OnResultExecuted.
Metoda OnResultExecuting uruchamiana jest przed zwróceniem rezultatu
akcji (np. przed wyĞwietleniem widoku lub przekierowaniem do innej akcji),
a OnResultExecuted dziaáa po zwróceniu wyniku akcji. Obie metody mogą
wprowadzaü dodatkowe przetwarzanie rezultatu akcji, np. mogą modyfikowaü
odpowiedĨ HTTP. Przykáadem takiego filtru jest klasa OutputCacheAttribute.
Kup książkęPoleć książkę 48
ASP.NET MVC 4. Programowanie aplikacji webowych
Filtry wyjątku (Exception) — filtr implementuje interfejs IExceptionFilter
i wykonywany jest, gdy podczas przetwarzania akcji wystąpi nieobsáugiwany
wyjątek. Filtr ten moĪe byü wykorzystywany do rejestrowania lub wyĞwietlania
strony báĊdu. Przykáadem implementacji filtru wyjątku jest klasa
HandleErrorAttribute.
W celu zdefiniowania filtru wystarczy utworzyü klasĊ, która bĊdzie implementowaáa
jeden z wymienionych wyĪej interfejsów, a w metodach tego interfejsu zdefiniowaü do-
datkowe dziaáania. Przykáadem takiej implementacji moĪe byü atrybut CaptchaValidator
´Attribute wykorzystany w aplikacji Portal Usáug (rozdziaá 8.).
DefinicjĊ CaptchaValidatorAttribute przedstawiono na listingu 3.13. Klasa atrybutu
dziedziczy po klasie ActionFilterAttribute. Nazwa klasy musi byü — wedáug przyjĊtej
we frameworku ASP.NET MVC konwencji — zakoĔczona przyrostkiem Attribute.
Filtr nadpisuje metodĊ OnActionExecuting, która uruchamiana jest przed wykonaniem
akcji. Metoda sprawdza wartoĞü przekazywaną w modelu (model.Captcha) i na jej pod-
stawie dodaje do akcji nowy parametr (captchaValid), który moĪna odczytaü podczas wy-
konywania akcji — listing 3.14.
Listing 3.13. Przykáadowa implementacja filtra akcji
public class CaptchaValidatorAttribute : ActionFilterAttribute
{
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
RegisterModel model = filterContext.ActionParameters[ model ] as RegisterModel;
if (filterContext.HttpContext.Session[ Captcha ] == null ||
´filterContext.HttpContext.Session[ Captcha ].ToString() != model.Captcha)
{
filterContext.ActionParameters[ captchaValid ] = false;
}
else
{
filterContext.ActionParameters[ captchaValid ] = true;
}
base.OnActionExecuting(filterContext);
}
}
Listing 3.14. Wykorzystanie atrybutu CaptchaValidator
[CaptchaValidator]
[AllowAnonymous]
[HttpPost]
public ActionResult Register(RegisterModel model, bool captchaValid)
{
if (captchaValid)
{
...
}
}
Kup książkęPoleć książkę Rozdziaä 3. i Kontrolery
49
Podczas wytwarzania prostych aplikacji nie trzeba definiowaü wáasnych filtrów. Frame-
work ASP.NET MVC 4 dostarcza cztery podstawowe filtry zaimplementowane w postaci
atrybutów. Filtry te mogą byü stosowane na poziomie akcji kontrolerów, kontrolerów
lub na poziomie aplikacji:
AuthorizeAttribute — ogranicza dostĊp.
HandleErrorAttribute — atrybut okreĞlający, jak obsáugiwaü wyjątek, który
wystąpi podczas przetwarzania (filtr wymaga, aby w pliku konfiguracyjnym
Web.config element CustomErrors miaá wartoĞü true).
OutputCacheAttribute — zapewnia buforowanie wyjĞcia.
RequireHttpsAttribute — wymusza ponowne przesáanie Īądania przez HTTPS,
gdy Īądanie przyszáo z HTTP.
3.4. Wbudowane atrybuty
Framework ASP.NET MVC udostĊpnia wbudowane atrybuty, takie jak NonAction
´Attribute, ActionNameAttribute oraz AcceptVerbsAttribute.
3.4.1. NonAction
Wszystkie publiczne metody definiowane w kontrolerach to akcje, które uĪytkownik
moĪe wywoáaü, wpisując odpowiedni adres URL w przeglądarce. Czasami jednak za-
chodzi potrzeba zdefiniowania publicznej metody, która nie bĊdzie dostĊpna dla uĪytkow-
nika, a widzialnoĞü tej metody nie moĪe zostaü zmieniona. Aby ograniczyü bezpoĞredni
dostĊp do metody z przeglądarki, wystarczy opatrzyü ją atrybutem NonActionAttribute
— listing 3.15.
Listing 3.15. Zastosowanie atrybutu NonActionAttribute
[NonAction]
public void Test()
{ // logika metody
}
Podczas próby wywoáania z przeglądarki metody opatrzonej atrybutem NonAction
framework nie uruchomi metody, tylko w odpowiedzi zwróci kod báĊdu 404.
3.4.2. Atrybut ActionNameAttribute
Zastosowanie atrybutu ActionNameAttribute pozwala zmieniü nazwĊ akcji. W przy-
káadzie przedstawionym na listingu 3.16 zdefiniowane są dwie metody: Delete oraz
DeleteConfirmed. Poprzez opatrzenie atrybutem ActionName( Delete ) metody Delete
´Confirmed zostanie ona wywoáana przy Īądaniu POST akcji Delete.
Kup książkęPoleć książkę 50
ASP.NET MVC 4. Programowanie aplikacji webowych
Listing 3.16. Zastosowanie atrybutu ActionNameAttribute
[HttpGet]
public ActionResult Delete(int id)
{
var model = repository.Find(id);
// WyĞwietla widok potwierdzający usuniĊcie rekordu.
return View(model);
}
[HttpPost, ActionName( Delete )]
public ActionResult DeleteConfirmed(int id)
{
repository.Delete(id);
return RedirectToAction( Index );
}
3.4.3. Atrybut AcceptVerbsAttribute
Atrybut AcceptVerbsAttribute sáuĪy do związania akcji z metodą protokoáu HTTP.
Metody protokoáu HTTP, które moĪna związaü tym atrybutem z akcjami, to GET, POST,
PUT i DELETE. Przykáadowo aby akcja Test() przekazywaáa wynik metodą POST, naleĪy
opatrzyü ją atrybutem jak na listingu 3.17.
Listing 3.17. Zastosowanie atrybutu AcceptVerbsAttribute
[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Test()
{
return ViewA()
}
Framework dostarcza równieĪ cztery skrócone formy tego atrybutu w postaci identyfika-
torów: HttpDeleteAttribute, HttpGetAttribute, HttpPostAttribute, HttpPutAttribute.
3.5. Podsumowanie
We frameworku ASP.NET MVC kontroler to klasa, która w odpowiedzi na Īądanie
uĪytkownika zwraca odpowiedĨ. Kontroler moĪe wydawaü dowolny zbiór poleceĔ do
modelu, a uĪytkownikowi (przeglądarce) zwróciü dowolny widok. KaĪdy kontroler
zawiera jedną lub wiĊcej akcji, które w istocie są specjalnymi metodami sáuĪącymi do
przekazywania róĪnego rodzaju wyników. Predefiniowane typy ActionResult zostaáy
zestawione w tabeli 3.1.
Z kontrolerami związany jest model binding, czyli mechanizm odwzorowania danych
przychodzących w Īądaniu HTTP bezpoĞrednio na parametry akcji i obiekty .NET (mo-
del). KaĪde przychodzące Īądanie jest rozpatrywane pod kątem kontrolera i akcji, której
Kup książkęPoleć książkę Rozdziaä 3. i Kontrolery
51
rezultat jest odpowiedzią na Īądanie. Framework najpierw poszukuje odpowiedniego
kontrolera, póĨniej akcji. JeĞli oba elementy zostaną odnalezione, to odszukiwane są dane
oczekiwane przez akcjĊ, a zdefiniowane jako parametry tej akcji.
Akcje są metodami publicznymi klasy kontrolera. JeĞli zachodzi koniecznoĞü wykluczenia
publicznej metody kontrolera jako akcji, to naleĪy ją opatrzyü atrybutem NonAction
´Attribute, co powoduje skutki opisane w punkcie 3.4. To jest jeden z trzech wbudo-
wanych atrybutów, nazywanych równieĪ filtrami akcji. Dwa pozostaáe to ActionName
´Attribute i AcceptVerbsAttribute. ActionNameAttribute sáuĪy do prostej zmiany
nazwy akcji. Atrybut drugi sáuĪy do związania akcji z metodą protokoáu HTTP.
Filtry mogą byü stosowane do indywidualnych akcji lub do caáego kontrolera. SáuĪą
do rozszerzania logiki, która jest stosowana w aplikacji podczas przetwarzania Īądania,
ale bez koniecznoĞci umieszczania tej logiki w sposobie dziaáania. W efekcie zapis dziaáaĔ
jest elegancki i czytelny.
Kup książkęPoleć książkę 52
ASP.NET MVC 4. Programowanie aplikacji webowych
Kup książkęPoleć książkę Skorowidz
A
adnotacja danych, 69
DataAnnotations, 121
AJAX, 80
Helpers, 80
Ajax.ActionLink, 81
Ajax.BeginForm, 80
Ajax.BeginRouteForm, 82
Ajax.RouteLink, 82
akcje, 39, 41, 51
About, 31
CaptchaImage, 190
Change, 229, 239
Confirm, 179
Create, 44, 45, 248, 276, 310
Delete, 230, 242, 265, 280, 313, 360, 362
testowanie, 365
DeleteConfirmed, 313
Details, 271, 283, 314
Edit, 226, 239, 260, 280, 311
Execute, 40
filtry, 47
Get, 360, 361
testowanie, 362
Index, 31, 60, 105, 217, 221, 235, 256, 290
KupZdjecie, 316
List, 106
Login, 131, 177
LogOff, 131
Manage, 180
MojeZdjecia, 314
PobierzZdjecie, 315
Post, 360, 361
testowanie, 363
Redirect, 32
RedirectToLocal, 131
Register, 172, 191
Send, 123, 205
Subscribe, 106, 108
Test(), 50
Unsubscribe, 107, 108
uruchamianie, 41
Wyszukaj, 328
arkusz stylów CSS, 212
ASP.NET, 23, 24
funkcjonalnoĞci, 24
MVC, 7, 25, 37
AcceptVerbsAttribute, 50
ActionNameAttribute, 49
ASP.NET MVC 4, 7
cykl Īycia Īądania, 54
deklaracja tras, 76
kod Ĩródáowy, 28
konfiguracja, 26
kontroler, 39, 50
konwencja, 26
mechanizm routingu, 27
metody helperów HTML, 26
NonActionAttribute, 49
routing, 75
rozszerzalnoĞü, 26
TempData, 57
testowalnoĞü, 27
testowanie, 30
ViewBag, 56
ViewData, 55
zaáoĪenia projektowe, 25
MVC 1, 28
MVC 2, 28
MVC 3, 28, 55
ViewBag, 55
MVC 4, 7, 23, 27, 29, 379
/App_Browsers, 37
/App_Data, 33
/App_GlobalResources, 37
Kup książkęPoleć książkę 384
ASP.NET MVC 4. Programowanie aplikacji webowych
ASP.NET
MVC 4
/App_LocalResources, 37
/App_Start, 33
/App_Themes, 37
/Areas, 37
/bin, 35
/Content, 35
/Controllers, 35
/Filters, 35
/Global.asax, 36
/Images, 35
/Models, 35
/packages. config, 36
/Scripts, 36
/Views, 36
/Web.config, 36
AJAX, 80
Bundling, 90
ControllerBase, 39
dodanie roli, 305
Entity Framework, 66
filtry, 46
foldery, 33
G M, 90
gáówne widoki, 61
metody pomocnicze HTML, 62
metody pomocnicze Razor, 63
Minification, 91
Moje ZdjĊcia, 8, 301
Planner, 8
pliki, 33
Portal Usáug, 8, 139
routing URL, 29
schemat URL, 29
strona startowa aplikacji, 99
struktura aplikacji, 33, 34
Subskrypcja, 8
szablon widoku, 60
szablony, 33
Web API, 349
widoki czĊĞciowe, 61
wybór rodzaju projektu, 305
wybór szablonu projektu, 98, 352
wybór typu projektu, 98
Web API, 349
definicja routingu, 355
dodane zadanie, 375
planner, 351
strona gáówna, 374
strona startowa, 353
struktura projektu, 353, 354
wáasnoĞci, 349
wybór daty i godziny, 375
wyszukanie zadania, 376
zastosowanie, 351
Web Forms, 7, 23, 24, 37
cechy, 24
objawy starzenia, 24
ASPX, 54, 57, 60
instrukcja warunkowa, 58
kontrolka logowania, 58
pĊtla foreach, 59
atrybut
AcceptVerbsAttribute, 50
ActionNameAttribute, 49
Bind, 45
NonActionAttribute, 49
autouzupeánianie, 332
implementacja, 332
biblioteki
Entity Framework, 66
jQuery, 209
MvcContrib, 219
SimpleMembership, 97, 127
Bundling, 90
widok, 93
B
C
CAPTCHA, 189
akcja generująca obrazek, 189
CaptchaValidator, 191
dodanie pola, 189
wynik dziaáania, 193
checkbox, 185
Code First, 67, 68, 84
Database First, 66
D
E
EDM, 66
Entity Framework, 83, 306
atrybut, 66
Code First, 66, 68, 84
dodanie nowych rekordów, 86
klasy modelu, 84
modyfikacja rekordów, 86
usuwanie rekordów, 86
Database First, 66
Kup książkęPoleć książkę Skorowidz
385
Database Migrations, 87
aktualizacja bazy, 89
klasa konfiguracji, 87
migracja, 88
EDM, 66
encja, 66
EntityFramework.SqlServerCompact, 103
ERM, 66
konfiguracja, 103
konwencje, 67
Model First, 66
ORM, 66, 83
POCO, 85
związki, 66, 70
dziedziczenie, 72
generalizacja, 72
jeden-do-jednego, 70
jeden-do-wielu, 71
wiele-do-wielu, 71, 72
ERM, 66
F
filtry, 39, 46, 51
akcji, 47
implementacja, 48
AuthorizeAttribute, 49
CaptchaValidatorAttribute, 48
definiowanie, 48
HandleErrorAttribute, 49
OutputCacheAttribute, 49
RequireHttpsAttribute, 49
rezultatu, 47
rodzaje, 47
wyjątku, 48
zezwoleĔ, 47
funkcja
@RenderBody(), 116
CreateAdministrator(), 208
Fill(), 254
find(), 373
GetAllCustomers(), 215
GetAllServiceProviders(), 233
GetCommentByServiceId, 270
GetNewServices, 289
GetServiceViewModelById, 269
SeedMembership, 129, 171
G
G M, 90
plik konfiguracyjny, 92
wáączenie, 94
wpáyw, 91
H
helper
Html.ActionLink, 79
Html.RouteLink, 80
MailHelper, 123
Html.TextAreaFor, 125
Razor, 63
TextBoxFor, 125
I
interfejs
IController, 39
ITaskRepository, 357
jQuery, 369
J
K
klasa
AccountHelper, 176
ActionFilterAttribute, 48
ActionResult, 42, 43
ApiController, 77, 361
AuthorizeAttribute, 47
BundleConfig, 185
CaptchaValidatorAttribute, 192
Category, 144, 145
CategoryRepository, 161
Comment, 144
CommentCategory, 144
CommentRepository, 163
Controller, 39, 77
ControllerBase, 39
Customer, 144
CustomerRepository, 164
DbContext, 68
HandleErrorAttribute, 48
HttpConfiguration, 355
InitializeMembership, 128, 170
LocalPasswordModel, 144
LoginModel, 130, 144
MailHelper, 175
Newsletter, 121, 144
PortalUslugContext, 153
RegisterModel, 144
RequireHttpsAttribute, 47
RouteConfig, 29
Service, 144, 145, 148
ServiceMetaData, 148
ServiceProvider, 144
Kup książkęPoleć książkę 386
ASP.NET MVC 4. Programowanie aplikacji webowych
klasa
ServiceProviderRepository, 166
ServiceRepository, 168
Subscriber, 101, 102
SubscriptionContext, 102
Task, 355
TaskContext, 356
TaskRepository, 358
WebApiConfig, 354
Zdjecie, 303, 307
ZdjecieDBContext, 307
kontroler, 39, 50
Account, 127, 171
CAPTCHA, 189
zmiana widoków, 182
ActionResult, 42, 43
Administrator, 130, 131
dodanie widoków, 132
akcje, 40, 41, 51
Category, 194
akcje, 195
modyfikacja, 197
Comment, 275
dodawanie widoków, 277
CommentCategory, 202
Controller, 39
ControllerBase, 39
Customer, 216
dodanie widoku, 217
filtry, 39, 46, 51
Home, 289
IController, 39
model binding, 44, 50
Newsletter, 122, 205
Authorize, 135, 209
dodanie widoków, 125, 206
przykáadowy kontroler, 40
Service, 246
dodanie widoków, 249, 257
ServiceProvider, 234
Subscriber, 104
akcje, 106
Authorize, 135
dodanie kontrolera, 105
dodanie widoków, 109
strona Index, 111
Tasks, 359, 360
akcje, 360
implementacja, 359
tworzenie, 41
uruchamianie akcji, 41
ValuesController, 353
wyniki akcji, 40
Zdjecia, 308
akcje, 309
modyfikacja, 309
ziarnistoĞü, 40
kontrolka
DataPicker, 375
Html.Grid, 223
Html.Pager, 224
LINQ, 68
L
M
mapowanie obiektowo-relacyjne, Patrz ORM
mechanizm grupowania i minimalizacji,
Patrz G M
mechanizm refleksji, 45
metody
ErrorCodeToString, 180
Execute, 39
GetActiveServicesByUserId, 284
GetEditCategories, 262
Hide(), 185
Index, 77, 79
MapHttpRoute, 77
MapRoute, 30
OnActionExecuted, 47
OnActionExecuting, 47, 48
OnResultExecuted, 47
OnResultExecuting, 47
PobierzKlucze, 333
pomocnicze
HTML, 62
Razor, 63
PrzyjmijPotwierdzenie, 318
Response.Write, 42
Show(), 40, 185
WyslijPotwierdzenie, 317
WyslijZdjecie, 319
Minification, 91
Model First, 67
model związków encji, Patrz ERM
Model-Widok-Kontroler, Patrz MVC
modele, 65
AccountModels, 154
Administrator, 130
adnotacja danych, 69
binding, 44
Bind, 45
DefaultModelBinder, 45
refleksja, 45
ValueProviderDictionary, 45
Category, 149
Kup książkęPoleć książkę Skorowidz
387
Comment, 149
CommentCategory, 150, 202
Customer, 150
CustomerFilterViewModel, 220
CustomerListContainerViewModel, 220
CustomerViewModel, 215, 216
danych encji, Patrz EDM
domenowy, 65, 68
Portal Usáug, 144, 147
ServiceProvider, 282
Subskrypcja, 101
klasy, 68
domenowa, 68, 70
typy asocjacji, 70
Newsletter, 153
RegisterModel, 182, 185
CAPTCHA, 189
rodzaje, 66
Service, 147
ServiceListContainerViewModel, 282
ServiceProvider, 151, 233
Subscriber, 114
Task, 355
walidacja danych, 69
wejĞciowy, 65
Newsletter, 121
widokowy, 65, 214
AddServiceModel, 246
CommentsFilterViewModel, 268
CommentViewModel, 268
KupZdjecieViewModel, 317
ServiceCommentsViewModel, 269
ServiceFilterViewModel, 252
ServiceListContainerViewModel, 252
ServiceViewModel, 252
Zdjecie, 303, 306
Moje ZdjĊcia, 8, 301, 380
autouzupeánianie, 332
implementacja, 332
biznesowa wizja, 302
diagram przypadków uĪycia, 303
dodanie modelu, 306
dodawanie kontrolera, 308
ekran niezalogowanego uĪytkownika, 337
model danych, 303
modyfikacja kontrolera, 309
modyfikacje widoków, 320
podstawowy widok aplikacji, 309
projektowa wizja, 302
przeszukiwanie zdjĊü, 328
Razor, 320
szablon strony, 320
uĪytkownicy, 302
anonimowy, 303
niezalogowany, 337
zarejestrowany, 303
wersja w chmurze, 337
Azure Storage, 341
Cloud Service, 341
modyfikacja plików konfiguracyjnych, 343
wdroĪenie serwisu, 344
wybieranie listy serwerów, 342
zakáadanie konta rozliczeniowego, 338
zarządzanie kluczami dostĊpu, 343
wybór rodzaju projektu, 305
MS SQL Server Compact, 99, 146
MVC, 11
aplikacje webowe, 17
obsáuga ĪądaĔ HTTP, 17
schemat dziaáania, 18
ASP.NET MVC 4, 23
Django, 20
interakcja warstw, 12
klasyczna postaü wzorca, 12
Kompozyt, 16
Kontroler, 12, 20
model, 65
domenowy, 65
wejĞciowy, 65
widokowy, 65
Model, 12, 20
MVP, 18
MVVM, 19
Obserwator, 15
PAC, 19
Ruby on Rails, 19
CoC, 19
DRY, 20
Spring, 11, 20
Strategia, 15, 16
Struts, 11, 20
szczegóáowa komunikacja, 14
usytuowanie uĪytkownika, 13
widok, 53
Widok, 12, 20
wzorzec projektowy, 14
wzorzec záoĪony, 14
Zend Framework, 20
N
narzĊdzia
@helper, 63
Fiddler, 362
Microsoft Web Platform Installer, 97
NuGet, 103
Kup książkęPoleć książkę 388
ASP.NET MVC 4. Programowanie aplikacji webowych
O
operacje CRUD, 88, 156
ORM, 66, 83
P
PHP, 20
Zend Framework, 20
Planner, 8, 351, 380
akcje kontrolera, 360
arkusz styli CSS, 369
biznesowa wizja, 351
definicja wywoáania akcji, 371
dodane zadanie, 375
dodanie bazy danych, 356
dodanie nowego kontrolera, 360
domenowy model aplikacji, 355
instalacja na zewnĊtrznym serwerze, 377
interfejs uĪytkownika, 366
jQuery, 369
przygotowanie projektu, 351
repozytorium, 357
interfejs, 357
klasa, 358
strona gáówna, 374
szablon listy zadaĔ, 372
testowanie akcji kontrolera, 362
wybór daty i godziny, 375
wybór szablonu projektu, 352
wyszukanie zadania, 376
platforma .NET, 23
ASP.NET, 23
MVC 4, 23
frameworki, 23
POCO, 85
Portal Usáug, 8, 139, 379
akcje, 172
biznesowa wizja, 139
byty biznesowe, 142
CAPTCHA, 189
checkbox, 185
diagram przypadków uĪycia, 143
dodawanie
bazy danych, 147
serwera, 147
arkusza stylów CSS, 211
domenowy model aplikacji, 144
instalacja aplikacjĊ na zewnĊtrznym
serwerze, 297
kategoria komentarzy, 144 150 201
generowanie kontrolera, 202
kategoria usáug, 194
dodawanie kategorii, 201
dodawanie kontrolera, 194
lista kategorii, 201
kategoria usáugi, 142, 149
komentarz, 144, 149, 275
dodawanie komentarzy, 275 279
dodawanie kontrolera, 275
edycja komentarzy, 279
usuwanie komentarzy, 279
komunikaty, 193
menu, 209
administratora, 214
implementacja, 209
usáugobiorcy, 214
model domenowy, 144, 147
newsletter, 144, 153
dodanie kontrolera, 204
wysyáanie, 208
poáączenie z lokalną bazą danych, 170
projekt aplikacji, 142
projektowa wizja, 140
projektowanie kontrolerów, 145
przygotowywanie projektu, 146
przypadki uĪycia, 141
rejestrowanie uĪytkowników, 169
repozytorium, 156
ICategoryRepository, 157
ICommentRepository, 158
ICustomerRepository, 158
interfejs, 156, 169
IServiceProviderRepository, 159
IServiceRepository, 160
strona gáówna, 289, 294
modyfikacja, 289
usáuga, 142, 148, 245
dodanie widoku, 257
dodawanie usáug, 246, 251
edycja usáug, 260, 265
implementacja kontrolera, 246
lista usáug, 260
szczegóáy usáugi, 279
usuwanie usáug, 264
wyĞwietlanie listy, 251
wyĞwietlanie szczegóáów, 267
usáugobiorca, 142, 150, 214
edycja danych, 225
formularz rejestracyjny, 186
implementacji kontrolera, 216
model widokowy, 214
usuwanie, 229
wyĞwietlanie listy, 216, 225
usáugodawca, 142, 151, 232
dane szczegóáowe, 282, 288
dodawanie widoku, 236, 240
edycja danych, 239
Kup książkęPoleć książkę Skorowidz
389
formularz rejestracyjny, 186
implementacja kontrolera, 234
lista aktywnych usáug, 282, 288
model widokowy, 232
usuwanie, 242
wyĞwietlanie listy, 235
uĪytkownicy, 139
Administrator, 141 208
niezarejestrowany, 140
rejestracja, 139, 169
usáugobiorca, 140
usáugodawca, 141
zarejestrowany, 141
uĪytkownik, 142
widoki mobilne, 291
lista usáug, 296
newsletter, 296
strona gáówna, 293
strona wzorcowa, 292
szczegóáy usáugi, 296
tryby wyĞwietlania, 291
Python, 20
Django, 20
R
RAD, 23
Razor, 54, 57, 60
instrukcja warunkowa, 58
kontrolka logowania, 58
metody pomocnicze, 63
pĊtla foreach, 59
routing, 75
modyfikacja, 119
trasowanie, 76
domyĞlna trasa przekierowaĔ, 76
generowanie linków, 79
trasa uĪytkownika, 78
URL, 29
Application_Start(), 29
domyĞlna konfiguracja, 30
MapRoute, 30
RouteConfig, 29
Ruby on Rails, 19
CoC, 19
DRY, 20
S
strona wzorcowa, 116
dodanie obsáugi komunikatów, 193
urządzenia mobilne, 292
studium przypadku, 8
Moje ZdjĊcia, 8
Planner, 8
Portal Usáug, 8
Subskrypcja, 8
Subskrypcja, 8, 95, 379
biznesowa wizja, 95
diagram przypadków uĪycia, 96
dodawanie
bazy danych, 100
modelu domenowego, 101
modelu wejĞciowego, 121
nowego kontrolera, 105
serwera, 99
nowego widoku, 110
Entity Framework, 102
konfiguracja, 103
formularz
dodawania subskrypcji, 114
logowania uĪytkownika, 134
instalacja aplikacji, 137
komunikat báĊdu
przy usuwaniu subskrypcji, 117
walidacji, 115
konfiguracja serwera pocztowego, 124
lista subskrybentów, 118
modyfikacja routingu, 119
oferowane dziaáania, 95
poáączenie z bazą danych, 128
projektowa wizja, 96
przygotowanie projektu, 97
strona gáówna aplikacji, 135
strona wzorcowa, 116, 119
dodanie obsáugi komunikatów, 116
modyfikacja kodu, 120
modyfikacja stopki, 120
modyfikacja tytuáu, 120
Subscriber, 102, 105
SubscriptionContext, 102
uĪytkownicy systemu, 96
Administrator, 96, 127
identyfikacja, 96
Subskrybent, 96
wysyáanie newslettera, 123, 126
T
tryby wyĞwietlania, 291
definiowanie nowego, 291
V
Visual Studio 2012, 97
uruchamianie, 97
Kup książkęPoleć książkę 390
ASP.NET MVC 4. Programowanie aplikacji webowych
Windows Azure, 301
Activity Log, 346
Cloud Service, 304, 337, 340
zakáadanie usáugi, 341
pliki konfiguracyjne, 335
pobranie pliku poĞwiadczeĔ, 345
ServiceConfiguration.Cloud, 336
ServiceConfiguration.Local, 335
ServiceDefinition, 336
SQL Database, 337, 340
connection string, 342
dodawanie nowego serwera, 342
Storage, 301, 337, 340
Blobs, 319
connection string, 343
zakáadanie konta, 341
zarządzanie kluczami dostĊpu, 343
Tools, 301
wybieranie listy serwerów, 342
zakáadanie konta rozliczeniowego, 338
wyniki akcji, 39
wzorce projektowe, 11
Kompozyt, 16
MVC, 11
MVP, 18
MVVM, 19
Obserwator, 15
PAC, 19
Repozytorium, 156
Strategia, 15, 16
Z
zdarzenie
Application_Start(), 29, 128, 170, 208, 291
W
widok, 53
_LoginPartial, 188
Bundling, 93
Create, 199, 250, 278, 323
czĊĞciowy, 61
_Filter, 222, 238, 259
_Menu, 210
_Menu.Mobile, 293
_ServiceFilter, 287
Delete, 231, 244, 267, 327
Details, 273, 285, 326
Edit, 200, 227, 240, 263, 281, 324
generowanie linków, 79
gáówny, 61
Index, 111, 199, 218, 237, 257, 290, 321,
328, 366
modyfikacja, 223
KupZdjecie, 331
List, 117
Login, 133, 186
Manage, 187
mobilny
Details.Mobile, 295
Index.Mobile, 294
Send.Mobile, 296
nietypizowany, 110
PotwierdzenieWyslane, 331
przekazywanie danych, 54, 55
Register, 182, 190
CAPTCHA, 191
Send, 125, 206
Sent, 126, 127, 208
silnik widoku, 53
ASPX, 54, 57
Razor, 54, 57
SprzedazZakonczona, 331
Subscribe, 112
szablony, 60
TempData, 57
Unsubscribe, 115
ViewBag, 56
ViewData, 55
ViewRe
Pobierz darmowy fragment (pdf)
