Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
01878 013014 17895136 na godz. na dobę w sumie
ASP.NET MVC 4. Zaawansowane programowanie - książka
ASP.NET MVC 4. Zaawansowane programowanie - książka
Autor: , Liczba stron: 696
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-7299-8 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> .net - programowanie
Porównaj ceny (książka, ebook, audiobook).

Kompendium wiedzy o platformie ASP.NET MVC 4!

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

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

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

Lektura obowiązkowa każdego programisty!

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

Darmowy fragment publikacji:

Tytuł oryginału: Pro ASP.NET MVC 4 Tłumaczenie: Robert Górczyński ISBN: 978-83-246-7299-8 Original edition copyright © 2012 by Adam Freeman. All rights reserved. Polish edition copyright © 2013 by HELION SA. All rights reserved. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Wydawnictwo HELION dołożyło wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie bierze jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Wydawnictwo HELION nie ponosi również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/aspmv4.zip Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/aspmv4 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treści O autorze ...............................................................................................................17 O recenzencie technicznym ....................................................................................19 Część I Wprowadzenie do ASP.NET MVC 4 ..........................................21 Zagadnienia ogólne ...............................................................................................23 Rozdział 1. Krótka historia programowania witryn WWW .............................................................................. 23 Tradycyjna technologia ASP.NET Web Forms ........................................................................ 23 Co poszło nie tak z ASP.NET Web Forms? .............................................................................. 25 Programowanie witryn WWW — stan obecny .............................................................................. 25 Standardy sieciowe oraz REST .................................................................................................... 26 Programowanie zwinne i sterowane testami ............................................................................ 26 Ruby on Rails ................................................................................................................................. 27 Sinatra ............................................................................................................................................. 27 Node.js ............................................................................................................................................ 28 Najważniejsze zalety ASP.NET MVC ............................................................................................... 28 Architektura MVC ........................................................................................................................ 28 Rozszerzalność .............................................................................................................................. 29 Ścisła kontrola nad HTML i HTTP ............................................................................................ 29 Łatwość testowania ....................................................................................................................... 30 Zawansowany system routingu .................................................................................................. 30 Zbudowany na najlepszych częściach platformy ASP.NET ................................................... 30 Nowoczesne API ........................................................................................................................... 31 ASP.NET MVC jest open source ................................................................................................ 31 Kto powinien korzystać z ASP.NET MVC? ..................................................................................... 31 Porównanie z ASP.NET Web Forms ......................................................................................... 31 Migracja z Web Forms do MVC ................................................................................................ 32 Porównanie z Ruby on Rails ....................................................................................................... 32 Porównanie z MonoRail .............................................................................................................. 32 Co nowego w ASP.NET MVC 4? ...................................................................................................... 33 Podsumowanie ..................................................................................................................................... 33 Kup książkęPoleć książkę SPIS TREŚCI Rozdział 2. Pierwsza aplikacja MVC .........................................................................................35 Przygotowanie stacji roboczej ............................................................................................................ 35 Tworzenie nowego projektu ASP.NET MVC ................................................................................. 36 Dodawanie pierwszego kontrolera ............................................................................................. 38 Przedstawiamy ścieżki .................................................................................................................. 40 Generowanie stron WWW ................................................................................................................ 41 Tworzenie i generowanie widoku .............................................................................................. 41 Dynamiczne dodawanie treści .................................................................................................... 43 Tworzenie prostej aplikacji wprowadzania danych ........................................................................ 45 Przygotowanie sceny .................................................................................................................... 45 Projektowanie modelu danych ................................................................................................... 46 Łączenie metod akcji .................................................................................................................... 47 Budowanie formularza ................................................................................................................. 49 Obsługa formularzy ...................................................................................................................... 51 Dodanie kontroli poprawności ................................................................................................... 54 Kończymy ...................................................................................................................................... 60 Podsumowanie ..................................................................................................................................... 61 Rozdział 3. Wzorzec MVC .........................................................................................................63 Historia MVC ....................................................................................................................................... 63 Wprowadzenie do wzorca MVC ....................................................................................................... 64 Budowa modelu domeny ............................................................................................................. 64 Implementacja MVC w ASP.NET .............................................................................................. 65 Porównanie MVC z innymi wzorcami ...................................................................................... 65 Przedstawiam wzorzec Smart UI ................................................................................................ 65 Modelowanie domeny ......................................................................................................................... 68 Przykładowy model domeny ....................................................................................................... 69 Wspólny język ............................................................................................................................... 69 Agregaty i uproszczenia ............................................................................................................... 70 Definiowanie repozytoriów ......................................................................................................... 71 Budowanie luźno połączonych komponentów ............................................................................... 73 Wykorzystanie wstrzykiwania zależności ................................................................................. 73 Przykład specyficzny dla MVC ................................................................................................... 75 Użycie kontenera wstrzykiwania zależności ............................................................................. 75 Zaczynamy testy automatyczne ......................................................................................................... 76 Zadania testów jednostkowych ................................................................................................... 77 Zadania testów integracyjnych ................................................................................................... 84 Podsumowanie ..................................................................................................................................... 84 Rozdział 4. Najważniejsze cechy języka ...................................................................................85 Utworzenie przykładowego projektu ................................................................................................ 85 Użycie automatycznie implementowanych właściwości ............................................................... 86 Użycie inicjalizatorów obiektów i kolekcji ....................................................................................... 89 Użycie metod rozszerzających ........................................................................................................... 91 Stosowanie metod rozszerzających do interfejsów .................................................................. 93 Tworzenie filtrujących metod rozszerzających ........................................................................ 95 Użycie wyrażeń lambda ...................................................................................................................... 97 Automatyczne wnioskowanie typów .............................................................................................. 100 Użycie typów anonimowych ............................................................................................................ 100 6 Kup książkęPoleć książkę SPIS TREŚCI Wykonywanie zapytań LINQ .......................................................................................................... 102 Opóźnione zapytania LINQ ...................................................................................................... 105 Użycie metod asynchronicznych ..................................................................................................... 107 Użycie słów kluczowych async i await ..................................................................................... 108 Podsumowanie ................................................................................................................................... 109 Rozdział 5. Praca z silnikiem Razor ........................................................................................111 Tworzenie projektu ........................................................................................................................... 111 Definiowanie modelu ................................................................................................................. 111 Definiowanie kontrolera ............................................................................................................ 112 Tworzenie widoku ...................................................................................................................... 113 Korzystanie z obiektów modelu ...................................................................................................... 114 Praca z układami ................................................................................................................................ 116 Tworzenie układu ....................................................................................................................... 116 Stosowanie układu ...................................................................................................................... 118 Użycie pliku ViewStart ............................................................................................................... 119 Użycie układów współdzielonych ............................................................................................ 119 Użycie wyrażeń Razor ....................................................................................................................... 123 Wstawianie wartości danych ..................................................................................................... 124 Przypisanie wartości atrybutu ................................................................................................... 125 Użycie konstrukcji warunkowych ............................................................................................ 127 Wyliczanie tablic i kolekcji ........................................................................................................ 129 Praca z przestrzenią nazw .......................................................................................................... 132 Podsumowanie ................................................................................................................................... 132 Rozdział 6. Ważne narzędzia wspierające MVC .....................................................................133 Tworzenie przykładowego projektu ............................................................................................... 134 Utworzenie klas modelu ............................................................................................................ 134 Dodanie kontrolera .................................................................................................................... 135 Dodanie widoku .......................................................................................................................... 136 Użycie Ninject .................................................................................................................................... 136 Zrozumienie problemu .............................................................................................................. 137 Zaczynamy korzystać z Ninject ................................................................................................ 139 Konfiguracja wstrzykiwania zależności na platformie MVC ............................................... 141 Tworzenie łańcucha zależności ................................................................................................. 144 Definiowanie wartości właściwości i parametrów ................................................................. 146 Użycie łączenia warunkowego .................................................................................................. 148 Testy jednostkowe w Visual Studio ................................................................................................. 149 Tworzenie projektu testów jednostkowych ............................................................................ 150 Tworzenie testów jednostkowych ............................................................................................ 151 Uruchamianie testów (nieudane) ............................................................................................. 154 Implementacja funkcji ............................................................................................................... 155 Testowanie i poprawianie kodu ................................................................................................ 156 Użycie Moq ......................................................................................................................................... 157 Zrozumienie problemu .............................................................................................................. 158 Dodawanie Moq do projektu Visual Studio ........................................................................... 159 Dodanie obiektu imitacyjnego do testu jednostkowego ....................................................... 160 Tworzenie obiektu imitacji ........................................................................................................ 161 Tworzenie bardziej skomplikowanych obiektów Mock ....................................................... 163 Podsumowanie ................................................................................................................................... 166 7 Kup książkęPoleć książkę SPIS TREŚCI Rozdział 7. Rozdział 8. Rozdział 9. 8 SportsStore — kompletna aplikacja ....................................................................167 Zaczynamy .......................................................................................................................................... 168 Tworzenie rozwiązania i projektów w Visual Studio ............................................................ 168 Dodawanie referencji ................................................................................................................. 169 Konfigurowanie kontenera DI .................................................................................................. 171 Uruchamiamy aplikację ............................................................................................................. 172 Tworzenie modelu domeny ............................................................................................................. 173 Tworzenie abstrakcyjnego repozytorium ................................................................................ 174 Tworzenie imitacji repozytorium ............................................................................................. 174 Wyświetlanie listy produktów ......................................................................................................... 175 Dodawanie kontrolera ............................................................................................................... 176 Dodawanie widoku ..................................................................................................................... 177 Konfigurowanie domyślnej ścieżki .......................................................................................... 178 Uruchamianie aplikacji .............................................................................................................. 179 Przygotowanie bazy danych ............................................................................................................. 179 Tworzenie bazy danych ............................................................................................................. 180 Definiowanie schematu bazy danych ...................................................................................... 181 Dodawanie danych do bazy ....................................................................................................... 182 Tworzenie kontekstu Entity Framework ................................................................................. 183 Tworzenie repozytorium produktów ...................................................................................... 184 Dodanie stronicowania ..................................................................................................................... 186 Wyświetlanie łączy stron ........................................................................................................... 188 Ulepszanie adresów URL ........................................................................................................... 195 Dodawanie stylu ................................................................................................................................. 196 Definiowanie wspólnej zawartości w pliku układu ................................................................ 197 Dodanie stylów CSS .................................................................................................................... 197 Tworzenie widoku częściowego ............................................................................................... 199 Podsumowanie ................................................................................................................................... 200 SportsStore — nawigacja ....................................................................................201 Dodawanie kontrolek nawigacji ...................................................................................................... 201 Filtrowanie listy produktów ...................................................................................................... 201 Ulepszanie schematu URL ......................................................................................................... 203 Budowanie menu nawigacji po kategoriach ........................................................................... 207 Poprawianie licznika stron ........................................................................................................ 214 Budowanie koszyka na zakupy ........................................................................................................ 216 Definiowanie encji koszyka ....................................................................................................... 217 Tworzenie przycisków koszyka ................................................................................................ 221 Implementowanie kontrolera koszyka .................................................................................... 222 Wyświetlanie zawartości koszyka ............................................................................................. 224 Podsumowanie ................................................................................................................................... 227 SportsStore — ukończenie koszyka na zakupy ....................................................229 Użycie dołączania danych ................................................................................................................ 229 Tworzenie własnego łącznika modelu ..................................................................................... 229 Kończenie budowania koszyka ........................................................................................................ 234 Usuwanie produktów z koszyka ............................................................................................... 234 Dodawanie podsumowania koszyka ........................................................................................ 234 Kup książkęPoleć książkę SPIS TREŚCI Składanie zamówień .......................................................................................................................... 237 Rozszerzanie modelu domeny .................................................................................................. 237 Dodawanie procesu zamawiania .............................................................................................. 238 Implementowanie mechanizmu przetwarzania zamówień .................................................. 241 Rejestrowanie implementacji .................................................................................................... 243 Zakończenie pracy nad kontrolerem koszyka ........................................................................ 244 Wyświetlanie informacji o błędach systemu kontroli poprawności ................................... 248 Wyświetlanie strony podsumowania ....................................................................................... 249 Podsumowanie ................................................................................................................................... 249 Rozdział 10. SportsStore — administracja ...............................................................................251 Dodajemy zarządzanie katalogiem .................................................................................................. 251 Tworzenie kontrolera CRUD .................................................................................................... 251 Tworzenie nowego pliku układu .............................................................................................. 253 Implementowanie widoku listy ................................................................................................ 255 Edycja produktów ....................................................................................................................... 260 Tworzenie nowych produktów ................................................................................................. 271 Usuwanie produktów ................................................................................................................. 272 Podsumowanie ................................................................................................................................... 275 Rozdział 11. SportsStore — bezpieczeństwo i ostatnie usprawnienia .....................................277 Zabezpieczanie funkcji administracyjnych .................................................................................... 277 Realizacja uwierzytelniania z użyciem filtrów ........................................................................ 278 Tworzenie dostawcy uwierzytelniania ..................................................................................... 280 Tworzenie kontrolera AccountController .............................................................................. 281 Tworzenie widoku ...................................................................................................................... 283 Przesyłanie zdjęć ................................................................................................................................ 286 Rozszerzanie bazy danych ......................................................................................................... 286 Rozszerzanie modelu domeny .................................................................................................. 287 Tworzenie interfejsu użytkownika do przesyłania plików ................................................... 288 Zapisywanie zdjęć do bazy danych ........................................................................................... 289 Implementowanie metody akcji GetImage ............................................................................. 290 Wyświetlanie zdjęć produktów ................................................................................................. 292 Podsumowanie ................................................................................................................................... 293 Część II ASP.NET MVC 4 — szczegółowy opis ....................................295 Rozdział 12. Przegląd projektu MVC ........................................................................................297 Korzystanie z projektów MVC z Visual Studio ............................................................................. 297 Przedstawienie konwencji MVC .............................................................................................. 301 Debugowanie aplikacji MVC ........................................................................................................... 302 Tworzenie projektu .................................................................................................................... 302 Uruchamianie debugera Visual Studio .................................................................................... 304 Przerywanie pracy aplikacji przez debuger Visual Studio .................................................... 306 Użycie opcji Edit and Continue ................................................................................................ 310 Podsumowanie ................................................................................................................................... 313 Rozdział 13. Routing URL .........................................................................................................315 Tworzenie projektu routingu ........................................................................................................... 316 Wprowadzenie do wzorców URL ................................................................................................... 318 9 Kup książkęPoleć książkę SPIS TREŚCI Tworzenie i rejestrowanie prostej ścieżki ....................................................................................... 319 Użycie prostej ścieżki ................................................................................................................. 324 Definiowanie wartości domyślnych ................................................................................................ 325 Użycie statycznych segmentów adresu URL ................................................................................. 327 Definiowanie własnych zmiennych segmentów ........................................................................... 331 Użycie własnych zmiennych jako parametrów metod akcji ................................................ 334 Definiowanie opcjonalnych segmentów URL ........................................................................ 335 Definiowanie ścieżek o zmiennej długości .............................................................................. 337 Definiowanie priorytetów kontrolerów na podstawie przestrzeni nazw ........................... 339 Ograniczenia ścieżek ......................................................................................................................... 342 Ograniczanie ścieżki z użyciem wyrażeń regularnych .......................................................... 342 Ograniczanie ścieżki do zbioru wartości ................................................................................. 343 Ograniczanie ścieżek z użyciem metod HTTP ....................................................................... 343 Definiowanie własnych ograniczeń ......................................................................................... 344 Routing żądań dla plików dyskowych ............................................................................................ 346 Konfiguracja serwera aplikacji .................................................................................................. 347 Definiowanie ścieżek dla plików na dysku .............................................................................. 349 Pomijanie systemu routingu ............................................................................................................ 350 Podsumowanie ................................................................................................................................... 351 Rozdział 14. Zaawansowane funkcje routingu ........................................................................353 Przygotowanie projektu .................................................................................................................... 353 Generowanie wychodzących adresów URL w widokach ............................................................. 354 Użycie systemu routingu do wygenerowania wychodzącego adresu URL ........................ 354 Użycie innych kontrolerów ....................................................................................................... 357 Przekazywanie dodatkowych parametrów .............................................................................. 358 Definiowanie atrybutów HTML ............................................................................................... 360 Generowanie w pełni kwalifikowanych adresów URL w łączach ........................................ 360 Generowanie adresów URL (nie łączy) ................................................................................... 361 Generowanie wychodzących adresów URL w metodach akcji ............................................ 362 Generowanie adresu URL na podstawie wybranej ścieżki ................................................... 363 Dostosowanie systemu routingu ..................................................................................................... 364 Tworzenie własnej implementacji RouteBase ........................................................................ 364 Tworzenie własnego obiektu obsługi ścieżki .......................................................................... 368 Korzystanie z obszarów .................................................................................................................... 369 Tworzenie obszaru ...................................................................................................................... 369 Wypełnianie obszaru .................................................................................................................. 371 Rozwiązywanie problemów z niejednoznacznością kontrolerów ....................................... 373 Generowanie łączy do akcji z obszarów .................................................................................. 374 Najlepsze praktyki schematu adresów URL .................................................................................. 375 Twórz jasne i przyjazne dla człowieka adresy URL ............................................................... 375 GET oraz POST — wybierz właściwie ..................................................................................... 376 Podsumowanie ................................................................................................................................... 376 Rozdział 15. Kontrolery i akcje .................................................................................................377 Wprowadzenie do kontrolerów ....................................................................................................... 377 Przygotowanie projektu ............................................................................................................. 377 Tworzenie kontrolera z użyciem interfejsu IController ....................................................... 378 Tworzenie kontrolera przez dziedziczenie po klasie Controller .......................................... 379 10 Kup książkęPoleć książkę SPIS TREŚCI Odczytywanie danych wejściowych ................................................................................................ 380 Pobieranie danych z obiektów kontekstu ................................................................................ 380 Użycie parametrów metod akcji ............................................................................................... 382 Tworzenie danych wyjściowych ...................................................................................................... 383 Wyniki akcji ................................................................................................................................. 385 Zwracanie kodu HTML przez generowanie widoku ............................................................. 388 Przekazywanie danych z metody akcji do widoku ................................................................. 391 Wykonywanie przekierowań .................................................................................................... 394 Zwracanie błędów i kodów HTTP ........................................................................................... 399 Podsumowanie ................................................................................................................................... 401 Rozdział 16. Filtry ....................................................................................................................403 Użycie filtrów ..................................................................................................................................... 403 Wprowadzenie do czterech podstawowych typów filtrów ................................................... 404 Dołączanie filtrów do kontrolerów i metod akcji .................................................................. 405 Tworzenie projektu ........................................................................................................................... 406 Użycie filtrów autoryzacji ................................................................................................................. 407 Użycie własnego filtra autoryzacji ............................................................................................ 409 Użycie wbudowanego filtra autoryzacji .................................................................................. 409 Użycie filtrów wyjątków ................................................................................................................... 410 Tworzenie filtra wyjątku ............................................................................................................ 411 Użycie filtra wyjątków ................................................................................................................ 412 Użycie widoku w celu reakcji na wyjątek ................................................................................ 414 Użycie wbudowanego filtra wyjątków ..................................................................................... 417 Użycie filtrów akcji ............................................................................................................................ 419 Implementacja metody OnActionExecuting .......................................................................... 420 Implementacja metody OnActionExecuted ........................................................................... 421 Używanie filtra wyniku ..................................................................................................................... 423 Użycie wbudowanych klas filtrów akcji i wyniku .................................................................. 424 Użycie innych funkcji filtrów ........................................................................................................... 425 Filtrowanie bez użycia atrybutów ............................................................................................. 426 Użycie filtrów globalnych .......................................................................................................... 427 Określanie kolejności wykonywania filtrów ........................................................................... 429 Użycie filtrów wbudowanych ........................................................................................................... 431 Użycie filtra RequireHttps ......................................................................................................... 432 Użycie filtra OutputCache ......................................................................................................... 432 Podsumowanie ................................................................................................................................... 435 Rozdział 17. Rozszerzanie kontrolerów ....................................................................................437 Tworzenie projektu ........................................................................................................................... 437 Tworzenie własnej fabryki kontrolerów ......................................................................................... 439 Przygotowanie kontrolera zapasowego ................................................................................... 441 Utworzenie klasy kontrolera ..................................................................................................... 442 Implementacja innych metod interfejsu ................................................................................. 442 Rejestrowanie własnej fabryki kontrolerów ............................................................................ 442 Wykorzystanie wbudowanej fabryki kontrolerów ........................................................................ 443 Nadawanie priorytetów przestrzeniom nazw ......................................................................... 444 Dostosowywanie sposobu tworzenia kontrolerów w DefaultControllerFactory .............. 445 Tworzenie własnego obiektu wywołującego akcje ........................................................................ 447 11 Kup książkęPoleć książkę SPIS TREŚCI Użycie wbudowanego obiektu wywołującego akcje ..................................................................... 449 Użycie własnych nazw akcji ...................................................................................................... 450 Selekcja metod akcji .................................................................................................................... 451 Poprawianie wydajności z użyciem specjalizowanych kontrolerów .......................................... 456 Użycie kontrolerów bezstanowych .......................................................................................... 456 Użycie kontrolerów asynchronicznych ................................................................................... 458 Podsumowanie ................................................................................................................................... 463 Rozdział 18. Widoki .................................................................................................................465 Tworzenie własnego silnika widoku ............................................................................................... 465 Tworzenie przykładowego projektu ........................................................................................ 467 Tworzenie własnej implementacji IView ................................................................................ 468 Tworzenie implementacji IViewEngine .................................................................................. 468 Rejestrowanie własnego silnika widoku .................................................................................. 470 Testowanie silnika widoku ........................................................................................................ 470 Korzystanie z silnika Razor .............................................................................................................. 472 Tworzenie przykładowego projektu ........................................................................................ 472 Sposób generowania widoków przez Razor ............................................................................ 473 Konfigurowanie wyszukiwania lokalizacji widoków ............................................................. 475 Dodawanie dynamicznych treści do widoku Razor ..................................................................... 477 Zastosowanie sekcji .................................................................................................................... 478 Użycie widoków częściowych ................................................................................................... 483 Użycie akcji podrzędnych .......................................................................................................... 486 Podsumowanie ................................................................................................................................... 488 Rozdział 19. Metody pomocnicze ............................................................................................489 Tworzenie przykładowego projektu ............................................................................................... 489 Tworzenie własnej metody pomocniczej ....................................................................................... 491 Tworzenie wewnętrznej metody pomocniczej HTML .......................................................... 491 Tworzenie zewnętrznej metody pomocniczej HTML ........................................................... 492 Zarządzanie kodowaniem ciągów tekstowych w metodzie pomocniczej .......................... 496 Użycie wbudowanych metod pomocniczych ................................................................................ 500 Przygotowania do obsługi formularzy ..................................................................................... 500 Określenie ścieżki używanej przez formularz ......................................................................... 507 Użycie metod pomocniczych do wprowadzania danych ...................................................... 508 Tworzenie znaczników select .................................................................................................... 513 Podsumowanie ................................................................................................................................... 515 Rozdział 20. Szablonowe metody pomocnicze ........................................................................517 Przegląd przykładowego projektu ................................................................................................... 517 Używanie szablonowych metod pomocniczych ............................................................................ 519 Generowanie etykiety i wyświetlanie elementów ................................................................... 522 Użycie szablonowych metod pomocniczych dla całego modelu ......................................... 525 Użycie metadanych modelu ............................................................................................................. 527 Użycie metadanych do sterowania edycją i widocznością .................................................... 528 Użycie metadanych dla etykiet ................................................................................................. 530 Użycie metadanych wartości danych ....................................................................................... 531 Użycie metadanych do wybierania szablonu wyświetlania .................................................. 533 Dodawanie metadanych do klasy zaprzyjaźnionej ................................................................ 535 Korzystanie z parametrów typów złożonych .......................................................................... 536 12 Kup książkęPoleć książkę SPIS TREŚCI Dostosowywanie systemu szablonowych metod pomocniczych ................................................ 538 Tworzenie własnego szablonu edytora .................................................................................... 538 Tworzenie szablonu ogólnego .................................................................................................. 539 Wymiana szablonów wbudowanych ....................................................................................... 540 Podsumowanie ................................................................................................................................... 541 Rozdział 21. Metody pomocnicze URL i Ajax ............................................................................543 Przegląd i przygotowanie projektu .................................................................................................. 543 Tworzenie podstawowych łączy i adresów URL ........................................................................... 545 Nieprzeszkadzający Ajax .................................................................................................................. 547 Tworzenie widoku formularza synchronicznego .................................................................. 547 Włączanie i wyłączanie nieprzeszkadzających wywołań Ajax ............................................. 549 Użycie nieprzeszkadzających formularzy Ajax ............................................................................. 550 Przygotowanie kontrolera ......................................................................................................... 550 Tworzenie formularza Ajax ....................................................................................................... 552 Sposób działania nieprzeszkadzających wywołań Ajax ........................................................ 553 Ustawianie opcji Ajax ........................................................................................................................ 554 Zapewnienie kontrolowanej degradacji .................................................................................. 554 Informowanie użytkownika o realizowanym żądaniu Ajax ................................................. 556 Wyświetlanie pytania przed wysłaniem żądania .................................................................... 557 Tworzenie łączy Ajax ........................................................................................................................ 558 Zapewnienie kontrolowanej degradacji dla łączy .................................................................. 559 Korzystanie z funkcji wywołania zwrotnego w Ajaksie ............................................................... 560 Wykorzystanie JSON ......................................................................................................................... 562 Dodanie obsługi JSON do kontrolera ...................................................................................... 562 Przetwarzanie JSON w przeglądarce ........................................................................................ 564 Przygotowanie danych do kodowania ..................................................................................... 565 Wykrywanie żądań Ajax w metodach akcji ............................................................................ 567 Podsumowanie ................................................................................................................................... 570 Rozdział 22. Dołączanie modelu ..............................................................................................571 Przygotowanie projektu .................................................................................................................... 571 Użycie dołączania modelu ................................................................................................................ 573 Użycie domyślnego łącznika modelu .............................................................................................. 575 Dołączanie typów prostych ....................................................................................................... 575 Dołączanie typów złożonych ..................................................................................................... 578 Dołączanie tablic i kolekcji ........................................................................................................ 584 Jawne wywoływanie dołączania modelu ........................................................................................ 589 Obsługa błędów dołączania modelu ........................................................................................ 590 Dostosowanie systemu dołączania modelu ................................................................................... 591 Tworzenie własnego dostawcy wartości .................................................................................. 591 Tworzenie własnego łącznika modelu ..................................................................................... 594 Rejestracja własnego łącznika modelu ..................................................................................... 596 Podsumowanie ................................................................................................................................... 597 Rozdział 23. Kontrola poprawności modelu ............................................................................599 Tworzenie projektu ........................................................................................................................... 599 Jawna kontrola poprawności modelu ............................................................................................. 602 Wyświetlenie użytkownikowi błędów podczas kontroli poprawności ............................... 603 13 Kup książkęPoleć książkę SPIS TREŚCI Wyświetlanie komunikatów kontroli poprawności ..................................................................... 604 Wyświetlanie komunikatów kontroli poprawności poziomu właściwości ........................ 608 Użycie alternatywnych technik kontroli poprawności ................................................................. 608 Kontrola poprawności w łączniku modelu ............................................................................. 609 Definiowanie zasad poprawności za pomocą metadanych .................................................. 610 Definiowanie modeli samokontrolujących się ....................................................................... 616 Użycie kontroli poprawności po stronie klienta ........................................................................... 618 Aktywowanie i wyłączanie kontroli poprawności po stronie klienta ................................. 618 Użycie kontroli poprawności po stronie klienta .................................................................... 619 Jak działa kontrola poprawności po stronie klienta? ............................................................. 620 Wykonywanie zdalnej kontroli poprawności ................................................................................ 621 Podsumowanie ................................................................................................................................... 624 Rozdział 24. Paczki i tryby wyświetlania .................................................................................625 Domyślne biblioteki skryptów ......................................................................................................... 625 Tworzenie przykładowej aplikacji ................................................................................................... 627 Zarządzanie skryptami i stylami ...................................................................................................... 630 Profilowanie wczytywania skryptów i arkuszy stylów .......................................................... 630 Używanie paczek stylów i skryptów ................................................................................................ 632 Stosowanie paczek ...................................................................................................................... 635 Używanie sekcji script ................................................................................................................ 637 Profilowanie wprowadzonych zmian ...................................................................................... 638 Przygotowanie aplikacji dla urządzeń mobilnych ........................................................................ 640 Aplikacja standardowa ............................................................................................................... 641 Użycie widoków i układów przeznaczonych dla urządzeń mobilnych .............................. 642 Tworzenie własnych trybów wyświetlania .............................................................................. 643 Podsumowanie ................................................................................................................................... 646 Rozdział 25. Web API ...............................................................................................................647 Zrozumienie Web API ...................................................................................................................... 647 Tworzenie aplikacji Web API .......................................................................................................... 648 Tworzenie modelu i repozytorium .......................................................................................... 648 Tworzenie kontrolera Home ..................................................................................................... 650 Utworzenie widoku i CSS .......................................................................................................... 651 Tworzenie kontrolera API ................................................................................................................ 653 Testowanie kontrolera API ....................................................................................................... 655 Jak działa kontroler API? .................................................................................................................. 656 Jak wybierana jest akcja kontrolera API? ................................................................................ 657 Mapowanie metod HTTP na metody akcji ............................................................................. 657 Tworzenie kodu JavaScript wykorzystującego interfejs Web API ............................................. 658 Tworzenie funkcji podstawowych ............................................................................................ 659 Dodanie obsługi edycji nowych rezerwacji ............................................................................. 661 Dodanie obsługi usuwania rezerwacji ..................................................................................... 663 Dodanie obsługi tworzenia rezerwacji ..................................................................................... 664 Podsumowanie ................................................................................................................................... 665 Rozdział 26. Wdrażanie aplikacji .............................................................................................667 Przygotowanie aplikacji do dystrybucji .......................................................................................... 668 Wykrywanie błędów widoku .................................................................................................... 668 Wyłączanie trybu debugowania ................................................................................................ 670 Usunięcie nieużywanych ciągów tekstowych połączenia ..................................................... 670 14 Kup książkęPoleć książkę SPIS TREŚCI Przygotowanie do użycia Windows Azure .................................................................................... 671 Tworzenie witryny internetowej i bazy danych ..................................................................... 672 Przygotowanie bazy danych do zdalnej administracji .......................................................... 674 Tworzenie schematu bazy danych ........................................................................................... 674 Wdrażanie aplikacji ........................................................................................................................... 676 Podsumowanie ................................................................................................................................... 680 Skorowidz ............................................................................................................681 15 Kup książkęPoleć książkę SPIS TREŚCI 16 Kup książkęPoleć książkę R O Z D Z I A ’ 1 3 . „ „ „ Routing URL Przed wprowadzeniem platformy MVC założono w ASP.NET, że istnieje bezpośrednia relacja pomiędzy adresem URL żądania a plikiem na dysku serwera. Zadaniem serwera było odczytanie żądania wysłanego przez przeglądarkę i dostarczenie wyniku z odpowiedniego pliku. ¿Èdany URL http://witryna.pl/default.aspx http://witryna.pl/admin/login.aspx http://witryna.pl/articles/AnnualReview OdpowiadajÈcy mu plik e:webrootdefault.aspx e:webrootadminlogin.aspx Plik nie został znaleziony! Wygeneruj błąd 404. Podejście to działa świetnie dla Web Forms, gdzie każda strona ASPX jest plikiem i zawiera odpowiedź na żądanie. Nie ma to sensu dla aplikacji MVC, w których żądania są przetwarzane przez metody akcji w klasach kontrolera i nie ma bezpośredniej korelacji z plikami na dysku. Aby obsługiwać adresy URL MVC, platforma ASP.NET korzysta z systemu routingu. W tym rozdziale pokażę, jak konfigurować i wykorzystywać routing w celu utworzenia zaawansowanego i elastycznego systemu obsługi adresów URL dla naszych projektów. Jak się przekonasz, system routingu oferuje możliwość tworzenia dowolnych wzorców URL i opisywania ich w jasny i spójny sposób. System routingu ma dwie funkcje: x Analiza przychodzącego żądania URL i określenie kontrolera i akcji przeznaczonych dla tego żądania. Jak można się spodziewać, jest to oczekiwana akcja w przypadku otrzymania żądania klienta. x Generowanie wychodzących adresów URL. Są to adresy URL pojawiające się w stronach HTML generowanych na podstawie naszych widoków, dzięki czemu po kliknięciu łącza przez użytkownika generowane są odpowiednie akcje (i stają się ponownie przychodzącymi żądaniami URL). W pierwszej części tego rozdziału skupimy się na definiowaniu ścieżek i korzystaniu z nich do przetwarzania przychodzących adresów URL, dzięki którym użytkownik wywołuje nasze kontrolery i akcje. Następnie pokażę, w jaki sposób korzystać z tych samych ścieżek do wygenerowania wychodzących adresów URL, które musimy dołączać do widoków. Dowiesz się również, jak system routingu dostosować do własnych potrzeb i jak używać funkcji o nazwie obszary. Kup książkęPoleć książkę CZ}¥m II „ ASP.NET MVC 4 — SZCZEGӒOWY OPIS Tworzenie projektu routingu Aby zademonstrować działanie systemu routingu, potrzebujemy projektu, w którym możemy dodawać ścieżki. Na potrzeby tego rozdziału tworzymy aplikację MVC z wykorzystaniem szablonu Podstawowe i nadajemy jej nazwę UrlsAndRoutes. „ Wskazówka W tym rozdziale znajdziesz wiele róĝnych testów jednostkowych. Jeĝeli chcesz je wykorzystaÊ, to podczas tworzenia nowego projektu musisz zaznaczyÊ pole wyboru Utwórz projekt testu jednostki, a nastÚpnie uĝyÊ me
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

ASP.NET MVC 4. Zaawansowane programowanie
Autor:
,

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ą: