ASP.NET MVC 5. Zaawansowane programowanie

ASP.NET MVC 5. Zaawansowane programowanie

Autorzy: Adam Freeman

Wydawnictwo: Helion

Kategorie: Informatyka

Typ: e-book

Formaty: PDF MOBI EPUB

Ilość stron: 744

Cena książki papierowej: 99.00 zł

cena od: 119.00 zł

Rozpocznij tworzenie łatwych w obsłudze, zgodnych ze standardami oraz oferujących najlepszą wydajność aplikacji sieciowych na platformie opracowanej przez Microsoft

Platforma ASP.NET MVC powstała jako alternatywa dla ASP.NET Web Forms. Dzięki zastosowaniu architektury model-widok-kontroler (ang. Model View Controller) tworzony kod jest przejrzysty oraz zdecydowanie łatwiejszy w utrzymaniu. Ciągły rozwój tej platformy zaowocował wydaniem kolejnej wersji, oznaczonej numerem 5. Dzięki zawartym tu nowościom stworzysz jeszcze lepszy kod w krótszym czasie. Przekonaj się sam!

Niniejsze wydanie tej cenionej przez programistów książki zostało rozszerzone o nowości wprowadzone na platformie ASP.NET MVC 5. Wśród nich znajdziesz opisy sposobu definiowania tras za pomocą atrybutów C# oraz metody nadpisywania filtrów. Odkryjesz tu również omówienia biblioteki Bootstrap (dzięki czemu programiści otrzymują szeroką gamę wieloplatformowych opcji w zakresie tworzenia CSS i HTML5) oraz możliwości zintegrowanego środowiska programistycznego Visual Studio 2013. Ponadto dowiesz się, jak zabezpieczać poszczególne obszary aplikacji, w jaki sposób korzystać z filtrów lub routingu oraz jak obsługiwać żądania AJAX. Ta książka jest kompletnym przewodnikiem po platformie ASP.NET MVC 5. Musisz ją mieć!

Dzięki tej książce:

  • poznasz nowości wprowadzone w wersji 5 platformy ASP.NET MVC
  • poznasz architekturę MVC i z jej pomocą zbudujesz aplikację
  • zaznajomisz się z nową wersją środowiska programistycznego Visual Studio 2013
  • zdobędziesz dogłębną wiedzę o ASP.NET MVC5

Lektura obowiązkowa każdego programisty!

Adam Freeman — specjalista z branży IT o ogromnym doświadczeniu. Przez wiele lat zajmował stanowiska kierownicze. Obecnie jest dyrektorem ds. technologii oraz dyrektorem naczelnym w międzynarodowym banku. Pisze książki i jest zapalonym biegaczem.

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

Tłumaczenie: Robert Górczyński

ISBN: 978-83-283-0651-6

Original edition copyright © 2013 by Adam Freeman.

All rights reserved.

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

Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce.

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/asp5zp.zip

Drogi Czytelniku!

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

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

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

Printed in Poland.

• Kup książkę

• Księgarnia internetowa

• Poleć książkę

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

• Oceń książkę

Spis treĂci

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

O recenzencie technicznym ....................................................................................18

Rozdziaï 1. ASP.NET MVC w szerszym kontekĂcie ....................................................................19

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

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

Programowanie witryn WWW — stan obecny .............................................................................. 21

Standardy sieciowe oraz REST .................................................................................................... 21

Programowanie zwinne i sterowane testami ............................................................................ 22

Ruby on Rails ................................................................................................................................. 22

Node.js ............................................................................................................................................ 22

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

Architektura MVC ........................................................................................................................ 23

Rozszerzalność .............................................................................................................................. 24

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

Łatwość testowania ....................................................................................................................... 24

Zaawansowany system routingu ................................................................................................ 25

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

Nowoczesne API ........................................................................................................................... 26

ASP.NET MVC jest open source ................................................................................................ 26

Co powinienem wiedzieć? .................................................................................................................. 26

Jaka jest struktura książki? .................................................................................................................. 27

Część I. Wprowadzenie do ASP.NET MVC 5 .......................................................................... 27

Część II. Szczegółowe omówienie platformy ASP.NET MVC ............................................... 27

Co nowego w ASP.NET MVC 5? ...................................................................................................... 27

Gdzie znajdę przykładowe fragmenty kodu? ................................................................................... 28

Jakiego oprogramowania będę potrzebował? .................................................................................. 28

Bootstrap ............................................................................................................................................... 29

Podsumowanie ..................................................................................................................................... 29

Kup książkę

Poleć książkę

SPIS TRE¥CI

Rozdziaï 2. Pierwsza aplikacja MVC .........................................................................................31

Przygotowanie Visual Studio ............................................................................................................. 31

Tworzenie nowego projektu ASP.NET MVC ................................................................................. 31

Dodawanie pierwszego kontrolera ............................................................................................. 34

Poznajemy trasy ............................................................................................................................ 37

Generowanie stron WWW ................................................................................................................ 37

Tworzenie i generowanie widoku .............................................................................................. 37

Dynamiczne dodawanie treści .................................................................................................... 41

Tworzenie prostej aplikacji wprowadzania danych ........................................................................ 42

Przygotowanie sceny .................................................................................................................... 42

Projektowanie modelu danych ................................................................................................... 43

Łączenie metod akcji .................................................................................................................... 44

Budowanie formularza ................................................................................................................. 47

Zdefiniowanie początkowego adresu URL ............................................................................... 49

Obsługa formularzy ...................................................................................................................... 50

Dodanie kontroli poprawności ................................................................................................... 53

Nadanie stylu zawartości ............................................................................................................. 58

Kończymy przykład ...................................................................................................................... 63

Podsumowanie ..................................................................................................................................... 64

Rozdziaï 3. Wzorzec MVC .........................................................................................................65

Historia MVC ....................................................................................................................................... 65

Wprowadzenie do wzorca MVC ....................................................................................................... 66

Budowa modelu domeny ............................................................................................................. 66

Implementacja MVC w ASP.NET .............................................................................................. 67

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

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

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

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

Zaczynamy testy automatyczne ......................................................................................................... 74

Zadania testów jednostkowych ................................................................................................... 74

Zadania testów integracyjnych ................................................................................................... 79

Podsumowanie ..................................................................................................................................... 79

Rozdziaï 4. Najwaĝniejsze cechy jÚzyka ...................................................................................81

Utworzenie przykładowego projektu ................................................................................................ 81

Dodanie podzespołu System.Net.Http ...................................................................................... 83

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

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

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

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

Tworzenie filtrujących metod rozszerzających ........................................................................ 92

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

Automatyczna inferencja typów ........................................................................................................ 97

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

Wykonywanie zapytań LINQ ............................................................................................................ 98

Opóźnione zapytania LINQ ...................................................................................................... 102

Użycie metod asynchronicznych ..................................................................................................... 103

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

Podsumowanie ................................................................................................................................... 106

6

Kup książkę

Poleć książkę

SPIS TRE¥CI

Rozdziaï 5. Praca z silnikiem Razor ........................................................................................107

Utworzenie przykładowego projektu .............................................................................................. 107

Definiowanie modelu ................................................................................................................. 108

Definiowanie kontrolera ............................................................................................................ 108

Tworzenie widoku ...................................................................................................................... 109

Korzystanie z obiektów modelu ...................................................................................................... 109

Praca z układami ................................................................................................................................ 111

Tworzenie układu ....................................................................................................................... 112

Stosowanie układu ...................................................................................................................... 113

Użycie pliku ViewStart ............................................................................................................... 114

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

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

Wstawianie wartości danych ..................................................................................................... 119

Przypisanie wartości atrybutu ................................................................................................... 121

Użycie konstrukcji warunkowych ............................................................................................ 123

Wyświetlanie zawartości tablic i kolekcji ................................................................................ 125

Praca z przestrzenią nazw .......................................................................................................... 127

Podsumowanie ................................................................................................................................... 128

Rozdziaï 6. Waĝne narzÚdzia wspierajÈce MVC .....................................................................129

Tworzenie przykładowego projektu ............................................................................................... 130

Utworzenie klas modelu ............................................................................................................ 130

Dodanie kontrolera .................................................................................................................... 132

Dodanie widoku .......................................................................................................................... 132

Użycie Ninject .................................................................................................................................... 133

Zrozumienie problemu .............................................................................................................. 133

Dodawanie Ninject do projektu Visual Studio ....................................................................... 135

Zaczynamy korzystać z Ninject ................................................................................................ 136

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

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

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

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

Ustawienie obiektu zakresu ....................................................................................................... 144

Testy jednostkowe w Visual Studio ................................................................................................. 147

Tworzenie projektu testów jednostkowych ............................................................................ 147

Tworzenie testów jednostkowych ............................................................................................ 148

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

Implementacja funkcji ............................................................................................................... 152

Testowanie i poprawianie kodu ................................................................................................ 153

Użycie Moq ......................................................................................................................................... 155

Zrozumienie problemu .............................................................................................................. 155

Dodawanie Moq do projektu Visual Studio ........................................................................... 157

Dodanie obiektu imitacyjnego do testu jednostkowego ....................................................... 157

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

Podsumowanie ................................................................................................................................... 162

7

Kup książkę

Poleć książkę

SPIS TRE¥CI

Rozdziaï 7. SportsStore — kompletna aplikacja ....................................................................163

Zaczynamy .......................................................................................................................................... 164

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

Instalacja pakietów narzędziowych .......................................................................................... 166

Dodawanie odwołań między projektami ................................................................................ 166

Konfigurowanie kontenera DI .................................................................................................. 167

Uruchamiamy aplikację ............................................................................................................. 168

Tworzenie modelu domeny ............................................................................................................. 168

Tworzenie abstrakcyjnego repozytorium ................................................................................ 169

Tworzenie imitacji repozytorium ............................................................................................. 169

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

Dodawanie kontrolera ............................................................................................................... 171

Dodawanie układu, pliku ViewStart i widoku ........................................................................ 172

Konfigurowanie domyślnej trasy .............................................................................................. 173

Uruchamianie aplikacji .............................................................................................................. 174

Przygotowanie bazy danych ............................................................................................................. 175

Tworzenie bazy danych ............................................................................................................. 176

Definiowanie schematu bazy danych ...................................................................................... 177

Dodawanie danych do bazy ....................................................................................................... 179

Tworzenie kontekstu Entity Framework ................................................................................. 180

Tworzenie repozytorium produktów ...................................................................................... 182

Dodanie stronicowania ..................................................................................................................... 184

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

Ulepszanie adresów URL ........................................................................................................... 193

Dodawanie stylu ................................................................................................................................. 194

Instalacja pakietu Bootstrap ...................................................................................................... 194

Zastosowanie w aplikacji stylów Bootstrap ............................................................................. 195

Tworzenie widoku częściowego ............................................................................................... 196

Podsumowanie ................................................................................................................................... 199

Rozdziaï 8. SportsStore — nawigacja ....................................................................................201

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

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

Ulepszanie schematu URL ......................................................................................................... 205

Budowanie menu nawigacji po kategoriach ........................................................................... 208

Poprawianie licznika stron ........................................................................................................ 213

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

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

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

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

Wyświetlanie zawartości koszyka ............................................................................................. 223

Podsumowanie ................................................................................................................................... 226

Rozdziaï 9. SportsStore — ukoñczenie koszyka na zakupy ....................................................227

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

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

Kończenie budowania koszyka ........................................................................................................ 231

Usuwanie produktów z koszyka ............................................................................................... 232

Dodawanie podsumowania koszyka ........................................................................................ 233

8

Kup książkę

Poleć książkę

SPIS TRE¥CI

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

Rozszerzanie modelu domeny .................................................................................................. 236

Dodawanie procesu składania zamówienia ............................................................................ 236

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

Rejestrowanie implementacji .................................................................................................... 244

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

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

Wyświetlanie strony podsumowania ....................................................................................... 251

Podsumowanie ................................................................................................................................... 252

Rozdziaï 10. SportsStore — wersja mobilna ..............................................................................253

Kontekst programowania sieciowego dla urządzeń mobilnych ................................................. 253

Odstąpienie od działania (lub jego podjęcie na minimalnym możliwym poziomie) ....... 254

Użycie układu responsywnego ........................................................................................................ 255

Utworzenie responsywnego nagłówka .................................................................................... 256

Tworzenie responsywnej listy produktów .............................................................................. 260

Utworzenie zawartości specjalnie dla urządzeń mobilnych ........................................................ 267

Utworzenie układu dla urządzeń mobilnych .......................................................................... 268

Utworzenie widoków dla urządzeń mobilnych ...................................................................... 269

Podsumowanie ................................................................................................................................... 272

Rozdziaï 11. SportsStore — administracja ...............................................................................275

Dodajemy zarządzanie katalogiem .................................................................................................. 275

Tworzenie kontrolera CRUD .................................................................................................... 276

Tworzenie nowego pliku układu .............................................................................................. 277

Implementowanie widoku listy ................................................................................................ 278

Edycja produktów ....................................................................................................................... 282

Tworzenie nowych produktów ................................................................................................. 295

Usuwanie produktów ................................................................................................................. 298

Podsumowanie ................................................................................................................................... 301

Rozdziaï 12. SportsStore — bezpieczeñstwo i ostatnie usprawnienia .....................................303

Zabezpieczanie kontrolera administracyjnego .............................................................................. 303

Zdefiniowanie prostej polityki bezpieczeństwa ...................................................................... 303

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

Tworzenie dostawcy uwierzytelniania ..................................................................................... 306

Tworzenie kontrolera AccountController .............................................................................. 308

Tworzenie widoku ...................................................................................................................... 309

Przesyłanie zdjęć ................................................................................................................................ 312

Rozszerzanie bazy danych ......................................................................................................... 312

Rozszerzanie modelu domeny .................................................................................................. 313

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

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

Implementowanie metody akcji GetImage ............................................................................. 317

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

Podsumowanie ................................................................................................................................... 322

9

Kup książkę

Poleć książkę

SPIS TRE¥CI

Rozdziaï 13. Wdraĝanie aplikacji .............................................................................................323

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

Tworzenie witryny internetowej i bazy danych ..................................................................... 324

Przygotowanie bazy danych do zdalnej administracji .......................................................... 325

Tworzenie schematu bazy danych ........................................................................................... 326

Wdrażanie aplikacji ........................................................................................................................... 328

Podsumowanie ................................................................................................................................... 332

Rozdziaï 14. PrzeglÈd projektu MVC ........................................................................................333

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

Tworzenie projektu .................................................................................................................... 334

Przedstawienie konwencji MVC .............................................................................................. 337

Debugowanie aplikacji MVC ........................................................................................................... 338

Tworzenie przykładowego projektu ........................................................................................ 338

Uruchamianie debugera Visual Studio .................................................................................... 341

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

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

Użycie funkcji połączonych przeglądarek ...................................................................................... 350

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

Rozdziaï 15. Routing URL .........................................................................................................353

Utworzenie przykładowego projektu .............................................................................................. 353

Utworzenie przykładowych kontrolerów .............................................................................. 355

Utworzenie widoku .................................................................................................................... 356

Ustawienie początkowego adresu URL i przetestowanie aplikacji ...................................... 356

Wprowadzenie do wzorców URL ................................................................................................... 357

Tworzenie i rejestrowanie prostej trasy .......................................................................................... 358

Użycie prostej trasy ................................................................................................................... 363

Definiowanie wartości domyślnych ................................................................................................ 363

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

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

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

Definiowanie opcjonalnych segmentów URL ........................................................................ 373

Definiowanie tras o zmiennej długości ................................................................................... 375

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

Ograniczenia tras ............................................................................................................................... 380

Ograniczanie trasy z użyciem wyrażeń regularnych ............................................................. 380

Ograniczanie trasy do zbioru wartości .................................................................................... 381

Ograniczanie tras z użyciem metod HTTP ............................................................................. 381

Użycie ograniczeń dotyczących typu i wartości ..................................................................... 383

Definiowanie własnych ograniczeń ......................................................................................... 385

Użycie atrybutów routingu .............................................................................................................. 387

Włączanie i stosowanie atrybutów routingu .......................................................................... 387

Tworzenie tras za pomocą zmiennych segmentu .................................................................. 389

Zastosowanie ograniczeń trasy ................................................................................................. 390

Użycie prefiksu trasy .................................................................................................................. 392

Podsumowanie ................................................................................................................................... 393

10

Kup książkę

Poleć książkę

SPIS TRE¥CI

Rozdziaï 16. Zaawansowane funkcje routingu ........................................................................395

Utworzenie przykładowego projektu .............................................................................................. 396

Uproszczenie tras ........................................................................................................................ 396

Dodanie pakietu optymalizacyjnego ........................................................................................ 396

Uaktualnienie projektu testów jednostkowych ...................................................................... 397

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

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

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

Przekazywanie dodatkowych parametrów .............................................................................. 401

Definiowanie atrybutów HTML ............................................................................................... 403

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

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

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

Generowanie adresu URL na podstawie wybranej trasy ...................................................... 407

Dostosowanie systemu routingu ..................................................................................................... 408

Tworzenie własnej implementacji RouteBase ........................................................................ 408

Tworzenie własnego obiektu obsługi trasy ............................................................................. 412

Korzystanie z obszarów .................................................................................................................... 414

Tworzenie obszaru ...................................................................................................................... 414

Wypełnianie obszaru .................................................................................................................. 416

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

Tworzenie obszarów za pomocą atrybutów ........................................................................... 418

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

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

Konfiguracja serwera aplikacji .................................................................................................. 421

Definiowanie tras dla plików na dysku .................................................................................... 422

Pomijanie systemu routingu ............................................................................................................ 424

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

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

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

Podsumowanie ................................................................................................................................... 426

Rozdziaï 17. Kontrolery i akcje .................................................................................................427

Utworzenie przykładowego projektu .............................................................................................. 428

Ustawienie początkowego adresu URL ................................................................................... 428

Wprowadzenie do kontrolerów ....................................................................................................... 428

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

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

Odczytywanie danych wejściowych ................................................................................................ 432

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

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

Tworzenie danych wyjściowych ...................................................................................................... 435

Wyniki akcji ................................................................................................................................. 436

Zwracanie kodu HTML przez generowanie widoku ............................................................. 440

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

Wykonywanie przekierowań .................................................................................................... 447

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

Podsumowanie ................................................................................................................................... 453

11

Kup książkę

Poleć książkę

SPIS TRE¥CI

Rozdziaï 18. Filtry ....................................................................................................................455

Utworzenie przykładowego projektu .............................................................................................. 456

Ustawienie początkowego adresu URL i przetestowanie aplikacji ...................................... 458

Użycie filtrów ..................................................................................................................................... 458

Wprowadzenie do podstawowych typów filtrów ................................................................... 459

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

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

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

Użycie wbudowanego filtra autoryzacji .................................................................................. 463

Użycie filtrów uwierzytelniania ....................................................................................................... 464

Interfejs IAuthenticationFilter .................................................................................................. 464

Implementacja sprawdzenia uwierzytelniania ....................................................................... 466

Połączenie filtrów uwierzytelniania i autoryzacji .................................................................. 468

Obsługa ostatniego uwierzytelnienia w żądaniu .................................................................... 469

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

Tworzenie filtra wyjątku ............................................................................................................ 470

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

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

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

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

Implementacja metody OnActionExecuting .......................................................................... 479

Implementacja metody OnActionExecuted ........................................................................... 481

Używanie filtra wyniku ..................................................................................................................... 482

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

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

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

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

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

Nadpisywanie filtrów ................................................................................................................. 491

Podsumowanie ................................................................................................................................... 494

Rozdziaï 19. Rozszerzanie kontrolerów ....................................................................................495

Utworzenie przykładowego projektu .............................................................................................. 496

Ustawienie początkowego adresu URL ................................................................................... 498

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

Przygotowanie kontrolera zapasowego ................................................................................... 500

Utworzenie klasy kontrolera ..................................................................................................... 500

Implementacja innych metod interfejsu ................................................................................. 501

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

Wykorzystanie wbudowanej fabryki kontrolerów ........................................................................ 502

Nadawanie priorytetów przestrzeniom nazw ......................................................................... 502

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

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

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

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

Selekcja metod akcji .................................................................................................................... 509

12

Kup książkę

Poleć książkę

SPIS TRE¥CI

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

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

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

Podsumowanie ................................................................................................................................... 521

Rozdziaï 20. Widoki .................................................................................................................523

Tworzenie własnego silnika widoku ............................................................................................... 523

Tworzenie przykładowego projektu ........................................................................................ 526

Tworzenie własnej implementacji IView ................................................................................ 527

Tworzenie implementacji IViewEngine .................................................................................. 528

Rejestrowanie własnego silnika widoku .................................................................................. 529

Testowanie silnika widoku ........................................................................................................ 529

Korzystanie z silnika Razor .............................................................................................................. 531

Tworzenie przykładowego projektu ........................................................................................ 531

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

Konfigurowanie wyszukiwania lokalizacji widoków ............................................................. 533

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

Zastosowanie sekcji układu ....................................................................................................... 536

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

Użycie akcji potomnych ............................................................................................................. 544

Podsumowanie ................................................................................................................................... 546

Rozdziaï 21. Metody pomocnicze ............................................................................................547

Tworzenie przykładowego projektu ................................................................................................. 548

Ustawienie początkowego adresu URL ................................................................................... 549

Przetestowanie aplikacji ............................................................................................................. 549

Tworzenie własnej metody pomocniczej ....................................................................................... 549

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

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

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

Użycie wbudowanych metod pomocniczych ................................................................................ 559

Przygotowania do obsługi formularzy ..................................................................................... 559

Określenie trasy używanej przez formularz ............................................................................ 565

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

Tworzenie znaczników select .................................................................................................... 571

Podsumowanie ................................................................................................................................... 573

Rozdziaï 22. Szablonowe metody pomocnicze ........................................................................575

Przygotowanie przykładowego projektu ........................................................................................ 576

Używanie szablonowych metod pomocniczych ............................................................................ 578

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

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

Użycie metadanych modelu ............................................................................................................. 586

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

Użycie metadanych dla etykiet ................................................................................................. 589

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

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

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

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

13

Kup książkę

Poleć książkę

SPIS TRE¥CI

Dostosowywanie systemu szablonowych metod pomocniczych ................................................ 596

Tworzenie własnego szablonu edytora .................................................................................... 596

Tworzenie szablonu ogólnego .................................................................................................. 597

Zastępowanie szablonów wbudowanych ................................................................................ 599

Podsumowanie ................................................................................................................................... 599

Rozdziaï 23. Metody pomocnicze URL i Ajax ............................................................................601

Przygotowanie przykładowego projektu ........................................................................................ 602

Definiowanie dodatkowych stylów CSS .................................................................................. 603

Instalacja pakietów NuGet ........................................................................................................ 603

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

Nieprzeszkadzający Ajax .................................................................................................................. 605

Tworzenie widoku formularza synchronicznego .................................................................. 606

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

Utworzenie nieprzeszkadzających formularzy Ajax ..................................................................... 608

Przygotowanie kontrolera ......................................................................................................... 608

Tworzenie formularza Ajax ....................................................................................................... 610

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

Ustawianie opcji Ajax ........................................................................................................................ 612

Zapewnienie kontrolowanej degradacji .................................................................................. 612

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

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

Tworzenie łączy Ajax ........................................................................................................................ 616

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

Korzystanie z funkcji wywołania zwrotnego w technologii Ajax ............................................... 618

Wykorzystanie JSON ......................................................................................................................... 621

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

Przetwarzanie JSON w przeglądarce ........................................................................................ 622

Przygotowanie danych do kodowania ..................................................................................... 624

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

Podsumowanie ................................................................................................................................... 628

Rozdziaï 24. DoïÈczanie modelu ..............................................................................................629

Przygotowanie przykładowego projektu ........................................................................................ 630

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

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

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

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

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

Ręczne wywoływanie dołączania modelu ...................................................................................... 648

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

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

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

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

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

Podsumowanie ................................................................................................................................... 656

14

Kup książkę

Poleć książkę

SPIS TRE¥CI

Rozdziaï 25. Kontrola poprawnoĂci modelu ............................................................................657

Utworzenie przykładowego projektu .............................................................................................. 658

Utworzenie układu ..................................................................................................................... 659

Utworzenie widoków ................................................................................................................. 660

Jawna kontrola poprawności modelu ............................................................................................. 661

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

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

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

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

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

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

Definiowanie modeli automatycznie przeprowadzających kontrolę .................................. 675

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

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

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

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

Wykonywanie zdalnej kontroli poprawności ................................................................................ 681

Podsumowanie ................................................................................................................................... 684

Rozdziaï 26. Paczki ..................................................................................................................685

Utworzenie przykładowego projektu .............................................................................................. 685

Dodanie pakietów NuGet .......................................................................................................... 685

Utworzenie modelu i kontrolera .............................................................................................. 686

Utworzenie układu i widoku ..................................................................................................... 687

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

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

Dodanie pakietu NuGet ............................................................................................................. 691

Definiowanie paczki ................................................................................................................... 692

Stosowanie paczek ...................................................................................................................... 694

Optymalizacja plików JavaScript i CSS .................................................................................... 695

Podsumowanie ................................................................................................................................... 697

Rozdziaï 27. Web API i aplikacje w postaci pojedynczej strony ...............................................699

Aplikacja w postaci pojedynczej strony .......................................................................................... 700

Utworzenie przykładowego projektu .............................................................................................. 700

Tworzenie modelu ...................................................................................................................... 701

Dodanie pakietów NuGet .......................................................................................................... 702

Tworzenie kontrolera Home ..................................................................................................... 703

Dodanie układu i widoków ....................................................................................................... 703

Ustawienie początkowego adresu URL i przetestowanie aplikacji ..................................... 705

Zrozumienie Web API ...................................................................................................................... 706

Tworzenie kontrolera Web API ............................................................................................... 707

Testowanie kontrolera API ....................................................................................................... 707

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

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

Mapowanie metod HTTP na metody akcji ............................................................................. 711

15

Kup książkę

Poleć książkę

SPIS TRE¥CI

Użycie Knockout do utworzenia aplikacji typu SPA .................................................................... 712

Dodanie bibliotek JavaScript do układu .................................................................................. 712

Implementacja podsumowania ................................................................................................. 713

Implementacja funkcji tworzenia rezerwacji .......................................................................... 719

Ukończenie aplikacji ......................................................................................................................... 722

Uproszczenie kontrolera Home ................................................................................................ 722

Zarządzanie wyświetlaniem zawartości ................................................................................... 723

Podsumowanie ................................................................................................................................... 725

Skorowidz ............................................................................................................727

16

Kup książkę

Poleć książkę

R O Z D Z I A ’ 1 4 .

„ „ „

PrzeglÈd projektu MVC

Zanim zagłębię się w szczegółach funkcji platformy MVC, podam nieco informacji ogólnych. W tym rozdziale przedstawię strukturę i naturę aplikacji ASP.NET MVC, w tym domyślną strukturę projektu oraz konwencje nazewnictwa. Niektóre konwencje są opcjonalne, z kolei inne na sztywno definiują sposób, w jaki działa platforma MVC.

Korzystanie z projektów MVC z Visual Studio

Gdy tworzymy nowy projekt MVC, Visual Studio daje nam możliwość wyboru jednego z kilku punktów startowych. Celem jest ułatwienie procesu nauki nowym programistom, a także zastosowanie pewnych pozwalających na oszczędność czasu najlepszych praktyk podczas implementacji najczęściej używanych funkcji. Tego rodzaju wsparcie oferowane programistom ma postać szablonów wykorzystywanych do tworzenia kontrolerów i widoków przygotowywanych z użyciem kodu szablonu do wymiany obiektów danych, edycji właściwości modelu itd.

W Visual Studio 2013 oraz MVC 5 firma Microsoft uaktualniła szablony i tak zwane szkielety kodu, niwelując różnice między poszczególnymi rodzajami projektów ASP.NET. Ma to na celu dostarczenie szerszej gamy szablonów projektów oraz konfiguracji.

Po lekturze pierwszej części książki nie powinieneś mieć wątpliwości, że nie jestem fanem podejścia polegającego na użyciu szablonów projektów. Intencje Microsoftu są dobre, ale wykonanie pozostawia sporo do życzenia. Jedną z cech charakterystycznych, którą niezwykle cenię w platformach ASP.NET i MVC, jest ogromna elastyczność pozwalająca na dostosowanie platformy do preferowanego przez daną osobę stylu programowania. Tworzone i wypełniane kodem przez Visual Studio projekty, klasy i widoki sprawiają, że czuję się ograniczony i zmuszony do pracy w stylu zupełnie kogoś innego. Ponadto automatycznie generowana zawartość i konfiguracja wydają się być zbyt ogólne, aby stały się szczególnie użyteczne. W rozdziale 10.

wspomniałem, że jednym z niebezpieczeństw użycia układu responsywnego dla urządzeń mobilnych jest uzyskanie przeciętnego kodu, który jest dopasowany do jak największej liczby urządzeń. W podobny sposób można określić szablony Visual Studio. Microsoft nie wie, jakiego rodzaju aplikacje będziesz chciał tworzyć, i dlatego stara się zapewnić obsługę maksymalnej liczby scenariuszy. Wynik jest tak bezbarwny i uogólniony, że zawartość generowaną przez Visual Studio wyrzucam od razu na początku pracy z projektem.

Moja rada (udzielana każdemu, kto popełnia błąd, pytając o nią) brzmi: rozpoczynaj pracę z pustym projektem, a następnie dodawaj niezbędne katalogi, pliki i pakiety. Dzięki takiemu podejściu nie tylko lepiej poznasz sposób działania platformy MVC, ale również zachowasz pełną kontrolę nad zawartością aplikacji.

Moje osobiste preferencje nie muszą pasować do Twojego doświadczenia w zakresie programowania. Być może dostarczane przez Visual Studio szablony i szkielety kodu uznasz za dużo bardziej użyteczne, niż są dla mnie, zwłaszcza jeżeli dopiero zaczynasz programowanie na platformie ASP.NET i nie wykształciłeś jeszcze

Kup książkę

Poleć książkę

ASP.NET MVC 5. ZAAWANSOWANE PROGRAMOWANIE

swojego stylu programowania. Ponadto szablony projektów możesz uznać za użyteczny zasób i źródło idei.

Powinieneś jednak zachować ostrożność podczas dodawania funkcji do aplikacji, zanim dokładnie nie poznasz jej sposobu działania.

Tworzenie projektu

Kiedy po raz pierwszy tworzysz projekt MVC, do dyspozycji masz dwa punkty startowe: szablony Empty i MVC.

Nazwy szablonów są nieco mylące, ponieważ podstawowe katalogi i podzespoły niezbędne dla platformy MVC można dodać do każdego szablonu projektu. W tym celu należy zaznaczyć pole wyboru MVC w sekcji Dodaj foldery i podstawowe odwołania dla: okna dialogowego Nowy projekt, jak pokazano na rysunku 14.1.

W przypadku szablonu projektu MVC odpowiednia opcja jest zaznaczona domyślnie.

Rysunek 14.1. Wybór typu projektu, katalogów i podzespołów dla nowego projektu Faktyczna różnica polega na umieszczeniu dodatkowej zawartości w szablonie projektu MVC. W ten sposób, tworząc nowy projekt, programista otrzymuje prawdziwy punkt startowy, zawierający pewne domyślne kontrolery, widoki, konfigurację zabezpieczeń, popularne pakiety JavaScript i CSS (na przykład jQuery i Bootstrap), a układ jest oparty na bibliotece Bootstrap, dostarczającej motyw graficzny dla zawartości aplikacji. Z kolei szablon Empty zawiera po prostu podstawowe odwołania wymagane przez platformę MVC oraz najprostszą strukturę katalogów. Szablon MVC dodaje znaczną ilość różnego rodzaju kodu, a różnica między omawianymi szablonami jest wyraźnie widoczna na rysunku 14.2, który pokazuje zawartość dwóch nowo utworzonych projektów. Projekt po lewej stronie utworzono na podstawie szablonu Empty wraz z zaznaczonym polem wyboru MVC. Okna po prawej stronie pokazują zawartość projektu utworzonego na podstawie szablonu MVC. Aby zmieścić na stronie książki listę wszystkich plików, zawartość niektórych katalogów projektu musiałem otworzyć w oddzielnych oknach.

W przeciwnym razie cała lista nie zmieściłaby się na stronie książki.

Wprawdzie liczba dodatkowych plików umieszczanych w projekcie opartym na szablonie MVC może przerażać, ale nie jest tak źle. Część plików jest powiązana z mechanizmem uwierzytelniania, inne to pliki JavaScript i CSS dostarczane w postaci zarówno zwykłej, jak i zminimalizowanej. (Sposób użycia tych plików przedstawię w rozdziale 26.).

334

Kup książkę

Poleć książkę

ROZDZIA’ 14. „ PRZEGLkD PROJEKTU MVC

Rysunek 14.2. Początkowa zawartość domyślnie dodawana do projektów Empty i MVC

„ Wskazówka Podzespoïy Visual Studio sÈ przez szablon MVC tworzone za pomocÈ pakietów NuGet. Oznacza to, ĝe uĝyte pakiety moĝesz zobaczyÊ po wybraniu opcji NarzÚdzia/Menedĝer pakietów NuGet/ZarzÈdzaj pakietami NuGet dla rozwiÈzania…. To jednoczeĂnie wskazuje na moĝliwoĂÊ dodawania tych samych pakietów do dowolnego projektu, w tym takĝe utworzonego na podstawie szablonu Empty. (Takie rozwiÈzanie zastosowaïem w pierwszej czÚĂci ksiÈĝki).

Niezależnie od rodzaju, szablony pozwalają na tworzenie projektów o podobnej strukturze. Niektóre z elementów projektu mają specjalne role, wbudowane w ASP.NET lub platformę MVC. Inne są wynikiem konwencji nazewnictwa. Każdy z tych plików i katalogów został opisany w tabeli 14.1. Część plików może nie znajdować się w domyślnych projektach, ale zostaną omówione w dalszych rozdziałach.

335

Kup książkę

Poleć książkę

ASP.NET MVC 5. ZAAWANSOWANE PROGRAMOWANIE

Tabela 14.1. Podsumowanie elementów projektu MVC

Katalog lub plik

Opis

Uwagi

/App_Data

W katalogu tym umieszczamy prywatne dane,

IIS nie udostępnia zawartości tego

takie jak pliki XML lub bazy danych

katalogu.

wykorzystywane przez SQL Server Express,

SQLite bądź inne repozytoria plikowe.

/App_Start

Ten katalog zawiera pewne ustawienia

System routingu zostanie omówiony

początkowe projektu, między innymi

w rozdziałach 15. i 16., filtry

definicje tras, filtry oraz paczki plików.

w rozdziale 18., natomiast paczki

plików w rozdziale 26.

/Areas

Obszary umożliwiają partycjonowanie

Obszary zostaną omówione

ogromnej aplikacji na mniejsze fragmenty.

w rozdziale 15.

/bin

Umieszczane są tu skompilowane podzespoły

Nie zobaczysz katalogu bin w oknie

aplikacji MVC wraz z wszystkimi

Eksplorator rozwiązania, o ile nie

wykorzystywanymi podzespołami,

klikniesz przycisku Pokaż wszystkie

które nie znajdują się w GAC.

pliki. Ponieważ te pliki binarne

są generowane w czasie kompilacji,

nie powinieneś ich przechowywać

w systemie kontroli wersji.

/Content

Jest to katalog na statyczną treść, na przykład

Jest to konwencja, ale niewymagana.

pliki CSS oraz obrazy.

Statyczne dane można umieścić

w dowolnym odpowiadającym

nam miejscu projektu.

/Controllers

Znajdują się tu klasy kontrolerów.

Jest to konwencja. Klasy kontrolerów

można umieszczać w dowolnym

katalogu, ponieważ są kompilowane

do tego samego podzespołu.

/Models

Jest to miejsce na klasy modelu widoku oraz

Jest to konwencja. Klasy modelu

modelu domeny, choć oprócz najprostszych

można definiować w dowolnym

aplikacji lepiej jest definiować model domeny

katalogu projektu lub w osobnym

w dedykowanym projekcie, jak pokazałem

projekcie.

to w aplikacji SportsStore.

/Scripts

Jest to katalog przeznaczony na biblioteki

Jest to konwencja. Pliki skryptów

JavaScript dla naszej aplikacji.

można umieścić w dowolnej

lokalizacji, ponieważ są one innym

typem zawartości statycznej. Więcej

informacji na temat zarządzania

plikami skryptów znajdziesz

w rozdziale 26.

/Views

Katalog ten jest przeznaczony na widoki i widoki

Plik /Views/Web.config uniemożliwia

częściowe, zwykle grupowane w katalogach

udostępnianie zawartości tych

mających nazwy kontrolerów, z którymi

katalogów. Widoki są generowane

są skojarzone.

za pomocą metod akcji.

/Views/Shared

Katalog ten jest przeznaczony na pliki układów

i widoków, które nie są skojarzone z konkretnym

kontrolerem.

/Views/

To nie jest plik konfiguracyjny dla aplikacji.

Web.config

Zawiera on konfigurację wymaganą do tego,

aby widoki działały w ASP.NET, oraz blokuje

możliwość udostępniania widoków przez IIS.

Przestrzenie nazw są domyślnie importowane

do widoków.

336

Kup książkę

Poleć książkę

ROZDZIA’ 14. „ PRZEGLkD PROJEKTU MVC

Tabela 14.1. Podsumowanie elementów projektu MVC (ciąg dalszy)

Katalog lub plik

Opis

Uwagi

/Global.asax

Definiuje globalną klasę aplikacji ASP.NET.

Plik Global.asax ma w aplikacji

Jego klasa kodu ukrytego ( /Global.asax.cs) jest

MVC taką samą funkcję

miejscem, w którym rejestrujemy konfigurację

jak w aplikacji Web Forms.

routingu, jak również dodajemy kod, jaki

powinien wykonać się w czasie inicjalizacji

lub wyłączenia aplikacji albo w przypadku

wystąpienia nieobsłużonego wyjątku.

/Web.config

Jest to plik konfiguracyjny dla naszej aplikacji.

Plik Web.config ma w aplikacji MVC

taką samą funkcję jak w aplikacji

Web Forms.

Przedstawienie konwencji MVC

W projektach MVC występują dwa rodzaje konwencji. Pierwszy rodzaj to raczej sugestia na temat tego, w jaki sposób możemy tworzyć strukturę projektu. Jest to na przykład konwencja zachęcająca nas do umieszczenia wszystkich plików JavaScript w katalogu Scripts. Programiści MVC oczekują, że znajdą je w tym właśnie katalogu.

Menedżer pakietów NuGet również umieszcza w nim pliki JavaScript dołączane do projektu MVC.

Możemy jednak zmienić nazwę katalogu Scripts lub całkiem go usunąć i umieścić skrypty w dowolnym innym miejscu. Nie spowoduje to, że platforma MVC nie będzie w stanie uruchomić aplikacji.

Inny rodzaj konwencji wynika z zasady konwencja przed konfiguracją, która była jedną z przyczyn tak ogromnej popularności Ruby on Rails. Konwencja przed konfiguracją oznacza, że nie musimy jawnie konfigurować połączeń pomiędzy kontrolerami i ich widokami. Po prostu stosujemy określone konwencje nazewnictwa i wszystko działa bez zarzutu. W przypadku tego typu konwencji mamy mniejsze możliwości zmiany struktury projektu.

W kolejnych punktach przedstawimy konwencje stosowane zamiast konfiguracji.

„ Wskazówka Wszystkie konwencje mogÈ byÊ zmienione przez uĝycie wïasnego silnika widoku, co opiszÚ

w rozdziale 20., ale to nie jest ïatwe zadanie. W wiÚkszoĂci przypadków w projektach MVC bÚdziesz miaï jednak do czynienia z wymienionymi konwencjami.

Stosowanie konwencji dla klas kontrolerów

Klasa kontrolera musi kończyć się słowem Controller, np.: ProductsController, AdminController czy też HomeController. Odwołując się do kontrolera z poziomu projektu, na przykład podczas użycia metody pomocniczej HTML, podajemy pierwszą część nazwy (na przykład Product), a platforma MVC automatycznie doda Controller do nazwy i zacznie szukać klasy kontrolera.

„ Wskazówka Moĝna zmieniÊ to zachowanie przez utworzenie wïasnej implementacji interfejsu IControllerFactory, co opiszÚ w rozdziale 19.

Stosowanie konwencji dla widoków

Widoki i widoki częściowe powinny być umieszczone w katalogu /Views/nazwakontrolera. Na przykład widok skojarzony z klasą ProductController powinien znajdować się w katalogu /Views/Product.

„ Wskazówka ZwróÊ uwagÚ, ĝe pomijamy drugÈ czÚĂÊ nazwy klasy w podkatalogu Views; uĝywamy katalogu

/Views/Product, a nie /Views/ProductController. Moĝe Ci siÚ to wydawaÊ na poczÈtku maïo intuicyjne, ale szybko stanie siÚ TwojÈ drugÈ naturÈ.

337

Kup książkę

Poleć książkę

ASP.NET MVC 5. ZAAWANSOWANE PROGRAMOWANIE

Platforma MVC oczekuje, że domyślny widok dla metody akcji powinien nosić nazwę tej metody. Na przykład widok skojarzony z metodą akcji List powinien mieć nazwę List.cshtml. Dlatego domyślny widok dla metody akcji List z klasy ProductController powinien znajdować się w /Views/Product/List.cshtml. Domyślny widok jest używany, gdy z metody akcji zwrócimy wynik wywołania metody View, na przykład:

...

return View();

...

Możemy również podać nazwę innego widoku, na przykład:

...

return View("InnyWidok");

...

Zwróć uwagę, że nie podajemy rozszerzenia nazwy pliku ani ścieżki dostępu do widoku. Platforma MVC

szuka widoku w katalogu o nazwie kontrolera, a następnie w katalogu /Views/Shared. Dlatego widoki stosowane przez więcej niż jeden kontroler możemy umieścić w katalogu /Views/Shared; platforma znajdzie je w razie potrzeby ich użycia.

Stosowanie konwencji dla układów

Konwencją nazewnictwa dla układów jest poprzedzanie ich nazw znakiem podkreślenia. Pliki układów są umieszczane w katalogu /Views/Shared. Visual Studio tworzy plik układu o nazwie _Layout.cshtml, który wchodzi w skład wszystkich szablonów projektów poza Pusta. Układ ten jest stosowany domyślnie do wszystkich widoków poprzez plik /Views/_ViewStart.cshtml. Jeżeli nie chcesz, aby domyślny widok był

stosowany do widoku, możesz zmienić ustawienie w pliku _ViewStart.cshtml, definiując w nim inny plik układu (lub usuwając ten plik).

@{

Layout = "~/Views/Shared/_MyLayout.cshtml";

}

Można również zablokować wszystkie układy dla pojedynczego widoku:

@{

Layout = null;

}

Debugowanie aplikacji MVC

Aplikację ASP.NET MVC można debugować dokładnie tak samo jak aplikację ASP.NET Web Forms. Debuger w Visual Studio jest niezwykle zaawansowanym i elastycznym narzędziem, które ma wiele funkcji i zastosowań.

W książce tej przedstawię jedynie kilka podstawowych funkcji. Pokażę, jak skonfigurować debuger i przeprowadzać różne zadania związane z usuwaniem błędów w projekcie MVC.

Tworzenie przykładowego projektu

Aby zademonstrować działanie debugera, utworzymy nowy projekt MVC, korzystający z szablonu MVC. W ten sposób będziesz mógł zobaczyć, jak przygotowywana jest zawartość i konfiguracja podstawowa projektu, a także jaki efekt ma zastosowanie motywu domyślnego w widokach. Nazwijmy nasz projekt DebuggingDemo. Jak pokazano na rysunku 14.3, jako uwierzytelnianie wybrano opcję Indywidualne konta uĝytkowników, która oznacza użycie podstawowego systemu uwierzytelniania użytkowników.

338

Kup książkę

Poleć książkę

ROZDZIA’ 14. „ PRZEGLkD PROJEKTU MVC

Rysunek 14.3. Tworzenie projektu DebuggingDemo

Po kliknięciu przycisku OK Visual Studio utworzy projekt, umieści w nim katalogi i pliki pakietów domyślnych znajdujących się w szablonie MVC. Dodane do projektu pliki i sposób ich konfiguracji możesz zobaczyć po uruchomieniu aplikacji (rysunek 14.4).

Rysunek 14.4. Efekt działania plików znajdujących się w szablonie projektu MVC

Projekt zawiera pewne miejsca zarejestrowane pozwalające na podanie nazwy aplikacji i promocję marki, a także oferuje łącza do dokumentów MVC, pakietów NuGet oraz opcji dotyczących hostingu.

339

Kup książkę

Poleć książkę

ASP.NET MVC 5. ZAAWANSOWANE PROGRAMOWANIE

Pasek nawigacyjny znajduje się na górze strony i ma taką samą postać, jakiej użyłem w aplikacji SportsStore. Ponadto w kodzie zastosowano pewne funkcje układu responsywnego. Aby się o tym przekonać, zmień szerokość okna przeglądarki internetowej.

Tworzenie kontrolera

Wprawdzie Visual Studio tworzy kontroler Home jako część projektu początkowego, ale jego kod zastąpimy przedstawionym na listingu 14.1.

Listing 14.1. Zawartość pliku HomeController.cs

using System.Web.Mvc;

namespace DebuggingDemo.Controllers

{

public class HomeController : Controller

{

public ActionResult Index()

{

int firstVal = 10;

int secondVal = 5;

int result = firstVal / secondVal;

ViewBag.Message = "Witamy na platformie ASP.NET MVC!";

return View(result);

}

}

}

Tworzenie widoku

Visual Studio tworzy także plik widoku Views/Home/Index.cshtml, jako część pierwotnej zawartości projektu.

Ponieważ nie potrzebujemy zawartości domyślnej tego widoku, zastąp ją kodem przedstawionym na listingu 14.2.

Listing 14.2. Zawartość pliku Index.cshtml

@model int

@{

Layout = null;

}

<!DOCTYPE html>

<html>

<head>

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

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

<title>Index</title>

</head>

<body>

<h2 class="message">@ViewData["Message"]</h2>

<p>

Wynik obliczeñ: @Model

</p>

</body>

</html>

340

Kup książkę

Poleć książkę

ROZDZIA’ 14. „ PRZEGLkD PROJEKTU MVC

Ostatnim krokiem w trakcie tych przygotowań projektu jest dodanie stylu do pliku /Content/Site.css przedstawionego na listingu 14.3 oraz zmiana jednego z istniejących. Plik Site.css jest tworzony przez Visual Studio jako część szablonu projektu MVC, stanowi domyślne miejsce dla stylów CSS aplikacji. (W przedstawionym na listingu 14.2 kodzie widoku dodałem element <link> importujący plik CSS do widoku Index.cshtml).

Listing 14.3. Dodanie stylu do pliku /Content/Site.css

body { padding-top: 5px; padding-bottom: 5px; }

.field-validation-error { color: #b94a48; }

.field-validation-valid { display: none; }

input.input-validation-error { border: 1px solid #b94a48; }

input[type="checkbox"].input-validation-error { border: 0 none; }

.validation-summary-errors { color: #b94a48; }

.validation-summary-valid { display: none; }

.no-color { background-color: white; border-style:none; }

.message { font-size: 20pt; text-decoration: underline; }

Uruchamianie debugera Visual Studio

Domyślnie Visual Studio włącza możliwość debugowania nowych projektów, choć warto wiedzieć, jak można samodzielnie to zmienić. Najważniejsze ustawienie znajduje się w pliku Web.config, położonym w katalogu głównym aplikacji. Odpowiednie ustawienie jest w elemencie <system.web>, jak pokazano na listingu 14.4.

„ Ostrzeĝenie Nie naleĝy instalowaÊ aplikacji na serwerze produkcyjnym bez wczeĂniejszego ustawienia wartoĂci false opcji debug. Jeĝeli do wdroĝenia aplikacji uĝywasz Visual Studio (podobnie jak to pokazaïem w rozdziale 13.), wówczas odpowiednia zmiana zostanie wprowadzona automatycznie po wybraniu konfiguracji Release w projekcie.

Listing 14.4. Atrybut Debug w pliku Web.config

...

<system.web>

<httpRuntime targetFramework="4.5.1" />

<compilation debug="true" targetFramework="4.5.1" />

</system.web>

...

Spora liczba operacji kompilacji w projekcie MVC jest przeprowadzana, gdy aplikacja działa w serwerze IIS.

W trakcie prac nad aplikacją musisz więc się upewnić, że atrybutowi debug jest przypisana wartość true. W ten sposób debuger będzie mógł operować na plikach klas wygenerowanych podczas kompilacji na żądanie.

Oprócz zmiany w pliku konfiguracyjnym Web.config, konieczne jest upewnienie się, że Visual Studio umieszcza informacje debugowania w tworzonych plikach klas. Wprawdzie to nie ma znaczenia krytycznego, ale może powodować problemy, jeśli poszczególne ustawienia debugowania nie są zsynchronizowane.

Upewnij się o wybraniu opcji konfiguracyjnej Debug na pasku narzędziowym Visual Studio, jak pokazano na rysunku 14.5.

Aby rozpocząć debugowanie aplikacji na platformie MVC, wybierz opcję Start Debugging z menu Debuguj w Visual Studio lub kliknij zieloną ikonę strzałki na pasku narzędziowym Visual Studio (wspomnianą ikonę widać na rysunku 14.5 tuż obok nazwy przeglądarki internetowej używanej do wyświetlenia aplikacji

— w omawianym przykładzie jest to Google Chrome).

Jeżeli w pliku konfiguracyjnym Web.config wartością atrybutu debug jest false, wtedy podczas uruchamiania debugera Visual Studio wyświetli okno dialogowe pokazane na rysunku 14.6. Wybierz opcję pozwalającą Visual Studio na przeprowadzenie modyfikacji pliku Web.config, a następnie kliknij przycisk OK.

Debuger zostanie uruchomiony.

341

Kup książkę

Poleć książkę

ASP.NET MVC 5. ZAAWANSOWANE PROGRAMOWANIE

Rysunek 14.5. Wybór opcji konfiguracyjnej Debug

Rysunek 14.6. Okno dialogowe wyświetlane przez Visual Studio, gdy debugowanie jest wyłączone w pliku Web.config

W tym momencie aplikacja jest uruchomiona i wyświetlona w oknie przeglądarki, jak pokazano na rysunku 14.7.

Debuger został dołączony do naszej aplikacji, ale nie zauważymy żadnej różnicy do momentu przerwania jej działania przez debuger (przedstawię to w następnym punkcie). Aby zatrzymać debuger, wybierz opcję Stop Debugging z menu Debuguj lub zamknij okno przeglądarki internetowej.

Rysunek 14.7. Uruchomienie debugera

Przerywanie pracy aplikacji przez debuger Visual Studio

Aplikacja działająca z podłączonym debugerem zachowuje się normalnie do momentu wystąpienia przerwania, w którym działanie aplikacji jest zatrzymywane i sterowanie jest przekazywane do debugera. W tym momencie możemy przeglądać i modyfikować stan aplikacji. Przerwania pojawiają się z dwóch głównych powodów: gdy zostanie napotkany punkt przerwania lub gdy wystąpi nieobsłużony wyjątek. Przykłady przedstawię w kolejnych punktach.

342

Kup książkę

Poleć książkę

ROZDZIA’ 14. „ PRZEGLkD PROJEKTU MVC

Użycie punktów przerwania

Punkt przerwania to instrukcja informująca debuger o konieczności zatrzymania wykonywania aplikacji i przekazania kontroli programiście. W tym momencie możemy przeglądać stan aplikacji, sprawdzać, co się w niej dzieje i — opcjonalnie — wznowić działanie aplikacji.

Aby utworzyć punkt przerwania, kliknij prawym przyciskiem myszy kod i wybierz opcję Punkt przerwania/

Insert Breakpoint z menu kontekstowego. W celu zademonstrowania działania punktów przerwania umieszczamy jeden taki punkt w pierwszym poleceniu metody akcji Index, w klasie Home. Na marginesie edytora tekstów pojawi się czerwona kropka (rysunek 14.8).

Rysunek 14.8. Dodawanie punktu przerwania w pierwszym poleceniu metody akcji Index

Rysunek 14.9. Napotkanie punktu przerwania

Aby zobaczyć efekt dodania punktu przerwania, musisz uruchomić debuger poprzez wybranie opcji Start Debugging z menu Debuguj w Visual Studio. Aplikacja będzie działała aż do chwili dotarcia do polecenia oznaczonego punktem przerwania. W tym momencie debuger przerwie działanie aplikacji i przekaże kontrolę programiście. Jak pokazano na rysunku 14.9, Visual Studio podświetla wiersz kodu, w którym nastąpiło zatrzymanie działania aplikacji.

343

Kup książkę

Poleć książkę

ASP.NET MVC 5. ZAAWANSOWANE PROGRAMOWANIE

„ Uwaga Punkt przerwania dziaïa tylko w momencie, gdy skojarzona z nim instrukcja jest wykonywana. W naszym przykïadzie punkt przerwania jest osiÈgany od razu po uruchomieniu aplikacji, poniewaĝ znajduje siÚ w metodzie akcji wywoïywanej w chwili otrzymania ĝÈdania domyĂlnego adresu URL. Jeĝeli umieĂcisz punkt przerwania wewnÈtrz innej metody akcji, musisz uĝyÊ przeglÈdarki do wywoïania adresu URL skojarzonego z tÈ metodÈ.

Moĝe to oznaczaÊ, ĝe konieczne bÚdzie skorzystanie z aplikacji w taki sposób, w jaki korzystajÈ z niej uĝytkownicy, lub bezpoĂrednie przejĂcie do adresu URL w oknie przeglÈdarki.

Po przejęciu kontroli nad wykonywaniem aplikacji możesz przejść do kolejnego polecenia, śledzić wykonywanie w innych metodach i ogólnie przeglądać stan aplikacji. Do tego celu wykorzystujesz przyciski znajdujące się na pasku narzędzi w Visual Studio bądź opcje dostępne w menu Debuguj. Oprócz kontroli nad wykonywaniem aplikacji, Visual Studio dostarcza Ci także wielu użytecznych informacji dotyczących stanu aplikacji. W rzeczywistości wspomnianych informacji jest tak wiele, że w niniejszej książce nie ma wystarczająco dużo miejsca na przedstawienie czegokolwiek więcej poza podstawami.

Przeglądanie wartości danych w edytorze kodu

Najczęstszym sposobem użycia punktów przerwania jest próba znalezienia błędów w kodzie. Zanim będziesz mógł usunąć błąd z kodu, najpierw musisz ustalić, co tak naprawdę się dzieje. Jedną z najbardziej użytecznych funkcji oferowanych przez Visual Studio jest możliwość przeglądania i monitorowania wartości zmiennych bezpośrednio w edytorze kodu.

Przykładowo, uruchom aplikację w debugerze i zaczekaj na zatrzymanie działania aplikacji po dotarciu do dodanego wcześniej punktu przerwania. Kiedy debuger zatrzyma działanie aplikacji, umieść kursor myszy nad poleceniem definiującym zmienną result. Po chwili na ekranie zobaczysz małe wyskakujące okno przedstawiające bieżącą wartość wspomnianej zmiennej (rysunek 14.10). Ponieważ wspomniane okno jest małe, na rysunku pokazano także jego powiększoną wersję.

Rysunek 14.10. Wyświetlenie wartości zmiennej w edytorze kodu Visual Studio Wykonywanie poleceń w metodzie akcji Index nie dotarło do miejsca, w którym następuje przypisanie wartości zmiennej result, więc Visual Studio pokazuje wartość domyślną wymienionej zmiennej, czyli 0 dla typu int. Wybieraj opcję Step Over w menu Debuguj (lub naciskaj klawisz F10) dopóty, dopóki nie dotrzesz do polecenia, w którym następuje zdefiniowanie właściwości ViewBag.Message. Teraz ponownie umieść kursor myszy nad zmienną result. Po wykonaniu polecenia przypisującego wartość zmiennej result wynik wykonania tego polecenia możesz zobaczyć na rysunku 14.11.

344

Kup książkę

Poleć książkę

ROZDZIA’ 14. „ PRZEGLkD PROJEKTU MVC

Rysunek 14.11. Efekt przypisania wartości zmiennej

Funkcji tej używamy w celu rozpoczęcia procesu wyszukiwania błędu, ponieważ daje ona natychmiastowy wgląd do tego, co się dzieje w aplikacji. Omawiana funkcja okazuje się szczególnie użyteczna w wykrywaniu wartości null oznaczających, że zmiennej nie została przypisana wartość (to źródło wielu błędów, jak wynika z mojego doświadczenia).

W wyświetlonym oknie, po prawej stronie wartości, możesz dostrzec ikonę pinezki. Jeżeli ją klikniesz, dane okno na stałe pozostanie wyświetlone na ekranie i będzie wskazywało zmianę wartości zmiennej.

W ten sposób możesz monitorować jedną lub więcej zmiennych i natychmiast dowiadywać się o zmianie ich wartości i poznawać nowo przypisane wartości.

Przegląd stanu aplikacji w oknie debugera

Visual Studio zawiera wiele różnych okien, które można wykorzystać do pobierania informacji o aplikacji, gdy jej działanie zostało zatrzymane w punkcie przerwania. Pełna lista okien jest dostępna w menu Debuguj/Okna, ale dwa najważniejsze z nich to Locals i Call Stack. W oknie Locals automatycznie są wyświetlane wartości wszystkich zmiennych w aktualnym zasięgu, co pokazano na rysunku 14.12. W ten sposób otrzymujesz pojedynczy widok zawierający wszystkie zmienne, którymi możesz być zainteresowany.

Rysunek 14.12. Okno Locals

Zmienne, których wartości uległy zmianie w trakcie poprzednio wykonanego polecenia, są wyświetlone w kolorze czerwonym. Na rysunku widać, że wartość zmiennej result jest wyświetlona na czerwono, ponieważ w poprzednim poleceniu nastąpiło przypisanie jej wartości.

„ Wskazówka Zestaw zmiennych wyĂwietlonych w oknie Locals ulega zmianie wraz z poruszaniem siÚ po aplikacji.

Jeĝeli chcesz globalnie ĂledziÊ wartoĂÊ wybranej zmiennej, kliknij jÈ prawym przyciskiem myszy, a nastÚpnie z menu kontekstowego wybierz opcjÚ Add Watch. Elementy w oknie Watch nie ulegajÈ zmianie podczas wykonywania kolejnych poleceñ w aplikacji i tym samym masz doskonaïe miejsce na ich Ăledzenie.

345

Kup książkę

Poleć książkę

ASP.NET MVC 5. ZAAWANSOWANE PROGRAMOWANIE

W oknie Call Stack jest wyświetlana sekwencja wywołań, które doprowadziły do aktualnego stanu aplikacji. To może być bardzo użyteczne, jeśli próbujesz znaleźć powód dziwnego zachowania aplikacji

— możesz wówczas przejrzeć stos wywołań i poznać przyczyny, które doprowadziły do wywołania danego punktu przerwania. (Na rysunku nie pokazano okna Call Stack, ponieważ w omawianej prostej aplikacji nie wystąpiło wystarczająco dużo wywołań, aby zapewnić użyteczny wgląd w nie. Zachęcam Cię do zapoznania się z omawianymi oraz pozostałymi oknami w Visual Studio, aby w ten sposób dowiedzieć się, jakie informacje możesz uzyskać z debugera).

„ Wskazówka Moĝliwe jest debugowanie widoków przez wstawianie do nich punktów przerwania. Moĝe to byÊ

bardzo pomocne w kontrolowaniu wartoĂci wïaĂciwoĂci modelu widoku. Aby dodaÊ punkt przerwania do widoku, naleĝy wykonaÊ takÈ samÈ operacjÚ jak w przypadku pliku kodu — kliknÈÊ prawym przyciskiem myszy interesujÈcÈ nas instrukcjÚ Razor i wybraÊ Punkt przerwania/Insert Breakpoint.

Przerywanie aplikacji przez wyjątki

Nieobsłużone wyjątki są smutnym faktem. Jednym z powodów wykonywania wielu testów jednostkowych i integracyjnych jest minimalizacja prawdopodobieństwa wystąpienia takiego wyjątku w środowisku produkcyjnym.

Debuger Visual Studio jest uruchamiany automatycznie w przypadku pojawienia się nieobsłużonego wyjątku.

„ Uwaga Jedynie nieobsïuĝone wyjÈtki powodujÈ wywoïanie debugera. WyjÈtek staje siÚ obsïuĝony, gdy przechwycimy go w bloku try ... catch. Obsïuĝone wyjÈtki sÈ uĝytecznym narzÚdziem programistycznym. SÈ one wykorzystywane do obsïugiwania scenariuszy, w których metoda nie jest w stanie dokoñczyÊ zadania i musimy poinformowaÊ

o tym wywoïujÈcego. Nieobsïuĝone wyjÈtki sÈ mankamentem, poniewaĝ reprezentujÈ nieoczekiwane warunki w aplikacji (i powodujÈ wyĂwietlenie uĝytkownikowi informacji o bïÚdzie).

Aby zademonstrować przerwanie pracy aplikacji w przypadku wyjątku, do naszej metody akcji Index wprowadzimy małą zmianę pokazaną na listingu 14.5.

Listing 14.5. Dodatkowe polecenie w pliku HomeController.cs powodujące wystąpienie wyjątku using System.Web.Mvc;

namespace DebuggingDemo.Controllers {

public class HomeController : Controller {

public ActionResult Index() {

int firstVal = 10;

int secondVal = 0;

int result = firstVal / secondVal;

ViewBag.Message = "Witamy w ASP.NET MVC!";

return View(result);

}

}

}

Zmieniliśmy wartość zmiennej secondVal na 0, co spowoduje wyjątek w instrukcji, w której firstVal jest dzielona przez secondVal.

„ Uwaga Z metody akcji Index usuniÚto takĝe punkt przerwania poprzez jego klikniÚcie prawym przyciskiem myszy i wybranie opcji Delete Breakpoint z wyĂwietlonego menu kontekstowego.

346

Kup książkę

Poleć książkę

ROZDZIA’ 14. „ PRZEGLkD PROJEKTU MVC

Jeżeli uruchomisz debuger, aplikacja będzie działała do momentu zgłoszenia wyjątku, gdy pojawi się okno informacji o wyjątku pokazane na rysunku 14.13.

Rysunek 14.13. Okno pomocnicze obsługi wyjątku

W tym oknie pomocniczym znajdują się informacje na temat wyjątku. Gdy debuger zostanie wywołany w wierszu powodującym wyjątek, możemy skontrolować stan aplikacji i sterować jej działaniem, podobnie jak w przypadku punktu przerwania.

Użycie opcji Edit and Continue

Jedną z najbardziej interesujących funkcji debugera Visual Studio jest Edit and Continue. Gdy zostanie wywołany debuger, można zmodyfikować kod, a następnie kontynuować debugowanie. Visual Studio ponownie skompiluje aplikację, po czym odtworzy jej stan w momencie aktywowania debugera.

Włączanie opcji Edit and Continue

Konieczne jest włączenie opcji Edit and Continue w dwóch miejscach:

x Upewnij się, że w sekcji Edit and Continue dla opcji Debugging zaznaczona jest opcja Enable Edit and Continue (wybierz Opcje… z menu Narzędzia), jak pokazano na rysunku 14.14.

x We właściwościach projektu (wybierz Właściwości DebuggingDemo… z menu Projekt) przejdź do sekcji Sieć Web i upewnij się, że zaznaczona jest opcja Włącz tryb edycji i kontynuuj (rysunek 14.15).

Modyfikowanie projektu

Funkcja Edit and Continue jest nieco kapryśna. Istnieją przypadki, w których nie będzie ona działać. Jeden z nich jest pokazany dla metody Index z klasy HomeController — użyte są w niej obiekty dynamiczne.

Rozwiązaniem problemu jest umieszczenie znaków komentarza na początku wiersza, w którym korzystamy z funkcji ViewBag, w pliku HomeController.cs, jak przedstawiono na listingu 14.6.

347

Kup książkę

Poleć książkę

ASP.NET MVC 5. ZAAWANSOWANE PROGRAMOWANIE

Rysunek 14.14. Włączenie opcji Edit and Continue w oknie dialogowym Opcje

Rysunek 14.15. Włączanie trybu edycji i kontynuacji we właściwościach projektu

Listing 14.6. Usunięcie wywołania ViewBag z metody Index w pliku HomeController.cs using System.Web.Mvc;

namespace DebuggingDemo.Controllers {

public class HomeController : Controller {

public ActionResult Index() {

int firstVal = 10;

int secondVal = 0;

int result = firstVal / secondVal;

// poniższe polecenie zostało poprzedzone znakiem komentarza

// ViewBag.Message = "Witamy w ASP.NET MVC!";

return View(result);

}

}

}

348

Kup książkę

Poleć książkę

ROZDZIA’ 14. „ PRZEGLkD PROJEKTU MVC

Analogiczną zmianę musimy wykonać w widoku Index.cshtml, co jest pokazane na listingu 14.7.

Listing 14.7. Usunięcie wywołania ViewBag z widoku

@model int

@{

Layout = null;

}

<!DOCTYPE html>

<html>

<head>

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

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

<title>Index</title>

</head>

<body>

<!-- Poniższy element został umieszczony w komentarzu. -->

<!--<h2 class="message">@ViewData["Message"]</h2>-->

<p>

WartoĂÊ obliczeñ to: @Model

</p>

</body>

</html>

Edycja i kontynuowanie pracy

Jesteśmy już gotowi do użycia funkcji Edit and Continue. Zaczniemy od wybrania opcji Start Debugging z menu Debuguj. Aplikacja uruchomi się z dołączonym debugerem i będzie realizowała metodę Index do momentu wykonania wiersza, w którym przeprowadzamy obliczenia. Wartość drugiego parametru wynosi zero, co spowoduje zgłoszenie wyjątku. W tym momencie debuger przerwie działanie i wyświetli się okno informacji o wyjątku (jak pokazano na wcześniejszym rysunku 14.13).

Kliknij łącze Włącz edytowanie w oknie wyjątku. W edytorze kodu zmień wyrażenie obliczające wartość zmiennej result na następujące:

...

int result = firstVal / 2;

...

Usunęliśmy odwołanie do zmiennej secondVal i zastąpiliśmy je wartością 2. Z menu Debuguj wybierz Continue. Aplikacja będzie kontynuowała działanie. Nowa wartość przypisana zmiennej zostanie użyta do wygenerowania wyniku zmiennej result, a przeglądarka wyświetli stronę, zamieszczoną na rysunku 14.16.

Rysunek 14.16. Efekt usunięcia błędu dzięki użyciu funkcji Edit and Continue Poświęć chwilę na analizę wyniku tych działań. Uruchomiliśmy aplikację zawierającą błąd — próbę dzielenia przez zero. Debuger wykrył wyjątek i zatrzymał wykonywanie programu. Aby poprawić błąd, zmodyfikowaliśmy kod, zamieniając odwołanie do zmiennej na literał o wartości 5. Następnie wznowiliśmy działanie debugera.

W tym momencie aplikacja została ponownie skompilowana przez Visual Studio, dzięki czemu nasza zmiana jest 349

Kup książkę

Poleć książkę

ASP.NET MVC 5. ZAAWANSOWANE PROGRAMOWANIE

uwzględniona w procesie kompilacji, stan aplikacji jest przywrócony, a następnie kontynuowany w normalny sposób. Przeglądarka otrzyma wygenerowany wynik uwzględniający naszą poprawkę. Bez opcji Edit and Continue musielibyśmy zatrzymać aplikację, wprowadzić zmiany, skompilować aplikację i ponownie uruchomić debuger. Następnie musielibyśmy powtórzyć w przeglądarce kroki, które doprowadziły do momentu wywołania debugera. Uniknięcie tego ostatniego kroku jest tu najważniejsze. Odtworzenie skomplikowanych błędów może wymagać wykonania wielu operacji w aplikacji, a możliwość testowania potencjalnych rozwiązań bez potrzeby powtarzania tych kroków pozwala zaoszczędzić czas i nerwy programisty.

Uĝycie funkcji poïÈczonych przeglÈdarek

Visual Studio 2013 zawiera funkcję o nazwie połączone przeglądarki, która pozwala na jednoczesne wyświetlanie aplikacji w wielu przeglądarkach internetowych i ich odświeżanie po wprowadzeniu zmiany. Ta funkcja okazuje się najbardziej użyteczna, gdy działanie aplikacji jest stabilne i pozostało już tylko dopracowanie kodu HTML i CSS generowanego przez widoki (wkrótce to wyjaśnię).

W celu użycia funkcji połączonych przeglądarek na pasku narzędzi w Visual Studio kliknij mały trójkąt skierowany w dół obok nazwy wybranej przeglądarki internetowej, a następnie z menu wybierz opcję Przeglądaj za pomocą…, jak pokazano na rysunku 14.17.

Rysunek 14.17. Przygotowanie do wyboru przeglądarek internetowych używanych wraz z funkcją Browser Link Na ekranie zostanie wyświetlone okno dialogowe Przeglądaj w. Naciśnij klawisz Control, a następnie zaznacz przeglądarki internetowe, których chcesz używać. Na rysunku 14.18 widać, że wybrałem Google Chrome i Opera Internet Browser. Za pomocą tego okna dialogowego możesz również dodać nowe przeglądarki, choć Visual Studio całkiem dobrze radzi sobie z wykrywaniem większości najważniejszych przeglądarek internetowych.

Po kliknięciu przycisku Przeglądaj Visual Studio uruchomi wybrane przeglądarki internetowe i wczyta aktualny projekt w każdej z nich. Teraz możesz przeprowadzić edycję kodu w aplikacji, a następnie uaktualnić wszystkie okna przeglądarek internetowych, wybierając opcję Odśwież połączone przeglądarki z paska narzędzi w Visual Studio, jak pokazano na rysunku 14.19. Aplikacja zostanie automatycznie skompilowana i będziesz mógł zobaczyć wprowadzone zmiany.

Omawiana funkcja działa przez wysłanie przeglądarce internetowej pewnego kodu JavaScript w dokumencie HTML i zapewnia elegancki sposób programowania iteracyjnego. Zalecam jej stosowanie jedynie podczas pracy z widokami, ponieważ wtedy istnieje najmniejsze prawdopodobieństwo, że serwer IIS wyśle przeglądarce internetowej komunikaty błędów HTTP. Wspomniane komunikaty są generowane, gdy w kodzie występuje błąd. Kod JavaScript nie jest dodawany do odpowiedzi dotyczących błędów, a tym samym następuje utrata połączenia między Visual Studio i przeglądarkami internetowymi. W takim przypadku trzeba ponownie przejść do okna dialogowego Przeglądaj w. Funkcja połączonych przeglądarek jest użyteczna, ale użycie kodu JavaScript okazuje się problemem. Podczas pracy nad projektami w innych technologiach niż ASP.NET

korzystam z podobnego narzędzia, o nazwie LiveReload ( http://livereload.com/). Wymienione narzędzie 350

Kup książkę

Poleć książkę

ROZDZIA’ 14. „ PRZEGLkD PROJEKTU MVC

Rysunek 14.18. Wybór dwóch przeglądarek internetowych

Rysunek 14.19. Odświeżenie przeglądarek internetowych

oferuje lepsze podejście, ponieważ jego działanie opiera się na wtyczkach przeglądarek internetowych, na które komunikaty błędów HTTP nie mają wpływu. Wartość funkcji połączonych przeglądarek w Visual Studio będzie ograniczona, dopóki Microsoft nie zastosuje podobnego rozwiązania.

Podsumowanie

W rozdziale tym omówiłem strukturę projektu Visual Studio MVC i wyjaśniłem, jak są połączone ze sobą jej części. Wskazałem również jedną z najważniejszych cech platformy MVC — możliwość stosowania konwencji.

Do omówionych tematów będę stale wracać w kolejnych rozdziałach, przedstawiając sposób działania platformy MVC.

351

Kup książkę

Poleć książkę

ASP.NET MVC 5. ZAAWANSOWANE PROGRAMOWANIE

352

Kup książkę

Poleć książkę

Skorowidz

A

arkusz stylów, 56

atrybuty

asercja, 362

autoryzacji, 462

abstrakcja, 20

ASP.NET MVC, 19

routingu, 387, 388

adres URL, 49, 193, 425

API, 26

warunkowe, 266

adres URL z systemu routingu, 449

architektura MVC, 23

automatyczna

AJAX, Asynchronous JavaScript

kontrola nad HTML, 24

inferencja typów, 97

and XML, 605

łatwość testowania, 24

kontrola, 675

akcja, 427

routing, 25

automatyczne wyróżnianie błędów,

CustomVariable, 371, 372

rozszerzalność, 24

58

GetPeopleDataJson, 628

ASP.NET MVC 5, 27

automatycznie implementowane

GetRemoteData, 519

ASP.NET Web Forms, 20

właściwości, 83, 85

kontrolera API, 710

asynchroniczność, 23

automatyzacja interfejsu

ValidateDate, 684

atrybut

użytkownika, 22, 79

akcje

ActionName, 509

potomne, 544, 545

AttributeUsage, 489

w kontrolerze Customer, 390

B

Authorize, 305

aktualizowanie repozytorium, 286

Bind, 642

baza danych, 175, 325

aktywator

class, 266, 565

Azure, 325

kontrolerów, 504

data-bind, 716

żądań, 505

LocalDB, 177

data-transition, 271

aliasy dla kontrolera, 369

SportsStore, 177

DataType, 590, 591

antywzorzec, 68

bezpieczeństwo, 303

Debug, 341, 695, 696

API Node.js, 23

biblioteka

Display, 590

aplikacja SportsStore, 163

Bootstrap, 24, 29, 59, 63

DisplayName, 589, 590

aplikacje

jQuery, 608, 693, 713

mobilne, 255

HiddenInput, 586, 587

jQuery Mobile, 268, 271

MVC, 31

href, 58

Knockout, 24, 28, 712–715, 719

Rails, 22

HttpPost, 510, 560, 637

LINQ, 98

SPA, 28, 699, 700, 712

loginUrl, 304, 456

Modernizr, 24

architektura

NonAction, 511

Moq, 155

model-widok, 68

Remote, 683

TPL, 517

model-widok-prezenter, 70

Route, 388–401

WatiN, 79

model-widok-widok-model, 70

RouteArea, 419

błąd, 153, 377, 634

MVC, 23

SessionState, 516

401, 453

trójwarstwowa, 69

UIHint, 592, 598

404, 367, 452, 480

Kup książkę

Poleć książkę

SKOROWIDZ

błąd

sekcji, 536

dołączanie

kontroli poprawności, 56, 58,

wartości domyślnych, 363

danych, 227, 715, 716

665, 669

własnych ograniczeń, 385

do kolekcji, 645

niejednoznaczności kontrolera,

własnych prefiksów, 640

do tablic, 643

417

zmiennych segmentów, 370

kodu HTML, 638

błędy

degradowanie łączy Ajax, 618

kolekcji, 646

dołączania modelu, 650

deklarowanie zależności, 72

modelu, 51, 432, 629, 653

kontroli poprawności, 664

DI, dependency injection, 71

dostosowanie systemu, 650

na poziomie modelu, 676

dodatkowe style CSS, 603

ręczne, 648

na poziomie właściwości, 676

dodawanie

tablic i kolekcji, 643

weryfikacji, 54

bibliotek JavaScript, 712

typów prostych, 634

budowa modelu domeny, 66

danych do bazy, 179

typów złożonych, 636

danych modelu widoku, 188

warunkowe, 144

C

danych tabeli, 327

właściwości, 640, 642

dynamicznych treści, 536

domyślne

C#, 81

filtra, 460

przeszukiwanie przestrzeni

ciągi tekstowe, 554

filtra globalnego, 487

nazw, 379

CRUD, 275

klasy modelu, 44

wartości parametrów, 434

cykl życia strony, 20

kolumn, 313

zachowanie filtra, 492

czas życia obiektów, 73, 144

kontrolek nawigacji, 201

domyślny

kontrolera, 34, 35, 132, 171

adres URL, 49, 363

D

kontroli poprawności, 53, 292

kod, 47

łącza do widoku, 45

łącznik modelu, 635

DAL, data access layer, 69

łączy Ajax, 617

widok, 38

dane

metadanych, 593

dopasowanie

JSON, 624, 707, 708

metody asynchronicznej, 520

adresów URL, 358, 365, 373,

modelu widoku, 188

modelu widoku, 186

376

statystyczne, 690

Moq, 157

tras, 399

stronicowania, 190, 214

Ninject, 135

dostawca

uwierzytelniające, 456

nowego produktu, 297

uwierzytelniania, 306, 307

wejściowe, 432

nowego widoku, 46

wartości, 651, 653

wyjściowe, 435

obiektu imitacyjnego, 157

dostosowanie systemu routingu,

XML, 708

obszaru, 414

408

debuger Visual Studio, 342

odwołań, 166

dynamiczne dodawanie treści, 41,

debugowanie, 166, 175, 402

pakietów NuGet, 678, 685, 691,

536

aplikacji, 338

702

dynamiczny widok, 42

atrybutów HTML, 403

parametru metody akcji, 372

dyrektywa click, 716

encji koszyka, 217

podsumowania koszyka, 233

działanie

funkcji Ajax, 714

przestrzeni nazw, 188

biblioteki Knockout, 715

intencji, 436

przycisków, 221

filtra Authorize, 306

interfejsu, 242

punktu przerwania, 343

filtra wyniku, 483

definiowanie

responsywnej zawartości, 258

filtrów akcji globalnych, 493

kontrolera, 108

stronicowania, 184

kontrolera API, 709

mechanizmu dołączania, 715

stylu, 194

koszyka, 217

metody akcji, 646

trasy, 193, 398

nieprzeszkadzających wywołań,

metody rozszerzającej, 88

układu, 172

612

modelu, 108, 715

widoku, 39, 115, 132, 172

silnika wyniku, 530

opcjonalnych segmentów URL,

widoku HTML, 43

dziedziczenie, 430

373

wielu filtrów, 489

dziedziczenie po atrybutach, 672

paczki, 692

zależności, 141

priorytetów kontrolerów, 377

728

Kup książkę

Poleć książkę

SKOROWIDZ

E

filtrowanie

stron WWW, 37

bez użycia atrybutów, 485

widoku, 37, 53, 440–443, 532,

edycja produktów, 282, 293

kolekcji obiektów, 92

582

edytor

listy produktów, 201

wychodzących adresów URL,

kodu, 344

obiektów, 95

406, 411

produktów, 287

według kategorii, 204

gettery, 84

efekt

filtry globalne, 487

graficzne interfejs użytkownika,

kliknięcia łącza, 399

format JSON, 624

GUI, 19

selektywnego kodowania treści,

formatowanie danych, 119

GridView, 192

558

formaty

użycia filtra, 489

danych, 708

H

użycia łącznika modelu, 656

daty, 636

użycia stylów, 586

formularz, 47, 50, 221, 560, 562

hasło, 304

użycia widoku częściowego,

Ajax, 608, 610

HTML, 24

543

RSVP, 44

HTTP, 24

zastosowania ograniczenia, 391

synchroniczny, 607

element

szczegółów wysyłki, 239

I

<credentials>, 305

formy wyrażeń lambda, 96

<div>, 62

framework

IIS, Internet Information Services,

<form>, 233, 567

Node.js, 23

323

<img>, 316

Rhino Mocks, 129

imitacja

<input>, 48, 62, 233, 568

funkcja

określonych wartości, 161

<label>, 62, 239

$.ajax, 714

repozytorium, 169, 205

<link>, 58, 250

Browser Link, 350

zachowania klasy, 160

<p>, 557

Edit and Continue, 349

zakresu wartości, 162

<script>, 58, 294

getAllItems, 715, 716

implementacja

<select>, 62, 571

Łącze przeglądarki, 690

elementów <input>, 721

<style>, 60, 233

paczki, 685

filtra wyjątku, 477

<table>, 233

processData, 623

funkcji, 152

elementy projektu, 336

removeItem, 718

funkcji tworzenia rezerwacji, 719

eliminowanie powielania

sendAjaxRequest, 714

interfejsu, 90, 243

widoków, 264

ViewBag, 119

interfejsu IControllerActivator,

encje koszyka, 217

ViewData, 527

504

Entity Framework, 181

funkcje

IProductRepository, 170

etykieta, 241

aplikacji, 174

IView, 527, 528

platformy ASP.NET, 25

IViewEngine, 528

F

routingu, 395

IValueProvider, 649

typu anonimowego, 62

kontrolera koszyka, 222

fabryka

w MVC 5, 27

mechanizmu przetwarzania

dostawcy wartości, 652

zamówień, 242

kontrolerów, 380, 498, 501

G

metody Menu, 209

wbudowana, 502

metody OnActionExecuted, 481

własna, 501

generowanie

MVC, 67

filtr, 431, 455

adresów URL, 397, 404–407

podsumowania, 713

akcji, 478

danych widoku, 173

repozytorium, 183

Authorize, 306

elementu <input>, 568

RouteBase, 408

autoryzacji, 461–463, 468

etykiet, 241, 581

sprawdzenia uwierzytelniania,

uwierzytelniania, 305, 464, 467,

listy kategorii, 209

466

468

łączy, 419

widoku listy, 278

wyjątku, 470, 471, 474, 476

sekcji opcjonalnych, 540

inferencja typów, 97

wyniku, 482

729

Kup książkę

Poleć książkę

SKOROWIDZ

informacja

K

DependencyResolver, 500, 501,

dotycząca usługi Azure, 329

504

o adresie, 639

katalog

EFProductRepository, 183

o żądaniu Ajax, 615

AdditionalControllers, 386

EmailSettings, 244

inicjowanie

Content, 420

ExceptionContext, 470

kolekcji, 87

Controllers, 208

FilterConfig, 487

obiektów, 86, 87

Infrastructure, 137, 307, 482,

FormCollection, 649

tablic, 87

534, 672

FormsAuthentication, 307

instalacja

Models, 140, 630

FutureDateAttribute, 673

pakietów narzędziowych, 166

produktów, 264

HandleErrorAttribute, 476

pakietów NuGet, 603

Scripts, 337, 678

HandleErrorInfo, 478

pakietu Bootstrap, 59, 194

Shared, 631

HomeController, 36, 82, 139,

IntelliSense, 48, 67, 433, 444

kierowanie

378

interakcje w aplikacji, 67

adresów URL, 409

HtmlHelper, 552, 558

interfejs, 90, 134

żądań, 411

HttpMethodConstraint, 382

IActionFilter, 478

klasa

HttpRequestBase, 361

IActionInvoker, 506

ActionExecutedContext, 482

HttpStatusCodeResult, 452

IAuthenticationFilter, 464

ActionExecutingContext, 479

IControllerFactory, 515

IController, 428

ActionFilterAttribute, 460, 483

It, 159

IControllerActivator, 504

ActionMethodSelectorAttribute,

LegacyRoute, 409

IControllerFactory, 498, 515

512

LinqValueCalculator, 131, 133,

IDependencyResolver, 138

AddressSummary, 640, 643,

139, 141, 145, 155

IDiscountHelper, 141, 156

654

MinimumDiscountHelper, 147,

IEmailSender, 71, 73

AddressSummaryBinder, 653

149, 153, 160

IEnumerable<T>, 91

AdminController, 75

MvcRouteHandler, 360

IHttpHandler, 413

AjaxOptions, 611, 618

MyAsyncMethod, 103

IKernel, 137

Appointment, 674, 679

NavController, 210

IModelBinder, 228, 633

AreaRegistrationContext, 416

NinjectDependencyResolver,

IOrderProcessor, 242

Assert, 150

138, 139

IOverrideFilter, 492

AuthenticationChallenge

PagingHelpers, 186

IProductRepository, 169

Ćontext, 465

PasswordResetHelper, 71, 72

IResultFilter, 482

AuthenticationContext, 466

Product, 168, 281, 293

IRouteConstraint, 385

AuthorizeAttribute, 463

ProductController, 502

IRouteHandler, 413

btn, 60

RemoteService, 518

IValidatableObject, 677

Cart, 217, 218

RequestContext, 429, 499

IValueCalculator, 139, 145

CartController, 247

RouteCollection, 359

IViewEngine, 524

CartLine, 217

RouteValueDictionary, 412

repozytorium, 287

CartModelBinder, 228

ShoppingCart, 88, 90, 131, 134,

typu CRUD, 275

Controller, 430, 431, 453

156

użytkownika, 314

ControllerContext, 228, 470

System.Diagnostics.Debug, 145

IoC, inversion of control, 71

CountryValueProvider, 651

TagBuilder, 553

CustomHelpers, 555

text-center, 60

J

CustomRedirectResult, 437

User, 76

CustomValueProviderFactory,

ViewBag, 41

jawna kontrola poprawności, 661

651

ViewContext, 526, 552

język

DebugDataView, 528

ViewDataDictionary, 526

C#, 81

DefaultControllerFactory,

ViewEngineResult, 524, 525

HTML5, 21

502–506

ViewResult, 212

JavaScript, 614

DefaultDiscountHelper, 141

WebMail, 64

JSON, JavaScript Object Notation,

DefaultModelBinder, 634, 636,

621

669

730

Kup książkę

Poleć książkę

SKOROWIDZ

klasy

konstrukcja warunkowa, 123

kontrolowana degradacja

Base, 429

konstruktor

formularza, 613

CartLine, 218

EmailOrderProcessor, 244

konwencje MVC, 337

ograniczania trasy, 384

MvcHtmlString, 556

koszyk, 216–227

Wrapper, 430

kontekst Entity Framework, 180

dodanie produktu, 225

zaprzyjaźnione, 593

kontener DI, 73, 167

działanie, 217

Knockout, 712

kontrola nad HTML, 20, 24

encje, 217

kod

kontrola poprawności, 53, 249,

implementowanie kontrolera,

401, 453

250, 292

222

404, 367, 452, 480

alternatywne techniki, 668

kontroler, 230, 246

źródłowy biblioteki MVC, 26

dla pojedynczych właściwości,

podsumowanie, 233

kodowanie

668

przyciski, 221

treści metody pomocniczej,

formularza, 54

testowanie, 218

556

jawna, 661

usuwanie towarów, 233

wartości danych, 557

metody akcji, 684

wartość towarów, 220

kody statusu HTTP, 398, 453

modelu, 292, 657, 661

wyświetlanie zawartości, 223,

kolejność

po stronie klienta, 677–681

226

przeszukiwania danych

unikanie konfliktów, 681

kwalifikowane adresy URL, 404

parametrów, 634

w jQuery, 681

przetwarzania żądania Ajax,

w łączniku modelu, 668

L

620

wbudowane atrybuty, 670

tras, 367

własny atrybut, 671, 674

licznik stron, 213

wykonywania filtrów, 489, 491

wyświetlanie komunikatów,

link do widoku, 57

wykorzystania przestrzeni

664

LINQ, Language Integrated Query,

nazw, 378

wyświetlenie błędów, 662

26, 81, 98, 625

wyszukiwania szablonów, 597

zdalna, 681, 684

lista

kolekcja, 86, 125

kontroler, 34, 66, 427

kategorii, 209

ValueProviderFactories.

AccountController, 308

produktów, 171, 201, 260

´Factories, 652

AdminController, 295

lokalizacja widoków, 533

ViewEngine.Engines, 529

API, 709

komponent MyEmailSender, 70

CRUD, 276

’

komunikat

Customer, 390

kontroli poprawności, 669

DerivedController, 437

łącza, 45

potwierdzający, 290

GoogleAccountController, 465

Ajax, 616

kontroli poprawności, 664

Home, 136, 472, 658, 703, 722

do akcji, 419

o błędach, 168, 249, 513, 541,

HomeController, 82, 132, 456,

do formularza RSVP, 44

667, 673, 680

630

kategorii, 211

konfiguracja

koszyka, 222, 230, 246

nawigacji, 192

bazy danych, 177, 325

nadzorujący, 70

przeglądarki, 690

domyślnej trasy, 173

nawigacji, 208

stron, 185, 191, 214

filtra globalnego, 488

RemoteData, 521

z atrybutami, 403

kontenera DI, 167

Web API, 707

łączenie

paczek, 693

kontrolery

filtrów, 468, 485

pliku widoku, 39

asynchroniczne, 517, 519

metod akcji, 44

routingu, 37, 407, 418, 617

bezstanowe, 515

ograniczeń, 392

serwera aplikacji, 421

zapasowe, 500

sekcji, 538

uwierzytelniania formularzy,

kontrolka

statycznych segmentów URL,

304

GridView, 192

368

wstrzykiwania zależności, 137

podsumowania koszyka, 235

warunkowe, 143

konflikt nazw, 377, 418

kontrolki nawigacji, 201

łącznik modelu, 229, 633, 635, 642,

konsola JavaScript, 718

644, 647, 649, 653

731

Kup książkę

Poleć książkę

SKOROWIDZ

M

Get, 137

Render, 695, 696

GetAll, 138

RenderBody, 261, 278

mapowanie, 423

GetCart, 222, 229

Returns, 159

metod HTTP, 711

GetControllerSessionBehavior,

RouteLink, 211

obiektowo-relacyjne, ORM, 22

501

RsvpForm, 46

mechanizm

GetImage, 317

SaveChanges, 288

IntelliSense, 48, 67, 433, 444

GetLegacyURL, 409

SaveProduct, 287

przetwarzania zamówień, 242

GetNames, 572

Select, 100

rozwiązywania zależności, 137

GetPeopleData, 611

SetResolver, 138

TempData, 451

GetRemoteData, 518

TestIncomingRoutes, 369

View Bag, 212

GetRemoteDataAsync, 521

TestIncommingRouteResult,

menedżer pakietów NuGet, 337

getTestObject, 149

362

menu nawigacji, 208

GetValue, 655

TestRouteMatch, 361, 363

metadane, 284, 589–593, 670

GetVirtualPath, 411

Throws, 162

metadane modelu, 586

HandleUnknownAction, 514

ToConstant, 170

metoda

Helper, 579

TryUpdateModel, 650

@RenderBody, 113

HelperFor, 579

UpdateModel, 649

Action, 194, 207, 264, 405, 546

HttpClient.GetAsync, 104, 105

UpdateReservation, 711

metoda

IgnoreRoute, 424

ValidationMessageFor, 667

ActionLink, 45, 397–404

Index, 36, 223, 276

ValidationSummary, 54, 664,

Add, 503, 655

InRequestScope, 146

665

AddModelError, 666

InvokeAction, 506

ValueProducts, 141

Application_Start, 359, 416,

Is, 162

View, 662

529

IsAjaxRequest, 627

WebMail, 64

AreEqual, 150

IsInRange, 162

metody

Assert, 362

IsSectionDefined, 541

akcji, 45, 125, 431, 433

Authenticate, 311

IsValid, 674

akcji i trasy, 390

BeginForm, 49, 221, 564–566,

IsValidForRequest, 512

asynchroniczne, 103, 520, 521

613

Keep, 452

dołączania warunkowego, 144

BeginRouteForm, 566

List, 189

dostarczające dane, 627

BindModel, 654

MakeBooking, 659

HTTP, 381, 711

CanChangeLoginName, 77

MapRoute, 360, 367, 380

klasy

ChangeLoginName, 76

Menu, 209, 263

Assert, 150

Checkout, 237, 238

Names, 643

DefaultControllerFactory,

ContainsPrefix, 651

OnActionExecuted, 481

506

ContinueWith, 104

OnActionExecuting, 479

DefaultModelBinder, 669

Create, 295

OnAuthentication, 467

It, 159

CreateController, 499

OnAuthenticationChallenge,

kontrolera filtra, 485

CreatePerson, 637, 638

466

MapRoute, 416

CustomVariable, 372

OnResultExecuted, 482

OnActionExecuting, 490

DateTime, 683

OrderByDescending, 100

pomocnicze, 45, 547

Delete, 299

Partial, 198

Ajax, 601

DisplayMessage, 556

PartialView, 263

HTML, 186, 191, 551, 604

DisplaySummary, 641

Peek, 451

szablonowe, 575–599

Edit, 283, 288

ProduceOutput, 436

szkieletów, 584, 585

Editor, 579

RedirectToAction, 406, 450,

URL, 601

EditorFor, 579, 639

451

wbudowane, 559

EditorForModel, 284

RedirectToRoute, 449

wewnętrzne, 549

ExecuteResult, 437, 440

RegisterRoutes, 363, 399

zewnętrzne, 551

FilterByCategory, 92, 93

ReleaseController, 501

przeciążone, 51

FilterTest, 486

RemoveLine, 219

rozszerzające, 88–91

732

Kup książkę

Poleć książkę

SKOROWIDZ

metody

O

nieznanych akcji, 514

filtrujące, 92

ostatniego uwierzytelnienia,

LINQ, 101

obiekt, 86

469

opóźnione, 102

ActionResult, 437, 453

trasy, 412, 413

PageLinks, 187

Cart, 230

własnych błędów, 477

użycie delegata, 93

EmailSettings, 245

wyjątku, 347, 473

testowe, 149

HttpResponseBase, 436

zdarzeń, 721

zakresu, 146

HttpResponseMessage, 104

żądania POST, 50

mobilne przeglądarki internetowe,

kernel, 136

żądań, 414, 288

253

Mock, 159

żądań JSON, 626

model, 66

ModelMetaData, 240

obszary, 414

code-behind, 20

Person, 582, 633

odczyt

danych, 43

Product[], 126

danych, 432, 446

domeny, 66, 108, 164, 168, 313

RedirectResult, 438

zdjęć, 319

widoku, 186

Reservation, 721

odmiany MVC, 69

modyfikowanie

Route, 400

odświeżenie przeglądarek

kodu HTML widoku, 40

RouteCollection, 399

internetowych, 351

konstruktora, 144

RouteData, 410

odwołania między projektami, 166

projektu, 347

RouteValues, 410

odwrócenie kontroli, IoC, 71

monitorowanie żądań, 717

ViewBag, 41, 445

ograniczanie

Moq, 155

ViewResult, 296

liczby adresów, 424

MVC, 65, 67

obiekty

łącznika, 649

MVP, 70

.NET, 629

pobierania wartości, 653

MVVM, 70

ActionResult, 523

ograniczenia

imitujące, 155–158

trasy, 380

N

kontekstu, 432, 433

do zbioru wartości, 381

modelu, 109

klasy, 384

nadawanie

modelu widoku, 443, 445

własne, 385

priorytetu kontrolerom, 378

Reservation, 714

z użyciem metod HTTP, 381

stylów, 58, 196

wywołujące akcje, 506, 507

zastosowanie, 390

stylu polom wyboru, 663

wbudowane, 508

typu i wartości, 383

nadpisywanie

własne, 507

układu responsywnego, 267

filtra, 491–494

zakresu, 144

okno

metod, 505

zarządzające zależnościami,

Dodaj szkielet, 35

nagłówek

504

Dodawanie widoku, 39

ContentLength, 104

obsługa

Eksplorator rozwiązania, 32,

user-agent, 386

atrybutów routingu, 388

165

narzędzia, 129

błędów, 662

Eksplorator testów, 77

automatyzacji UI, 22

błędów dołączania modelu,

Eksploratora serwera, 178

testów jednostkowych, 22

650

Locals, 345

narzędzie Moq, 129

danych zdjęcia, 316

Menedżer odwołań, 83

nawias klamrowy, 357

formularzy, 50, 559

opcja Edit and Continue, 347

nawigacja, 363

IntelliSense, 67

opcje Ajax, 612

nazywanie tras, 360, 408

JavaScriptu, 614

opcjonalne segmenty URL, 373, 375

niejednoznaczność

JSON, 621

operacje CRUD, 279

kontrolerów, 417

kategorii, 202

opóźnione zapytania LINQ, 102

metod akcji, 514

komunikatu, 291

optymalizacja plików

Node.js, 22

łańcucha zależności, 73

CSS, 695

nowoczesne API, 26

nieprzeszkadzających

JavaScript, 695

wywołań, 607

OSI, Open Source Initiative, 26

733

Kup książkę

Poleć książkę

SKOROWIDZ

P

bootstrap-theme.css, 60

FlexMenu.cshtml, 265

Cart.cs, 217

FlexMenu.Mobile.cshtml, 269

paczki, 685

CartController.cs, 222, 229,

FormsAuthProvider.cs, 307

pakiet

234, 237, 246

FutureDateAttribute.cs, 673

Bootstrap, 59, 194

CartIndexViewModel.cs, 223

GetLegacyURL.cshtml, 409

narzędziowy, 166

CartModelBinder.cs, 227

GetPeople.cshtml, 606, 613,

NuGet, 335, 603, 702

Checkout.cshtml, 238, 240, 249

619, 622

optymalizacyjny, 396

Completed.cshtml, 251, 660

GetPeopleData.cshtml, 609

parametr

CountryValueProvider.cs, 651

Global.asax, 415, 488, 501, 505,

Cart, 247

CreatePerson.cshtml, 563–572,

529, 534

Func, 94

577, 595

Global.asax.cs, 228, 359

ShippingDetails, 247

CustomActionAttribute.cs, 479

GoogleAccountController.cs,

parametry

CustomActionInvoker.cs, 506

465

generyczne, 508

CustomAuthAttribute.cs, 461

GoogleAuthAttribute.cs, 465,

konstruktora, 73, 142

CustomControllerFactory.cs,

467, 469

obowiązkowe, 434

498, 515

GuestResponse.cs, 44

opcjonalne, 434

Customer.cs, 488

HomeController.cs, 36, 41, 50,

typów złożonych, 595

CustomerController.cs, 355,

84–91, 94–97, 115, 132, 340,

pasywna implementacja widoku, 70

388, 408, 492, 511

480, 512, 630, 703, 722

pętla foreach, 126, 128

CustomHelpers.cs, 555

IAuthProvider.cs, 307

pierwsza aplikacja, 31

CustomLocationViewEngine.cs,

Index.cshtml, 40, 59, 109, 110,

platforma

534

132, 224, 232, 237, 279, 340,

ASP.NET, 333

CustomOverrideActionFiltersA

416, 444, 548, 604, 704, 719,

Azure, 332

ttribute.cs, 493

723

plik

CustomRedirectResult.cs, 437

Index.js, 713

_AdminLayout.cshtml, 277,

CustomRouteHandler.cs, 413

IOrderProcessor.cs, 242

290, 294

CustomValueProviderFactory.cs,

IProductRepository.cs, 169,

_BasicLayout.cshtml, 112, 113,

652

287, 298

116

CustomVariable.cshtml, 371

IValueCalculator.cs, 134

_Layout.cshtml, 172, 208, 235,

Data.cshtml, 518

LegacyController.cs, 409

250, 256, 260, 263, 537–540,

DebugDataView.cs, 527

LegacyRoute.cs, 409, 411

561, 603, 608, 631, 659, 703

DebugDataViewEngine.cs, 528

LinqValueCalculator.cs, 131,

_Layout.Mobile.cshtml, 268,

DemoArray.cshtml, 126

144, 155

269

DemoExpression.cshtml, 120

List.cshtml, 173, 191, 196, 535,

_ViewStart.cshtml, 114, 195

DerivedController.cs, 438

542

AccountController.cs, 309, 457

DerivedControllers.cs, 431

LocalAttribute.cs, 512

ActionName.cshtml, 400–404,

Discount.cs, 140, 142, 143

Login.cshtml, 310, 457

412

DisplayPerson.cshtml, 582

LoginViewModel.cs, 308

Address.cshtml, 646

DisplaySummary.cshtml, 641

MakeBooking.cshtml, 660, 664,

AddressSummary.cs, 647

Edit.cs, 292

667, 687

AddressSummaryBinder.cs, 654

Edit.cshtml, 283, 286, 296, 314

Menu.cshtml, 211, 213

AdminAreaRegistration.cs, 415

Editor.cshtml, 705

MinimumDiscountHelper.cs,

AdminController.cs, 276, 288,

EfDbContext.cs, 181

147

299, 305, 316, 356

EFProductRepository.cs, 182,

MustBeTrueAttribute.cs, 672

AdminSecurityTests.cs, 311

287, 317

MyAsyncMethods.cs, 103

AdminTests.cs, 281

EmailOrderProcessor.cs, 243

MyExtensionMethods.cs, 88–93

Appointment.cs, 658, 672, 676,

Enum.cshtml, 598

MyPartial.cshtml, 542

679, 686

ErrorStyles.css, 250

MyStronglyTypedPartial.cshtm

BasicController.cs, 428, 435

FastController.cs, 516

l, 543

Boolean.cshtml, 599

FilterConfig.cs, 487

MyView.cshtml, 431

bootstrap.css, 60

FlexibleDiscountHelper.cs, 143

NameAndPrice.cshtml, 117

734

Kup książkę

Poleć książkę

SKOROWIDZ

Names.cshtml, 644

Styles.css, 57

potwierdzenie pobierania danych,

NavController.cs, 208, 212,

Summary.cshtml, 234, 258, 704

717

263, 266

Thanks.cshtml, 64

powiązanie z repozytorium, 182

NinjectDependencyResolver.cs,

Time.cshtml, 545

powielanie widoków, 264

137, 141, 145, 167, 170, 182,

UnitTest1.cs, 149, 151

prefiks, 638

245, 307

UnitTest2.cs, 157, 160

@, 124

NinjectWebCommon.cs, 139

UserAgentConstraint.cs, 385

~/, 393

NoJoeOnMondayAttribute.cs,

View.cshtml, 532

trasy, 392

674

ViewStart, 172

własny, 640

PagingHelpers.cs, 186

Web.config, 181, 183, 188, 245,

priorytety

PagingInfo.cs, 186

304–307, 341, 695

kontrolera, 378

PeopleController.cs, 602, 609,

WebApiConfig.cs, 709

przestrzeni nazw, 502

621, 625, 626

WebController.cs, 707, 711

procedura obsługi zdarzeń, 721

Person.cs, 559, 576, 587, 630

pliki

profilowanie

PersonMetadata.cs, 594

.aspx, 39

aplikacji, 696

Product.cs, 83, 85, 169

.cshtml, 39, 534

wczytywania skryptów, 689

ProductController.cs, 171, 189,

CSS, 695

programowanie

202, 214, 318, 497

JavaScript, 695

sieciowe, 26, 253

ProductsListViewModel.cs,

układu, 112

sterowane testami, 74, 78

189, 201

widoków, 113

sterowane testami, TDD, 22

ProductSummary.cs, 197, 321

pobieranie

witryn WWW, 19, 21

ProductSummary.cshtml, 221

danych, 99, 432

zwinne, 22

ProductSummary.Mobile.csht

schematu bazy danych, 327

projekt, 333

ml, 272

podgląd wartości danych, 344

ClientFeatures, 685

ProfileActionAttribute.cs, 481

podpowiadanie nazwy, 111

ControllerExtensibility, 496

ProfileAllAttribute.cs, 484

podsumowanie

ControllersAndActions, 428

ProfileResultAttribute.cs, 482

danych profilowania, 696

DebuggingDemo, 339

RangeError.cshtml, 474, 475

koszyka, 233, 235

EssentialTools, 130

RangeErrorPage.html, 471

podzespół System.Net.Http, 83, 104

Filters, 456

RangeExceptionAttribute.cs,

pola z błędami, 56

HelperMethods, 548, 576, 602

471, 474

pole

LanguageFeatures, 81

RemoteDataController.cs, 518,

__VIEWSTATE, 55

ModelValidation, 658

520

wyboru, 567

MvcModels, 630

RemoteService.cs, 518, 520

polecenia

PartyInvites, 32

Reservation.cs, 701

Razor, 109

Razor, 107

ReservationRepository.cs, 701

SQL, 328

SportsStore, 164, 201, 227, 253,

Result.cs, 496

polecenie

275, 303

Result.cshtml, 82

@if, 126

SportsStore.WebUI, 256

Role.cshtml, 596

@model, 109

UrlAndRoutes, 353

RouteConfig.cs, 173, 193, 205,

if, 124

UrlsAndRoutes, 396

358–375, 378, 402, 407, 411,

Install-Package, 59

Views, 526

413, 418, 421, 424, 565, 632

switch, 123, 124, 125

WebServices, 700

RouteTests.cs, 360

using, 149

WorkingWithRazor, 531

RsvpForm.cshtml, 46, 54, 61

połączenie

projektowanie modelu danych, 43

ShippingDetails.cs, 236

ograniczeń trasy, 384

projekty

ShippingDetails.cshtml, 241

z bazą danych, 181, 326

sklepów internetowych, 163

ShoppingCart.cs, 88, 131

połączone przeglądarki, 350

testów jednostkowych, 147

SimpleMessageAttribute.cs,

pomijanie systemu routingu, 424

Visual Studio, 135

489, 491

poprawianie

przechwytywanie informacji

Site.css, 341

kodu, 153

o adresie, 639

StaticContent.html, 420

licznika stron, 213

przeciążanie metod, 564, 665

735

Kup książkę

Poleć książkę

SKOROWIDZ

przegląd projektu, 333

rejestrowanie

Selenium RC, 79

przeglądarka internetowa, 350, 423,

aktywatora kontrolerów, 505

separacja zadań, 374

691

dostawcy uwierzytelniania, 307

serializowanie wartości, 55

przekazywanie

fabryki kontrolerów, 501

serwer

danych

implementacji, 244

aplikacji, 421

do widoku, 443

łącznika modelu, 655, 656

IIS Express, 422

z użyciem ViewBag, 445

silnika widoku, 529

settery, 84

parametrów, 401

trasy, 358–360

silnie typowane metody, 570

przekierowanie, 406, 407, 447, 449

repozytorium

silnik

do innej metody akcji, 450

abstrakcyjne, 169

Razor, 107, 531, 536, 541

trwałe, 448

produktów, 182, 286

widoku, 67, 107, 523

z użyciem tras, 449

resetowanie hasła, 70

składanie zamówień, 236

aplikacji, 346

responsywne

składnia Knockout, 719

przestrzeń nazw, 127, 377

funkcje CSS, 257

składniki klasy TagBuilder, 553

EssentialTools.Models, 149

listy produktów, 260

słowo kluczowe

System.Web, 430

nagłówki, 256

async, 105

System.Web.Http, 711

siatki, 262

await, 105

przesyłanie

REST, 21

class, 62

danych edycji, 289

routing, 25, 37, 387, 395

model, 444

plików, 314

URL, 353

new, 73, 136

zdjęć, 312

żądań, 420

return, 104

przetwarzanie

rozbudowa modelu, 721

using, 49, 100

danych, 119

rozdzielanie komponentów, 71

SPA, Single Page Application, 28,

JSON, 622

rozszerzalność, 24

699

właściwości modelu, 634

rozszerzanie

SportsStore, 163

zamówień, 242, 247

bazy danych, 312

administracja, 275

przychodzące żądania URL, 353

kontrolerów, 495

bezpieczeństwo, 303

przycisk

modelu domeny, 236, 313

koszyk, 216, 227

Dodaj do koszyka, 216

wyrażenia filtrującego, 96

nawigacja, 201

Publish, 331

rozwiązywanie zależności, 137, 138,

promowanie marki, 257

Update Database, 179

142

usprawnienia, 303

usuwania, 232

Ruby on Rails, 22

wersja mobilna, 253

zamówienia, 237

rzutowanie

sprawdzanie

Złóż zamówienie, 237

na IController, 501

błędów, 54

przyciski koszyka, 221

parametru, 409

istnienia sekcji, 540

przygotowanie obiektów danych, 626

wartości, 123

uwierzytelniania, 466

przypisanie wartości atrybutu, 121

stan

przyrostek Attribute, 488

S

aplikacji, 345

publikowanie aplikacji sieciowej, 329

sesji, 515, 516

punkt przerwania, 343, 344

schemat

standardy sieciowe, 21

pusty ciąg znaków, 666

adresów URL, 205, 357, 424

statyczne segmenty URL, 366, 368

opcjonalny, 373

sterowanie edycją i widocznością,

R

statyczny, 366

586

własne zmienne, 370

stosowanie

raportowanie kategorii, 212

bazy danych, 177, 326, 327

konwencji dla klas

Razor, 107, 532

segmenty statyczne adresu URL,

kontrolerów, 337

reakcja na wyjątek, 474

366

konwencji dla układów, 338

refaktoring

selekcja metod akcji, 509, 512

konwencji dla widoków, 337

aplikacji, 196

selektywne

metod rozszerzających, 90

kontrolera Home, 139

kodowanie treści, 558

układu, 113

metod akcji, 609

kodowanie wartości danych, 558

strona podsumowania, 251

736

Kup książkę

Poleć książkę

SKOROWIDZ

stronicowanie, 184

przekierowanie, 448

arkusza stylów, 56

struktura plików i katalogów, 33

przesyłanie danych edycji, 289

atrybutu kontroli poprawności,

styl widoku

przetwarzanie zamówień, 247

672, 674

Index, 59

raportowanie kategorii, 212

bazy danych, 176, 324

RsvpForm, 61

segmenty statyczne, 369

danych wyjściowych, 435

Thanks, 62

stronicowanie, 184

dostawcy uwierzytelniania, 306

style, 194

usuwanie produktów, 299

dostawcy wartości, 651

Bootstrap, 195

uwierzytelnianie, 311

edytora, 596

CSS, 603

ViewBag, 446

elementu select, 572

system

wartości domyślne, 365

fabryki kontrolerów, 498

kontroli poprawności, 249

zliczanie produktów, 216

filtra wyjątku, 470

routingu, 37, 353, 357

zmienne segmentów, 372

filtrujących metod

szablon

zmienne segmenty

rozszerzających, 92

Empty, 196

przechwytujące, 376

formularza Ajax, 610

projektu, 32, 339

testowanie, 24, 153

formularzy, 562

szablonowe metody pomocnicze,

aplikacji, 133, 356, 458, 549,

imitacji repozytorium, 169, 205

575–599

705

implementacji IViewEngine,

szablony

funkcji tworzenia rezerwacji,

528

ogólne, 597

722

implementacji RouteBase, 408

wbudowane, 599

kontrolera API, 707

interfejsu użytkownika, 314

szkielet, 583

koszyka, 218

klasy kontrolera, 500

operacji dołączania danych,

klasy Product, 168

¥

717

kodu zabezpieczeń, 461

przychodzących adresów URL,

kontekstu Entity Framework,

ścieżka dostępu, 443

360

180

regresyjne, 74

kontrolera, 340, 355, 428, 430

T

segmentów statycznych, 369

AccountController, 308

silnika widoku, 529

asynchronicznego, 519, 520

tabela Products, 180

stronicowania, 184

CRUD, 276

tablica, 125

widoku, 41

Home, 703

TDD, test-driven development, 74,

zmiennych segmentów, 372

nawigacji, 208

78

zmiennych segmentów

Web API, 707

test jednostkowy, 22, 74, 147, 155,

przechwytujących, 376

koszyka, 216

163

testy

łańcucha zależności, 140

adres URL, 360

automatyczne, 74

łącznika modelu, 227, 653

akcja Index, 276

integracyjne, 74, 79

łączy, 603, 605

aktualizowanie, 203

jednostkowe, 22, 74, 147, 155,

łączy Ajax, 616

dane stronicowania, 190

163

metody akcji, 45

filtrowanie według kategorii,

TPL, Task Parallel Library, 517

metody akcji Edit, 283

205

trasa formularza, 565

metody pomocniczej, 549

generowanie listy kategorii, 210

trasy, 37, 207, 357

modelu, 701

generowanie widoku, 441

dla plików na dysku, 422

modelu domeny, 168

kody statusu HTTP, 453

domyślne, 173

nieprzeszkadzających

kontroler koszyka, 230

nazwane, 408

formularzy, 608

kontrolery i akcje, 438

o zmiennej długości, 375

nowego projektu, 31

koszyk na zakupy, 218

tworzenie

nowych produktów, 295

łącza stron, 187

abstrakcyjnego repozytorium,

obiektów .NET, 629

obiekty modelu widoku, 445

169

obiektów parametrów, 434

odczyt zdjęć, 319

adresów URL, 603, 605

obiektu domeny, 66

ograniczenia tras, 382

akcji potomnych, 544

obiektu imitacji, 158

opcjonalne segmenty URL, 375

aplikacji SPA, 712

obiektu obsługi trasy, 412

737

Kup książkę

Poleć książkę

SKOROWIDZ

tworzenie

niestandardowe, 646

atrybutu

obszaru, 414, 418

proste, 634

Bind, 642

pliku układu, 277

ściśle określone, 570

DataType, 590, 591

procedury obsługi zdarzeń, 721

wyliczeniowe, 572

Display, 241, 242, 590

projektu, 334, 338

złożone, 595, 636

DisplayName, 589

projektu testów

HiddenInput, 586, 587

jednostkowych, 147

U

HttpPost, 510

przycisków koszyka, 221

NonAction, 511

repozytorium produktów, 182

uaktualnienie projektu testów

Remote, 683

responsywnego nagłówka, 256

jednostkowych, 397

UIHint, 592, 598

responsywnej listy produktów,

układ, 111

automatycznie

260

_AdminLayout.cshtml, 310

implementowanych

rezerwacji, 719, 722, 725

dla urządzeń mobilnych, 268

właściwości, 83

rozwiązania, 164

układy

biblioteki Moq, 159

schematu bazy danych, 326

responsywne, 255, 267

Bootstrap, 196

sekcji opcjonalnej, 541

współdzielone, 115

delegata, 93

silnika widoku, 523

ukończenie aplikacji, 722

dołączania danych, 227

szablonu ogólnego, 597

ukrywanie właściwości obiektu, 588

dołączania modelu, 51, 632

tabeli, 178, 327

ulepszanie adresów URL, 193, 205

fabryki kontrolerów, 502

tablicy obiektów, 97

upraszczanie

filtra HandleErrorAttribute, 477

testów automatycznych, 20

kontrolera Home, 722

filtrów, 458, 459

testów jednostkowych, 148

tras, 396

akcji, 478–481

tras, 389

uruchamianie

autoryzacji, 461

trasy, 358

aplikacji, 168, 174

globalnych, 487, 489

typu anonimowego, 97

debugera, 341

uwierzytelniania, 464

układu, 112, 659, 687

testów, 152

wbudowanych, 483

widoków, 660

usługa Azure, 324, 329

wyjątków, 470, 471

widoku, 37, 109, 210, 309, 340,

usprawnienie funkcji removeItem,

wyników, 482

356, 687

718

filtrującej metody

widoku częściowego, 196, 197,

ustawianie

rozszerzającej, 92

542

danych widoku, 41

formularza HTML, 561

widoku edycji, 283

obiektu zakresu, 144

funkcji połączonych

widoku formularza

opcji Ajax, 612

przeglądarek, 350

synchronicznego, 606

ustawienia

inferencji typów, 97

widoku Index, 278

aplikacji, 245, 330

inicjalizatorów obiektów, 86

wielu formularzy, 221

regionalne, 636

interfejsu IController, 428

witryny internetowej, 324

usuwanie

JavaScript, 23

zewnętrznej metody

atrybutu class, 266

Knockout, 712

pomocniczej, 551

jawnej kontroli poprawności,

kolekcji, 645

znaczników select, 571

675

konstrukcji warunkowych, 123

typ

produktów, 232, 298–300

kontenera DI, 73

bool, 54

rezerwacji, 718

kontrolek, 570

click, 721

towarów, 233

kontrolerów asynchronicznych,

enum, 572

uwierzytelnianie, 311, 466

517

JsonRequestBehavior, 622

formularzy, 304

kontrolerów bezstanowych, 515

Role, 572

z użyciem filtrów, 305

kontroli poprawności, 679

SessionStateBehavior, 515

użycie

LINQ, 99

value, 721

@using, 188

łączenia warunkowego, 143

typy

akcji potomnych, 544, 546

łącznika modelu, 633

anonimowe, 97

aktywatora kontrolerów, 504

mechanizmu ViewBag, 212,

filtrów, 459

atrybutów routingu, 387

446

738

Kup książkę

Poleć książkę

SKOROWIDZ

metadanych, 284, 589, 590, 591

wbudowanych metod

wbudowane

metadanych modelu, 586

pomocniczych, 559

atrybuty kontroli poprawności,

metod

widoków częściowych, 198,

670

asynchronicznych, 103, 520,

541, 543

szablony widoku, 592, 593

521

wielu egzemplarzy, 145

typy ActionResult, 439

kontrolera filtra, 485

wielu tras, 379

wbudowany filtr wyjątków, 476

pomocniczych, 582

Windows Azure, 324

wczytywanie

pomocniczych szkieletów, 584

własnych lokalizacji, 536

arkuszy stylów, 689

rozszerzających, 88

własnych nazw akcji, 508

skryptów, 689

metody Html.ActionLink, 397

własnych zmiennych, 372

wdrażanie aplikacji, 323, 328–331

Moq, 155

właściwości

Web API, 699, 706

niestandardowego ograniczenia

Layout, 113

wersja

trasy, 386

Order, 490

biurowa, 259

Ninject, 133

Response, 436

mobilna, 259

notacji kropki, 100

RouteData.Values, 372

weryfikacja danych, 55

obiektu imitacyjnego, 157

wyrażenia

wewnętrzna metoda pomocnicza,

obiektu Mock, 159

@model, 110

549

obiektu modelu widoku, 443

@Model, 109

widok, 37, 523–46

opcji Edit and Continue, 347

@using, 127

Address, 647

opcjonalnych segmentów URL,

wyrażeń

Completed, 660, 664

374

lambda, 93, 95

CreatePerson, 572

opóźnionych metod

Razor, 118, 121

DebugData, 529

rozszerzających LINQ, 102

regularnych, 380

DemoExpression.cshtml, 120

paczek stylów i skryptów, 691

wywołań zwrotnych, 619

DisplayPerson, 582, 583

parametrów metod akcji, 433

zakresu żądania, 145

DisplaySummary, 641

parametrów opcjonalnych, 434

zewnętrznej metody

dla urządzeń mobilnych, 269,

parametru konstruktora, 143

pomocniczej, 553

273

pliku ViewStart, 114

zmiennych segmentu, 390

edycji, 283

polecenia warunkowego, 124

formularza synchronicznego,

prefiksu trasy, 392

V

606

punktów przerwania, 343

GetPeople, 606, 622

responsywnego układu

ViewState, 20

Index, 59, 60, 281, 417

Bootstrap, 258

Visual Studio, 31, 135, 147, 157

Index.cshtml, 548

responsywnej siatki, 262

debuger, 341, 342

List.cshtml, 191, 195, 198

sekcji w widoku, 538

projekty MVC, 333

listy, 278, 280

słowa async, 105

tworzenie rozwiązania, 164

Login, 310

słowa await, 105

Visual Studio Express 2013 for

MakeBooking, 660, 662, 689

stylów, 586

Web, 28

NameAndPrice, 118

szablonowych metod

RangeError, 474, 475

pomocniczych, 578

W

Razor, 109, 532

szablonu niestandardowego, 599

Role, 596

tras nazwanych, 408

warstwa dostępu do danych, 69

RsvpForm, 50, 61

trasy, 363

wartości

ściśle określonego typu, 46

typów anonimowych, 97

domyślne, 363, 365

Thanks, 52, 62, 63

układów współdzielonych, 115

domyślne parametru, 636

z formularzem, 47

układu responsywnego, 255

typu DataType, 591

widoki, 66

warunkowego dołączania, 144

typu wyliczeniowego, 515

beztypowe, 444

wbudowanego filtra

wartość null, 54, 320, 635

częściowe, 196–198, 541

autoryzacji, 463

warunkowe dołączanie, 144

silnie typowane, 444

wbudowanego filtra wyjątków,

WatiN, 79

wielokrotne wykorzystanie

476

zmiennych segmentów, 402

739

Kup książkę

Poleć książkę

SKOROWIDZ

wiersz poleceń NuGet, 59

wskazywanie

wysyłanie

właściwości

trasy, 566

formularza, 641

automatyczne, 85, 86

widoku, 581

kodów, 452

klasy

wstawianie wartości danych, 119

kodu 401, 453

ActionExecutedContext, 482

wstrzykiwanie zależności, DI, 71,

kodu 404, 452

ActionExecutingContext,

129, 137

wyszukiwanie

479

wstrzyknięcie konstruktora, 140

lokalizacji widoków, 533

AjaxOptions, 611, 618

wybieranie szablonu wyświetlania,

szablonów, 597

ControllerContext, 470

591

wyświetlanie

ExceptionContext, 470

wybór

błędów, 662

HandleErrorAttribute, 476

pliku układu, 116, 117

danych JSON, 625

HandleErrorInfo, 478

przeglądarki, 350

elementów, 581

HtmlHelper, 552

pustego kontrolera, 35

komunikatów, 250, 667

ModelBindingContext, 654

silnika widoku, 67

komunikatów kontroli

RequestContext, 499

widoku, 262

poprawności, 664

ViewContext, 526, 552

wychodzące adresy URL, 395, 398,

komunikatu potwierdzającego,

ViewDataDictionary, 526

399

290

konstruktora, 142

wyjątek, 346

liczby stron, 215

wyszukiwania, 534

ArgumentOutOfRange

listy produktów, 171

właściwość

Éxception, 471

łączy nawigacji, 192

@Model, 109

DivideByZeroException, 476

łączy stron, 185, 191, 207

AjaxOptions.Confirm, 615

System.ArgumentException, 183

nieobsługiwanego widoku, 530

AjaxOptions.LoadingElementId,

wykonywanie

niewłaściwych łączy, 214

615

intencji, 436

strony podsumowania, 251

AppRelativeCurrentExecution

przekierowań, 447

wartości domyślnej zmiennej,

´FilePath, 361

zapytań, 98

371

ClientName, 662

zapytań LINQ, 98, 103

wartości zmiennej, 371

controller, 502

wykrywanie żądań Ajax, 626

zawartości, 723

CurrentCategory, 202

wyłączanie

zawartości koszyka, 223, 226

Date, 658

kontroli poprawności, 678

zawartości tablic, 125

DiscountSize, 142

nieprzeszkadzających wywołań

zdjęć produktów, 321

DisplayName, 242

Ajax, 607

wywołania zwrotne, 618

Exclude, 643

właściwości, 588

wywołania zwrotne Ajax, 620

HomeAddress, 595, 639

wymuszanie separacji zadań, 374

wywoływanie

HttpContext.Session, 516

wynik akcji, 431

akcji potomnej, 545

IDENTITY, 178

wypełnianie obszaru, 416

metod akcji, 495

Layout, 113, 115

wyrażenia

względne adresy URL, 404

LoadingElementDration, 615

Razor, 118

wzorzec

LoadingElementId, 614

regularne, 380

architektury trójwarstwowej,

Model, 655

wyrażenie

69

ModelState.IsValid, 662

@foreach, 126

model-widok, 69

Order, 490

@model, 110, 714

MVC, 65

PersonId, 588

@Model, 111, 119, 133

POST-Redirect-GET, 447

Response, 436

@Model.ClientName, 716

repozytorium, 169

RouteData.Values, 372

@using, 127, 128

Smart UI, 67

RouteExistingFiles, 420

@ViewBag, 119

URL, 357, 363, 366

ViewBag, 212

lambda, 93–96

ViewContext, 265

wyróżnianie

włączanie opcji Edit and Continue,

bieżącej kategorii, 212–214

347

błędów, 58

wprowadzanie danych, 567, 570

pól, 56

740

Kup książkę

Poleć książkę

SKOROWIDZ

Z

filtra

znak

akcji, 481

@, 62, 109, 123, 533

zabezpieczanie kontrolera

uwierzytelniania, 467

cudzysłowu, 188

administracyjnego, 303

wyjątku, 473

zrywanie zależności, 72

zadania testów

wyniku, 483

zwracanie

integracyjnych, 79

interfejsu, 134, 135

błędów, 452

jednostkowych, 74

metadanych, 285

kodów HTTP, 452

zagnieżdżona klasa modelu, 638

ograniczeń trasy, 390

kodu HTML, 440

zakres wartości, 162

paczek, 694, 696

wyniku, 159

zalety ASP.NET MVC, 23

sekcji układu, 536

zamówienia, 236

stylów Bootstrap, 195

½

zapisywanie zdjęć, 316

zdalna kontrola poprawności, 681,

zapytania

684

źródło danych łącznika, 649

LINQ, 98

zdarzenia, 721

opóźnione, 102

zdjęcia produktów, 321

¿

złożone, 100

zgłaszanie wyjątku, 161

zarządzanie

zintegrowane środowisko

żądania

katalogiem, 275

programistyczne, IDE, 129

Ajax, 614

kodowaniem ciągów

zliczanie produktów, 216

asynchroniczne, 615

tekstowych, 554

zmiana kodu

dla plików dyskowych, 420

stanem sesji, 515, 516

metody pomocniczej, 550

żądanie

wyświetlaniem zawartości, 723

znaczników, 551

adresu URL, 400, 511

zależnościami, 504

zmienianie hasła, 75

GET, 50, 426, 622

zasady poprawności, 670

zmienne

pliku dyskowego, 423

zastępowanie szablonów, 599

lokalne, 265

pliku statycznego, 422

zastosowanie, Patrz także użycie

przechwytujące, 375

POST, 50, 288, 426, 622

atrybutu kontroli poprawności,

segmentu, 370, 389, 402

przesłania pliku, 421

672

znacznik, Patrz element

wartości null, 635

atrybutu Route, 389

741

Kup książkę

Poleć książkę

SKOROWIDZ

728

Kup książkę

Poleć książkę

KSIĄŻKI TEGO AUTORA

Angular. Profesjonalne techniki programowania. Wydanie II ASP.NET Core MVC 2. Zaawansowane programowanie. Wydanie VII ASP.NET MVC 5. Zaawansowane programowanie AngularJS. Profesjonalne techniki HTML5. Przewodnik encyklopedyczny ASP.NET MVC 4. Zaawansowane programowanie