Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00663 013916 20610888 na godz. na dobę w sumie
wyszukaj dokładnie | pobierz wtyczkę
ASP.NET MVC 3 Framework. Zaawansowane programowanie - książka
ASP.NET MVC 3 Framework. Zaawansowane programowanie - książka
Autor: , Liczba stron: 648
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-4822-1 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> webmasterstwo >> asp
Porównaj ceny (książka, ebook, audiobook).
Czytaj online.
Komentuj

Twórz rozbudowane aplikacje webowe!

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

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

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

Wykorzystaj nowoczesne wzorce w Twoich projektach!

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: Pro ASP.NET MVC 3 Framework Tłumaczenie: Paweł Gonera ISBN: 978-83-246-4822-1 Original edition copyright © 2011 by Adam Freeman and Steven Sanderson. All rights reserved. Polish edition copyright © 2012 by HELION SA. All rights reserved. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Wydawnictwo HELION dołożyło wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie bierze jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Wydawnictwo HELION nie ponosi również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/aspmv3.zip Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/aspmv3 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treĂci CzÚĂÊ I Rozdziaï 1. O autorach ...............................................................................................................5 O recenzencie technicznym ......................................................................................7 Wprowadzenie do ASP.NET MVC 3 .................................................. 19 Zagadnienia ogólne ...............................................................................................21 Krótka historia programowania witryn WWW .............................................................................. 21 Tradycyjna technologia ASP.NET Web Forms ........................................................................ 21 Co poszło nie tak z ASP.NET Web Forms? .............................................................................. 23 Programowanie witryn WWW — stan obecny .............................................................................. 23 Standardy WWW oraz REST ...................................................................................................... 24 Programowanie zwinne i sterowane testami ............................................................................ 24 Ruby on Rails ................................................................................................................................. 25 Sinatra ............................................................................................................................................. 25 Node.js ............................................................................................................................................ 25 Najważniejsze zalety ASP.NET MVC ............................................................................................... 26 Architektura MVC ........................................................................................................................ 26 Rozszerzalność .............................................................................................................................. 26 Ścisła kontrola nad HTML i HTTP ............................................................................................ 27 Łatwość testowania ....................................................................................................................... 27 Zaawansowany system routingu ................................................................................................ 28 Zbudowany na najlepszych częściach platformy ASP.NET ................................................... 28 Nowoczesne API ........................................................................................................................... 28 ASP.NET MVC jest open source ................................................................................................ 29 Kto powinien korzystać z ASP.NET MVC? ..................................................................................... 29 Porównanie z ASP.NET Web Forms ......................................................................................... 29 Migracja z Web Forms do MVC ................................................................................................ 30 Porównanie z Ruby on Rails ....................................................................................................... 30 Porównanie z MonoRail .............................................................................................................. 30 Co nowego w ASP.NET MVC 3? ...................................................................................................... 30 Podsumowanie ..................................................................................................................................... 31 SPIS TRE¥CI Rozdziaï 2. Przygotowania ......................................................................................................33 Przygotowanie stacji roboczej ............................................................................................................ 33 Instalowanie Visual Studio 2010 ................................................................................................ 33 Instalowanie podstawowego oprogramowania ........................................................................ 34 Instalowanie opcjonalnych komponentów ............................................................................... 35 Przygotowanie serwera ....................................................................................................................... 37 Włączanie roli serwera WWW ................................................................................................... 37 Instalowanie dodatkowych komponentów ............................................................................... 38 Konfigurowanie Web Deployment ............................................................................................ 39 Uzyskiwanie dalszych informacji ...................................................................................................... 40 Podsumowanie ..................................................................................................................................... 41 Rozdziaï 3. Pierwsza aplikacja MVC .........................................................................................43 Tworzenie nowego projektu ASP.NET MVC ................................................................................. 43 Dodawanie pierwszego kontrolera ............................................................................................. 45 Przedstawiamy ścieżki .................................................................................................................. 47 Generowanie stron WWW ................................................................................................................ 47 Tworzenie i generowanie widoku .............................................................................................. 47 Dynamiczne dodawanie treści .................................................................................................... 50 Tworzenie prostej aplikacji wprowadzania danych ........................................................................ 51 Przygotowanie sceny .................................................................................................................... 51 Projektowanie modelu danych ................................................................................................... 52 Łączenie metod akcji .................................................................................................................... 53 Budowanie formularza ................................................................................................................. 55 Obsługa formularzy ...................................................................................................................... 57 Dodanie kontroli poprawności ................................................................................................... 60 Kończymy ...................................................................................................................................... 63 Podsumowanie ..................................................................................................................................... 65 Rozdziaï 4. Wzorzec MVC .........................................................................................................67 Historia MVC ....................................................................................................................................... 67 Wprowadzenie do wzorca MVC ....................................................................................................... 67 Budowa modelu domeny ............................................................................................................. 68 Implementacja MVC w ASP.NET .............................................................................................. 69 Porównanie MVC z innymi wzorcami ...................................................................................... 69 Przedstawiamy wzorzec Smart UI .............................................................................................. 69 Modelowanie domeny ......................................................................................................................... 72 Przykładowy model domeny ....................................................................................................... 73 Wspólny język ............................................................................................................................... 73 Agregaty i uproszczenia ............................................................................................................... 74 Definiowanie repozytoriów ......................................................................................................... 75 Budowanie luźno połączonych komponentów ............................................................................... 76 Wykorzystanie wstrzykiwania zależności ................................................................................. 77 Przykład specyficzny dla MVC ................................................................................................... 78 Użycie kontenera wstrzykiwania zależności ............................................................................. 79 Zaczynamy testy automatyczne ......................................................................................................... 80 Zadania testów jednostkowych ................................................................................................... 80 Zadania testów integracyjnych ................................................................................................... 87 Podsumowanie ..................................................................................................................................... 87 Rozdziaï 5. Najwaĝniejsze cechy jÚzyka ...................................................................................89 Najważniejsze cechy C# ...................................................................................................................... 89 Użycie automatycznie implementowanych właściwości ........................................................ 89 Użycie inicjalizatorów obiektów i kolekcji ................................................................................ 91 10 SPIS TRE¥CI Użycie metod rozszerzających .................................................................................................... 93 Użycie wyrażeń lambda ............................................................................................................... 97 Automatyczne wnioskowanie typów ......................................................................................... 98 Użycie typów anonimowych ....................................................................................................... 99 Wykonywanie zapytań zintegrowanych z językiem .............................................................. 100 Przedstawiamy składnię silnika Razor ............................................................................................ 105 Tworzenie projektu .................................................................................................................... 105 Prosty widok korzystający z silnika Razor .............................................................................. 108 Podsumowanie ................................................................................................................................... 115 Rozdziaï 6. Waĝne narzÚdzia wspierajÈce MVC .....................................................................117 Użycie Ninject .................................................................................................................................... 117 Tworzenie projektu .................................................................................................................... 119 Zaczynamy korzystać z Ninject ................................................................................................ 119 Tworzenie łańcucha zależności ................................................................................................. 121 Definiowanie wartości właściwości i parametrów ................................................................. 122 Użycie samodzielnego łączenia ................................................................................................. 124 Dołączanie do typu pochodnego .............................................................................................. 124 Użycie łączenia warunkowego .................................................................................................. 125 Użycie Ninject w ASP.NET MVC ................................................................................................... 126 Testowanie jednostkowe w Visual Studio ...................................................................................... 128 Tworzenie projektu .................................................................................................................... 128 Tworzenie testów jednostkowych ............................................................................................ 130 Uruchamianie testów (nieudane) ............................................................................................. 133 Implementacja funkcji ............................................................................................................... 134 Użycie Moq ......................................................................................................................................... 135 Dodawanie Moq do projektu Visual Studio ........................................................................... 135 Tworzenie imitacji za pomocą Moq ......................................................................................... 135 Testy jednostkowe z użyciem Moq .......................................................................................... 137 Weryfikowanie przy użyciu Moq ............................................................................................. 139 Podsumowanie ................................................................................................................................... 139 SportsStore — kompletna aplikacja ....................................................................141 Zaczynamy .......................................................................................................................................... 142 Tworzenie rozwiązania i projektów w Visual Studio ............................................................ 142 Dodawanie referencji ................................................................................................................. 143 Konfigurowanie kontenera DI .................................................................................................. 144 Uruchamiamy aplikację ............................................................................................................. 145 Tworzenie modelu domeny ............................................................................................................. 146 Tworzenie abstrakcyjnego repozytorium ................................................................................ 147 Tworzenie imitacji repozytorium ............................................................................................. 148 Wyświetlanie listy produktów ......................................................................................................... 148 Dodawanie kontrolera ............................................................................................................... 148 Dodawanie widoku ..................................................................................................................... 149 Konfigurowanie domyślnej ścieżki .......................................................................................... 150 Uruchamianie aplikacji .............................................................................................................. 151 Przygotowanie bazy danych ............................................................................................................. 151 Tworzenie bazy danych ............................................................................................................. 152 Definiowanie schematu bazy danych ...................................................................................... 153 Dodawanie danych do bazy ....................................................................................................... 154 Tworzenie kontekstu Entity Framework ................................................................................. 154 Tworzenie repozytorium produktów ...................................................................................... 156 Rozdziaï 7. 11 SPIS TRE¥CI Rozdziaï 8. Rozdziaï 9. 12 Dodanie stronicowania ..................................................................................................................... 157 Wyświetlanie łączy stron ........................................................................................................... 158 Ulepszanie adresów URL ........................................................................................................... 165 Dodawanie stylu ................................................................................................................................. 165 Definiowanie wspólnej zawartości w pliku układu ................................................................ 166 Dodanie zasad CSS ..................................................................................................................... 167 Tworzenie widoku częściowego ............................................................................................... 167 Podsumowanie ................................................................................................................................... 169 SportsStore — nawigacja i koszyk na zakupy .....................................................171 Dodawanie kontrolek nawigacji ...................................................................................................... 171 Filtrowanie listy produktów ...................................................................................................... 171 Ulepszanie schematu URL ......................................................................................................... 172 Budowanie menu nawigacji po kategoriach ........................................................................... 175 Poprawianie licznika stron ........................................................................................................ 182 Budowanie koszyka na zakupy ........................................................................................................ 184 Definiowanie encji koszyka ....................................................................................................... 185 Tworzenie przycisków koszyka ................................................................................................ 188 Implementowanie kontrolera koszyka .................................................................................... 189 Wyświetlanie zawartości koszyka ............................................................................................. 190 Użycie dołączania danych ................................................................................................................ 193 Tworzenie własnego łącznika modelu ..................................................................................... 193 Kończenie budowania koszyka ........................................................................................................ 197 Usuwanie produktów z koszyka ............................................................................................... 197 Dodawanie podsumowania koszyka ........................................................................................ 198 Składanie zamówień .......................................................................................................................... 200 Rozszerzanie modelu domeny .................................................................................................. 200 Dodawanie procesu zamawiania .............................................................................................. 201 Implementowanie procesora zamówień ................................................................................. 204 Rejestrowanie implementacji .................................................................................................... 206 Dokańczanie kontrolera koszyka ............................................................................................. 206 Wyświetlanie informacji o błędach systemu kontroli poprawności ................................... 210 Wyświetlanie strony podsumowania ....................................................................................... 210 Podsumowanie ................................................................................................................................... 212 SportsStore — administracja ...............................................................................213 Dodajemy zarządzanie katalogiem .................................................................................................. 213 Tworzenie kontrolera CRUD .................................................................................................... 214 Generowanie tabeli z produktami dostępnymi w repozytorium ......................................... 215 Tworzenie nowego pliku układu .............................................................................................. 216 Implementowanie widoku listy ................................................................................................ 218 Edycja produktów ....................................................................................................................... 221 Tworzenie nowych produktów ................................................................................................. 232 Usuwanie produktów ................................................................................................................. 232 Zabezpieczanie funkcji administracyjnych .................................................................................... 235 Konfiguracja uwierzytelniania Forms ..................................................................................... 235 Realizacja uwierzytelniania z użyciem filtrów ........................................................................ 236 Tworzenie dostawcy uwierzytelniania ..................................................................................... 238 Tworzenie kontrolera AccountController .............................................................................. 239 Tworzenie widoku ...................................................................................................................... 240 Przesyłanie zdjęć ................................................................................................................................ 242 Rozszerzanie bazy danych ......................................................................................................... 242 Rozszerzanie modelu domeny .................................................................................................. 244 SPIS TRE¥CI Tworzenie interfejsu użytkownika do przesyłania plików ................................................... 244 Zapisywanie zdjęć do bazy danych ........................................................................................... 245 Implementowanie metody akcji GetImage ............................................................................. 246 Wyświetlanie zdjęć produktów ................................................................................................. 247 Podsumowanie ................................................................................................................................... 249 CzÚĂÊ II ASP.NET MVC 3 — szczegóïowy opis ............................................ 251 Rozdziaï 10. PrzeglÈd projektu MVC ........................................................................................253 Korzystanie z projektów MVC z Visual Studio ............................................................................. 253 Użycie kontrolerów aplikacji internetowej i intranetowej ................................................... 256 Przedstawiamy konwencje MVC ............................................................................................. 257 Debugowanie aplikacji MVC ........................................................................................................... 258 Tworzenie projektu .................................................................................................................... 258 Uruchamianie debugera Visual Studio .................................................................................... 258 Przerywanie pracy aplikacji przez debuger Visual Studio .................................................... 260 Użycie opcji Edit and Continue ................................................................................................ 263 Wstrzykiwanie zależności na poziomie projektu .......................................................................... 266 Podsumowanie ................................................................................................................................... 268 Rozdziaï 11. Adresy URL, routing i obszary ..............................................................................269 Wprowadzenie do systemu routingu .............................................................................................. 269 Tworzenie projektu routingu .................................................................................................... 270 Wprowadzenie do wzorców URL ............................................................................................ 271 Tworzenie i rejestrowanie prostej ścieżki ................................................................................ 272 Definiowanie wartości domyślnych ......................................................................................... 275 Użycie statycznych segmentów adresu URL .......................................................................... 277 Definiowanie własnych zmiennych segmentów .................................................................... 280 Definiowanie opcjonalnych segmentów URL ........................................................................ 282 Definiowanie ścieżek o zmiennej długości .............................................................................. 282 Definiowanie priorytetów kontrolerów na podstawie przestrzeni nazw ........................... 284 Ograniczenia ścieżek .................................................................................................................. 286 Routing żądań dla plików dyskowych ..................................................................................... 290 Pomijanie systemu routingu ..................................................................................................... 292 Generowanie wychodzących adresów URL ................................................................................... 293 Przygotowanie projektu ............................................................................................................. 293 Generowanie wychodzących adresów URL w widokach ...................................................... 294 Generowanie wychodzących adresów URL w metodach akcji ............................................ 299 Generowanie adresu URL na podstawie wybranej ścieżki ................................................... 300 Dostosowanie systemu routingu ..................................................................................................... 300 Tworzenie własnej implementacji RouteBase ........................................................................ 301 Tworzenie własnego obiektu obsługi ścieżki .......................................................................... 304 Korzystanie z obszarów .................................................................................................................... 305 Tworzenie obszaru ...................................................................................................................... 306 Wypełnianie obszaru .................................................................................................................. 307 Rozwiązywanie problemów z niejednoznacznością kontrolerów ....................................... 308 Generowanie łączy do akcji z obszarów .................................................................................. 310 Najlepsze praktyki schematu adresów URL .................................................................................. 310 Twórz jasne i przyjazne dla człowieka adresy URL ............................................................... 310 GET oraz POST — wybierz właściwie ..................................................................................... 311 Podsumowanie ................................................................................................................................... 312 13 SPIS TRE¥CI Rozdziaï 12. Kontrolery i akcje .................................................................................................313 Wprowadzenie do kontrolerów ....................................................................................................... 313 Przygotowanie projektu ............................................................................................................. 313 Tworzenie kontrolera z użyciem interfejsu IController ....................................................... 313 Tworzenie kontrolera przez dziedziczenie po klasie Controller .......................................... 314 Odczytywanie danych wejściowych ................................................................................................ 316 Pobieranie danych z obiektów kontekstu ................................................................................ 316 Użycie parametrów metod akcji ............................................................................................... 317 Tworzenie danych wyjściowych ...................................................................................................... 319 Wyniki akcji ................................................................................................................................. 320 Zwracanie kodu HTML przez generowanie widoku ............................................................. 322 Przekazywanie danych z metody akcji do widoku ................................................................. 327 Wykonywanie przekierowań .................................................................................................... 331 Zwracanie danych tekstowych .................................................................................................. 333 Zwracanie danych XML ............................................................................................................. 336 Zwracanie danych JSON ............................................................................................................ 336 Zwracanie plików i danych binarnych ..................................................................................... 337 Zwracanie błędów i kodów HTTP ........................................................................................... 339 Tworzenie własnego wyniku akcji ............................................................................................ 341 Podsumowanie ................................................................................................................................... 343 Rozdziaï 13. Filtry ....................................................................................................................345 Użycie filtrów ..................................................................................................................................... 345 Wprowadzenie do czterech podstawowych typów filtrów ................................................... 346 Dołączanie filtrów do kontrolerów i metod akcji .................................................................. 347 Użycie filtrów autoryzacji .......................................................................................................... 348 Użycie filtrów wyjątków ............................................................................................................ 353 Użycie filtrów akcji i wyniku ..................................................................................................... 356 Użycie innych funkcji filtrów .................................................................................................... 361 Użycie filtrów wbudowanych .................................................................................................... 366 Podsumowanie ................................................................................................................................... 369 Rozdziaï 14. Rozszerzanie kontrolerów ....................................................................................371 Komponenty potoku przetwarzania żądania ................................................................................. 371 Tworzenie własnej fabryki kontrolerów ......................................................................................... 372 Definiowanie własnej fabryki kontrolerów ............................................................................. 372 Rejestrowanie własnej fabryki kontrolerów ............................................................................ 374 Wykorzystanie wbudowanej fabryki kontrolerów ........................................................................ 374 Nadawanie priorytetów przestrzeniom nazw ......................................................................... 374 Dostosowywanie sposobu tworzenia kontrolerów w DefaultControllerFactory .............. 375 Tworzenie własnego obiektu wywołującego akcje ........................................................................ 377 Użycie wbudowanego obiektu wywołującego akcje ..................................................................... 378 Użycie własnych nazw akcji ...................................................................................................... 379 Selekcja metod akcji .................................................................................................................... 380 Użycie selektorów metod akcji do obsługi żądań REST ....................................................... 383 Poprawianie wydajności z użyciem specjalizowanych kontrolerów .......................................... 385 Użycie kontrolerów bezstanowych .......................................................................................... 385 Użycie kontrolerów asynchronicznych ................................................................................... 386 Podsumowanie ................................................................................................................................... 394 14 SPIS TRE¥CI Rozdziaï 15. Widoki .................................................................................................................395 Tworzenie własnego silnika widoku ............................................................................................... 395 Tworzenie własnej implementacji IView ................................................................................ 397 Tworzenie implementacji IViewEngine .................................................................................. 397 Rejestrowanie własnego silnika widoku .................................................................................. 398 Korzystanie z silnika Razor .............................................................................................................. 401 Sposób generowania widoków przez Razor ............................................................................ 401 Wstrzykiwanie zależności w widokach Razor ........................................................................ 402 Konfigurowanie wyszukiwania lokalizacji widoków ............................................................. 404 Dodawanie dynamicznych treści do widoku Razor ..................................................................... 405 Użycie kodu wbudowanego ...................................................................................................... 405 Użycie metod pomocniczych HTML .............................................................................................. 410 Tworzenie wewnętrznej metody pomocniczej HTML .......................................................... 411 Tworzenie zewnętrznej metody pomocniczej HTML ........................................................... 411 Użycie wbudowanych metod pomocniczych ......................................................................... 413 Zastosowanie sekcji ........................................................................................................................... 425 Sprawdzanie istnienia sekcji ...................................................................................................... 427 Generowanie sekcji opcjonalnych ............................................................................................ 428 Użycie widoków częściowych .......................................................................................................... 428 Tworzenie widoku częściowego ............................................................................................... 428 Użycie silnie typowanych widoków częściowych .................................................................. 430 Użycie akcji podrzędnych ................................................................................................................. 431 Tworzenie akcji podrzędnych ................................................................................................... 431 Wywoływanie akcji podrzędnych ............................................................................................. 432 Podsumowanie ................................................................................................................................... 433 Rozdziaï 16. Szablony modelu .................................................................................................435 Użycie metod pomocniczych widoku szablonowego ................................................................... 435 Nadawanie stylów wygenerowanym znacznikom HTML .................................................... 438 Użycie metadanych modelu ...................................................................................................... 440 Użycie metadanych wartości danych ....................................................................................... 443 Korzystanie z parametrów typów złożonych .......................................................................... 447 Dostosowywanie systemu metod pomocniczych widoku szablonowego ................................. 448 Tworzenie własnego szablonu edytora .................................................................................... 448 Tworzenie własnego szablonu wyświetlania ........................................................................... 450 Tworzenie szablonu ogólnego .................................................................................................. 452 Wymiana szablonów wbudowanych ....................................................................................... 453 Użycie właściwości ViewData.TemplateInfo .......................................................................... 454 Przekazywanie dodatkowych metadanych do szablonu ....................................................... 455 System dostawców metadanych ...................................................................................................... 456 Tworzenie własnego dostawcy metadanych modelu ............................................................ 457 Dostosowywanie adnotacji danych dostawcy metadanych modelu ................................... 458 Podsumowanie ................................................................................................................................... 459 Rozdziaï 17. DoïÈczanie modelu ..............................................................................................461 Użycie dołączania danych ................................................................................................................ 461 Użycie domyślnego łącznika modelu .............................................................................................. 462 Dołączanie typów prostych ....................................................................................................... 463 Dołączanie typów złożonych ..................................................................................................... 464 Dołączanie tablic i kolekcji ........................................................................................................ 467 15 SPIS TRE¥CI Jawne wywoływanie dołączania modelu ........................................................................................ 469 Ograniczanie dołączania do wybranego źródła danych ........................................................ 470 Obsługa błędów dołączania modelu ........................................................................................ 471 Użycie dołączania modelu w celu pobierania przesłanych plików ............................................ 472 Dostosowanie systemu dołączania danych .................................................................................... 472 Tworzenie własnego dostawcy wartości .................................................................................. 473 Tworzenie łącznika modelu obsługującego zależności ......................................................... 474 Tworzenie własnego łącznika modelu ..................................................................................... 475 Tworzenie dostawcy łączników modelu .................................................................................. 477 Użycie atrybutu ModelBinder .................................................................................................. 478 Podsumowanie ................................................................................................................................... 478 Rozdziaï 18. Kontrola poprawnoĂci modelu ............................................................................479 Tworzenie projektu ........................................................................................................................... 479 Jawna kontrola poprawności modelu ............................................................................................. 481 Wyświetlanie komunikatów kontroli poprawności ..................................................................... 482 Wyświetlanie komunikatów kontroli poprawności poziomu właściwości ........................ 486 Użycie alternatywnych technik kontroli poprawności ................................................................. 487 Kontrola poprawności w łączniku modelu ............................................................................. 488 Definiowanie zasad poprawności za pomocą metadanych .................................................. 491 Definiowanie modeli samokontrolujących się ....................................................................... 494 Tworzenie własnego dostawcy kontroli poprawności ........................................................... 495 Użycie kontroli poprawności po stronie klienta ........................................................................... 499 Aktywowanie i wyłączanie kontroli poprawności po stronie klienta ................................. 499 Użycie kontroli poprawności po stronie klienta .................................................................... 502 Jak działa kontrola poprawności po stronie klienta? ............................................................. 504 Modyfikowanie kontroli poprawności na kliencie ................................................................ 505 Wykonywanie zdalnej kontroli poprawności ................................................................................ 511 Podsumowanie ................................................................................................................................... 513 Rozdziaï 19. NieprzeszkadzajÈcy Ajax ......................................................................................515 Użycie nieprzeszkadzających wywołań Ajax w MVC .................................................................. 515 Tworzenie projektu .................................................................................................................... 515 Włączanie i wyłączanie nieprzeszkadzających wywołań Ajax ............................................. 518 Użycie nieprzeszkadzających formularzy Ajax ...................................................................... 518 Sposób działania nieprzeszkadzających wywołań Ajax ........................................................ 520 Ustawianie opcji Ajax ........................................................................................................................ 520 Zapewnienie kontrolowanej degradacji .................................................................................. 520 Informowanie użytkownika o realizowanym żądaniu Ajax ................................................. 522 Wyświetlanie pytania przed wysłaniem żądania .................................................................... 523 Tworzenie łączy Ajax ........................................................................................................................ 524 Zapewnienie kontrolowanej degradacji dla łączy .................................................................. 526 Korzystanie z funkcji wywołania zwrotnego w Ajaksie ............................................................... 527 Wykorzystanie JSON ......................................................................................................................... 529 Dodanie obsługi JSON do kontrolera ...................................................................................... 530 Przetwarzanie JSON w przeglądarce ........................................................................................ 531 Wykrywanie żądań Ajax w metodach akcji ............................................................................ 532 Odbieranie danych JSON .......................................................................................................... 533 Podsumowanie ................................................................................................................................... 535 16 SPIS TRE¥CI Rozdziaï 20. jQuery ..................................................................................................................537 Tworzenie projektu ........................................................................................................................... 537 Odwoływanie się do jQuery ............................................................................................................. 539 Tworzenie kodu jQuery .................................................................................................................... 541 Utworzenie środowiska testowego dla jQuery ....................................................................... 542 Podstawy jQuery ................................................................................................................................ 544 Poznajemy selektory jQuery ..................................................................................................... 545 Użycie filtrów jQuery ................................................................................................................. 546 Poznajemy metody jQuery ........................................................................................................ 548 Czekając na DOM ....................................................................................................................... 549 Użycie metod CSS z jQuery ....................................................................................................... 550 Manipulowanie modelem DOM .............................................................................................. 552 Użycie zdarzeń jQuery ...................................................................................................................... 555 Użycie efektów wizualnych jQuery ................................................................................................. 556 Użycie jQuery UI ............................................................................................................................... 558 Odwoływanie się do jQuery UI ................................................................................................ 558 Tworzenie lepszych przycisków ............................................................................................... 559 Użycie kontrolki Slider .............................................................................................................. 560 Podsumowanie ................................................................................................................................... 562 CzÚĂÊ III Tworzenie udanych projektów ASP.NET MVC 3 ............................. 565 Rozdziaï 21. Bezpieczeñstwo i sïabe punkty ............................................................................567 Każde dane mogą być sfałszowane .................................................................................................. 567 Fałszowanie żądań HTTP .......................................................................................................... 569 Skrypty międzywitrynowe i wstrzykiwanie HTML ...................................................................... 570 Przedstawiamy ataki XSS ........................................................................................................... 570 Kodowanie HTML w Razor ...................................................................................................... 571 Kontrola żądań ............................................................................................................................ 572 Kodowanie ciągów znaków JavaScript a XSS ......................................................................... 574 Przejęcie sesji ...................................................................................................................................... 576 Obrona przez sprawdzanie adresu IP klienta ......................................................................... 576 Obrona przez ustawienie w cookie znacznika HttpOnly ...................................................... 577 Międzywitrynowe fałszowanie żądań ............................................................................................. 577 Atak ............................................................................................................................................... 578 Obrona .......................................................................................................................................... 578 Ochrona przed atakami CSRF z użyciem metod zapobiegających fałszerstwom ............. 579 Wstrzykiwanie SQL ........................................................................................................................... 580 Atak ............................................................................................................................................... 580 Obrona z użyciem zapytań parametrycznych ........................................................................ 581 Obrona z użyciem odwzorowania obiektowo-relacyjnego .................................................. 581 Bezpieczne korzystanie z biblioteki MVC ...................................................................................... 581 Nie udostępniaj przypadkowo metod akcji ............................................................................ 581 Nie używaj dołączania modelu w celu zmiany wrażliwych właściwości ............................ 582 Podsumowanie ................................................................................................................................... 582 Rozdziaï 22. Uwierzytelnianie i autoryzacja .............................................................................583 Użycie uwierzytelniania Windows .................................................................................................. 583 Użycie uwierzytelniania Forms ....................................................................................................... 585 Konfiguracja uwierzytelniania Forms ..................................................................................... 586 Uwierzytelnianie Forms bez użycia cookies ........................................................................... 587 17 SPIS TRE¥CI Członkostwo, role i profile ............................................................................................................... 588 Konfigurowanie i wykorzystanie członkostwa ....................................................................... 589 Konfigurowanie i wykorzystanie ról ........................................................................................ 597 Konfigurowanie i wykorzystanie profili .................................................................................. 600 Dlaczego nie należy korzystać z uwierzytelniania bazującego na adresach URL ..................... 604 Ograniczanie dostępu z użyciem adresów IP oraz domen .......................................................... 604 Podsumowanie ................................................................................................................................... 606 Rozdziaï 23. Instalacja .............................................................................................................607 Przygotowanie aplikacji do dystrybucji .......................................................................................... 607 Wykrywanie błędów przed instalacją ...................................................................................... 607 Kontrolowanie dynamicznej kompilacji stron ....................................................................... 608 Przygotowanie do instalacji binarnej ....................................................................................... 609 Przygotowanie pliku Web.config do przekształcania ............................................................ 609 Przygotowanie projektu do instalacji bazy danych ................................................................ 619 Podstawy działania serwera IIS ........................................................................................................ 621 Witryny Web ............................................................................................................................... 621 Katalogi wirtualne ....................................................................................................................... 621 Pule aplikacji ................................................................................................................................ 621 Wiązanie witryn z nazwami hostów, adresami IP oraz portami ......................................... 622 Przygotowanie serwera do instalacji ............................................................................................... 622 Instalowanie aplikacji ........................................................................................................................ 624 Instalowanie aplikacji przez kopiowanie plików .................................................................... 624 Użycie pakietu instalacyjnego ................................................................................................... 625 Publikowanie jednym kliknięciem ........................................................................................... 628 Podsumowanie ................................................................................................................................... 629 Skorowidz ............................................................................................................631 18 R O Z D Z I A ’ 1 8 „ „ „ Kontrola poprawnoĂci modelu W poprzednim rozdziale przedstawiliśmy, w jaki sposób na podstawie żądań HTTP biblioteka MVC tworzy obiekty modelu w procesie dołączania modelu. Zakładaliśmy, że dane wprowadzone przez użytkownika były prawidłowe. W rzeczywistości użytkownicy często wprowadzają dane, z których nie możemy skorzystać, i tym zajmiemy się teraz — kontrolą poprawności danych modelu. Kontrola poprawności modelu jest procesem, dzięki któremu upewniamy się, że otrzymane dane nadają się do użycia w modelu, a jeżeli nie, dostarczamy użytkownikom informacje pomagające rozwiązać problem. Pierwsza część procesu — sprawdzanie otrzymanych danych — jest jednym ze sposobów zapewnienia integralności danych w modelu domeny. Przez odrzucenie danych, które nie mają sensu w kontekście naszej domeny, zapobiegamy powstawaniu dziwnych i niechcianych stanów aplikacji. Druga część — pomoc użytkownikowi w rozwiązaniu problemu — jest równie ważna. Jeżeli nie zapewnimy użytkownikowi informacji i narzędzi potrzebnych do interakcji z aplikacją w oczekiwany przez nas sposób, szybko spowodujemy jego frustrację. W przypadku aplikacji dostępnych publicznie często powoduje to wycofywanie się użytkowników, natomiast w przypadku aplikacji korporacyjnych może to skutkować spowolnieniem ich działań. Każda z tych sytuacji jest niepożądana. Na szczęście biblioteka MVC zapewnia rozbudowaną obsługę kontroli poprawności modelu. Pokażemy teraz, w jaki sposób korzystać z podstawowych funkcji, a następnie przejdziemy do bardziej zaawansowanych technik sterowania procesem kontroli poprawności. Tworzenie projektu Potrzebna jest nam prosta aplikacja MVC, w której będziemy mogli stosować różne techniki kontroli poprawności modelu. Na jej potrzeby utworzyliśmy klasę modelu widoku o nazwie Appointment, zamieszczoną na listingu 18.1. Listing 18.1. Klasa modelu widoku using System; using System.ComponentModel.DataAnnotations; namespace MvcApp.Models { public class Appointment { public string ClientName { get; set; } [DataType(DataType.Date)] public DateTime Date {get; set;} CZ}¥m II „ ASP.NET MVC 3 — SZCZEGӒOWY OPIS public bool TermsAccepted { get; set; } } } Na listingu 18.2 zamieszczony jest widok generujący edytory dla klasy Appointment, zapisany w pliku MakeBooking.cshtml. Listing 18.2. Widok edytora @model MvcApp.Models.Appointment @{ ViewBag.Title = Rezerwacja ; } h4 Rezerwacja wizyty /h4 @using (Html.BeginForm()) { p Nazwisko: @Html.EditorFor(m = m.ClientName) /p p Data wizyty: @Html.EditorFor(m = m.Date) /p p @Html.EditorFor(m = m.TermsAccepted) AkceptujÚ warunki /p input type= submit value= WyĂlij rezerwacjÚ / } Na listingu 18.3 zamieszczona jest klasa kontrolera, AppointmentController, posiadająca metody akcji operujące na obiektach Appointment. Listing 18.3. Klasa AppointmentController public class AppointmentController : Controller { private IAppointmentRepository repository; public AppointmentController(IAppointmentRepository repo) { repository = repo; } public ViewResult MakeBooking() { return View(new Appointment { Date = DateTime.Now }); } [HttpPost] public ViewResult MakeBooking(Appointment appt) { repository.SaveAppointment(appt); return View( Completed , appt); } } Kontroler realizuje znany już nam wzorzec. Metoda akcji MakeBooking generuje widok MakeBooking.cshtml. Widok ten zawiera formularz, którego dane są przesyłane do drugiej wersji metody MakeBooking, oczekującej parametru Appointment. Łącznik modelu tworzy obiekt Appointment na podstawie wartości elementów formularza HTML, a następnie przekazuje go do metody akcji, zapisującej nowy obiekt w repozytorium, które zostanie dostarczone poprzez wstrzykiwanie zależności (utworzyliśmy tylko szkielet repozytorium — dane wizyty są ignorowane, ponieważ chcemy się tu skupić wyłącznie na kontroli poprawności). Po przekazaniu wizyty do repozytorium kontroler generuje widok Completed.cshtml, który pozwala przekazać informację zwrotną dla użytkownika. Na rysunku 18.1 przedstawiona jest ta sekwencja widoków. 480 ROZDZIA’ 18. „ KONTROLA POPRAWNO¥CI MODELU Rysunek 18.1. Kolejność widoków w przykładowej aplikacji Obecnie nasza aplikacja będzie akceptowała dowolne przesłane przez użytkownika dane, ale aby zachować integralność aplikacji i modelu domeny, wymagamy spełnienia trzech warunków przed zaakceptowaniem przesłanych przez użytkownika danych wizyty: x użytkownik musi podać nazwisko, x użytkownik musi podać przyszłą datę (w formacie mm-dd-rrrr), x użytkownik musi zaznaczyć pole wyboru informujące o zaakceptowaniu zasad. Kontrola poprawności modelu jest procesem umożliwiającym wymuszenie tych wymagań. W kolejnych pu
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

ASP.NET MVC 3 Framework. Zaawansowane programowanie
Autor: ,
Sklep
Format
Cena
Helion.pl Helion.pl
książka
99,00 zł
Idź do sklepu »

Opinie na temat publikacji:

Inne popularne pozycje z tej kategorii:

Czytaj również:

Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: