Search and Find
Service
Title page
1
Copyright page
2
Contents at a Glance
4
Table of contents
5
About the Author
20
About the Technical Reviewers
21
Acknowledgments
22
Introduction
23
You Don’t Need to Know ASP.NET MVC 1 Already
23
Which Technologies Are Used in This Book
23
Code Samples
23
Errata
24
Contacting the Author
24
PART 1 Introducing ASP.NETMVC 2
25
CHAPTER 1 What’s the Big Idea?
26
A Brief History of Web Development
26
Traditional ASP.NET Web Forms
27
What’s Wrong with ASP.NET Web Forms?
28
Web Development Today
29
Web Standards and REST
29
Agile and Test-Driven Development
30
Ruby on Rails
30
Key Benefits of ASP.NET MVC
31
MVC Architecture
31
Extensibility
31
Tight Control over HTML and HTTP
32
Testability
32
Powerful Routing System
33
Built on the Best Parts of the ASP.NET Platform
33
Modern API
34
ASP.NET MVC Is Open Source
34
Who Should Use ASP.NET MVC?
34
Comparisons with ASP.NET Web Forms
34
Migrating from Web Forms to MVC
35
Comparisons with Ruby on Rails
35
Comparisons with MonoRail
36
What’s New in ASP.NET MVC 2
36
Summary
37
CHAPTER 2 Your First ASP.NET MVCApplication
38
Preparing Your Workstation
38
Creating a New ASP.NET MVC Project
39
Adding the First Controller
41
Rendering Web Pages
42
Creating and Rendering a View
42
Adding Dynamic Output
45
A Starter Application
46
The Story
46
Designing a Data Model
47
Adding a Model Class
47
Linking Between Actions
48
Introducing Strongly Typed Views
51
Building a Form
52
Dude, Where’s My Data?
55
Handling Form Submissions
55
Introducing Model Binding
56
Rendering Arbitrary Views and Passing a Model Object to Them
56
Adding Validation
58
Model Binding Tells Input Controls to Redisplay User-Entered Values
60
Highlighting Invalid Fields
61
Finishing Off
62
Summary
64
CHAPTER 3 Prerequisites
65
Understanding MVC Architecture
65
The Smart UI (Anti-Pattern)
66
Separating Out the Domain Model
67
Model-View Architecture
67
Three-Tier Architecture
68
MVC Architecture
69
Implementation in ASP.NET MVC
70
History and Benefits
70
Variations on MVC
71
Where’s the Data Access Code?
71
Putting Domain Logic Directly into Controllers
71
Model-View-Presenter
71
Model-View-View Model
72
Domain Modeling
72
An Example Domain Model
73
Ubiquitous Language
74
Aggregates and Simplification
74
Is It Worth Defining Aggregates?
76
Keeping Data Access Code in Repositories
76
Using LINQ to SQL
77
Implementing the Auctions Domain Model
79
Implementing the Auction Repositories
81
Building Loosely Coupled Components
83
Taking a Balanced Approach
84
Using Dependency Injection
84
An MVC-Specific Example
85
Using a DI Container
86
Meet Ninject
87
Getting Started with Automated Testing
88
Understanding Unit Testing
89
How DI Supports Unit Testing
91
TDD and the Red-Green-Refactor Workflow
91
To Unit Test or Not to Unit Test
94
Understanding Integration Testing
95
BDD and the Given-When-Then Model
97
Why This Book Demonstrates Unit Testing Rather Than Integration Testing
99
C# 3 Language Features
100
The Design Goal: Language-Integrated Query
100
Extension Methods
101
Lambda Methods
102
Generic Type Inference
103
Automatic Properties
103
Object and Collection Initializers
104
Type Inference
104
Anonymous Types
105
Putting It All Together
105
Deferred Execution
107
Using LINQ to Objects
107
Lambda Expressions
108
IQueryable
and LINQ to SQL 109
LINQ to Everything
111
Summary
111
CHAPTER 4 SportsStore: A Real Application
112
Getting Started
114
Creating Your Solutions and Projects
114
Starting Your Domain Model
117
Creating an Abstract Repository
118
Making a Fake Repository
119
Displaying a List of Products
119
Adding the First Controller
120
Setting Up the Default Route
121
Adding the First View
122
Connecting to a Database
125
Defining the Database Schema
125
Setting Up LINQ to SQL
128
Creating a Real Repository
128
Setting Up DI
130
Creating a Custom Controller Factory
130
Using Your DI Container
131
Creating Unit Tests
134
Configuring a Custom URL Schema
139
Assigning a Default Parameter Value
140
Displaying Page Links
141
Making the HTML Helper Method Visible to All View Pages
144
Supplying a Page Number to the View
145
Improving the URLs
149
Styling It Up
150
Defining Page Layout in the Master Page
150
Adding CSS Rules
151
Creating a Partial View
153
Summary
155
CHAPTER 5 SportsStore: Navigation andShopping Cart
156
Adding Navigation Controls
156
Filtering the Product List
156
Implementing the Category Filter
158
Defining a URL Schema for Categories
160
Building a Category Navigation Menu
162
Creating the Navigation Controller
162
Selecting and Rendering a List of Category Links
165
Highlighting the Current Category
167
Building the Shopping Cart
170
Defining the Cart Entity
170
Adding “Add to Cart” Buttons
173
Multiple
174
Giving Each Visitor a Separate Shopping Cart
175
ASP.NET MVC Offers a Tidier Way of Working with Session Storage
175
Creating a Custom Model Binder
176
Creating CartController
176
Implementing AddToCart and RemoveFromCart
178
Displaying the Cart
180
Removing Items from the Cart
183
Displaying a Cart Summary in the Title Bar
184
Submitting Orders
186
Enhancing the Domain Model
186
Adding the “Check Out Now” Button
187
Prompting the Customer for Shipping Details
188
Defining an Order Submitter DI Component
190
Completing CartController
190
Adding a Fake Order Submitter
193
Displaying Validation Errors
194
Displaying a “Thanks for Your Order” Screen
195
Implementing EmailOrderSubmitter
196
Summary
199
CHAPTER 6 SportsStore: Administration andFinal Enhancements
200
Adding Catalog Management
201
Creating AdminController: A Place for the CRUD Features
201
Rendering a Grid of Products in the Repository
203
Implementing the List View
204
Building a Product Editor
207
Creating a Product Editor UI
207
Handling Edit Submissions
210
Adding Validation
213
Enabling Client-Side Validation
215
Creating New Products
215
Deleting Products
217
Securing the Administration Features
219
Setting Up Forms Authentication
219
Using a Filter to Enforce Authentication
220
Displaying a Login Prompt
221
Image Uploads
225
Preparing the Domain Model and Database
225
Accepting File Uploads
226
A Little-Known Fact About HTML Forms
227
Saving the Uploaded Image to the Database
227
Handling Form Posts That Don’t Include an Image
228
Displaying Product Images
230
Summary
233
PART 2 ASP.NET MVC in Detail
234
CHAPTER 7 Overview of ASP.NET MVC Projects
235
Developing MVC Applications in Visual Studio
235
Naming Conventions
240
The Initial Application Skeleton
240
Debugging MVC Applications and Unit Tests
241
Launching the Visual Studio Debugger
241
Attaching the Debugger to IIS
243
Attaching the Debugger to a Test Runner (e.g., NUnit GUI)
243
Remote Debugging
244
Using the Debugger
244
Stepping into the .NET Framework Source Code
245
Stepping into the ASP.NET MVC Framework Source Code
246
The Request Processing Pipeline
247
Stage 1: IIS
249
Stage 2: Core Routing
250
Routing Configurations
251
Stage 3: Controllers and Actions
251
Finding and Invoking Controllers
251
What Controllers Must Do
251
What Controllers Normally Do
252
Stage 4: Action Results and Views
252
Rendering a View
252
Summary
253
CHAPTER 8 URLs and Routing
254
Putting the Programmer Back in Control
254
About Routing and Its .NET Assemblies
255
Setting Up Routes
255
Understanding the Routing Mechanism
258
The Main Characters: RouteBase, Route, and RouteCollection
258
How Routing Fits into the Request Processing Pipeline
258
The Order of Your Route Entries Is Important
259
Adding a Route Entry
260
URL Patterns Match the Path Portion of a URL
260
Meet RouteValueDictionary
261
Take a Shortcut with MapRoute()
261
Using Parameters
262
Receiving Parameter Values in Action Methods
262
Using Defaults
263
Creating Optional Parameters with No Default Value
264
Using Constraints
264
Matching Against Regular Expressions
265
Matching HTTP Methods
266
Matching Custom Constraints
267
Prioritizing Controllers by Namespace
267
Accepting a Variable-Length List of Parameters
268
Matching Files on the Server’s Hard Disk
269
Using the RouteExistingFiles Flag
269
Using IgnoreRoute to Bypass the Routing System
270
Generating Outgoing URLs
271
Generating Hyperlinks with Html.ActionLink()
271
Passing Extra Parameters
272
How Parameter Defaults Are Handled
273
Generating Fully Qualified Absolute URLs
273
Generating Links and URLs from Pure Routing Data
274
Performing Redirections to Generated URLs
275
Understanding the Outbound URL-Matching Algorithm
275
Generating Hyperlinks with Html.ActionLink
and Lambda Expressions 278
Working with Named Routes
279
Why You Might Not Want to Use Named Routes
279
Working with Areas
280
Setting Up Areas
280
Routing and URL Generation with Areas
283
Linking to an Action in the Same Area
284
Linking to an Action in a Different Area
285
Linking to an Action in the Root Area
285
Areas and Explicitly Named Routes
285
Areas and the Ambiguous Controller Problem
286
Areas Summary
286
Unit Testing Your Routes
286
Testing Inbound URL Routing
287
Using Test Doubles
288
Using a Mocking Framework (Moq)
289
Testing Outbound URL Generation
291
Unit Testing Area Routes
293
Further Customization
293
Implementing a Custom RouteBase Entry
294
Implementing a Custom Route Handler
295
URL Schema Best Practices
296
Make Your URLs Clean and Human-Friendly
296
Follow HTTP Conventions
297
GET and POST: Pick the Right One
298
On Query Strings
298
Use the Correct Type of HTTP Redirection
298
SEO
300
Summary
300
CHAPTER 9 Controllers and Actions
301
An Overview
301
Comparisons with ASP.NET Web Forms
302
All Controllers Implement IController
302
The Controller Base Class
303
Receiving Input
304
Getting Data from Context Objects
305
Using Action Method Parameters
306
Parameters Objects Are Instantiated Using Value Providers and Model Binders
307
Optional and Compulsory Parameters
307
Specifying Default Parameter Values
308
Parameters You Can’t Bind To
309
Invoking Model Binding Manually in an Action Method
309
Producing Output
310
Understanding the ActionResult Concept
310
Returning HTML by Rendering a View
313
Rendering a View by Path
314
Passing a ViewData Dictionary and a Model Object
314
Treating ViewData As a Loosely Typed Dictionary
315
Sending a Strongly Typed Object in ViewData.Model
316
Combining Both Approaches
317
Passing a Dynamic Object As ViewData.Model
317
Performing Redirections
318
Redirecting to a Different Action Method
319
Redirecting to a Different URL
320
Using TempData to Preserve Data Across a Redirection
320
Where TempData Stores Its Data
321
Controlling the Lifetime of TempData Items
321
Returning Textual Data
322
Generating an RSS Feed
323
Returning JSON Data
324
Returning JavaScript Commands
325
Returning Files and Binary Data
326
Sending a File Directly from Disk
326
Sending the Contents of a Byte Array
328
Sending the Contents of a Stream
328
Creating a Custom Action Result Type
329
Example: Watermarking an Image (and the Concept of Unit Testability Seams)
329
Unit Testing Controllers and Actions
331
How to Arrange, Act, and Assert
332
Testing a Choice of View and ViewData
332
Testing ViewData Values
333
Testing Redirections
334
More Comments About Unit Testing
335
Mocking Context Objects
335
Reducing the Pain of Mocking
337
Method 1: Make a Reusable Helper That Sets Up a Standard Mock Context
337
Method 2: Access Dependencies Through Virtual Properties
339
Method 3: Receive Dependencies Using Model Binding
341
Method 4: Turn Your Dependencies into DI Components
341
Method 5: Factor Out Complexity and Don’t Unit Test Controllers
341
Summary
342
CHAPTER 10 Controller Extensibility
343
Using Filters to Attach Reusable Behaviors
343
Introducing the Four Basic Types of Filter
344
Applying Filters to Controllers and Action Methods
345
Creating Action Filters and Result Filters
346
Controlling the Order of Execution
348
Filters on Actions Can Override Filters on Controllers
350
Using the Controller Itself As a Filter
351
Creating and Using Authorization Filters
351
How Authorization Filters Interact with Output Caching
352
Creating a Custom Authorization Filter
353
Creating and Using Exception Filters
354
Using HandleErrorAttribute
355
Creating a Custom Exception Filter
357
Bubbling Exceptions Through Action and Result Filters
358
The [OutputCache] Action Filter
359
The [RequireHttps] Filter
362
Other Built-In Filter Types
362
Controllers As Part of the Request Processing Pipeline
362
Working with Default Controller Factory
363
Prioritizing Namespaces Globally Using DefaultNamespaces
364
Prioritizing Namespaces on Individual Route Entries
364
Limiting a Route Entry to Match Controllers in a Specific Set of Namespaces
365
Creating a Custom Controller Factory
366
Registering a Custom Controller Factory
367
Customizing How Action Methods Are Selected and Invoked
367
The Real Definition of an Action
367
Using [ActionName] to Specify a Custom Action Name
368
Method Selection: Controlling Whether a C# Method Should Agree to Handle a Request
368
Creating a Custom Action Method Selector Attribute
369
Using the [NonAction] Attribute
370
How the Whole Method Selection Process Fits Together
370
Handling Unknown Actions
372
Overriding HTTP Methods to Support REST Web Services
373
Submitting a Plain HTML Form with an Overridden HTTP Method
374
How HTTP Method Overriding Works
374
Boosting Server Capacity with Asynchronous Controllers
375
Introducing Asynchronous Requests
376
Using Asynchronous Controllers
376
Turning a Synchronous Action into an Asynchronous Action
377
Passing Parameters to the Completion Method
382
Controlling and Handling Timeouts
383
Using Finish() to Abort All Remaining Asynchronous Operations
383
Using Sync() to Transition Back to the Original HTTP Context
384
Adding Asynchronous Methods to Domain Classes
385
Choosing When to Use Asynchronous Controllers
386
Measuring the Effects of Asynchronous Controllers
386
Ensuring Your Server Is Configured to Benefit from Asynchronous Requests
388
Summary
389
CHAPTER 11 Views
390
How Views Fit into ASP.NET MVC
390
The Web Forms View Engine
391
View Engines Are Replaceable
391
Web Forms View Engine Basics
391
Adding Content to a View
391
Five Ways to Add Dynamic Content to a View
392
Using Inline Code
393
Why Inline Code Is a Good Thing in MVC Views
395
Understanding How MVC Views Actually Work
395
Understanding How ASPX Pages Are Compiled
395
The Code-Behind Model
398
How Automatic HTML Encoding Works
398
How ASP.NET 4 Automatically Skips Encoding When Rendering HTML Helpers
399
Introducing the <%: ... %> Syntax
399
Working with MvcHtmlString
400
Using Custom Encoding Logic (Applies to .NET 4 Only)
400
Understanding ViewData
401
Extracting ViewData Items Using ViewData.Eval
402
Using HTML Helper Methods
403
The Framework’s Built-In Helper Methods
404
Rendering Input Controls
404
Using Strongly Typed Input Controls
405
How Input Controls Get Their Values
406
Adding Arbitrary Tag Attributes
406
A Note About HTML Encoding
407
Rendering Links and URLs
407
Performing HTML and HTML Attribute Encoding
408
Rendering Drop-Down and Multiselect Lists
409
Bonus Helper Methods in Microsoft.Web.Mvc.dll
411
Other HTML Helpers
413
Rendering Form Tags
414
Forms That Post Back to the Same URL
415
Using Html.BeginForm
416
Creating Your Own HTML Helper Methods
416
Using Partial Views
418
Creating and Rendering a Partial View
418
Rendering a Partial Directly to the Response Stream
419
Passing ViewData to a Partial View
419
Passing an Explicit Model Object to a Partial View
420
Rendering a Partial View Using Server Tags
423
Passing ViewData to the Control
424
Passing an Explicit Model Object to the Control
424
Summary
425
CHAPTER 12 Models and Data Entry
426
How It All Fits Together
426
Templated View Helpers
427
Displaying and Editing Models Using Templated View Helpers
428
Using Model Metadata to Influence Templated View Helpers
431
Rendering Editors for Individual Properties
433
Rendering Labels for Individual Properties
435
The Built-in Editor Templates
435
Displaying Models Using Templated View Helpers
437
Using Partial Views to Define Custom Templates
439
Creating a Custom Editor Template
441
Respecting Formatting Metadata and Inheriting from ViewTemplateUserControl
442
Passing Additional View Data to Custom Templates
442
Working with HTML Field Prefixes and the TemplateInfo Context
442
Model Metadata
444
Working with Data Annotations
445
Creating a Custom Metadata Provider
446
The Full Set of Metadata Options
447
Consuming Model Metadata in Custom HTML Helpers
450
Using [MetadataType] to Define Metadata on a Buddy Class
451
Model Binding
451
Model-Binding to Action Method Parameters
452
Model-Binding to Custom Types
453
Specifying a Custom Prefix
455
Omitting a Prefix
455
Choosing a Subset of Properties to Bind
455
Invoking Model Binding Directly
456
Dealing with Model Binding Errors
457
Model-Binding to Arrays, Collections, and Dictionaries
458
Model-Binding Collections of Custom Types
459
Using Nonsequential Indexes
460
Model-Binding to a Dictionary
461
Creating a Custom Value Provider
461
Creating a Custom Model Binder
462
Configuring Which Model Binders Are Used
464
Using Model Binding to Receive File Uploads
466
Validation
467
Registering and Displaying Validation Errors
467
Using the Built-In Validation HTML Helpers
469
Controlling Where Validation Messages Appear
471
Distinguishing Property-Level Errors from Model-Level Errors
472
How the Framework Retains State After a Validation Failure
473
Performing Validation As Part of Model Binding
473
Specifying Validation Rules
475
Using Data Annotations Validation Attributes
475
Using the IDataErrorInfo Interface
478
Creating a Custom Validation Provider
479
Invoking Validation Manually
481
Using Client-Side Validation
482
Using Client-Side Validation with a Validation Summary
483
Dynamically Highlighting Valid and Invalid Fields
484
Allowing Specific Buttons to Bypass Validation
484
How Client-Side Validation Works
485
Implementing Custom Client-Side Validation Logic
486
Reusing the Built-In Client-Side Validation Logic
488
Putting Your Model Layer in Charge of Validation
489
Summary
493
CHAPTER 13 User Interface Techniques
494
Wizards and Multistep Forms
494
Defining the Model
495
Navigation Through Multiple Steps
496
Collecting and Preserving Data
498
Completing the Wizard
500
Validation
502
Implementing a CAPTCHA
506
Creating an Html.Captcha() Helper
507
Rendering a Dynamic Image
509
Distorting the Text
511
Verifying the Form Submission
512
Using Child Actions to Create Reusable Widgets with Application Logic
513
How the Html.RenderAction Helper Invokes Child Actions
514
When It’s Appropriate to Use Child Actions
514
Creating a Widget Based on a Child Action
515
Capturing a Child Action’s Output As a String
518
Detecting Whether You’re Inside a Child Request
518
Restricting an Action to Handle Child Requests Only
519
Sharing Page Layouts Using Master Pages
519
Using Widgets in MVC View Master Pages
520
Method 1: Have Your Controller Put a Control-Specific Data Item into ViewData
520
Method 2: Use an Action Filter to Put a Control-Specific Data Item into ViewData
521
Method 3: Use Child Actions
521
Implementing a Custom View Engine
522
A View Engine That Renders XML Using XSLT
522
Step 1: Implement IViewEngine, or Derive a Class from VirtualPathProviderViewEngine
522
Step 2: Implement IView
523
Step 3: Use It
524
Step 4: Register Your View Engine with the Framework
526
Using Alternative View Engines
527
Using the NVelocity View Engine
528
Using the Brail View Engine
529
Using the NHaml View Engine
530
Using the Spark View Engine
531
Summary
532
CHAPTER 14 Ajax and Client Scripting
533
Why You Should Use a JavaScript Toolkit
533
ASP.NET MVC’s Ajax Helpers
534
Fetching Page Content Asynchronously Using Ajax.ActionLink
535
Passing Options to Ajax.ActionLink
538
Running JavaScript Functions Before or After Asynchronous Requests
539
Detecting Ajax Requests
540
Submitting Forms Asynchronously Using Ajax.BeginForm
541
Invoking JavaScript Commands from an Action Method
542
Reviewing ASP.NET MVC’s Ajax Helpers
544
Using jQuery with ASP.NET MVC
545
Referencing jQuery
546
Referencing jQuery on a Content Delivery Network
546
Basic jQuery Theory
548
Waiting for the DOM
550
Event Handling
550
Global Helpers
551
Unobtrusive JavaScript
552
Adding Client-Side Interactivity to an MVC View
553
Improvement 1: Zebra-Striping
554
Improvement 2: Confirm Before Deletion
556
Improvement 3: Hiding and Showing Sections of the Page
557
Ajax-Enabling Links and Forms
558
Unobtrusive JavaScript and Hijaxing
558
Hijaxing Links
558
Performing Partial Page Updates
560
Using live to Retain Behaviors After Partial Page Updates
561
Hijaxing Forms
563
Client/Server Data Transfer with JSON
564
A Note About JsonResult and GET Requests
567
Performing Cross-Domain JSON Requests Using JSONP
568
Fetching XML Data Using jQuery
570
Animations and Other Graphical Effects
571
jQuery UI’s Prebuilt UI Widgets
572
Example: A Sortable List
573
Summarizing jQuery
574
Summary
575
PART 3 Delivering SuccessfulASP.NET MVC 2 Projects
576
CHAPTER 15 Security and Vulnerability
577
All Input Can Be Forged
577
Forging HTTP Requests
579
Cross-Site Scripting and HTML Injection
581
Example XSS Vulnerability
582
Attack
582
Defense
583
ASP.NET’s Request Validation Feature
583
Request Validation: Good or Bad?
584
Disabling Request Validation
585
Customizing Request Validation Logic
585
Filtering HTML Using the HTML Agility Pack
586
JavaScript String Encoding and XSS
588
Session Hijacking
589
Defense via Client IP Address Checks
590
Defense by Setting the HttpOnly Flag on Cookies
590
Cross-Site Request Forgery
591
Attack
591
Defense
592
Preventing CSRF Using the Anti-Forgery Helpers
592
SQL Injection
594
Attack
595
Defense by Encoding Inputs
595
Defense Using Parameterized Queries
595
Defense Using Object-Relational Mapping
596
Using the MVC Framework Securely
596
Don’t Expose Action Methods Accidentally
596
Don’t Allow Model Binding to Change Sensitive Properties
597
Summary
597
CHAPTER 16 Deployment
598
Server Requirements
598
Building Your Application for Production Use
599
Controlling Dynamic Page Compilation
599
Detecting Compiler Errors in Views Before Deployment
600
Detecting Compiler Errors in Views Only When Building in Release Mode
601
IIS Basics
601
Understanding Web Sites and Virtual Directories
602
Binding Web Sites to Hostnames, IP Addresses, and Ports
603
Deploying Your Application
603
Manually Copying Application Files to the Server
603
Where Should I Put My Application?
604
Bin-Deploying ASP.NET MVC 2
604
Deploying to IIS 6 on Windows Server 2003
606
Adding and Configuring a New MVC Web Site in IIS Manager
606
How IIS 6 Processes Requests
608
Making Extensionless URLs Work on IIS 6
608
Using a Wildcard Map
611
Disadvantages of Using Wildcard Maps
611
Excluding Certain Subdirectories from a Wildcard Map
612
Using a Traditional ASP.NET File Name Extension
612
Using a Custom File Name Extension
613
Extensionless URLs on IIS 6 with .NET 4
613
Troubleshooting IIS 6 Errors
614
Deploying to IIS 7.x on Windows Server 2008/2008 R2
615
Installing IIS 7.x on Windows Server 2008/2008 R2
615
Adding and Configuring a New MVC Web Site in IIS 7.x
616
How IIS 7.x Processes Requests in Classic Pipeline Mode
617
How IIS 7.x Processes Requests in Integrated Pipeline Mode
618
How Integrated Mode Makes Extensionless URLs Easy
619
Why Extensionless URLs Work on IIS 7.x Integrated Pipeline Mode with .NET 3.5
619
Why Extensionless URLs Work in IIS 7.x Integrated Pipeline Mode with .NET 4
619
Further IIS 7.x Deployment Considerations
620
Troubleshooting IIS 7.x Errors
621
Deploying to IIS 7.5 on Windows Server 2008 R2 Core
622
Automating Deployments with WebDeploy and Visual Studio 2010
623
Transforming Configuration Files
625
Automating Online Deployments with One-Click Publishing
628
Automating Offline Deployments with Packaging
629
Summary
631
CHAPTER 17 ASP.NET Platform Features
632
Windows Authentication
633
Preventing or Limiting Anonymous Access
635
Forms Authentication
636
Setting Up Forms Authentication
637
Handling Login Attempts
639
Using Cookieless Forms Authentication
640
Membership, Roles, and Profiles
641
Setting Up a Membership Provider
643
Setting Up SqlMembershipProvider
643
Using a SQL Server Express User Instance Database
644
Preparing Your Own Database for Membership, Roles, and Profiles
644
Managing Members Using the Web Administration Tool
646
Managing Members Using IIS 7.x’s .NET Users Configuration Tool
647
Using a Membership Provider with Forms Authentication
648
Creating a Custom Membership Provider
649
Setting Up and Using Roles
650
Using the Built-In SqlRoleProvider
651
Securing Controllers and Actions by Role
652
Creating a Custom Roles Provider
652
Setting Up and Using Profiles
653
Using the Built-In SqlProfileProvider
653
Configuring, Reading, and Writing Profile Data
654
Creating a Custom Profile Provider
655
URL-Based Authorization
657
Configuration
657
Configuring Connection Strings
658
Configuring Arbitrary Key/Value Pairs
659
Defining Configuration Sections to Configure Arbitrary Data Structures
659
Data Caching
661
Reading and Writing Cache Data
661
Using Advanced Cache Features
664
Site Maps
665
Setting Up and Using Site Maps
666
Creating a Custom Navigation Control with the Site Maps API
667
Generating Site Map URLs from Routing Data
668
Using Security Trimming
670
Internationalization
671
Setting Up Localization
672
Tips for Working with Resource Files
675
Using Placeholders in Resource Strings
675
Internationalizing Validation
676
Globalizing Validation Rules
676
Localizing Data Annotations Validation Messages
678
Localizing the Client-Side Number Validation Message
679
Performance
680
HTTP Compression
680
Tracing and Monitoring
682
Monitoring Page Generation Times
683
Monitoring LINQ to SQL Database Queries
684
Summary
687
CHAPTER 18 Upgrading and CombiningASP.NET Technologies
688
Using ASP.NET MVC in a Web Forms Application
688
Upgrading an ASP.NET Web Forms Application to Support MVC
689
Changing the Project Type
690
Adding Assembly References
691
Enabling and Configuring Routing
692
Adding Controllers and Views
694
Interactions Between Web Forms Pages and MVC Controllers
696
Linking and Redirecting from Web Forms Pages to MVC Actions
696
Transferring Data Between MVC and Web Forms
698
Using Web Forms Technologies in an MVC Application
699
Using Web Forms Controls in MVC Views
699
Using Web Forms Pages in an MVC Web Application
701
Adding Routing Support for Web Forms Pages
702
Web Forms Routing on .NET 4
703
Web Forms Routing on .NET 3.5
704
A Note About URL-Based Authorization
706
Upgrading from ASP.NET MVC 1
707
Using Visual Studio 2010’s Built-In Upgrade Wizard
708
Upgrading to .NET 4
709
Other Ways to Upgrade
710
A Post-Upgrade Checklist
710
Avoiding Anti-Forgery Token Problems Next Time You Deploy
712
Summary
713
Index
714
All prices incl. VAT