Preview only show first 10 pages with watermark. For full document please download

Beginning Asp.net For Visual Studio 2015 | Dhruvin Bhatt ...

NET 6.0 Code Downloads for this Chapter: An Introduction to ASP.NET vNext Using Visual Studio 2015 The Sample Application Summary What You Learned in This Chapter Chapter 2: Building an Initial ASP.NET Application Code Downloads for this Chapter: Creating Websites with Visual Studio 2015 Working with Files in ...

   EMBED

  • Rating

  • Date

    April 2017
  • Size

    25.5MB
  • Views

    10,151
  • Categories


Share

Transcript

Table of Contents Cover Introduction Who This Book Is For What This Book Covers How This Book Is Structured What You Need to Use This Book Conventions Source Code Errata p2p.wrox.com Chapter 1: Getting Started with ASP.NET 6.0 Code Downloads for this Chapter: An Introduction to ASP.NET vNext Using Visual Studio 2015 The Sample Application Summary What You Learned in This Chapter Chapter 2: Building an Initial ASP.NET Application Code Downloads for this Chapter: Creating Websites with Visual Studio 2015 Working with Files in Your Application MVC and Web Form File Differences Creating the Sample Application Summary What You Learned in This Chapter Chapter 3: Designing Your Web Pages Code Downloads for this Chapter: HTML and CSS More CSS The Style Sheet Applying Styles Managing Styles Summary What You Learned in this Chapter Chapter 4: Programming in C# and VB.NET Code Downloads for this Chapter: Introduction to Programming Organizing Code Object-Oriented Programming Basics Important OO Terminology Summary What You Learned in This Chapter Chapter 5: ASP.NET Web Form Server Controls Code Downloads for this Chapter: Introduction to Server Controls Defining Controls in Your Pages Types of Controls The ASP.NET State Engine How the State Engine Works Summary What You Learned in This Chapter Chapter 6: ASP.NET MVC Helpers and Extensions Code Downloads for this Chapter: Why MVC Has Fewer Controls Than Web Forms A Different Approach Form-Building Helpers Summary What You Learned in This Chapter Chapter 7: Creating Consistent-Looking Websites Code Downloads for this Chapter: Consistent Page Layout with Master Pages Using a Centralized Base Page Summary What You Learned in This Chapter Chapter 8: Navigation Code Downloads for this Chapter: Different Ways to Move around Your Site Using the ASP.NET Web Forms Navigation Controls Navigating in ASP.NET MVC Practical Tips on Navigation Summary What You Learned in This Chapter Chapter 9: Displaying and Updating Data Code Downloads for this Chapter: Working with SQL Server Express Entity Framework Approach to Data Access Data Controls in Web Forms Data Display in MVC Summary What You Learned in This Chapter Chapter 10: Working with Data—Advanced Topics Code downloads for this chapter: Sorting and Pagination Updating and/or Inserting Data A Non-Code First Approach to Database Access Caching Summary What You Learned in This Chapter Chapter 11: User Controls and Partial Views Code Downloads for this Chapter: Introduction to User Controls Using Partial Views Templates Summary What You Learned in This Chapter Chapter 12: Validating User Input Code Downloads for this Chapter: Gathering Data from the User Validating User Input in Web Forms Validating User Input in MVC Validation Tips Summary What You Learned in This Chapter Chapter 13: ASP.NET AJAX Code Downloads for this Chapter: Introducing the Concept of AJAX Using Web Services in AJAX Websites JQuery in AJAX Practical AJAX Tips Summary What You Learned in This Chapter Chapter 14: jQuery Code Downloads for this Chapter: An Introduction to JQuery JQuery Syntax Modifying the DOM with JQuery Debugging JQuery Practical Tips on JQuery Summary What You Learned in This Chapter Chapter 15: Security in Your ASP.NET Website Code Downloads for this Chapter: Introducing Security Roles Practical Security Tips Summary What You Learned in This Chapter Chapter 16: Personalizing Websites Code Downloads for this Chapter: Understanding the Profile Practical Personalization Tips Summary What You Learned in This Chapter Chapter 17: Exception Handling, Debugging, and Tracing Code Downloads for this Chapter: Error Handling The Basics of Debugging Tracing Your ASP.NET Web Pages Logging Summary What You Learned in This Chapter Chapter 18: Working with Source Control Code Downloads for this Chapter: Introducing Team Foundation Services Branching and Merging Summary What You Learned in This Chapter Chapter 19: Deploying Your Website Code Downloads for this Chapter: Preparing Your Website for Deployment Preparing for Deployment Publishing Your Site Smoke Testing Your Application Going Forward Summary What You Learned in This Chapter Answers to Exercises Chapter 1 Chapter 2 Chapter 3 Chapter 4 Chapter 5 Chapter 6 Chapter 7 Chapter 8 Chapter 9 Chapter 10 Chapter 11 Chapter 12 Chapter 13 Chapter 14 Chapter 15 Chapter 16 Chapter 17 Chapter 18 Chapter 19 End User License Agreement List of Illustrations Chapter 1: Getting Started with ASP.NET 6.0 Figure 1.1 Request response Figure 1.2 HTML rendered in the browser Figure 1.3 Model-View-Controller (MVC) design Figure 1.4 Different Approaches Between MVC and Web Forms Figure 1.5 Visual Studio site to download Community Edition Figure 1.6 Installation screen for Community Edition Figure 1.7 Select items to install Figure 1.8 Setup Completed window Figure 1.9 Login screen in Visual Studio Figure 1.10 Initial configuration of Visual Studio Figure 1.11 Start Page for Visual Studio Chapter 2: Building an Initial ASP.NET Application Figure 2.1 Creating a project or web site Figure 2.2 Options when creating a new web site Figure 2.3 Creating a new project in Visual Studio Figure 2.4 Selecting the appropriate ASP.NET template Figure 2.5 Authentication options for a new project Figure 2.6 Adding directories and unit tests Figure 2.7 Creating a project using the Empty template Figure 2.8 References created for an empty template Figure 2.9 Running a newly created default Web Forms project Figure 2.10 API Help page in a Web API project Figure 2.11 Installed folders with ASP.NET MVC Figure 2.12 Details under the Controllers and Views folders Figure 2.13 Relationship between View files and Controller files in an ASP.NET MVC application Figure 2.14 Account management functionality in Web Forms Figure 2.15 Creating your initial project Chapter 3: Designing Your Web Pages Figure 3.1 HTML without any CSS styling Figure 3.2 HTML with some simple styles added Figure 3.3 New ASP.NET Web Form file Figure 3.4 Selecting Split mode displays both design and source code information. Figure 3.5 Code window with display of text Figure 3.6 Design mode view of style and HTML content Figure 3.7 Inheritance in CSS Figure 3.8 Padding, border, and margin Figure 3.9 Rendered HTML with padding, margin, and width Figure 3.10 Adding a user style sheet to your browser Figure 3.11 Adding a new style sheet Figure 3.12 Page after removing style Figure 3.13 Viewing the file in Design mode Figure 3.14 Formatting toolbar Figure 3.15 New Style dialog Figure 3.16 Menu options available in Design mode Figure 3.17 Screen changes after selecting both ruler and grid Figure 3.18 Design mode with all visual aids enabled Figure 3.19 Displaying Tag Marks in Design mode Figure 3.20 CSS Properties window Figure 3.21 Simple design for sample application home page Figure 3.22 Simple design for the list of product items Figure 3.23 Initial styling approach to the home page Figure 3.24 Content in Design mode Figure 3.25 Setting body style Chapter 4: Programming in C# and VB.NET Figure 4.1 Demonstration of XML comments in IntelliSense Figure 4.2 Inheritance displayed in IntelliSense Chapter 5: ASP.NET Web Form Server Controls Figure 5.1 Toolbox menu in Visual Studio Figure 5.2 IntelliSense support for manually entering server controls Figure 5.3 Figure 5.4 IntelliSense for help selecting the OnClick Event Figure 5.5 IntelliSense help for creating an event handler Figure 5.6 Initial display of HTML Figure 5.7 Setting breakpoints in your code Figure 5.8 HTML created when using server controls Figure 5.9 Standard controls list from the Toolbox Figure 5.10 Data controls list from the Toolbox Figure 5.11 Figure 5.12 Figure 5.13 Figure 5.14 AJAX extensions Figure 5.15 Other ASP.NET controls Figure 5.16 Create a report UI. Figure 5.17 Changed textbox value is returned. Figure 5.18 Web Form with Master Page Figure 5.19 Selecting a Master Page Figure 5.20 Newly created form fields Figure 5.21 Poorly formatted form Figure 5.22 Code-behind in Debug mode Chapter 6: ASP.NET MVC Helpers and Extensions Figure 6.1 Workflow for a model being passed to a view Figure 6.2 Simple model displayed in your MVC view Figure 6.3 Output when including the @ character Figure 6.4 Output of a @foreach loop writing the display Figure 6.5 The RouteConfig.cs file in the App_Start directory Figure 6.6 Error when Id is not included in the URL Figure 6.7 Creating the Model class Figure 6.8 Creating the Controller class Figure 6.9 Naming the Controller class Figure 6.10 Views folder created when adding the controller Figure 6.11 Dialog to add a view Figure 6.12 Browser display of the Index field Figure 6.13 Initial data-entry form Figure 6.14 Edited data-entry form Figure 6.15 Create a breakpoint in a method Figure 6.16 404 error when running the Manage view Figure 6.17 Displaying the Edit screen Chapter 7: Creating Consistent-Looking Websites Figure 7.1 Web page within a template Figure 7.2 Master page with multiple content sections Figure 7.3 Nested master pages Figure 7.4 Nested master pages Figure 7.5 Adding a new master page Figure 7.6 Unstyled master page in Design mode Figure 7.7 Styled master page in Design mode Figure 7.8 Location of linked master page in the project Figure 7.9 Error caused by having text outside content control Figure 7.10 Add New Item dialog Figure 7.11 Selecting the master page Figure 7.12 Form in the new master page Figure 7.13 Relationship between content page and Render command Figure 7.14 Add View dialog Figure 7.15 Initial dialog when creating a brand-new view Figure 7.16 Addition of a base class Figure 7.17 Creating a new base class Figure 7.18 Inheriting the Page class Figure 7.19 Overriding the OnLoad method Figure 7.20 Adding values to the page definition Figure 7.21 Adding validation that keywords and description are set Figure 7.22 Error thrown when keywords and description are not set Figure 7.23 Error thrown when the page does not extend System.Web.UI.Page Chapter 8: Navigation Figure 8.1 Relative URLs Figure 8.2 IIS management console with RentMyWrox as a virtual application Figure 8.3 Initial RouteConfig.cs file Figure 8.4 Default display of TreeView and Menu controls Figure 8.5 Creating the Web.sitemap file Figure 8.6 Error displayed when multiple siteMapNodes appear within the sitemap element Figure 8.7 Configuring the Menu control in Design mode Figure 8.8 Selecting data source for the Menu control Figure 8.9 Menu display after turning off the starting node Figure 8.10 Rendered example of the menu Figure 8.11 HTML created by the Menu control Figure 8.12 Page with styled menu Figure 8.13 Routing process Figure 8.14 The initial RouteConfig.cs file Figure 8.15 Ambiguous action exception Figure 8.16 Add View dialog Figure 8.17 Client-side redirection flow Figure 8.18 Creating a WeeklySpecial page Figure 8.19 Code for the redirect of the WeeklySpecial Figure 8.20 Exception using Server.Transfer Figure 8.21 Server.Transfer to .aspx page Figure 8.22 Server transfer of page flow Chapter 9: Displaying and Updating Data Figure 9.1 User Account Control dialog Figure 9.2 Selecting extract directory Figure 9.3 SQL Server Installation Center Figure 9.4 SQL Server Installation Center - Tools Figure 9.5 Setup Support Rules Figure 9.6 License Terms dialog Figure 9.7 Microsoft Update dialog Figure 9.8 Feature Selection dialog Figure 9.9 Instance Configuration dialog Figure 9.10 Server Configuration dialog Figure 9.11 Database Engine Configuration dialog Figure 9.12 Windows Services installed as part of SQL Server Figure 9.13 SQL Server shortcut Figure 9.14 Connect to Server dialog in SQL Server Management Studio Figure 9.15 Object Explorer, showing connected server Figure 9.16 New Database dialog Figure 9.17 Expanded database Figure 9.18 Window for creating a table Figure 9.19 Filled-out table information Figure 9.20 Editable window Figure 9.21 Object Explorer, showing the active server Figure 9.22 Object Explorer, showing the stopped server Figure 9.23 SQL Server Object Explorer Figure 9.24 SQL Server Object Explorer Connect to Server dialog Figure 9.25 SQL Server Object Explorer Browse for Servers dialog Figure 9.26 New database connection in SQL Server Object Explorer Figure 9.27 Working with the data in SQL Server Object Explorer Figure 9.28 Preview Database Updates in SQL Server Object Explorer Figure 9.29 Adding the database context file Figure 9.30 Entity Data Model Wizard Figure 9.31 Basic DbContext file Figure 9.32 SQL Server Object Explorer with server name Figure 9.33 Web.ConFigure file connection strings Figure 9.34 Hobby class Figure 9.35 UserDemographics class Figure 9.36 Updated data context class Figure 9.37 Newly created database tables Figure 9.38 Visual Designer approach Figure 9.39 New DetailsView control Figure 9.40 DetailsView control with methods assigned Figure 9.41 DetailsView rendered in the browser Figure 9.42 Debug values before running the SaveChanges method Figure 9.43 Debug values after running the SaveChanges method Figure 9.44 Error displayed when trying to update the database Figure 9.45 Package Manager Console Figure 9.46 Server Manager and Design mode Figure 9.47 Screen after dropping table into page design Figure 9.48 Displaying the GridView Figure 9.49 Migrations directory after enabling and running code first migrations Figure 9.50 Adding the view file Figure 9.51 List of items on front page Figure 9.52 Details page for an item Figure 9.53 Details page when an item does not exist Figure 9.54 Details page when an item is not available Chapter 10: Working with Data—Advanced Topics Figure 10.1 GridView with pagination and sorting Figure 10.2 GridView with pagination turned off Figure 10.3 New Index method signature Figure 10.4 New Index method Figure 10.5 New view code Figure 10.6 New view pagination code Figure 10.7 Running the paginated list Figure 10.8 Initial change to the Manage view Figure 10.9 Redoing the Manage view Figure 10.10 New property in the code-behind Figure 10.11 Add New Item link in the Item List page Figure 10.12 HTML created to support the hobby selection Figure 10.13 New method in UserDemographicsController Figure 10.14 Add View dialog Figure 10.15 New view code Figure 10.16 Running HobbyReport Figure 10.17 Setting up the new stored procedure Figure 10.18 Displaying the residency report Figure 10.19 Directory of cached items Figure 10.20 Output caching on the Details action Figure 10.21 Breakpoint in the Details action Chapter 11: User Controls and Partial Views Figure 11.1 Creating a Web Forms user control Figure 11.2 Editing the markup of your control Figure 11.3 Adding the Notification model Figure 11.4 Editing the code-behind of your control Figure 11.5 Database view of the Notifications table created by the application Figure 11.6 Page after registering your user control Figure 11.7 Empty Notifications table Figure 11.8 Entering data into the Notifications table Figure 11.9 Default page showing the user control Figure 11.10 Default Web.ConFigure file Figure 11.11 Web.conFigure after registering your user control Figure 11.12 Adding the user control Figure 11.13 ManageItem page after the control is successfully added Figure 11.14 Enum values shown in IntelliSense Figure 11.15 Validation when using an incorrect type Figure 11.16 Error when using an incorrect type in a user control Figure 11.17 Adding in user control with additional properties Figure 11.18 Page life cycle with page and hosted control Figure 11.19 Adding a partial view Figure 11.20 Removing scaffolded information Figure 11.21 Finished partial view Figure 11.22 Finished partial view Figure 11.23 Partial view shown in the UI Figure 11.24 Scaffolding for adding a new controller Figure 11.25 Empty controller Figure 11.26 Notifications controller with actions Figure 11.27 Updated layout view Figure 11.28 SQL Table view after adding new item Figure 11.29 New notification displayed in the UI from a partial view Figure 11.30 Initial screen showing default DateTime management Figure 11.31 Views directory after Templates directories are added Figure 11.32 Adding DateTime Display template Figure 11.33 Viewing the DisplayFor template Figure 11.34 Content of the project's Scripts directory Figure 11.35 Selecting jQuery package in Package Manager Figure 11.36 Installing the jQuery UI package Figure 11.37 Updating the layout page Figure 11.38 Finished Editor template Chapter 12: Validating User Input Figure 12.1 Validation controls in Visual Studio Toolbox Figure 12.2 Adding the ValidationSummary control Figure 12.3 Adding some validation controls Figure 12.4 Additional validation controls Figure 12.5 Validation displayed Figure 12.6 Validation displayed Figure 12.7 Error thrown during request validation Figure 12.8 Attributed property Figure 12.9 Fully attributed class Figure 12.10 Package Manager Console Figure 12.11 Error caused by StringLength on the integer property Figure 12.12 Properties showing 15-character column Figure 12.13 Error when trying to save invalid data in the controller Figure 12.14 Nuget Package Manager Window Figure 12.15 Scripts directory after adding new packages Figure 12.16 Content of the BundleConFigure file Figure 12.17 New ValidationSummary configuration Figure 12.18 Updated code block Figure 12.19 Changed view page Figure 12.20 Validation displayed in the browser Chapter 13: ASP.NET AJAX Figure 13.1 Classic and asynchronous models Figure 13.2 Google Chrome Developer tools Figure 13.3 Mozilla Firefox Developer tools Figure 13.4 Opening the F12 Developer Tools through the menu Figure 13.5 Dom Explorer and the Styles tab Figure 13.6 Network tab Figure 13.7 Network tab recording requests Figure 13.8 DOM Explorer tab showing Styles Figure 13.9 DOM Explorer tab showing the Computed tab Figure 13.10 DOM Explorer tab showing the Layout tab Figure 13.11 Network tab showing the Request headers Figure 13.12 AJAX controls available in Visual Studio Figure 13.13 UpdatePanel and ScriptManager relationship Figure 13.14 Updated notifications control markup page Figure 13.15 Rendered Notifications control Figure 13.16 F12 Network tab without the UpdatePanel Figure 13.17 F12 Response body without the UpdatePanel Figure 13.18 F12 Network tab with the UpdatePanel Figure 13.19 F12 Response body with UpdatePanel Figure 13.20 Difference between displayed item and view source output Figure 13.21 Request body differences Figure 13.22 Updated DisplayInformation method Figure 13.23 Updated control to include UpdateProgress method Figure 13.24 Update Progress message visible Figure 13.25 Updated context file Figure 13.26 Configuration for a new partial view Figure 13.27 New partial view content Figure 13.28 New Controller with private variable Figure 13.29 Search results in NuGet Package Manager Figure 13.30 Screen with empty shopping cart Figure 13.31 Screen with updated shopping cart Figure 13.32 F12 Developer Tool showing the response body Figure 13.33 Downloading the StoreOpen.json file Figure 13.34 Addition of area to display store hours message Figure 13.35 JavaScript added to the page Figure 13.36 Running the new changes Chapter 14: jQuery Figure 14.1 Installed jQuery packages Figure 14.2 Bottom of the _MVCLayout.cshtml page Figure 14.3 Adding a new JavaScript file Figure 14.4 After moving some JavaScript from the layout file Figure 14.5 The updated layout file Figure 14.6 The newly created source Figure 14.7 Web.conFigure file content Figure 14.8 Debugging Not Enabled dialog Figure 14.9 Source code with bundling Figure 14.10 Bundled JavaScript output Figure 14.11 Updated Ajax.ActionLink Figure 14.12 Updating the Index page Figure 14.13 Enabling debugging in Internet Explorer Figure 14.14 Adding breakpoints in jQuery/JavaScript Figure 14.15 Hitting a breakpoint in JavaScript Figure 14.16 Setting a breakpoint in the browser tools Figure 14.17 Hitting a breakpoint in the browser tools Figure 14.18 Error in browser when trying to debug Chapter 15: Security in Your ASP.NET Website Figure 15.1 Startup_Auth page Figure 15.2 Interaction with third-party authorizer Figure 15.3 Current Web.ConFigure file Figure 15.4 Updated head section of the Master page Figure 15.5 Post-deleted section of the Master page Figure 15.6 New Shopping cart summary partial view Figure 15.7 Initial tables in database Figure 15.8 Login page Figure 15.9 Register page Figure 15.10 Validation failure page Figure 15.11 Empty checkout page Figure 15.12 Updated database Figure 15.13 AspNetUsers data Figure 15.14 UserHelper.cs Figure 15.15 UserHelper.cs Figure 15.16 Default page in the Admin directory Figure 15.17 Creating a web.conFigure file for the Admin directory Figure 15.18 Adding a role to the database Figure 15.19 Assigning a role to a user in the database Figure 15.20 ApplicationUser with roles collection populated Figure 15.21 Updating the menu in the _MVCLayout.cshtml file Figure 15.22 Home page with Admin menu Chapter 16: Personalizing Websites Figure 16.1 New class for addresses Figure 16.2 Additional user properties Figure 16.3 Initial migration script Figure 16.4 New migrations directory Figure 16.5 ApplicationDbMigration migration file Figure 16.6 Failed database update Figure 16.7 Figure 16.8 Updated GetShoppingCartSummary method Figure 16.9 Updated registration page Figure 16.10 Updated AddToCart method Figure 16.11 Adding a new view Figure 16.12 Updated layout page Figure 16.13 Home page with recent items displayed at the bottom Figure 16.14 Shopping cart area displaying name Chapter 17: Exception Handling, Debugging, and Tracing Figure 17.1 Error List in Visual Studio Figure 17.2 ASP.NET Web Forms parser error Figure 17.3 ASP.NET Web Forms server error with VS Figure 17.4 This MVC view has syntax error yet compiles. Figure 17.5 Runtime error caused by MVC view syntax error Figure 17.6 Application_Error event handler Figure 17.7 Master page selected Figure 17.8 Error404 content Figure 17.9 Custom error configuration in the web.conFigure file Figure 17.10 Displaying the Error404 page Figure 17.11 Debugging toolbar Figure 17.12 Debugging toolbar Figure 17.13 Watch windows Figure 17.14 Working Watch window Figure 17.15 Working Autos window Figure 17.16 Expanded this variable in the Autos window Figure 17.17 Working Locals window Figure 17.18 Working Breakpoint window Figure 17.19 Window for selecting a condition Figure 17.20 Using the Call Stack window Figure 17.21 Using the Immediate window Figure 17.22 _MVCLayout content Figure 17.23 Addition of checks Figure 17.24 Error thrown when checking out Figure 17.25 Locals window when stopped by error Figure 17.26 Successful Checkout window Figure 17.27 Autos window Figure 17.28 Autos window with details displayed Figure 17.29 Completed order detail screen Figure 17.30 Trace listing page Figure 17.31 Trace details page Figure 17.32 Web.conFigure file after enabling trace Figure 17.33 Web.conFigure file after enabling listeners Figure 17.34 Trace details page with error Figure 17.35 Figure 17.36 Chapter 18: Working with Source Control Figure 18.1 Visual Studio Online initial login message Figure 18.2 Creating a Visual Studio Online account Figure 18.3 Creating a project in Visual Studio Online Figure 18.4 Team Explorer - Connect dialog Figure 18.5 Connect to Team Foundation Server dialog Figure 18.6 Adding a Team Foundation Server Figure 18.7 Team Foundation Server list Figure 18.8 Selecting projects to use as a repository Figure 18.9 Team Explorer pane before workspace mapping Figure 18.10 Configuring the workspace Figure 18.11 Adding your solution to Source Control Figure 18.12 Source Control Explorer window after adding the solution Figure 18.13 Pending changes before a check-in Figure 18.14 Team Explorer context menu Figure 18.15 Undo Pending Changes confirmation Figure 18.16 Final confirmation dialog before undoing changes Figure 18.17 Creating a shelveset Figure 18.18 Source Code menu from Solution Explorer Figure 18.19 Get dialog, for retrieving a specific version Figure 18.20 Conflict found Figure 18.21 Finding a shelveset Figure 18.22 Unshelving a shelveset Figure 18.23 Visualizing file status in Solution Explorer Figure 18.24 History window for a file Figure 18.25 Comparing two versions of a file Figure 18.26 Creating and applying a label Figure 18.27 Changing default settings when working with a file in source control Figure 18.28 Branch dialog Figure 18.29 Source Control Explorer after branching Figure 18.30 Merging branches Chapter 19: Deploying Your Website Figure 19.1 Properties window Figure 19.2 Expressions dialog Figure 19.3 AppSettings in the Expressions dialog Figure 19.4 Updated StoreOpenController Figure 19.5 Updated ItemList markup file Figure 19.6 Azure home page Figure 19.7 Azure free trial page Figure 19.8 Azure sign-up page Figure 19.9 Subscription is ready page Figure 19.10 Azure tour page Figure 19.11 Azure dashboard page Figure 19.12 Publish Web dialog Figure 19.13 Select Existing Web App dialog Figure 19.14 Create Web App on Microsoft Azure dialog Figure 19.15 Completed Create Web App on Microsoft Azure dialog Figure 19.16 Creating the new Web App Figure 19.17 Creation screen with connection validated Figure 19.18 Web Apps listing in Azure Figure 19.19 SQL Database listing in Azure Figure 19.20 Creating a SQL Database Figure 19.21 Create Server dialog in Azure Figure 19.22 Database being created in Azure Figure 19.23 Adding a custom publish profile Figure 19.24 Configuration screen for a custom profile Figure 19.25 Selecting a target location for a custom profile Figure 19.26 Published files Figure 19.27 Web App .pubxml file Figure 19.28 Multiple configuration files Figure 19.29 Publish-Profiles directory Figure 19.30 New PublishProfiles-based configuration Figure 19.31 Previewing the transformation Figure 19.32 Transformed store hours change Figure 19.33 Transformed store hours change Figure 19.34 SQL Database details screen Figure 19.35 Connection Strings dialog Figure 19.36 Deployed, but empty, web server Figure 19.37 Confirmation screen to add IP address Figure 19.38 Generate Scripts menu Figure 19.39 Generate Scripts dialog Figure 19.40 Generate Scripts menu Figure 19.41 Specifying script output Figure 19.42 Advanced Scripting Options Figure 19.43 Finished creating items Figure 19.44 Connecting to Azure SQL Figure 19.45 Selecting the appropriate database Figure 19.46 Output of database-seeding Figure 19.47 Populated online application Figure 19.48 Completed smoke test order List of Tables Chapter 1: Getting Started with ASP.NET 6.0 Table 1.1 Most Frequently Used HTTP Verbs Table 1.2 Commonly Used HTML Elements Table 1.3 ASP.NET Page Lifecycle Stages Table 1.4 Lifecycle Events for ASP.NET Pages Chapter 2: Building an Initial ASP.NET Application Table 2.1 ASP.NET MVC File Types Table 2.2 ASP.NET General Folders Table 2.3 File Types of an ASP.NET Web Forms Application Chapter 3: Designing Your Web Pages Table 3.1 CSS Properties Table 3.2 Visual Aids Chapter 4: Programming in C# and VB.NET Table 4.1 Common Data Types Available in C# and VB.NET Table 4.2 Arithmetic Operators Table 4.3 Convert.ToDouble() Examples Table 4.4 Using a List Table 4.5 Comparison Operators Table 4.6 Logical Operators Chapter 5: ASP.NET Web Form Server Controls Table 5.1 Common Standard Server Controls Table 5.2 Common Standard Control General Attributes Table 5.3 Standard Server Control Special Attributes Chapter 6: ASP.NET MVC Helpers and Extensions Table 6.1 Display Extension Methods Table 6.2 Type-Safe Extensions Table 6.3 Scaffold-Created Actions in a New Controller Chapter 8: Navigation Table 8.1 Attributes of a Menu Control Chapter 9: Displaying and Updating Data Table 9.1 Minimum and Maximum System Settings Table 9.2 SQL Server Management Studio Folders Table 9.3 Database Management Feature Availability Table 9.4 Parts of a Connection String Table 9.5 Selecting and Sorting Data Table 9.6 Data Control Field Definitions Table 9.7 Data-Binding Methods Chapter 10: Working with Data—Advanced Topics Table 10.1 GridView Pagination and Sorting Attributes Table 10.2 Displaying Links by Page Table 10.3 Methods Available on DbContext.Database Table 10.4 Caching Locations Chapter 11: User Controls and Partial Views Table 11.1 Notification Properties Table 11.2 Attributes for User Control Registration Table 11.3 ClientIdMode Values Table 11.4 Method Signatures for Including Partial Views Table 11.5 DateTime Formatting Chapter 12: Validating User Input Table 12.1 Validation Server Controls Table 12.2 Validator Properties Table 12.3 Data Attributes Used in Validation Chapter 13: ASP.NET AJAX Table 13.1 Common UpdatePanel Properties Table 13.2 Potential Items for Populating an Ajax.ActionLink Chapter 14: jQuery Table 14.1 Additional jQuery Modules Table 14.2 Useful jQuery Utility Methods Table 14.3 jQuery Selectors Table 14.4 CSS Methods in jQuery Table 14.5 Animation and Other Effects in jQuery Table 14.6 Common JavaScript Events Chapter 15: Security in Your ASP.NET Website Table 15.1 SignInStatus Values Table 15.2 IdentityUser Properties Table 15.3 Password Validation Configuration Properties Chapter 16: Personalizing Websites Table 16.1 Database Migration Configuration Properties Chapter 17: Exception Handling, Debugging, and Tracing Table 17.1 Common Exceptions Table 17.2 Properties on the Exception Class Table 17.3 HandleError Properties Table 17.4 Keystrokes That Support Debugging Table 17.5 Sections Available in Trace Output Table 17.6 Trace Configuration Attributes Table 17.7 Trace Methods Table 17.8 nLog Logging Levels Chapter 19: Deploying Your Website Table 19.1 Transformation Items Introduction It was estimated in June 2015 that 45 percent of the world's population has accessed the Internet. That's over 3 billion users, and the number is growing every day. This is a vast, connected market that can reach any content you decide to make available, be it a simple web page or a complex web application. There are a lot of ways that you can make a simple web page available online. There are a lot fewer approaches when you are trying to build a web application. One of these web application technologies is ASP.NET from Microsoft. ASP.NET is a framework that supports the building of robust and performant web applications. Think of it as the structural support for a car. You can add a couple of different body designs on top of this structure: ASP.NET Web Forms and ASP.NET MVC. These two approaches both rest on ASP.NET and depend on common functionality that is made available through ASP.NET. Visual Studio 2015 is the primary tool used when creating and maintaining ASP.NET web applications. It will help you easily work with every aspect of your web application, from the “look and feel” all the way through to deployment of your application—and skipping none of the steps in between. In addition, because Microsoft is committed to supporting ASP.NET developers, it is available in a fully functional free version! This book is an exploration of both ASP.NET Web Forms and MVC. As part of this exploration you will become familiar with all of the various components of a functional web application, creating a sample application as you go through the different parts of the development process. You will learn how the two frameworks do things, with some approaches being very similar while others are completely different. No matter the style of approach, however, it is always clear that they both rest on the same framework. Who This Book Is For This book is designed for anyone who wants to build robust, performant, and scalable web applications. Although the development tools run in Microsoft Windows, you are free to deploy the application onto virtually any current operating system; therefore, even organizations that don't have Microsoft servers have the capability to now run ASP.NET web applications. If you are new to software development you should have no problem following along, as the book has been structured with you in mind. Those of you who are experienced developers but new to web development will also find many different areas of interest and use, especially if C# is not your current programming language. Lastly, experienced ASP.NET developers should also find many topics of interest, especially if your experience is mainly related to either Web Forms or MVC, but not both. This book will give you experience in both approaches as well as demonstrate how to integrate the two approaches into a single application. What This Book Covers This book teaches you how to build a fully functional web application. You will have the opportunity to build a complete site using both ASP.NET MVC and ASP.NET Web Forms approaches so that you can develop an understanding of, and build a comfort level with, the complete ASP.NET set of functionality. Each chapter takes you a step further along the development process: Chapter 1: Getting Started with ASP.NET 6.0—You will get an introduction to ASP.NET as a general framework and specifically with Web Forms and MVC. You will also download and install Visual Studio 2015. Chapter 2: Building an Initial ASP.NET Application—In this chapter you create the initial project, including configuring it to support both Web Forms and MVC. Chapter 3: Designing Your Web Pages—This chapter introduces you to HTML and CSS so that you can build attractive and understandable web sites. Chapter 4: Programming in C# and VB.NET—ASP.NET is a developmental framework with which you can use different programming languages, including C# and VB.NET. This chapter provides an introduction to using them. Chapter 5: ASP.NET Web Form Server Controls—ASP.NET Web Forms offers many different forms of built-in functionality that it provides as server controls. These controls enable you to create complex and feature-rich web sites with very little code. This chapter covers the most common controls. Chapter 6: ASP.NET MVC Helpers and Extensions—Whereas ASP.NET Web Forms have server controls to provide features, ASP.NET MVC offers a different type of support through the use of helpers and extensions. This chapter describes that different support. Chapter 7: Creating Consistent-Looking Websites—You will learn how ASP.NET enables you to use master pages and layout pages to create a consistent look and feel throughout your web application. Chapter 8: Navigation—In this chapter you learn the different ways to create menus and other navigation structures. You also look at the different types of links that you can build in both Web Forms and MVC. Chapter 9: Displaying and Updating Data—When you want to use a database with ASP.NET, there are no better options than SQL Server. In this chapter, you install SQL Server, create your initial database schema, and incorporate the creation and display of data into your application. Chapter 10: Working with Data—Advanced Topics—Advanced topics include pagination, sorting, and using advanced database items such as stored procedures to retrieve special sets of information from the database. You will also learn how you can speed up responsiveness by storing data in various places. Chapter 11: User Controls and Partial Views—ASP.NET offers server controls and helpers to provide built-in functionality. Learn how to create your own items to provide common functionality across multiple pages. Chapter 12: Validating User Input—A large part of your site's functionality is defined by the data that users input into your application. This chapter shows you how to accept, validate, and process user input using tools for both Web Forms and MVC. Chapter 13: ASP.NET AJAX—AJAX is a technology that enables you to update parts of your page without making a full-page call to the server. Learn how to do this for both Web Forms and MVC. Chapter 14: jQuery—Everything covered up until this point has been based on doing work on the server. In this chapter you are introduced to using jQuery for work on the client, without having to call back to the server. Chapter 15: Security in Your ASP.NET Website—This chapter adds the concept of a user, demonstrating how you can identify your visitors by requiring them to log in to your application. Chapter 16: Personalizing Websites—Here you will learn how to customize the user information you are using to get the information needed to ensure that users feel welcome at your site. Capturing information about the user's visit also helps you better understand what they want when they visit your site. Chapter 17: Exception Handling, Debugging, and Tracing— Unfortunately, it's very difficult to write code that is totally problem-free. Learn how to manage these problems, including finding and fixing them as well as ensuring that when they happen, users are given the relevant information as to why their actions were not successful. Chapter 18: Working with Source Control—Working within a team is an important aspect of being a professional developer. Source control provides a way for you to share code among users. It also manages backing up your source code with saved versions. Chapter 19: Deploying Your Website—After completing all the work to build your application, the last step is getting out onto the web where your users can visit it! How This Book Is Structured The primary instructional approach in this book is a set of detailed hands-on steps that walk you through the process of building a complete application. These “Try It Out” activities, which demonstrate whatever topic is under discussion, are followed by a “How It Works” section that explains what each step accomplishes. Each of the “Try It Out” sections builds on what was done previously, so they should be followed sequentially. Exercise questions at the end of the chapter enable you to test your understanding of the material, and answers are available in the appendix. Some questions are specific, others more general. Together they are designed to help reinforce the information presented in the chapter. A lot of information is presented in this book; it covers two technological approaches that sometimes seem completely different. Additional sources of information are included in the chapters if you want more detailed information about a particular approach or product. What You Need to Use This Book In order to follow along with the chapter and its hands-on activities, you will need the following: Windows 7, 8, or 10 or Windows Server 2008 or 2012 The minimum requirements for Visual Studio 2015, including RAM and hard drive space Conventions To help you get the most from the text and keep track of what's happening, we've used a number of conventions throughout the book. TRY IT OUT: TRY IT OUT This is a hands-on exercise you should work through, following the text in the book. 1. They consist of a set of steps. 2. Each step has a number. 3. Follow the steps with your copy of the database. How It Works This section explains in detail the code from each “Try It Out” activity. WARNING Boxes like this one hold important, not-to-be forgotten information that is directly relevant to the surrounding text. NOTE These are tips, hints, tricks, or asides to the current discussion, offset and placed in italics like this. As for styles in the text: We highlight new terms and important words when we introduce them. We show keyboard strokes like this: Ctrl+A. We show filenames, URLs, and code within the text like so: persistence.properties. We present code in two different ways: We use a monofont type with no highlighting for most code examples. We use bold to emphasize code that's particularly important in the present context. Source Code As you work through the examples in this book, you may choose either to type in all the code manually or to use the source code files that accompany the book. All the source code used in this book is available for download at http://www.wrox.com/go/beginningaspnetforvisualstudio. You will find the code snippets from the source code are accompanied by a download icon and note indicating the name of the program so you know it's available for download and can easily locate it in the download file. Once at the site, simply locate the book's title (either by using the Search box or by using one of the title lists) and click the Download Code link on the book's detail page to obtain all the source code for the book. NOTE Because many books have similar titles, you may find it easiest to search by ISBN; this book's ISBN is 978-1-119-07742-8. After downloading the code, just decompress it with your favorite compression tool. Alternately, you can go to the main Wrox code download page at http://www.wrox.com/dynamic/books/download.aspx to see the code available for this book and all other Wrox books. Errata We make every effort to ensure that there are no errors in the text or in the code. However, no one is perfect, and mistakes do occur. If you find an error in one of our books, such as a spelling mistake or a faulty piece of code, we would be very grateful for your feedback. By sending in errata you may save another reader hours of frustration, and at the same time you will be helping us provide even higher quality information. To find the errata page for this book, go to http://www.wrox.com and locate the title using the Search box or one of the title lists. Then, on the book details page, click the Book Errata link. On this page you can view all errata that has been submitted for this book and posted by Wrox editors. A complete book list, including links to each book's errata, is also available at www.wrox.com/miscpages/booklist.shtml. If you don't spot “your” error on the Book Errata page, go to www.wrox.com/contact/techsupport.shtml and complete the form there to send us the error you have found. We'll check the information and, if appropriate, post a message to the book's errata page and fix the problem in subsequent editions of the book. p2p.wrox.com For author and peer discussion, join the P2P forums at p2p.wrox.com. The forums are a Web-based system for you to post messages relating to Wrox books and related technologies and interact with other readers and technology users. The forums offer a subscription feature to e-mail you topics of interest of your choosing when new posts are made to the forums. Wrox authors, editors, other industry experts, and your fellow readers are present on these forums. At http://p2p.wrox.com you will find a number of different forums that will help you not only as you read this book, but also as you develop your own applications. To join the forums, just follow these steps: 1. Go to p2p.wrox.com and click the Register link. 2. Read the terms of use and click Agree. 3. Complete the required information to join as well as any optional information you wish to provide and click Submit. 4. You will receive an e-mail with information describing how to verify your account and complete the joining process. NOTE You can read messages in the forums without joining P2P but in order to post your own messages, you must join. Once you join, you can post new messages and respond to messages other users post. You can read messages at any time on the Web. If you would like to have new messages from a particular forum e-mailed to you, click the Subscribe to This Forum icon by the forum name in the forum listing. For more information about how to use the Wrox P2P, be sure to read the P2P FAQs for answers to questions about how the forum software works as well as many common questions specific to P2P and Wrox books. To read the FAQs, click the FAQ link on any P2P page. Chapter 1 Getting Started with ASP.NET 6.0 What you will learn in this chapter: A brief history of ASP.NET and why it supports both Web Forms and MVC About the two frameworks, Web Forms and MVC How to install and use Visual Studio 2015 The sample application that will be used throughout this book Code Downloads for this Chapter: The wrox.com code downloads for this chapter are found at www.wrox.com/go/beginningaspnetforvisualstudio on the Download Code tab. The code is in the chapter 01 download and individually named according to the names throughout the chapter. The Internet has become a critical part of life to millions of people across the world. This growth in the use of the Internet has been accelerating since the 1990s and will continue as technology and access becomes more affordable. The Internet has become the go-to source for shopping, leisure, learning, and communications. It has helped to both build new businesses and give revolutionaries the capability to spread their message to the rest of the world. This growth means that there will be a long-term demand for people with the skills to build and maintain the next generation of web applications. As an increasing percentage of the world's business is accomplished with web applications, learning how to work on these applications is an obvious career move. An Introduction to ASP.NET vNext The Internet started off as a set of sealed, private networks designed to share information between research institutions across the United States. The primary users of this system were the research scientists in those labs. However, as the usefulness and flexibility of this information-sharing approach became obvious, interest grew exponentially. More and more institutions became involved, resulting in the evolution of standards and protocols to support the sharing of additional types of information. The initial networks quickly expanded as commercial entities became involved. Soon, Internet service providers were available, enabling regular, everyday people to access and share the burgeoning content of the Internet. In the early days of the Internet, most content was created and stored statically. Each HTTP request would be for a specific page or piece of stored content, and the response would simply provide that content. Early application frameworks changed that model, enabling the dynamic generation of content based on a certain set of criteria sent as part of that request. This enabled content to be built from databases and other sources, exponentially increasing the usefulness of the Web. It was at this point that the general public, rather than only scientists, really started to take advantage of the Internet's enhanced usability. ASP.NET is one of those early web application frameworks, with the first version of the .NET Framework released in 2002. The ASP part of the name stands for “Active Server Pages,” which was Microsoft's initial web application framework that used server-side processing to create browser-readable HTML pages. The original ASP, now called “Classic ASP,” allowed the developer to use VBScript to add scripting code to HTML. However, the code and the HTML were all intermingled together in a single file. ASP.NET was considered a major enhancement at the time because it allowed for a much cleaner separation of the code-behind, the code that handles the processing and markup, the code handling the building of the display, than any of the other frameworks available at that time. There have been improvements to this initial ASP.NET framework with every new release of the .NET Framework. In 2008 Microsoft introduced a new framework that supported a different approach to content creation and navigation: ASP.NET MVC. MVC stands for Model View Controller, and references a software design pattern that provides a more complete separation between the user interface and the processing code. The original framework became known as Web Forms. Even as the Internet contentcreation technologies evolve, the way that the Internet runs stays surprisingly unchanged. The movement of the information from the server to the client follows a very simple protocol that has barely changed since the beginning of the Internet. Hypertext Transfer Protocol (HTTP) Hypertext Transfer Protocol (HTTP) is the application protocol that acts as the foundation for communications within the Internet. It defines the interaction between the client machine and the server as following a request-response model whereby the client machine requests, or asks for, a specific resource and the server responds with, or sends a reply about, the information as appropriate. This request can be very simple, from “show me this picture,” to something very complex, such as a transfer between your bank accounts. Figure 1.1 shows the outcome of that request—whether it is displaying the picture for the first, simple request or whether it is displaying the receipt for the bank transfer from the second, more complex request. Figure 1.1 Request response The HTTP protocol also defines what the requests and responses should look like. It includes methods, also known as verbs, which describe what kind of action should be taken on the item being requested. These verbs are not really used that much in ASP.NET Web Forms, but they are especially important in ASP.NET MVC because MVC uses these methods to identify the actions being taken on the requested object. The major verbs are listed in Table 1.1. Table 1.1 Most Frequently Used HTTP Verbs Name Description GET A GET is a request for a resource. It should retrieve that resource without any other effect resulting from taking that action. You should be able to GET a resource multiple times. POST A POST indicates that there is information included in the request that should create a new version of the resource. By definition, any item posted should create a new version, so passing in the same information multiple times should result in multiple instances of that object being created. PUT A PUT indicates that the information included in the request should change already existing items. The definition also allows the server to create a new item if the item that is expected to be changed has not already been created. This is different from the POST verb because a new item is only created when the request includes new information. DELETE The DELETE verb indicates that the specified resource should be deleted. This means that upon deletion, a GET or PUT to that resource will fail. An HTTP request includes the following: A request line. For example, GET/images/RockMyWroxLogo.png HTTP/1.1 requests a resource called /images/RockMyWroxLogo.png from the server. Request header fields, such as Accept-Language: en An empty line An optional message body; when using either the POST or PUT verbs, the information needed to create the object is generally put in this message body An HTTP response includes these items: A status line, which includes the status code and reason message (e.g., HTTP/1.1 200 OK, which says the request was successful) Response header fields, such as Content-Type: text/html An empty line An optional message body The following example shows a typical response: HTTP/1.1 200 OK Date: Thur, 21 May 2015 22:38:34 GMT Server: Apache/1.3.3.7 (Unix) (Red-Hat/Linux) Last-Modified: Wed, 08 Jan 2015 23:11:55 GMT ETag: "xxxxxxxxxxxxxxxxx" Content-Type: text/html; charset=UTF-8 Content-Length: 131 Accept-Ranges: bytes Connection: close I'm a useful title to this page

I'm some interesting content that people can't wait to consume.

The status codes, such as 200 OK in the preceding example, provide details about the request. The most common types of status codes are the 4XX and 5XX codes. The 4XX codes are for client errors, with the most common being a 404, which denotes that the resource being requested does not exist. The 5XX codes are for server codes, the most common of which is 500, or an Internal Server error. Anyone who does much web development will quickly become accustomed to the dreaded 500 errors. These verbs are needed because, by definition, HTTP is a stateless protocol. That is why nothing in the request identifies any previous request; instead, each request-response is expected to act completely independently. Much of this communication happens behind the scenes and is handled by the user's browser and the web server. However, the information being sent and received affects your web application. As you continue developing your knowledge and skills about ASP.NET, you will find cases where digging in deeper to the different values in either the request or the response becomes important. You may need to set request and/or response headers to ensure that some contextual information (such as an authorization token or the client's preferred language) are properly set. Microsoft Internet Information Services Microsoft Internet Information Services (IIS) is an application that comes with Microsoft Windows that is designed to support HTTP (known as a web server). It is included with all current versions of Windows, although it is not installed by default. When you develop an ASP.NET application, either Web Forms or MVC, the work of processing and creating the content that is returned to the client is done by IIS. HTML 5 Whereas HTTP is the process of communicating between a client and a server, HTML is the core markup language of the Internet. HTML (HyperText Markup Language) is used for structuring and presenting content on the Web, and is a standard from the W3C (World Wide Web Consortium). HTML 5, finalized in October 2014, is the newest version of this standard. The previous version, HTML 4, was standardized in 1997. As you can imagine, the Web went through some dramatic evolution during the 17 years between HTML 4 and HTML 5. While this evolution provided some advantages, especially to users, it also created some problems for website developers. One of the primary problems was that web browser companies tried to differentiate their products by providing a set of browser-specific enhancements, especially related to multimedia. This made developing an interactive website problematic because each browser had different specific development requirements. HTML 5 was designed to help solve the problems caused by this fragmentation. Improvements include the following: Additional support for multimedia, including layout, video, and audio tags Support for additional graphics formats Added accessibility attributes that help differently abled users access the web page content Significant improvements in the scripting APIs that allow the HTML elements to interact with JavaScript (you will learn more about this in Chapter 14, “jQuery”) HTML Markup HTML documents are human-readable documents that use HTML elements to provide structure to information. This structure is used to provide context to the information being displayed. A web browser takes the context and content into account and displays the information accordingly. These elements can be nested, meaning one element can be completely contained within another element, making the whole page basically a set of nested elements, as shown here: I'm a useful title to this page

I'm some interesting content that people can't wait to consume.

Each layer of elements acts to group related content. As each element is parsed by the browser, it is evaluated as to where it belongs within the logical structure. This structure is what gives the browser the capability to relate content based upon its proximity and relationship to other elements within the structure. In the preceding example, the title element is a child of the head element. Note also the expectation of both open and close tags. This fits in with the concept that an element can be contained within other elements. Only those elements that cannot contain other elements do not need to be closed. The open tag is a set of angled brackets <> around an element html, while the close tag is a set of angled brackets around the same element name but prefaced with a slash /html. This enables the browser to identify each section appropriately. Some browsers may support some tags that are not properly closed, but this behavior is inconsistent, thus care should be taken to close all elements. The only item that does not follow this standard is the declaration. Instead, this identifies how the content that follows should be defined. In this case, the content is defined as html, so the browser knows that the content should be parsed as HTML 5. Some of the more useful elements available in HTML 5 are listed in Table 1.2. This is not a complete list! Visit the W3C site for a complete list of HTML elements and a full description of their usage at http://www.w3.org/TR/html5/index.html. Table 1.2 Commonly Used HTML Elements Element Description Name html Identifies the content as HTML code. head Defines the content as the head section of the page. This is a high-level section containing information that the browser uses to control the display of the content. title An item within the head section, this element contains the content normally displayed in the browser's title bar. body Defines the content as the body section of the page. This section contains the content that is displayed within the browser window. a Anchor tag that acts as a navigation link to other content. It can redirect the user to another location on that same page or to a completely different page. img This tag places an image onto the page. It is one of the few elements that does not have a closing tag. form The form tag identifies the contained content as a set of information that will be submitted together as a block. It is generally used to transfer information from the user to the server. input This element plays a lot of roles within a form. Depending upon the type (much more on this later!) it can be a text box, a radio button, or even a button. span A way to delimit content inline. This enables you to give a special format to one or more words in a sentence without affecting the spacing of those words. div Like the span tag, this tag acts as a container for content. However, it is a block element, and different in that there is a line break before and after the content. audio An HTML 5 feature that allows you to embed an audio file into the page. The types of audio files supported may differ according to browser. video An HTML 5 feature to embed video files into the page so that the browser will play the content inline. section An HTML 5 addition that identifies a set of content as belonging together. Think of it as a chapter in a book, or areas of a single web page such as introduction and news. article Another HTML 5 addition that defines a more complete, selfcontained set of content than the section element. p A paragraph element that breaks up content into related, manageable chunks. header Provides introductory content for another element, generally the nearest element. This may include the body, which means the content is the header for the entire page. h1, h2, h3 An element that enables content to be designated as header text. The smaller the number, the higher it appears in the hierarchy. An h1 element would be similar to a book title, h2 could be chapter title, h3 section title, and so on. ul Enables the creation of an unordered, bulleted list. ol Enables the creation of an ordered, generally numbered list. li The list item element tells the browser that the content is one of the items that should be included in a list. Attributes in HTML An attribute is additional information that is placed within the angle braces of the opening element. This attribute provides detail so that the browser knows how to behave when rendering or interacting with that element. An example is the anchor element, which provides a navigational link to other content: Awesome books here! The href is an attribute that tells the browser where to send users after they click the “Awesome books here!” link. All elements support attributes of some sort, whether they are implied required items such as the href attribute in an anchor tag, or optional tags such as name, style, or class, which can be used to control the identification and appearance of the attributed element. HTML Example The code in Listing 1.1 is a sample HTML page that contains almost all of the elements in Table 1.2. Listing 1.1: An example HTML page Beginning ASP.NET Web Forms and MVC

ASP.NET from Wrox

Creating awesome output

ASP.NET Web Forms

More than a decade of experience and reliability.

  1. Lots of provided controls
  2. Thousands of examples available online

ASP.NET MVC

A new framework that emphasizes a
stateless
approach.
  • Less page-centric
  • More content centric

Enter your email to sign up:

Microsoft's Internet Explorer renders this HTML content as shown in Figure 1.2. All other HTML 5 browsers will also render this comment in a very similar way. Figure 1.2 HTML rendered in the browser As you can see, HTML provides some simple layout to the content. However, when you look at various sites on the Web, you will likely not see anything that looks like the preceding example. That's because HTML provides layout, but there is another technology that provides more control over the user experience (UX) by enhancing design. This technology is Cascading Style Sheets (CSS). REFERENCE CSS is explained in more detail in Chapter 3, “Designing Your Web Pages.” ASP.NET Web Forms ASP.NET Web Forms have been part of the .NET infrastructure since its initial release. Web Forms generally take a page-based approach whereby each web page that may be requested is its own unique entity. During development there are two physical pages in the file system that make up each viewable page: the .aspx code, which contains the viewable markup, and the .aspx.cs or aspx.vb, which contains the code to do the actual processing, such as creating the initial content or responding to button clicks. These two pages together provide the code and markup necessary to create the HTML that is sent to the browser for viewing. The main benefit of ASP.NET Web Forms is the level of abstraction that it provides compared to the request/response approach and the creation of the HTML that is sent to the client. A detailed knowledge of HTML is less critical than a detailed knowledge of C# or Visual Basic. The framework itself hides a lot of the HTML generation by doing it for you. The primary model for communications between the client and the server is an approach called the postback, whereby a page is rendered in the browser, the user takes some action, and that page is sent back to the server using the same resource name. This allows each page to be responsible for both the creation of the page content and responding to changes in the page content as necessary. ViewState This response to change in the page content is enhanced through the use of ViewState. Because HTTP is a stateless protocol, anything that needs state needs to be managed in a more customized approach. ViewState is how ASP.NET Web Forms take this customized approach and transfer state information between the browser and the server. ViewState is a hidden field that is included within the page. The entity's value contains hashed information that is unreadable by humans. Fortunately, ASP.NET is able to parse the information and get an understanding of the previous version of the various items on the page. It is important to understand view state because of the significant role it plays in how ASP.NET Web Forms do their work. Say you are working on a page that has several postbacks. Perhaps one of the postbacks changes the value of a label. If the label had a default value from the first rendering, every initialization of that control on each new postback will reset that value to the default value. However, the system then analyzes the view state and determines that this particular label has a different value that should be displayed. The system now recognizes that it is in a different state and will override the default setting to set the label to the newer, changed version of the text. This is a powerful way to persist changes between multiple postbacks. However, the more items that change and need to be tracked, the larger the set of view state information, which can be problematic. This information is passed both directions, from server to the client, and then back to the server. In some cases the amount of information being transferred as part of the view state can slow down the download/upload time, especially in those cases where network speed or bandwidth is limited. By default, the use of ViewState is enabled on every control. However, as the developer you can override those settings as necessary, such as when you know that you won't need to know the previous state of the control. You can also use the view state programmatically. Imagine a large list of data that has both sorting capabilities and paging. If you are going to sort before paging, then the sorting criteria needs to be stored somewhere so that it is available to the next postback. The view state is one place to store this information. ASP.NET Web Forms Events and Page Lifecycle One of the strengths of Web Forms is the ability it gives developers to plug into the various events in the page lifecycle. The ASP.NET lifecycle allows the developer to interact with information at various points in the HTML creation phase. As part of the flow, the developer can also use event handlers to respond to events that may happen on the client, including clicking a button or selecting an item in a dropdown list. For developers who are coming from a traditional event-driven development approach, such as Windows Forms, this approach will be very easy to pick up. While the lifecycle process gives a lot of power to a developer, it also adds to the complexity of the application—the same code can result in a different outcome depending on when it is called during the lifecycle. The steps in the lifecycle are shown in Table 1.3. Some of these items may not make any sense to you at this point, but as we move through the process of creating an interactive web site, you will start to see how this all comes together. Table 1.3 ASP.NET Page Lifecycle Stages Stage Description Request This stage happens before the page-calling process starts. It is when the system determines whether run-time compilation is necessary, whether cached output can be returned, or whether a compiled page needs to be run. There are no hooks into this stage from within the ASP.NET page itself. Start The page starts to do some processing on the HTTP request. Some base variables are initialized, such as Request, Response, and the UICulture. The page also determines if it is a postback. Initialization During this phase, the controls on the page are initialized and assigned their unique IDs. Master pages and themes are applied as applicable. None of the postback data is available, and information in the view state has not yet been applied. Load If the request is a postback, control information is loaded with the information recovered from view state. Postback event handling If the request is a postback, all the various controls fire their event handlers as needed. Validation also happens at this time. Rendering Before the rendering stage starts, ViewState is saved for the page and all of the controls as configured. At this time, the page output is added to the response so that information may start flowing to the client. Unload This happens after the content was created and sent to the client. Objects are unloaded from memory and cleanup happens. The steps in the lifecycle are exposed through a set of lifecycle events. A developer can interact with a lifecycle event as necessary. You will learn more about this interaction as you develop the sample application. These events are listed in Table 1.4. Table 1.4 Lifecycle Events for ASP.NET Pages Event Description and Typical Use Preinit Raised after the start stage is complete and before the initialization stage begins. Typically used to create or recreate dynamic controls, setting master pages or themes dynamically (more on this later). Information in this stage has not yet been replaced with the ViewState information, covered earlier. Init This event is raised after all the controls have been initialized. It is typically used to initialize control properties. These initializations do not affect view state. InitComplete Only one thing happens between Init and InitComplete, and that is the enabling of view state for the controls. Changes applied in this event and after will impact view state, so are available upon postback. PreLoad Raised after the page manages the view state information for itself and all controls. Postback data is also processed. Load The OnLoad method is called in a page, which then recursively calls that same method on every control. This is typically where the majority of your creation work happens, initializing database connections, setting control values, etc. Control Events These are specific control-based events, such as the Click of a button, or TextChanged on a text box. LoadComplete This event is raised after all the event handling has occurred. Doing anything here would generally require all of the controls to be loaded and completed. PreRender After all the controls have been loaded, the Page object starts its Pre-render phase. This is the last point at which you can make any changes to the content or the page. PreRenderComplete Raised after every databound control has been bound. This happens at the individual control level. SaveStateComplete Raised after view state and control state have been saved for the page and for all controls. Any changes to the page or controls at this point affect rendering, but the changes will not be retrieved on the next postback. Render This is not an event. Rather, at this point in the process, the Page object calls this method on each control. All ASP.NET Web server controls have a Render method that writes out the control's markup to send to the browser. Unload This is used to perform special cleanup activities, such as closing file or database connections, logging, etc. The work that you will be doing in the sample application only takes advantage of a few of these events. However, understanding that they may occur gives you an idea of how ASP.NET Web Forms works under the covers. Web Forms enable you to tap into each of these events as needed, both at a page level and a control level. While you will likely encounter entire application projects that don't require anything outside of the Load and Control Events sections, Web Forms provide you with the power to do so as needed. Some of the more powerful controls have their own sets of events, which you will learn about when you start to work on the sample application. Control Library One of the benefits of ASP.NET Web Forms is a powerful set of built-in server controls that give developers a boost in development speed and enhance rapid application development (RAD). Using these controls turns the development process into one that's more about configuration than development, providing an out-of-the-box experience that will likely satisfy many developers who need the most common default behavior. In addition, because of the maturity of this approach, an extensive set of third-party controls are available as well as rich and powerful support within Visual Studio. These ASP.NET server controls are items that a developer places on an ASP.NET web page. They run when the page is requested, and their main responsibility is to create and render markup to the browser. Many of these server controls are similar to the familiar HTML elements, such as buttons and text boxes. Other of these server controls allow for more complex behavior, such as a calendar control that manages the display of data in a calendar format and other controls that you can use to connect to data sources and display data: There are four main types of controls: HTML server controls Web server controls Validation controls User controls HTML Server Controls HTML server controls are generally wrappers for traditional HTML elements. These wrappers enable the developer to set values in code and to use events, such as a textbox control firing an event when its text display value has been changed. You will be working with many different HTML server controls as you work through the Web Forms part of the application. Web Server Controls A web server control acts as more than a wrapper around an HTML element. It tends to encompass more functionality and be more abstract than an HTML server control, because it does more things. A calendar control is a good example of a web server control; it enhances UI functionality by providing a button that enables users to access a grid-like calendar to select the appropriate date. The calendar control also provides other functionality, such as limiting the range of selectable dates, formatting the date being displayed, and moving through the calendar by month or year. Validation Controls The third type of control is the validation control. This control ensures that the values entered into other controls meet certain criteria, or are valid. A textbox that is expected to only capture money amounts, for example, should only accept numbers and perhaps the comma (,) and period (.). It should also ensure that if the value entered contains a period, then there are no more than two numbers to the right of the period. The validator provides this support on the client side and on the server. This ensures that the data is correct before being sent to the server and then ensures that the data is correct when it gets to the server. User Controls The last type of control is a user control. This is a control that you build yourself. If a set of functionality needs to be available on multiple pages, then it is most likely that you should create this functionality as a user control. This enables the same control to be reused in multiple places, rather than copying the code itself into multiple pages. These controls can do a lot of very useful things for you, but they come at a cost. By using these controls, you may lose some control over the finished HTML, which may lead to bloated output or HTML that does not quite fit what the designer may desire. ASP.NET MVC Earlier, you learned that ASP.NET Web Forms is a page-based approach to designing a web application. ASP.NET MVC is a different architectural approach that emphasizes the separation of concerns. Whereas Web Forms are generally made up of two sections, markup and code-behind, MVC breaks the concerns into three parts, model, view, and controller. The model is the data that is being displayed, the view is how the data is being displayed to the user, and the controller is the intermediary that does the work of ensuring that the appropriate model is presented to the correct view. Figure 1.3 illustrates the interaction between the different parts. Figure 1.3 Model-View-Controller (MVC) design A key difference between ASP.NET Web Forms and MVC is that MVC presents views, not pages, to the client. This is more than simple semantics, it indicates a difference in approach. Web Forms take a file system approach to presenting content; MVC takes an approach whereby content is based on the “type of action” that you are trying to perform on a particular thing, as shown in Figure 1.4. Figure 1.4 Different Approaches Between MVC and Web Forms NOTE This kind of approach may be less intuitive for developers who are coming from a more event-driven background. However, developers who have experience with other MVC approaches, such as Ruby on Rails, will find the MVC pattern to be comfortable and a good fit with their previous experience. The key reason for the MVC pattern's success is the degree to which it helps developers create applications whose different aspects can be separated (input logic, business logic, and UI logic), while still providing a relatively loose coupling between these elements. A loosely coupled system is one in which each component has very little to no knowledge of the other components. This enables you to make changes in one of the components without disturbing the others. In an MVC application, the view only displays information; the controller handles and responds to user input and interaction. For example, the controller handles query-string values, and passes these values to the model, which in turn might use these values to query the database. Because of this separation, you can completely redesign the UI without affecting the controller or model at all. Because of the loose coupling, the interdependency is much less rigorous. It also enables different people to assume different roles in the development of the application, by disassociating the HTML creation from the server that creates the data to be displayed. The MVC pattern specifies where each type of logic should be located within your application. The UI-specific logic belongs in the view. Input logic, or the logic that handles the request from the client, belongs in the controller. Business logic belongs in the model layer. This separation helps you manage complexity when you build an application because it enables you to focus on one aspect of the implementation at a time. Testability An important consideration when using an MVC approach is the valuable increase in testability it offers. Unit tests are re-runnable items that validate a particular subset of functionality. This is important in modern development because these unit tests enable the developer to refactor, or make changes to, existing code. The unit tests enable developers to determine whether any negative side effects result from the change by running the already created unit tests. An ASP.NET Web Forms application is difficult to unit test for precisely the same reasons that it works so well as a RAD approach: the power of the built-in controls and the page lifecycle. They are very specific to the page of which they are a part, so trying to test discrete pieces of functionality becomes much more complicated because of the dependencies with other items on the page. ASP.NET MVC's approach and separation means that controllers and models can be fully tested. This ensures that the behavior of the application can be better evaluated, understood, and verified. When building a very simple application this may not be important, but in a larger, enterprise-level application it becomes critical. The functionality it provides to the business might be essential, and it will likely be managed, maintained, tweaked, and changed over a long lifetime; and the more complex the code, the more risk that a change in one area may impact other areas. Running unit tests after a set of changes provides assurance that previously created functionality continues to work as expected. Building unit tests on new functionality verifies that the code is working as expected and provides insurance against future changes. You won't be specifically building unit tests as part of the process in building the sample web application. However, the available source code does have a unit test project and some tests will be created as you work through the development process, especially for those areas that are using ASP.NET MVC. Full Control over Output ASP.NET MVC does not have the same dependence upon controls that ASP.NET Web Forms do, thus it does not have the same risk of becoming bloated HTML output. Instead, developers create the specific HTML that they want sent to the client. This allows full access to all attributes within an HTML element rather than just those allowed by the ASP.NET Web Form server control. It also allows for much more predictable and clearly understood output. Another advantage in having full control over the rendered HTML is that it makes the inclusion of JavaScript much easier. There is no potential for clashes between control-created JavaScript and developer-created JavaScript; and because the developer controls everything that is rendered on the page, using element names and other attributes that may have been commandeered by the generated HTML becomes easier. Of course, this additional flexibility comes at some cost: Developers are required to spend more time building the HTML than otherwise may have been necessary with the Web Form controls. It also requires that developers be more knowledgeable about HTML and client-side coding, such as JavaScript, than was necessary with Web Forms. Web Forms and MVC Similarities It is important to understand that Web Forms and MVC are not opposing approaches but rather different approaches that have inherently different strengths and weaknesses. They each address different concerns and are not mutually exclusive. A developer can create unit tests in Web Forms; it just takes more work and requires the developer to add abstraction where the framework does not provide any by default. Just as with virtually any other development problem, there are multiple potential solutions and approaches. A well-designed application will be successful, regardless of the approach taken. Fundamentally, as both Web Forms and MVC are designed to solve the same base requirement—creating HTML content that will be provided to the client user— there are a lot of similarities between the two. Properly architected applications will be much the same, especially in terms of backend processing. Accessing databases, web services, or file system objects will all be the same regardless of approach. This is why many developers can become proficient in both. Choosing the Best Approach As described earlier, each of these frameworks has its own set of advantages and disadvantages. You need to evaluate your requirements against these concerns and determine which is the most important to your project. This means that there is no right answer; some projects would be best implemented via Web Forms, whereas others might be better served by taking an MVC approach. There are additional concerns when determining the appropriate development approach, including the background and experience of the developers who will be doing the work and how much information is being shown the same way on multiple pages. Fortunately, with the advent of Visual Studio 2015 and ASP.NET 5.0 you no longer have to make an either/or choice. With a little bit of maneuvering, you can create a project that uses both approaches as necessary, enabling you to determine on a case-by-case basis which approach to use, instead of using a site-by-site determination. This case-by-case approach is used in the sample application, which uses both ASP.NET Web Forms and ASP.NET MVC to solve various business problems presented. Using Visual Studio 2015 Microsoft's Visual Studio is the primary integrated development environment (IDE) used to create ASP.NET sites and applications. The most recent version is Microsoft Visual Studio 2015, which includes quite a few enhancements. There are also new versions of both C#, version 6.0, and VB.NET, version 14. ASP.NET 5 is also an important release because it can now run on OS X and Linux with Mono installed. Mono is a software platform designed to enable developers to easily create crossplatform applications. It is an open-source implementation of Microsoft's .NET Framework that runs on non-Windows operating systems. This is a tremendous game changer; because until now, every ASP.NET application, either Web Form or MVC, needed to be deployed to and run on a Microsoft Windows server. Versions Several different versions of Visual Studio are available for web developers: Visual Studio Community Edition: A free version of Visual Studio that is designed to help hobbyists, students, and other non-professional software developers build Microsoft-based applications Visual Studio Web Developer Express: Another free version of Visual Studio, supporting only the development of ASP.NET applications Visual Studio Professional Edition: A full IDE for use in creating solutions for the Web, desktop, server, cloud, and phone Visual Studio Test Professional Edition: Contains all the features of the Professional Edition, with the capability to manage test plans and create virtual testing labs Visual Studio Premium Edition: Contains all the features of the Professional Editions with the addition of architect-level functionality related to analyzing code and reporting on unit testing and other advanced features Visual Studio Ultimate Edition: The most complete version of Visual Studio, including everything needed for development, analysis, and software testing The sample application will use the Community Edition because it provides a complete Visual Studio experience. Downloading and Installing Downloading and installing Visual Studio is straightforward. The following Try It Out takes you through the various steps involved, from downloading the correct edition, to selecting appropriate options, and completing the install. TRY IT OUT: Installing Visual Studio 1. Go to http://www.visualstudio.com/products/visual-studio-communityvs. You will see a site similar to what is shown in Figure 1.5. Figure 1.5 Visual Studio site to download Community Edition 2. Select the green Download button to run the installation program. Running the download will give you the screen shown in Figure 1.6. Figure 1.6 Installation screen for Community Edition 3. You can select the Custom radio button and see the screen as shown in Figure 1.7, or you can choose Typical and start the installation process. Figure 1.7 Select items to install 4. Leave the default settings and click the Install button. You will likely get a User Account Control acceptance box to which you must agree before continuing, after which the download and installation process begins. This may take a while. When the installation is completed you will see a window like the one shown in Figure 1.8. Once completed you may need to restart your computer. Figure 1.8 Setup Completed window 5. To launch the application, click the Launch button. This will bring you to the login screen shown in Figure 1.9. Figure 1.9 Login screen in Visual Studio 6. For now, skip the login. This will bring up the Development Settings and Color Theme selection screen shown in Figure 1.10. Figure 1.10 Initial configuration of Visual Studio 7. Select the Web Development option, and whichever set of colors you prefer. After configuring these preferences, the application will open, as shown in Figure 1.11. Figure 1.11 Start Page for Visual Studio How It Works You have completed installing Visual Studio. It is a relatively straightforward installation process, with the only unusual aspect being that Visual Studio now gives you the opportunity to link your installation to an online profile. This enables you to share source code repository information and some system settings between different installations of Visual Studio If you have not used Visual Studio before don't worry; you will be spending a lot of time going through it as you build the sample application. The Sample Application The best way to learn how to do something, such as build an Internet application, is simply to do it. With this in mind, you will be building a real application as we go through each functional area of ASP.NET. We will be developing an application called RentMyWrox that acts as a loaning library. Because this app supports both ASP.NET Web Forms and ASP.NET MVC, there will be some duplication of code and/or effort to show critical features in both frameworks. For some functionality you will be able to do this in two different pages; with other functionality you will have to replicate the same functionality both ways, basically replacing one version with the other version. The requirements for this application are as follows: The site owner (administrator) can create a list of items that are available for rent or borrowing. The items contain pictures and text. Users can create and register an account online that will give them secure access to the application. Users can log in and select one to many items that they want to check out. The listing of items can be filtered. Users can complete their reservation through a type of checkout process. These requirements will give you the opportunity to go over the design of the look and feel of the website, getting and saving information in a database, and handling user account creation and authentication using both ASP.NET Web Forms and MVC approaches. Summary Microsoft has provided many different web application frameworks over the years. Before the .NET Framework was introduced, there was an approach that provided the capability to incorporate HTML5 markup with business processing. This approach, now known as “Classic ASP,” was innovative at the time and enabled developers to quickly and relatively easily build complex business applications. ASP.NET follows in those footsteps by providing developers with a framework on which to balance all development work. When ASP.NET was introduced, only a single development framework was supported: ASP.NET Web Forms. This framework took a page-bound approach, tying together a specific page and a resource name that would be called. There were two physical pages to each resource page: one page containing the HTML markup that would be returned to the client, and another page that provided all the processing. This allowed for a separation of concerns that Classic ASP did not address. However, after several years Microsoft released another framework: ASP.NET MVC. This approach allows even more separation of concerns, and greatly enhances the capability to test the business processing in an automated fashion. This is important because it dramatically increases confidence in the correctness of the code. All of these frameworks are designed to do one single thing: provide HTML from the server to a client. HTML is the language of the Internet—it incorporates the layout and markup of everything that you would see on a web site. The creation of this HTML is primary. Obviously, other processing is going on in the background, but every representation of this work back to the requesting client will be HTML. Exercises 1. What is the difference between HTML and HTTP? 2. Why is ViewState important when you are working with ASP.NET Web Forms? 3. What are the three different architectural components of ASP.NET MVC? 4. What is Microsoft Visual Studio and what are we using it for in this book? What You Learned in This Chapter Attributes Extra information you can put in an HTML element that may change how that element interacts with the browser or with the user. Elements A section of HTML that defines a set of content. The elements define the content because there is an opening tag

and a closing tag

around the content. HTML Hypertext Markup Language, how content is identified on the Internet so that browsers know how to handle and display the information. HTTP Hypertext Transfer Protocol, the definition that handles the request/response behavior which delivers information from the client to the server and back. IDE Integrated development environment, a collection of tools and aids that help developers build programs and applications. MVC An architectural pattern that separates the responsibilities of a website into three different components: models, views, and controllers. Each of the sections takes responsibility for part of the process of building a user interface. Web Forms An approach to building web applications that is based on a page approach, so each set of functionality is its own page, responsible for both its rendering and business logic. Chapter 2 Building an Initial ASP.NET Application What you will learn in this chapter: The differences between web site projects and web application projects in Visual Studio The project types available in Visual Studio and what they mean to our sample application How to create a new ASP.NET site in Visual Studio File types and directory structures in both ASP.NET Web Forms and MVC The differences between ASP.NET Web Forms and MVC Code Downloads for this Chapter: The wrox.com code downloads for this chapter are found at www.wrox.com/go/beginningaspnetforvisualstudio on the Download Code tab. The code is in the chapter 02 download and individually named according to the names throughout the chapter. Now that you have installed Visual Studio and have an understanding of the requirements for the sample application, it's time to get started building it. Visual Studio makes the creation of the application shell (the initial directory structure and commonly used files) very straightforward if you are using either ASP.NET Web Forms or ASP.NET MVC. Creating a project that enables you to do both, as we will do here, is not quite as easy because it is not a traditional approach. However, there is no better way to see the two different approaches than by doing them side by side. This chapter covers the different aspects of each approach, ASP.NET Web Forms and MVC, including file type and directory structure, as well as the differences that you will see as you work through the two different frameworks. Finally, the chapter explains in detail how to make a project that supports both ASP.NET Web Forms and ASP.NET MVC. Creating Websites with Visual Studio 2015 Visual Studio 2015 is a very powerful integrated development environment (IDE). You can develop web applications, web services, mobile applications, and desktop applications with the same tool, using the same designer interfaces and many of the same development approaches. Because of this power, it is easy to make a misstep as you determine the approach that you want to take for designing and building your application. Luckily, however, starting over again is as simple as deleting your problem project and its directories. Available Project Types A project is Visual Studio's way of identifying a different approach to building an application. A project acts as a container for organizing source code files and other resources. It enables you to manage the organization, building, debugging, testing, analysis, and deployment of your application. A project file is either a .csproj or a .vbproj file and contains all the information necessary to manage all of the preceding relationships. When creating a site that will be accessed online, you can use two types of projects: web site and web application. In Visual Studio, a web site project is treated differently than a web application project. Figure 2.1 shows how they are created differently. Figure 2.1 Creating a project or web site There are a lot more differences between the two approaches than how they are created, however, as you will see in the following sections. Web Site Project–Based Approach The web site project is a less enterprise-type approach toward managing and deploying a web site. The markup (.aspx) files are copied to the server and called during the request. The code-behind files are compiled on the server and saved as temporary .dll files during the first call to the server. This process, where compilation is done during the execution of a program, at run time, rather than needing to be done before the program is run, is called just-in-time compilation. There is no project file as part of the project. Instead, each of the files and directories are treated individually. As you can imagine, this makes it easy to work with a website. There are no special installations that have to be run on the server; all you need to do to get the site running is to copy the entire folder to a machine running Microsoft Internet Information Services (IIS). Adding and removing files from the web site is as simple as removing them from the directory, although once they are removed from the server they will not be reachable so it is important that any links to the page be edited as well! However, this very flexibility in approach comes with some limitations. The limitation that impacts us the most for this project is that you cannot create an ASP.NET MVC application, because MVC applications require full compilation. You can only create ASP.NET Web Forms and other projects that do not require full compilation. Figure 2.2 shows the New Web Site dialog that appears after selecting New Web Site from the menu. Figure 2.2 Options when creating a new web site While there are many different options when creating a web site, note that they do not include an MVC application. Web Application Project Web applications are a much different approach to creating an application than web sites. The web application treats the project more as a true application than a simple grouping of files. This means that everything you may want to do with the site, such as adding an image file or other supporting item, should be done using the IDE. You also have to compile the application before deployment. While this requires a bit more work during the deployment phase, it also enables you to avoid deploying source code to the server. In addition, it speeds up the response time for your application, as your users do not have to wait for the just-in-time compilation to occur before their content can be created. Because ASP.NET web sites do not allow for the creation of an ASP.NET MVC site, and that is one of the main requirements, you need to use a web application project as the approach to build your application. Creating a New Site The first step in creating the sample application is to create an appropriate project in Visual Studio. By selecting File New Project you will get the New Project dialog shown in Figure 2.3. Figure 2.3 Creating a new project in Visual Studio Select the ASP.NET Web Application project type, give it your desired name, and select your preferred location to store the project files. By default, Visual Studio is configured to save your files into directories under “My Documents.” You can also select the .NET Framework version that you want to use in your application. Your filled-out screen should look something like what is shown in Figure 2.3. Once you select the ASP.NET Web Application projects and click the OK button, you will get the dialog shown in Figure 2.4, which shows the available templates from which you can choose. This tells the IDE what type of ASP.NET project you wish to create. Figure 2.4 Selecting the appropriate ASP.NET template Selecting one of these templates will create the appropriate file structure and most commonly used files for that particular template. Each of these available templates is covered in detail in the following sections. While Creating a Project There are several other sections of the New ASP.NET Project window that you need to know because they impact the way the project is created. The template section is in the upper-left area of the window. The upper-right area of the window contains the selection for the type of authentication that your application will support “out of the box.” The lower-left section of the window contains settings for “folders and core reference files” and unit tests, while the lower-right corner of the window allows you to manage deployment of your project to Microsoft Azure if you so desire. Authentication Options Authentication is an important consideration for every application that you will build, which is why it appears in the project creation window. As you likely know, authentication is the process of evaluating whether or not users of your application are who they say they are. If your application needs to be able to identify the user as a specific person, then the use of authentication is required. The most common way to verify that a person is who they say they are is through the use of a username and password. The username identifies the user while the password confirms that the person is who they say they are. NOTE You should always understand your authentication needs from the very beginning. “Plugging in” security partway through the development process can be problematic because it can easily lead to security holes in your application due to missed retrofitting. It is always easier to remove security if you determine that you do not need it as you go forward than to add it after development is underway. The project templates have built-in support for four different settings for authentication, as shown in Figure 2.5: No authentication Organization Accounts Individual User Accounts Windows Authentication Figure 2.5 Authentication options for a new project No authentication is pretty straightforward; it means that the application does not do any authentication out of the box. This could be used for sites for which the individual user doesn't matter—such as an informational website or a product site that does not support online ordering, or sites for which authentication will be handled differently than one of the built-in default approaches. The Organization Accounts authentication option implies that you are using a third-party system to handle authentication. These third-party systems are generally on-premise Active Directory, Active Directory in the cloud (such as Microsoft Azure Active Directory), or Office 365. Other approaches are also supported if they follow some authentication standards. Windows Authentication is a special feature only supported by Microsoft Internet Explorer. In this approach to authorization, the browser includes a special user token that the server can use to determine and identify the requesting user. This eliminates any username/password requests. However, it requires that the user has already logged into an Active Directory domain and that this information is available to the browser. This is different from the Organization Accounts approach mentioned previously, because that approach requires the user to enter a username and password that is then authenticated against the network, whereas this approach simply sends along an identifier and an acknowledgment that the user has already been authenticated. Individual User Accounts is the default authentication setting, used for those cases where you need to determine who the user is and you do not want to use an Active Directory or Windows Authentication approach. When using this approach, you can use a SQL Server database to manage users, as well as other approaches, such as letting other systems (Windows Live or Facebook, for example) handle authentication of the user. You will be using this setting for your project. REFERENCE There is much more than this selection that goes into the configuration of security and authentication for a web application. Chapter 15, “Security in Your ASP.NET Website,” covers application configuration, but there is still more! The server that you will use to host your application also needs to be configured to ensure that it supports the same authentication approach that your application will be using. This aspect is covered in Chapter 19, “Deploying Your Website.” Folders, Core Reference Files, and Unit Tests The lower-left section of the New ASP.NET Project window provides two different configuration settings. The first is a selection of the folders and core references that you want added during creation of the new project. The options are Web Forms, MVC, and Web API. The items that will already be checked vary according to which template you select; thus, if you chose an ASP.NET MVC template, the MVC checkbox will already be selected. This section is shown in Figure 2.6. Figure 2.6 Adding directories and unit tests Adding additional folders and core reference files does just that; it creates the folder structure and any default files, but it will not change any of the application creation from the template. For example, if you use a Web Forms project but select to add MVC folders, all the MVC folders are created for you, but they will have no content. The other selection in this quadrant specifies whether you want to create a Unit Test project. A unit test is generally a way to test the smallest possible unit of functionality in a replicable, automated manner—a check to ensure that a particular method or function works as expected. Unit testing is the process of creating re-runnable tests that validate a particular subset of functionality. A Unit Test project is a Visual Studio project that manages the creation, maintenance, and running of unit tests. It enables a developer to run previously created unit tests against the application to ensure that changes have not negatively impacted other parts of the application. If you were creating a true line-of-business application, then creating a unit test project is imperative. Unit tests give you assurance that your code is performing as expected by enabling you to provide known sets of data to parts of the application and then comparing the actual results from the application to the previously identified and expected results. This enables you to recognize when a change that may be needed in one part of an application can break another part of the application. NOTE Because the proper design and implementation of unit tests is a topic warranting a book of its own, creating unit tests is not covered during our building of the sample application. However, the finished sample application available online includes unit tests, so you can see what they look like in order to get an understanding or to see how unit testing can help enhance the stability and correctness of your application. Hosting Your Project in Microsoft Azure Microsoft Azure enables you to deploy web sites into the cloud rather than directly onto servers that you control. In this instance, it's a cloud computing platform used to build, deploy, and manage applications through a global network of Microsoft-managed data centers. Azure enables applications to be built using many different programming languages, tools, and frameworks, after which they can be deployed into the cloud. As part of the project creation process, you can specify whether you will be deploying your application in Azure and configure how the deployment will be managed. Because we will not be deploying our example application into Azure, you can leave this checkbox empty and not worry about entering any configuration information. Empty Template An empty template creates just that, basically an empty directory compared to the other templates that create a sample application. There are some base-supporting files added, as well as those items you selected from the lower-left quadrant in the “Add folders and core references for” section. When you choose the Empty template, none of the “Add Folders” options are selected by default. The outcome of not selecting any of these options becomes obvious pretty quickly. Figure 2.7 shows how an empty template creates a project with no folder and only a single file, the configuration file, “Web.config.” Figure 2.7 Creating a project using the Empty template This is an empty template because no content is created. Attempting to view the output in a browser will result in an error, as there is nothing to display to the user. PROPERTIES AND REFERENCES Two additional items appear to be part of the project created from an empty template: Properties and References. These two items play special roles in a project. The Properties item has a wrench icon and is used to maintain information about the project, such as the version numbers for the .dll. This won't be part of our sample application. The References section is different in that it contains all of the other libraries that your application uses. Figure 2.8 shows an expanded version of this item. Figure 2.8 References created for an empty template Although there are no working files created in this template, there are already some references. That's because all of ASP.NET is based on different areas of the .NET Framework. Each of the items shown in Figure 2.8 references a specific subset of functionality that the project assumes you need to build even the simplest of web applications. As you look through the various namespaces that are listed, these assumptions begin to make sense, as items such as Microsoft.CSharp (for C# projects) or System.Web will play a role in successfully building your application. Web Forms Template The Web Forms template creates a web site project with a few sample files so that you can get an initial start on your project. Some of the functionality that is added through this template includes user registration and the capability to log in to the application. These are some of the more complex parts of a web application, yet the template is created with this already working out of the box. Shown in Figure 2.9, this working application contains information about using ASP.NET and contains pages for Home, or default, About, and Contact. Figure 2.9 Running a newly created default Web Forms project The pages listed as menu items are all created as starter pages so that you can get an understanding of how applications of this type are built, especially when using authentication, which involves complex configuration. MVC Template The MVC template takes the same approach as the Web Forms template by creating a small set of functionality, including the capability for a user to create an account and then log into the application. It contains the same Home page, About page, and a stubbed-in, empty Contact page as the Web Forms template. The look of the application when running is even identical, but the directory and file structures are completely different. We will cover more of the specific differences later in this chapter. When running the output of this template, however, you will see an application that is indistinguishable from that shown in Figure 2.9. Web API Template The Web API is an approach to developing RESTful web services that is based off of ASP.NET MVC; it was initially called ASP.NET MVC Web API. The conventions that it follows and the way that it is built will be very familiar to ASP.NET MVC developers. Once you complete the sample application you will also understand how you would write a Web API application. Web services have become much more important in the Internet, as they enable two machines to communicate online. It follows the HTTP approach whereby one machine requests a resource from another through a well-defined locator, or URL. Whereas a user's browser would most likely ask for, and get, an HTML file, a web service will instead return information. Asking a web site for information about a product may return a nicely formatted HTML file with a picture, and perhaps other ancillary information about that product such as ratings. However, the web services would just return you any data about that product, formatted as either an XML or json file. These two formatting types are covered in more detail in Chapter 13, “ASP.NET AJAX.” RESTful web services are those web services that follow the representational state transfer (REST) architectural style to provide information over the Web. This style is highly representative of the HTTP process as mentioned earlier—including the HTTP verbs. The use of services in the sample application is covered in Chapter 13. Although the concept of REST services means that there are no HTML files supporting them, this template does create two pages: a home page and an API Help page. The API Help page is the start of documentation for the types of information that your web service will understand and work with. Figure 2.10 shows the default API Help page. Figure 2.10 API Help page in a Web API project While you will not be directly working with a Web API project as part of the sample application, there are a lot of similarities between the project and some of what you will be doing with services later as you build the sample application. Single Page Application Template Unlike the standard MVC and Web Forms approach, the Single Page Application template takes a different approach to building a web application. Rather than have different views and/or web pages, it is instead a single web page with the goal of providing a more fluid user experience akin to a desktop application. This means that there is one initial download of HTML and JavaScript files and then the application runs in that single page, fetching information and re-displaying either data or parts of the screen, sometimes even the entire visual screen as necessary. The single-page approach means that most of the work is done either on the client, where the data is fetched from the server and then parsed through a client-side template, or on the server, where complete HTML-formatted snippets are returned to the client and replace various sections of the loaded page as necessary. The key difference is that the entire page is never called from the server again, only portions of the page are called. This eliminates several traditional problems: the flicker of a page in the web browser as it is completely replaced in memory by the newly downloaded page, the obviousness of waiting for an entire page to travel both ways to and from the server, and the necessity of moving all of the data both ways, thus requiring lower bandwidth and offering higher performance. This approach takes advantage of the AJAX (Asynchronous JavaScript And XML) approach to use client code to call web services for information. Chapter 13 covers the use of AJAX in a web application. Creating a single-page application is an extension of that approach. In most cases, a single-page application will be working with RESTful services to get the data that needs to be displayed. Azure Mobile Service Template This project template is specifically for creating a Web API–based backend for Microsoft Azure Mobile Services. There are many different aspects to Azure, with one of them being their Mobile Services offering, which enables a developer to host a .NET or node.js (JavaScript on the server) backend to provide data to mobile consumers. Although mobile development is a rapidly growing development area, the sample app does not use this template. Working with Files in Your Application Just as in all other work on a Microsoft Windows computer, all of the work that you will do comes down to the individual files and the roles they play in the overall construct that is your web application. Because we are taking the web application approach rather than the web site approach to building an ASP.NET application, each of the files that the sample project uses will be either compiled into a single .dll file or copied over as a separate file to the web site. Anything having to do with the server-side work is compiled into the .dll file. Anything that is going to be sent to the client, such as an image, JavaScript, or CSS files, is left intact and copied to the output folder on the server. This enables changes in design and client-side functionality to occur without having to do a complete web site deployment if so desired. Because Web Forms and MVC each have a different implementation pattern there are different file types for each, stored in somewhat different folder structures. File Types of an ASP.NET MVC Application An ASP.NET MVC application is an implementation of the MVC pattern, or model, view, controller. This means that there will be three different types of files in the project to support this approach—one that will support the view, one that will support the model, and one that will support the controller. It will also contain supporting files that will be used for various other purposes such as configuration and client-side support. The main file types for a basic MVC application are shown in Table 2.1. Table 2.1 ASP.NET MVC File Types File Type File Description Extension(s) View file .vbhtml .cshtml Used for creating the HTML output that makes up the view portion of the MVC application JavaScript file .js JavaScript file that the browser uses to manage execution of code on the client side Code file .vb.cs Anything that is compiled, executes and runs; both models and controllers are stored as code files within the project Style sheet .css Gives the browser instructions on how to style the appearance of the web page Configuration .config file Contains configuration information that is used by the application, such as a database configuration string, shown later Application event file .asax Used by Microsoft IIS web server to handle application and session-level events such as creating routes Web file .html A static web file that does not do any server-side processing yet presents HTML to the browser for rendering Each of the files has a different kind of content. You can tell the type of file from both the extension and the content. A view file, for example, will have content that looks like the code in Listing 2.1. Listing 2.1: Example of the content for the Account/Register.cshtml file @model WebApplication3.Models.RegisterViewModel @{ ViewBag.Title = "Register"; }

@ViewBag.Title.

@using (Html.BeginForm("Register", "Account", FormMethod.Post, new { @class = "form- horizontal", role = "form" })) { @Html.AntiForgeryToken()

Create a new account.


@Html.ValidationSummary("", new { @class = "text-danger" })
@Html.LabelFor(m => m.Email, new { @class = "col-md-2 controllabel" })
@Html.TextBoxFor(m => m.Email, new { @class = "formcontrol" })
The HTML elements covered in Chapter 1, such as

and
, should be somewhat familiar. Several different elements in there, however, are not HTML. Those are Razor commands, which you will spend a lot of time learning about going forward. Another type of file created in the ASP.NET MVC application is the code file. Listing Listing 2.2 shows an example of C# code from one of the controller files. None of the context in the file will be familiar to you yet, but by the end of the sample application you will have created controllers very similar to the example. Listing 2.2: Example of code from the Controller/AccountController [HttpPost] [AllowAnonymous] [ValidateAntiForgeryToken] public async Task Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser:false); // For more information on how to enable account confirmation and password // reset please visit http://go.microsoft.com/fwlink/?LinkID=320771 // Send an email with this link // string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id); // var callbackUrl = Url.Action("ConfirmEmail", "Account", // new { userId = user.Id, code = code }, protocol: Request.Url.Scheme); // await UserManager.SendEmailAsync(user.Id, "Confirm your account", // "Please confirm your account by clicking here"); return RedirectToAction("Index", "Home"); } AddErrors(result); } // If we got this far, something failed, redisplay form return View(model); } The rest of the files have their own specific internal design because they play very specific roles in the building and running of a web application. This specificity means that most of them are copied to the server as individual files so that they can be directly downloaded to the user's browser as required. File System Structure of an ASP.NET MVC Application When creating an ASP.NET application, some folders are created for both MVC and ASP.NET applications. These folders are listed in Table 2.2. Table 2.2 ASP.NET General Folders Folder Description App_Data A folder used for data storage. It generally holds any SQL Server .mdf file that may be used in the web application. This is covered in more detail in Chapter 10, “Working with Data—Advanced Topics.” App_Start The App_Start folder contains many of the configuration files used by the application. You will learn more about the different files throughout the book, as they are related with behaviors such as bundling JavaScript files, authentication, and URL construction or routing. Content The content directory is designed to hold items that will be sent to the client. By default, the Cascading Style Sheets (CSS) created as part of the initial application templates are stored there. Fonts This directory holds some of the glyph-fonts used in the default application. Normally you probably won't be using fonts like this, but you do have the capability. Models The Models folder is used to hold the models that were created as part of the template process. The models that are added as part of the project creation process are all related to authentication. Scripts This folder is used to store the JavaScript files that are sent to the client's browser to perform client-side processing. When you create an ASP.NET MVC from the template, the folders shown in Figure 2.11 are also created as part of the process. Figure 2.11 Installed folders with ASP.NET MVC The extra folders added as part of the MVC template are for the views and controllers. You have already taken a brief look at how views and controllers fit into the framework, so now you'll take your first look at how these all come together in the template application. Figure 2.12 shows the expanded folders for Controllers and Views. You should be able to see some similarities between the two, mainly in terms of how the different controller files have a corresponding view sub-folder that is named the same as the Controller file, without the text “controller” at the end. There's a views folder rather than a single file, as with the Controller, because each views folder generally contains multiple files. Figure 2.12 Details under the Controllers and Views folders If you look at the names of the files in the Account sub-folder, you will be able to identify a pattern whereby each file represents an aspect of user account management, from registration, as shown by Register.cshtml, to logging in, as shown by Login.cshtml, to handling a forgotten password, ForgotPassword.cshtml, to resetting a password and getting a confirmation that your password was reset, ResetPassword.cshtml and ResetPasswordConfirmation.cshtml. All of the folders covered so far are folders created by default when adding a project from the ASP.NET MVC template. When you look at an ASP.NET Web Forms structure, you will see that it matches the directories listed in Table 2.2. This initially may seem surprising, but the approach when building a web application with Web Forms is different because the template and processing files go together, not like in an MVC application where they are separated into different directories. File Types of an ASP.NET Web Forms Application There are some shared file types between ASP.NET MVC and Web Form projects. Table 2.3 provides a list of the common file types in an ASP.NET Web Forms project. Table 2.3 File Types of an ASP.NET Web Forms Application File Type File Description Extension(s) Web Form page .aspx The individual pages that are viewed by your users Web User Control .ascx A set of files that act as a single part of the UI; a user control is a set of reusable application parts Code-behind .aspx.cs/.vb The page that contains the processing code; the or ascx.cd/.vb .aspx and .ascx files contain the markup, and its corresponding .cs or .vb files contain the code that manages the processing Master page .master Enables you to create a template that is used for multiple pages, such as the navigation structure Style sheet .css Gives you the capability to style and design your application HTML file .html HTML page within the application Configuration .config file Contains information that the application uses to perform other work SiteMap .sitemap Contains an XML listing of the files in your application JavaScript file .js Contains JavaScript that can be run on the client's computer; this is identical to the JavaScript files in the MVC application Skin file .skin Holds design information for some of the ASP.NET controls that you may use in your application The only file types that are the same are the configuration files, .config, and the files that are sent to the client side, the .html, .js, and .css files. The configuration files, as you saw when you were looking at the structure created when creating a project using the “empty template,” are a default, and included with every ASP.NET application. This is because Microsoft IIS, the web server, uses the configuration files to determine how it needs to manage the web application. The files that are sent to the client side are the same because that is how the client is expecting them. Your HTML page tells the browser which file it needs to fetch based on different aspects, such as styling or scripting, so you are not required to use a .js extension for your JavaScript files. However, using the appropriate extension is the standard approach and will make the content of the file more obvious to other developers. An extension of .js clearly identifies the content as being JavaScript. Just as you can tell the type of MVC file both by the extension and by the content, you can do the same with the ASP.NET Web Form files. As you look at the following code listings, think about the similarities and differences between the samples shown previously and these, starting with Listing 2.3. Listing 2.3: Register.aspx code snippet <%@ Page Title="Register" Language="C#" MasterPageFile="˜/Site.Master" AutoEventWireup="true" CodeBehind="Register.aspx.cs" Inherits="WebFormsTemplate.Account.Register" %>

<%: Title %>.

Create a new account


Email
Password
… Again, you can see HTML elements in this file so you know that it contains the markup, the beginning of the information that will be sent to the user's browser. Listing 2.4 shows a snippet of the code-behind file. Listing 2.4: Snippet from the Registration.aspx.cs code-behind file using System; using System.Linq; using System.Web; using System.Web.UI; using Microsoft.AspNet.Identity; using Microsoft.AspNet.Identity.Owin; using Owin; using WebFormsTemplate.Models; namespace WebFormsTemplate.Account { public partial class Register : Page { protected void CreateUser_Click(object sender, EventArgs e) { var manager = Context.GetOwinContext() .GetUserManager(); var signInManager = Context.GetOwinContext() .Get(); var user = new ApplicationUser() { UserName = Email.Text, Email = Email.Text }; IdentityResult result = manager.Create(user, Password.Text); if (result.Succeeded) { // For more information on how to enable account confirmation and // password reset please visit // http://go.microsoft.com/fwlink/?LinkID=320771 //string code = manager.GenerateEmailConfirmationToken(user.Id); //string callbackUrl = IdentityHelper // .GetUserConfirmationRedirectUrl(code, user.Id, Request); // manager.SendEmail(user.Id, "Confirm your account", // "Please confirm your account by clicking // here."); } } } Listing 2.4 is pure C# code. There is no HTML in it, so it is obvious that it is the processing portion of the file. While these are different files, playing completely different roles, they work together to create a single HTML file that is returned from the server to the user. MVC and Web Form File Differences When you look at the prior code listings, you may be struck more by their similarities than their differences. Yes, the contents of each file look somewhat different, but in the end you have two examples for each approach: one containing markup and the other containing the processing code. Therefore, conceptually, the approaches are very similar. The primary difference between the two approaches is not how the files are built, but how they are assembled. ASP.NET Web Forms makes a very firm linkage between the markup file and the applicable processing file. You can tell by looking at them that they are related; Visual Studio even shows them together in the Solution Explorer. ASP.NET MVC is different. There is no automatic one-to-one relationship between the files. Instead, as shown by Figure 2.13, there are multiple View files to a single Controller file approach. In this case, there are 12 separate View files that all relate to a single file, the AccountController. Figure 2.13 Relationship between View files and Controller files in an ASP.NET MVC application The one thing that we haven't yet covered is the model, the “M” part of the MVC architectural pattern. That's because it is not a new concept. While the MVC pattern calls out the model as a separate entity, a well-architected Web Forms application embodies the same concept. This is demonstrated by how the Model directory was created for both the ASP.NET MVC template application and the ASP.NET Web Forms template application. Looking back at the multiple View files for a single Controller file shows the primary difference between the two approaches. Whereas Figure 2.13 shows that 13 files are part of the account management process in ASP.NET MVC, 12 View files and one Controller file, when you look at the same set of functionality in ASP.NET Web Forms, you see something different, as shown in Figure 2.14. Figure 2.14 Account management functionality in Web Forms In this case, you see at least 15 files listed in Solution Explorer. Also, because each of the files is actually the combination of .aspx and .aspx.cs files, there are 30 files in the directory that manage the same processes supported by the 13 files in the MVC system. That demonstrates the main difference between the two—the complete separation between processing and view. Yes, ASP.NET Web Forms provide some separation, but there is always the expectation of a linked processing file. MVC takes a much more flexible and better separated approach. Creating the Sample Application So far, you have learned about various templates that are available when you create a new application, but not how you're going to start the application. What you do know: You want to support both ASP.NET MVC and ASP.NET Web Forms in the same application. The ASP.NET Web Forms list of directories is a subset of the directories created by the ASP.NET MVC template. ASP.NET Web Forms does not have a convention whereby separate folders are created. Looking at these various points, it would seem to make the most sense to create the sample application using the ASP.NET MVC template, because that provides everything that you need. Go ahead and create the initial shell of the application by using the MVC template. You should also select the Web Forms additional directory checkbox. Making this change doesn't add any additional folders or files, but it does add the necessary references for both ASP.NET MVC and Web Forms. The following Try It Out walks you through the steps of creating the project. TRY IT OUT: Creating the Initial Project 1. Open Visual Studio and select the File New Project menu item. 2. In the template section on the left-hand side of the screen, select the language that you want to work in (Visual Basic or C#). Then, in the Web listing, select the ASP.NET Web Application project template. Your window should look something like Figure 2.15. Be sure you give it the appropriate name at the bottom of the window. Figure 2.15 Creating your initial project 3. Select the MVC template, also ensuring that you check the box labeled Web Forms under the “Add folders and core references for:” section. Click the OK button to create the project. 4. Clicking the green arrow in the Visual Studio toolbar will compile this initial template and run it in the browser listed next to the arrow. The page that is displayed should look like Figure 2.9, shown earlier. How It Works The preceding process uses a Visual Studio feature called ASP.NET scaffolding. Visual Studio uses a set of templates to generate code files and build new content. You will see that the project name and the layout of the folder structure is based on information that you entered during the simple setup process. If you look closer at the folders that are created, you will see that they include a set of views and controllers, as well as a model. Many of these views and controllers are there to support the user and account management process, some of which will be used out of the box for the application. Some of the other views simply provide example information. Many of these will be replaced by your own content as you build your application. These initially built files will remain; you just change them to better suit your needs. You were easily able to open the site in the browser by clicking the green arrow. However, you didn't do anything to “install” the application on a web server. This worked because Visual Studio installs a local version of Microsoft Internet Information Services Express (IIS Express). IIS Express is a small, lightweight web server that is suitable for running your application so that you can interact with it at runtime. Because IIS Express is running locally, you can do some very useful things such as debugging and tracing. If your web project is still running, you should be able to see an icon for IIS Express in the notification area of your Windows taskbar. Summary Visual Studio and ASP.NET provide two different approaches to building ASP.NET applications. The first is through the use of a web site. A web site approach enables you to create an application that's easy to manage and deploy. It is handled differently during the deployment of the site because the files only need to be copied to the server, which then compiles the code-behind files as required. This makes the deployment process very straightforward. Unfortunately, this approach is only available for ASP.NET Web Form applications. You cannot create an MVC application as a web site. The web application takes a more traditional application-based approach in that it requires that the application be compiled before being copied to the server. The large number of templates that are available in Visual Studio when you want to create an ASP.NET web application project indicates how popular web development is within the Microsoft development community. The two templates that matter for the sample application are the ASP.NET MVC and the ASP.NET Web Forms templates. Both create an initial application that looks and works identically although they are built completely differently. Web Form files come in sets, with a markup file and a processing file, whereas MVC files come with Views and Controllers files. Exercises 1. There are two approaches in Visual Studio to creating a web-based application. What are they, and what are their main differences? 2. What is a project template? 3. Compared to an ASP.NET Web Forms project, several extra folders are created in an ASP.NET MVC project. What are these extra folders and what purpose do they serve? What You Learned in This Chapter Code File Types Files that are created during the ASP.NET MVC project creation process with .vb or .cs file extensions are code files. These files are either the Controller or the Model files; you can tell which is which by the file filters that the code files are in. MVC Template The MVC Project template is used to create an ASP.NET MVC project. Depending upon choices made during the creation process, the template may create some base pages as well as integrate authentication into the project. Project Types Project types are how Visual Studio defines the type of output that will be created when a project is created. This output then determines what the project will look like when it is compiled, such as a web application, a desktop application, web services, or many other different types. View File Types The file extensions for views in an ASP.NET MVC application are .vbhtml and .cshtml. These contain the HTML that will eventually be sent to the client. Web A web application project is one that is accessible over the Internet. Application Code files are compiled and deployed to the server where Microsoft Internet Information Services (IIS) takes server requests calls and creates HTML content to respond to the user. Web Form A project template that is used to create an ASP.NET Web Forms Template application. Depending upon choices made during the creation process, the template may create some base pages as well as integrate authentication into the project. Web Site A web site project is an approach to creating a set of files that can be copied to a web server to provide Internet content. The source files are copied to the server, where IIS compiles them just before making the method call. Chapter 3 Designing Your Web Pages What you will learn in this chapter: How HTML and CSS work together Using CSS to add a design Adding and referencing CSS in your pages How to best manage styles Code Downloads for this Chapter: The wrox.com code downloads for this chapter are found at www.wrox.com/go/beginningaspnetforvisualstudio on the Download Code tab. The code is in the chapter 03 download and individually named according to the names throughout the chapter. In many ways, modern websites are quite similar, regardless of their purpose. They tend to be functional, responsive, and attractive. Having a website that looks good is as important to getting and retaining visitors as the site's functionality. Very few sites can minimize the design elements and remain effective. However, all sites—regardless of content, design approach, and business needs—provide the same type of information to the user, who downloads one or more HTML documents, some styling information, and perhaps some imagery and even videos. This chapter covers how all these aspects of a site come together, especially HTML and ​styling information, otherwise known as CSS. You won't become a design expert, but you will become familiar with CSS and learn how you can take advantage of Visual Studio tools to make working with CSS easier. You also work out the overall design of the sample application and review the strategies available to build a style dictionary. HTML and CSS Chapter 1 talked about HTML and explains how it is the default language of the Internet, designed to provide context to content—especially with HTML5, the newest version. Earlier versions of HTML supported some styling-specific elements that allowed for some control over presentation on the screen. For example, there was an element for controlling the size, color, and font face of text contained within the element called font: I am large purple text While these kinds of tags give you some ability to control the look and feel of your page, they have one major limiting feature: They are all embedded in the HTML and are not flexible. For example, suppose you wanted to change all the “large purple text” to “medium-size orange text.” You would have to manually edit every page that used it, changing each instance. This means that even a relatively minor change in design can be both time-consuming and risky, because every page may require some changes. This is why CSS was born; it provides a more robust and powerful way of managing design. Why Use Both HTML and CSS? HTML is the language of the markup, and that is what it does best. HTML does a great job of helping you identify, delineate, and markup content, but it does little about controlling the appearance of the content. You can confirm this yourself with Figure 3.1, which shows the browser's rendition of the traditional HTML shown in Listing 3.1. Figure 3.1 HTML without any CSS styling Listing 3.1: HTML for a simple web page Beginning ASP.NET Web Forms and MVC

ASP.NET from Wrox

ASP.NET Web Forms

More than a decade of experience and reliability.

  1. Lots of provided controls
  2. Thousands of examples available online

Enter your email to sign up:

As you can see in the figure, virtually no styling is applied to the content. Some default fonts are selected, and different levels of headings provide different font sizes, but everything is shown as a plain black font on a plain white background. CSS enables you to exert much better control over the presentation of your content. Simply adding 21 lines of CSS code (including whitespace) results in something considerably different, although you won't see the full effect in Figure 3.2, because it doesn't show the color you added. The CSS code to achieve this, shown in Listing 3.2, is added right below the opening tag. Figure 3.2 HTML with some simple styles added Listing 3.2: Styles added to the HTML file Granted, this page may not be attractive yet, but it effectively demonstrate how a small amount of CSS can alter the appearance of a page, and how this styling differs from the old HTML approach to styling. You will go over this in much greater detail later in this chapter, but the styling code in Listing 3.2 does two things. First, it sets the default look for every body, header,
    , and
      element on the page. Second, it sets the look for a particular style called “button.” Consider the level of control this gives you over the element mentioned earlier. Instead of having to find and change every one of the affected elements, you can instead change one instance and have it affect, or cascade to, every applicable element. CSS provides an elegant way to abstract out the control of the look and feel of your website. ABSTRACTION Abstraction is a technique that allows you to control more complex systems. It enables you to create a version of that system that is usually simpler and easier to control and maintain. Just as everything in VB.NET or C# is an abstraction of the work being done deeper in the system (you do not have to worry about copying the contents of one section of memory to another), CSS is an abstraction that gives you control of each page element, enabling you to make one change, in one place, and have it affect the entire site without additional risk. Combining HTML and CSS allows you to separate the content from its display. Just as Web Forms and ASP.NET MVC both offer some separation of concerns in terms of displaying the information and creating the information, CSS and HTML enable you to separate the definition and display of the content on the page; it basically provides an additional separation of concern within the UI itself. In other words, whereas HTML tells the browser what it should display, CSS defines how it should be displayed. An Introduction to CSS If you look at CSS as a separate language, you will find that it is relatively easy to learn; each of the concepts by itself is pretty straightforward and clear. However, what becomes more complex is how the language elements may interact with each other and how to best use a particular approach to solve a specific problem. We'll start by having you add some styling to the website. In the following Try It Out, you add a new page to the site and then add some content and styling to that page. You will learn about the different aspects of what you are doing as you go through the process. TRY IT OUT: Styling Your First Web Page In this example you create a new page and then enter some CSS code by hand so that you can see how it affects the appearance of your content. The CSS tools included in Visual Studio are introduced later in the chapter. 1. Open the web application project that you created in the last chapter. Select the project within the Solution Explorer window. Add a new Web Form page from the top menu by selecting Project Add New Item. Select Web Form and name the file IntroToCss.aspx. This exercise uses a Web Form page because it is a lot easier to see immediate results. The overall process of styling content is identical for both MVC views and Web Form pages. Creating this page creates code that looks like what is shown in Figure 3.3. Figure 3.3 New ASP.NET Web Form file 2. Locate the closing head element and press the Enter key right before it to add a blank line. If you begin by typing in the will cause IntelliSense to close the element for you. INTELLISENSE IS YOUR FRIEND! IntelliSense is a Visual Studio feature designed to improve your productivity. Its primary feature is AutoComplete, whereby IntelliSense examines the context of what you have entered and is able to “guess” what you are trying to type, whether it is Visual Basic, C#, or HTML code. While this may negatively impact your ability to remember the names of classes, methods, or parameters outside of IntelliSense, it gives you rapid access to all the code support information you need right in the development environment, as you are writing the code. 3. Type the following code in between the style elements that you just added: body { color: orange; font-size: 20px; font-weight: 800; } 4. Ensure that you are in Split mode, where you can see both Design and Source modes in Visual Studio. Most likely you are currently in Source mode. Click the Split button on the bottom of the page in the right-hand side of the window to switch the window to the multiple mode window as shown in Figure 3.4. Figure 3.4 Selecting Split mode displays both design and source code information. IDE VIEWS OF WEB FORMS IN VISUAL STUDIO Two different views are available when working within an .ASPX page: Design mode and Source mode. In Source mode, you can see and edit the code on the page—in this case, the HTML and CSS style you are working on. Design mode shows how the code is going to be rendered and displayed by the user's browser. Split mode enables you to see both Design mode and Source mode at once. As you change information or content in one area, you may be prompted to refresh to see it in the other. Running in Split mode enables you to see how the output changes as you make your changes in Source mode. 5. Once you are in Split mode, enter some text directly below the tag and then refresh the Design mode. You will be able to see both your code and the rendered version of the text you entered. It should look something like Figure 3.5. Figure 3.5 Code window with display of text 6. In Step 2 you added some default settings for all text that is entered into the HTML body. Now you will expand the style for the body section by including a colored background. In the styles area you created, add the following line: background-color: lightblue; Refreshing your Design mode view will show that the background color has changed. Also, note how IntelliSense helped you select the appropriate value! 7. Create another style by adding the following code right below the closing bracket of the body style: h1 { color: red; font-size: 26px; } .special { color: black; font-size: 16px; } 8. Alter your body text to the following:

      Introduction to CSS

      I am test text
      And I am special text!
      This will give you output that looks like Figure 3.6. Figure 3.6 Design mode view of style and HTML content 9. Perform a Ctrl+F5 (Run without Debugging) to view the output in the browser. You will see that the output in your browser is identical to the view in your Design mode screen. How It Works The work that you performed seems relatively simple, but the changes that you made completely changed the appearance of your page. The first thing that you did was add the
      content
      This snippet will display in the browser as shown in Figure 3.9, but keep in mind the black and white images don't truly demonstrate what you should see on screen, which will appear in color. Figure 3.9 Rendered HTML with padding, margin, and width Figure 3.9 illustrates some interesting points about styling. The space immediately between “content” and the first line is the padding. The space between that first line and the left, top, and bottom sections, as shown by the darker box on the left, is the margin. Note how the margin and padding affect the width of the element. Both elements, innerelement and outerelement, have the same width. However, the inner element is obviously wider. That's because of the padding property. The use of padding extends the width of the element past the content. Margin, conversely, extends outside the element. This is why the leftmost box is spread outside the inner box—the margin pushes it out from the element. Figure 3.9 also shows another interesting aspect of styling — the absolute nature of some of the properties. Even though the inner element is contained within the outer element, the outer element's width is still rendered at 200px, regardless of the overall width of the containing element. The overall width of the inner element is 510 pixels wide, and is calculated by combining the 200px of width, the left padding of 50px, the right padding of 50px, the left border of 5px, the right border of 5px, the left margin of 100px, and the right margin of 100px. Precedence in Styles You have seen some examples illustrating how styles can affect each other. This is an important concept, because the styles of nested and adjacent elements all interact with each other and may affect the display of other elements. This means that when an element does not look as expected, it may be due to the styling of an adjacent, containing, or contained element. Therefore, a base understanding of precedence may prevent some styling frustration. The typical precedence takes multiple things into account. One of the things that it takes into account is something that you haven't really talked about, the origin of the style. Styles have three primary origins: Author: A style provided by the site's author, such as the styles that you have been creating User: A style created by the user, whereas the default style is the one built into the browser Default: A style that is built into the browser and acts as the style when no others have been added. This may be different depending upon the browser. CREATING USER STYLE SHEETS You may not realize it, but as a user you have control over the styles that are displayed in your browser. Microsoft's Internet Explorer, for example, allows you to create and apply your own style sheet to every page that you visit. You can do this by selecting Internet Options and then choosing the Accessibility button. This will bring up the dialog shown in Figure 3.10, from which you can change font settings and even add a custom-made user style sheet. Figure 3.10 Adding a user style sheet to your browser Each of the other major browsers have their own way to add user style sheets. You will learn more about what makes up a style sheet later in this chapter. When the browser is determining how to render content, the initial specificity is calculated with the following rules: 1. Find all of the style assignments that apply to both the element and the property being parsed for display. 2. Sort by origin and weight. Origin was discussed previously, and weight refers to the importance of the declaration. Weight is calculated in the same order (author, then user, and then default) but it takes into account some special tags that can be added to the style. 3. The browser then calculates the specificity. 4. If any two rules are equal for all of the above, the one that declared last takes precedence. This means that CSS embedded in HTML always follows any page declared styles (as shown so far with styles contained in the element), which comes after external style sheets (what you will be doing later in this chapter). Step 3, calculating specificity, is more complex than it may seem. At the simplest level, an id is more specific than a class, which in turn is more specific than an element. However, it is not as clear as that. Examine the following code snippets: div p.special {color: red;} #superspecial p {color: purple}

      Content

      What color do you think the content will be? When you look at the first style, you see that it is for paragraph elements with a class of “special” that are contained within a
      element. This pretty well describes the HTML code, doesn't it? The second style also seems to match the HTML code, as it selects paragraph elements that are contained within an element that has an id of “superspecial”. Will the content be red or purple? You may be surprised by the answer: The content will be purple. That may seem counterintuitive because the first styles just combine element matching and class matching, and the nesting within the element of the proper type seems very straightforward. However, because the second style is matched based on the parent element's id, it trumps the first style. If you remove the “p” from the second line, what do you think happens? Does the specificity of the id in the containing element still override the first style? In this case, you will find that the content will display in red. This happens because the identification of the exact element in the first style offers more specificity than the second style after the paragraph reference has been removed. If the first style were completely removed, however, the content would again be displayed in purple because of the inheritance from the hosting element. Understanding precedence will come with practice. The easiest way to understand the precedence calculation is by looking at the output. Visual Studio enables you to look at both the design and the output at the same time; don't hesitate to take advantage of this to see the full interaction of your styles with your HTML. The Style Sheet You have done your first work with styles, but this is not the way that you will be styling the application as you move forward. While this approach is much more efficient than using HTML styling, in that you can put all the styles in one place on the page and enable them to be used everywhere on that page, it also means that if you want different pages to be styled the same, then you have to copy the styles to each of those pages. Thus, if you want to change these styles, you have to go through each page and update them. While this is definitely better than having to retouch every element on the page, it still is error prone. This is where the “sheet” part of Cascading Style Sheets comes into play. You can put all your styles into a single page and then link that style-containing page to each page that will be using it. That means all pages in your site (if they have been set up correctly) will be able to use the same set of styles. With this capability, changing styles throughout your site becomes very easy, as you have only one file to work with, rather than one area on each page. Adding CSS to Your Pages You have learned about adding CSS styles to your page using the Run the app and note how much better the form looks. 10. Add the remaining fields and the button that you need to submit the form:
      11. Open the code-behind page. As you may have noticed, the button that you added in step 10 has an OnClick event that is registered to an event handler. You need to add that event handler. This handler needs to be within the brackets around the ManageItem class definition: protected void SaveItem_Clicked(object sender, EventArgs e) { } 12. Run the page by clicking F5. Notice that the file upload section is not properly placed. The file upload control has an independent streak; it has its own bizarre sets of rules for appearance, so add the following to the styles that you created earlier so that you can style the control based on its id (as shown by using the “#” in the selector).: #fuPicture { margin-top: -20px; margin-left: 120px; } 13. Now that you have the data entry form looking consistent, you'll add some code to the code-behind to demonstrate how you can use the content returned from the form. In the SaveItem_Clicked method created earlier, add the following lines of code: string name = tbName.Text; string description = tbDescription.Text; string itemNumber = tbItemNumber.Text; double cost = double.Parse(tbCost.Text); DateTime acquiredDate = DateTime.Parse(tbAcquiredDate.Text); byte[] uploadedFileContent = fuPicture.FileBytes; This code that you are adding now will be changed in future chapters, but it gives you an idea of how to work with the values that are returned. As you can tell, there is some risk with this code because it relies on tbCost and tbAcquiredDate having the text input in the right format. You fix this as well through the use of validators. Lastly, the information that you are getting from the file upload control is simply the byte array that makes up the image. You will store this in the database, so this format makes it easier. You could also store the uploaded file on the server's file system if desired rather than just storing the content of the file as an array of bytes. 14. Put a breakpoint by the closing bracket of the method and run the application by clicking the green arrow or the F5 key. Mousing over the various values shows that you have captured the values from the form. Figure 5.22 shows the content of the byte array. Figure 5.22 Code-behind in Debug mode How It Works You have created an initial data entry screen that is capable of persisting items into the database (which you will learn how to do later). You added several different types of controls, including labels, textboxes, and file upload. You also created some code to capture information that has been submitted to the server through the form. These two parts, the markup and the code-behind, work together to create multiple complete request/response sets. The first set covers when the client does the first request for a page and the server responds. At this point the communication is not a postback. When the client receives this first response, the form entry page is rendered in the browser. When the user completes filling out the form and submits it, the second request/response set starts. When this second request gets to the server, the processor can recognize that it is a postback and is able to handle anything that may be implied by that difference, including accessing view state and running through specific areas of the code. At this point any event handlers may be called as necessary; the form has been delivered, filled out, and returned to the server. You have not completed every data entry form, nor have you used every control, but you should have an idea of how the controls are added in the markup page and then accessed in the code-behind. Creating and working with ASP.NET server controls is quick and simple. You can easily add a series of controls to a page, wire them up in the code-behind, and validate that they work correctly in a matter of minutes. Summary ASP.NET Web Form server controls provide a robust set of functional support for web developers. These controls provide full control over many common pieces of a web-based user interface, ranging from simple blocks of text to textboxes that are used to capture data from within a Web Form. Other controls can provide calendars for date selection, file upload capability, and dropdown list selection, among other things; each fulfills a need that you may have during the construction of a website. There are two parts to using server controls: putting them in the markup so they are written out to the client as part of the returned and rendered HTML, and working with the results in the code-behind after the filled out controls are returned to the server. Working with the results in the code-behind requires that you first access the control by Id, and then the property that you are trying to access. Not only can you access the values in the control, you can have the server perform an analysis of the data that is coming in, comparing it against the previous version. This is all controlled by the state management engine. The state management system uses ViewState to maintain the previous values of controls— basically, an old copy of the data that can be compared against the newly submitted version in order to understand what changed. Exercises 1. Can every property be set in the code-behind, or must some always be set in the markup? 2. What do you have to do differently in order to understand the selected items in a CheckBoxList versus what you do to understand the text in a TextBox? 3. Does adding a runat=”server” attribute to an HTML element change anything? 4. What is view state? What You Learned in This Chapter CssClass A property on standard controls. When used, the value that is entered into this property will be put into the class attribute of the outermost HTML element. Debugging Debugging is a feature of Visual Studio that enables you to trace code as it runs. You can set breakpoints that tell the program where to stop while running, as well as look into the values of properties and other items while running through code. EnableViewState A standard control property that determines whether the control's content is stored in ViewState while running. Those items that do not enable view state may end up losing data or missing event calls. HTML Controls These controls are created by adding a runat="server" attribute to the HTML element in the markup. This enables you to access various values and attributes in code-behind. Markup A term that describes the .aspx page where the HTML is written OnClick An event on a button. To take advantage of the event in your code you have to wire it up to an event handler. This event handler must have a method signature of object and EventArgs. Postback Describes when a page is posted back to itself. This is one of the most common Web Forms approaches, because a file is downloaded to the client where the user can make changes and then that file is sent back to the server for processing. This sending back is the postback. The Page object in the code-behind has an IsPostback property that can be used to determine when the data is coming in through a postback. Standard Controls The most common type of controls. This set of controls includes textboxes, radio buttons, checkboxes, and labels—most of the items you need to make an interactive website. ViewState Enables ASP.NET to manage state. It is a hidden field in the HTML form containing hashed versions of all the information where ViewState is enabled that is sent to the client. This copy of the information is sent on the round-trip so that the server can understand both the current version of the data, as filled out by the user, and the previous version of the data. Chapter 6 ASP.NET MVC Helpers and Extensions What you will learn in this chapter: How to display dynamic information What Razor syntax is and how you use it in the view How routing works Creating actions on the controller Getting your controllers and views to work together Code Downloads for this Chapter: The wrox.com code downloads for this chapter are found at www.wrox.com/go/beginningaspnetforvisualstudio on the Download Code tab. The code is in the chapter 06 download and individually named according to the names throughout the chapter. You have learned about how ASP.NET Web Forms take one type of approach, server controls, to do work whose outcome is rendered into HTML for consumption by the browser on the client machine. For example, a developer can add a server control to the markup and know that a textbox will be displayed in the browser. However, the complete structure of the HTML that is output is not within the developers' control unless they are using HTML controls, with their ancillary limited functionality. The process is different in ASP.NET MVC. There is no such thing as a server control in the MVC world. There is, instead, a way of writing code “in the UI” that enables the developer to have complete control over the output that is sent to the client. As you can guess, however, “more control” means that you may have to do more writing of code. In some cases you may have scaffolding, or automatically created code (much like the project you started with), that can provide create, edit, view, and list functionality simply by clicking a few buttons. In other cases, you will have to perform the coding yourself. One of the ways in which MVC provides support is by supporting various language structures in the part of the application that was called markup in ASP.NET Web Forms but in MVC is simply referred to as the view. This chapter introduces this new language structure, Razor, and describes the various approaches you can use for creating your own UIs in lieu of having them created through server controls. This chapter also covers how information from the UI is returned to the server and processed there to perform the work. This entire process provides an overview of the MVC approach to building websites, and by the end of the chapter you should begin to understand some of the fundamental differences between these approaches. Why MVC Has Fewer Controls Than Web Forms It has already been mentioned several times that MVC does not have as many controls as Web Forms. For example, there is no concept of an in the world of ASP.NET MVC. The main reason is because of the different approaches of these two different ASP.NET technologies. In Web Forms, the markup and the code-behind are intertwined; they are always together. Their names are even together—for example, SomePage.aspx and SomePage.aspx.cs (or .vb)—and the Solution Explorer shows them together. This closeness is indicated by how the Id property from a server control is available in the code-behind, as the server control is an instantiated object with all properties available for examination or use. They are a single, bound instance. It is not that way in ASP.NET MVC. Each piece is independent of the others. A view, whereby the HTML is created, is completely separate from the controllers and knows nothing about them. This separation explains the lack of server controls. Server controls were designed to help both the creation of the HTML and the management of content returned from the client. In MVC, that approach violates the concept of a separation of concerns. A view is concerned only with creating a user interface. A controller is concerned only with receiving information from, and providing information to, a view, and models are concerned only with performing the business logic. ASP.NET MVC separates all those responsibilities by default, whereas ASP.NET Web Forms only partially separates them. That being said, there are still approaches that make building an ASP.NET MVC site more rapid and provide some help to both developers and designers. These approaches are just completely different from what you have worked with up until this chapter. A Different Approach Whereas ASP.NET Web Forms makes content available between both markup and the code-behind, ASP.NET MVC takes a different approach. Rather than use a control to manage the passing of information, it instead uses the concept of a model. A model represents the underlying logical structure of the data. It is also important to understand that the model has no knowledge of either controller or the view. This model is populated in the controller and then fed into the view. The view then does the work of assigning these property values to the appropriate user interface items that are part of the HTML returned to the client. Figure 6.1 demonstrates this flow. Figure 6.1 Workflow for a model being passed to a view To examine what this looks like in code, first look at how the pieces fit together (later you will actually put them together): Model public class DemoModel { public string Property1 { get; set; } public string Property2 { get; set; } public string Property3 { get; set; } } This first code snippet defines the model that you are displaying. This model is creatively named DemoModel and had three properties: Property1, Property2, and Property3. Each of these properties is a string. Now that you have defined the model you are going to display, take a look at how to display it: View @model RentMyWrox.Models.DemoModel

      Demo Model

      @Html.DisplayFor(model => model.Property1)
      @Html.DisplayFor(model => model.Property2)
      @Html.DisplayFor(model => model.Property3)
      The preceding snippet demonstrates using Razor syntax to write out the information. There is a small title and then three rows, each listing the value of the property specified. The @ provides a signal to the server that the following item is to be processed as code. This approach, Razor, enables you to intermingle your HTML elements with code snippets that perform some kind of work, likely using the model while still in the view. You will learn about the different aspects of this in a little bit. Now that you have the code necessary to display the object, you need to actually create the object and ensure that the view has been given the information that is needed. This is demonstrated in the following snippet: Controller // GET: DemoModel/Details/5 public ActionResult Details(int id) { DemoModel dm = new DemoModel { Property1 = id.ToString(), Property2 = string.Format("Property2 {0}", id), Property3 = string.Format("Property3 {0}", id) }; return View("DemoModelView", dm); } The preceding controller action creates a new DemoModel object, gives it some values, and then returns the instantiated view with the filled-out value. Figure 6.2 shows what this looks like in a browser. Figure 6.2 Simple model displayed in your MVC view The last thing to examine in this process is the HTML that is generated for display:

      Demo Model

      5
      Property2 5
      Property3 5
      As you can see, this code is considerably cleaner than the HTML that was created as part of the ASP.NET Web Form process. When you asked the system to display a property, that is all the system did. No additional HTML elements are created; it simply writes out the value. VISUAL STUDIO BROWSER LINK You may see additional information in your source code file that looks something like the following: This is added only when you are working with the application in Visual Studio. Browser Link creates a communication channel between Visual Studio and the browser. When Browser Link is enabled, it injects special 13. Run the application and go to UserDemographics/Create. You should see a screen similar to Figure 11.38. To get the jQuery calendar picker, click the textbox. Figure 11.38 Finished Editor template How It Works Custom Display and Editor templates are very similar to partial views (without controllers) in how they are created and how they interact within the code. The main difference is that ASP.NET MVC uses a convention-based approach to understand the roles that these particular template views play because of their location in the directory structure. These same templates, put in a different directory, could not be used in an EditorFor or DisplayFor call. Other than having the templates in special directories, the relationship is defined by the name of the file and the data type of the model that the view supports. The default is to give the file the same name as the type, but you also have the capability to create different versions that will support the same type. Perhaps you have a case where you want a DateTime displayed in one way, and a different case where you want it displayed in a second format. This is supported through the use of the UIHint attribute, which enables you to point that particular property to a different definition. The following code takes the property SomeDate, and when used with an EditorFor or DisplayFor call it will first look for a template named "SpecialDateTime.cshtml" rather than the default DateTime.cshtml : [UIHint("SpecialDateTime")] public DateTime SomeDate { get; set; } . As the framework parses through the code in the view, it is able to interpret these various template calls just like it would the Html.Partial and Html.Action methods. In this example, your display template is only managing the formatting of the date that is displayed; it could do the same thing for a full custom type whereby the view contains many different labels and other DisplayFors. In the same way, your editor template could take the same approach. The custom DisplayFor that you used ensures that dates are displayed in a consistent format. You have seen the ToString method before, but in this case you are providing it a custom layout structure. DateTime is an interesting type because there are so many different ways that it can be displayed. While it is a pretty simple concept, displaying the type can be complicated. There are cultural and language differences as well as a size impact (spelling out the month versus using the integer representative, two-digit years vs. four-digit years, etc.). Table 11.5 lists the most commonly used formatting identifiers for DateTimes. Table 11.5 DateTime Formatting Format Description Example d Day of the month 1–31 January 7, 2015 -> 1 dd Day of the month, 01–31 (2-digit) January 7, 2015 -> 01 ddd Abbreviated day of the week January 7, 2015 -> Wed dddd Compete day of the week January 7, 2015 -> Wednesday h Hour, using 12-hour clock, 1–12 2:08 PM -> 2 hh Hour, using 12-hour clock, 01–12 (2digit) 2:08 PM -> 02 H Hour, using a 24-hour clock, 0 to 23 2:08 PM -> 14 HH Hour, using a 24-hour clock, 00 to 23 (2-digit) 2:08 PM -> 14 m Minute, 0–59 2:08 PM -> 8 mm Minute, 00–59 (2-digit) 2:08 PM -> 08 M Month, 1–12 January 7, 2015 -> 1 MM Month, 01–12 (2-digit) January 7, 2015 -> 01 MMM Abbreviated name of month January 7, 2015 -> Jan MMMM Complete name of month January 7, 2015 -> January0 t First letter of AM/PM designator 2:08 PM -> P tt Complete AM/PM designator 2:08 PM -> PM y Year, 0–99 January 7, 2015 -> 15 yy Year, 00–99 (2-digit) January 7, 2015 -> 15 yyy Year, three digits January 7, 2015 -> 015 yyyy Year, four digits January 7, 2015 -> 2015 The DisplayFor template that you created used the formatting string of ("MMMM dd, yyyy"). Looking at Table 11.5, you can determine that this will be displayed as the full month name, the two-digit day, and the four-digit year, or January 07, 2015. Your EditorFor template was simple as well; you didn't really need to do anything in the template itself other than add an override so that the class attribute of the text box is set to "editordatepicker". This was the beginning of a series of changes you then made to do some special work with this specific class name. All of these changes were made so that you would be able to configure the jQuery UI DatePicker to be the default method for editing values of type DateTime. jQuery UI is a set of user interface interactions, effects, widgets, and themes built on top of the jQuery JavaScript Library. To take advantage of one of these widgets, the DatePicker, you had to install the jQuery UI NuGet package. NuGet is an open-source package management system that is built into Visual Studio. It enables developers to add sets of functionality, in this case the JavaScript files that are necessary to provide the client-side functionality. Using NuGet enables you to work with the various scripts and other files as a set, rather than having to worry about managing the scripts separately in a more manual fashion. After adding the jQuery JavaScript files to your project, the last thing you did was ensure that your web pages would be able to use them. Adding the script links to the header of the layout file ensured that they would be available to every page that uses the layout. This is important because the EditorFor for the DateTime could be called anywhere. The only way to ensure that the necessary JavaScript code was available was to put it into either the layout page or the template itself. However, putting it into the template itself would lead to redundant calls because, as in the example, the DateTime might be used multiple times on a page. Therefore, this code would be downloaded as many times as there are DateTimes, which could lead to performance issues as well as make the JavaScript code more difficult to work with—what happens when the same method is loaded multiple times? The jQuery function that was added to the layout page is shown here for easy reference: $(document).ready(function () { $(".editordatepicker").datepicker(); }); There's a whole chapter (Chapter 14) on jQuery coming up, so you'll learn more details later, but at this point you should just understand what the function is doing. Once the document is loaded, ​clicking any HTML element with a class of editordatepicker will run the datepicker function. This ​ datepicker function is what opens the UI element with the calendar and supports the movement of information between the calendar and the textbox. You also added a link to a stylesheet file from the jQuery site. This file could just as easily be copied to your local application and referenced there; and if any styling changes were required, the stylesheet file would have to be copied locally so that it could be changed. However, the default behavior is acceptable at this time, so you took advantage of the jQuery site hosting the file and used their version. Summary User controls and partial views enable you to build reusable components to manage interaction with the client. The purpose of both is to fulfill a specific subset of functionality and each control is responsible for gathering all the necessary information and displaying it to the user. This is especially true with ASP.NET Web Form user controls because they always have code-behind that supports the entire page life cycle, just like a traditional Web Form. As shown in the example, the MVC partial view gives you a little more flexibility. It can be used to display an item that is passed into the view using the Html.Partial method from a view; or through the Html.Action method, which doesn't call a partial view but instead calls an action on a controller that returns the partial view. Because the controller is involved, you have the capability to do business logic behind the scenes to create the model given to the view. Thus, the same MVC partial view can be called from a view and passed in a model or it can be returned from an action with a model. Because of the decoupled nature between the two, it doesn't matter from where the view gets its model—only that it has it. Before user controls can be used they need to be registered, which can be done at the page level or the application level. Once they have been registered, you can drop them onto the markup page just like any other server control. When you are using partial views, registering them is not necessary; simply determine how you want to reference the view (partial vs. action) and the system takes it from there. You can take partial views a little further by designating them as templates. A template is simply a partial view that is put it into a special folder. By its presence in the EditorTemplate or DisplayTemplate directory of the Shared directory under Views, the system knows to use it for the appropriate model type. MVC also allows you to use property attribution to define the relationship between a specific implementation of a type and a template. This enables you to create multiple templates and then determine according to the model property itself which template should be used as necessary. User controls and partial views enable you to take specific parts of the page output and separate them into different objects that can be called from other pages. If a piece of functionality is only going to be used on one page, then it may not make sense to break it into user controls or partial views; but if the functionality is, or might be, replicated on other pages, then you should always pull it out into its own control or partial view. That way you can reuse it as much as desired. Exercises 1. The ASP.NET MVC template displays a model in a certain format. Is it possible to do the same thing in an ASP.NET Web Forms application? 2. When you want to get a partial view that has been processed on the server, when do you not have to pass the controller into the Html.Action method? 3. When you are working with ASP.NET Web User Controls, what would happen if you have a property that is a string and you pass an integer into it though an attribute? What happens if the property is an integer and you pass a string into it? What You Learned in This Chapter Action An HTML extension method that runs an action on a controller. The output from the action should be a partial view. When you call the method, you ​typically pass in an action name, which assumes that the action is on the same controller that rendered the current view; otherwise, you need to pass in the controller name as well. Taking this approach results in a string value that can be written directly into the markup or assigned to a variable and further worked with. AutoId An approach that creates a client-side ID that is basically a concatenation of all ids from all controls in the hierarchy. The output of this approach is the same as the examples in this chapters examples. This is also the value from all versions of ASP.NET prior to 3.5. Display Template An MVC partial view that is used to display a specific type. In order for a partial view to act as a display template, it needs to be located in the DisplayTemplates directory under the Views\Shared directory. Editor Template An MVC partial view that is used to display a specific type. In order for a partial view to act as a display template, it needs to be located in the EditorTemplates directory under the Views\Shared directory. Inherit This value sets the ClientIdMode of a control to the ClientIdMode ClientIdMode of its hosting item, whether it is another control (either user control or server control) or a page. This is actually the default value of all controls, while Predictable is the default mode for all pages. Partial This extension method on HTML is used to reference a partial view that should be displayed. It is generally called with the name of the view and the model that is needed by the partial view. Taking this approach results in a string value that can either be written directly into the markup or assigned to a variable and further worked with. Predictable This mode is generally used in databound controls for which you ClientIdMode want every item in the set of output to have an ID that you can predict. This is useful in cases where you may have a user control that is displayed with each row in a list of items. Using Predictable and the ClientIDRowSuffix attribute enables you to define the Id of the output element to include some known value, such as the Id of the item in the list. If you are not using this mode in an area where there are multiple instantiations, such as a list, the output will be the same as AutoId. Register A command used to build the link to a Web Form user control. As part of the Register, you set both the TagName and TagPrefix that are used in the page to identify and instantiate the user control. RenderAction This is the same as the Action extension method, except that it does not return a string. Instead, it writes the output directly into the response stream. Take this action if you do not expect to use the output of the action call, because it increases performance by removing that overhead. RenderPartial This is the same as the Partial extension method, except that it does not return a string. Instead, it writes the output directly into the response stream. Take this action if you do not expect to use the output of the partial call, as it increases performance by removing that overhead. Server Caching Server caching is configurable on an action, whose output is retained on the server for a specific duration of time. This is especially useful for those actions that return output which rarely changes. Sitewide Registration Sitewide registration of a Web Forms user control replaces the page-by-page registration process using Register with a single registration using the Web.config file. As with the regular Register, sitewide registration requires that you identify the TagName and TagPrefix that are used to instantiate the control. Static Using this means there will be no concatenation within the ClientIdMode control's client ID. Thus, any ID that you assign the control will be given to the rendered element. However, there is no validation that the ID is unique even though this is a requirement of HTML. You have to manage this uniqueness yourself as you build out your markup. TagName This is set when you register an ASP.NET Web Forms user control. This value, along with the TagPrefix, is used to define the relationship between the control being referenced in the markup and the particular control that is being referenced. This has to be unique for each control being registered. TagPrefix This is set when you register your ASP.NET user control and is used to help define the relationship between the item placed on the page and the user control that is going to be used on the page. Chapter 12 Validating User Input What you will learn in this chapter: How client-side and server-side validation of input data differs Changing your model classes to help support validation Using validation controls to validate input in ASP.NET Web Form pages Enforcing validation in ASP.NET MVC views and controllers Working with controllers that return partial views Some tips for implementing validation Code Downloads for this Chapter: The wrox.com code downloads for this chapter are found at www.wrox.com/go/beginningaspnetforvisualstudio on the Download Code tab. The code is in the chapter 12 download and individually named according to the names throughout the chapter. There is an old saying, “garbage in, garbage out” (GIGO). The implication is clear: When you allow bad data (garbage) into your application, you will have problems from then on out because your application will give you garbage back. The best way to ensure that your application does not have garbage data is to validate as much of the incoming information as possible to ensure that it fits some known criteria, such as ensuring that a phone number includes all digits, that an e-mail address has the correct format, or a quantity is an integer; for all sorts of userentered pieces of information, you can, and should, define some expectations regarding how that data should appear. Both MVC and Web Forms provide support to help you keep your application as garbage-free as possible. In this chapter, you will examine some of the more common validation needs, and work with them in both MVC and Web Forms. Gathering Data from the User Gathering information from visitors to your site is key to your success. Because this information is so important to your business, you have to help ensure its validity and correctness. Obviously you can't always ensure the correctness of the input data; if George Smith enters his name as Janet Jones, there is no way to determine that. However, you can ensure that the user has entered a first name and a last name and that they are actual names—for example, such as not including numbers or symbols. When you approach validation, you want to look for a couple of things on each piece of data received by the user: Required fields: There are some values that a user must provide in order for your system to work. Is this particular property one of them? Data type: Any data that is input must be of a particular type. A value entered in a quantity box needs to be numeric at least, most likely an integer. Data size: Just as you may need to have data fit a specific type, you may also need the data to fit some particular ranges of sizes. The most common of these is a maximum size, or length. This is necessary because each column in a relational database table was defined with a size in characters. Trying to insert a value larger than that value will either lose data or cause an exception. Format validation: A piece of data that represents, for example, an e-mail address, needs to follow some kind of standard template: [email protected] Phone numbers have their own rules, credit card numbers have their own rules, and so on. Range validation: Some data must fall between a realistic range. Entering a birth date of January 1, 1756, for example, should raise some red flags. Comparison validation: Sometimes an entry in one field implies a set of values in another field. For example, selecting a gender of female implies a title of Ms. but not Mr. Another example is comparing the two values in a date range to ensure that the “from value” is less than the “to value.” Others: Custom validations may be necessary as well—those that fall outside the scope of the other validation approaches already listed. These will be completely dependent upon your application needs. Ideally, all this validation would work on the client side, so if the user enters invalid data then the form cannot be submitted. This gives users a more immediate update when information is incomplete or incorrect. However, as a responsible developer, you cannot rely on the client to do all of your validation, as the user may have turned that functionality off. Thus, you have to ensure that the information that comes across the network to your server is correct as well, so server-side validation is also a requirement. In fact, if you had to choose between supporting only one of the validation approaches, client-side or server-side, you should always choose server-side because you want full control over the information being validated. When you review all of the preceding considerations, the ideal form of validation is one that you could use on both server and client. Another useful function would be defining the requirements as close to the model as possible, ideally even on the model itself. This means when you look at the class file you would be able to understand, right there, the data expectations. Keep all of this in mind as you take your journey through validation. As you have likely already surmised, MVC and Web Forms each manage the requirement of validation differently. Validating User Input in Web Forms There is a special set of server controls designed to perform validation. Briefly mentioned earlier in the book, these are the aptly named validation server controls, and they are available in the Visual Studio Toolbox, as shown in Figure 12.1. Figure 12.1 Validation controls in Visual Studio Toolbox Each of these ASP.NET Web Form validation controls supports one or more of the necessary validations. Table 12.1 describes each one in detail. Table 12.1 Validation Server Controls Control Description CompareValidator Use the CompareValidator control to compare the value entered by the user in an input control, such as a TextBox control, with the value entered in another input control or a constant value. The CompareValidator control passes validation if the input control's value matches the criteria specified by the Operator, ValueToCompare, and/or ControlToCompare properties.You can also use the CompareValidator control to indicate whether the value entered in an input control can be converted to the data type specified by the Type property.When compared to the list of validation needs from the list in the previous section, this control fills both the “DataType” and “Compare” needs. CustomValidator The CustomValidator control applies a user-defined validation function against a control. When using this control, the developer first creates the JavaScript functionality to ensure that the values entered into the control are correct. This control enables you to perform any validation you need, as long as you can figure out how to write the JavaScript to support it.However, the JavaScript portion is only the client-side validation. You also need to write server-side logic to validate on the server. The combination of these two approaches ensures full validation.When compared to the list of validation needs, this control can fulfill any type, as it is completely customizable. RangeValidator The RangeValidator control tests whether the value of an input control is within a specified range. You supply a minimum value and a maximum value, and the type of the item being compared. RegularExpressionValidator The RegularExpressionValidator control checks whether the value of an input control matches a pattern defined by a regular expression. This type of validation enables you to check for predictable sequences of characters, such as those in e-mail addresses, telephone numbers, and postal codes.This control provides formatting validation and can also be used to provide minimum and maximum length validation. RequiredFieldValidator Use this control to make an input control a required field. The input control fails validation if its value was not changed from the InitialValue property upon losing focus.This control supports the required field's validation, likely the most common scenario; it only validates that there is data rather than anything about that data. ValidationSummary The ValidationSummary control is used on a page to display all the validation errors that have occurred. Generally at the top of the form, it displays the validations as well as a link that takes the user to the field that failed validation. Because each of the controls typically does a specific validation, you have the capability to link multiple validation controls to an input field, thus performing multiple different validations. For example, if Date of Birth were both required and expected to be between a set of values, you could hook up both a RequiredFieldValidator and a RangeValidator to the same input item, as shown here:
      The preceding code snippet includes four different server controls: A Label control A TextBox control A RequiredFieldValidator A RangeValidator All the controls are related in that the two validators and the label are all associated with the TextBox control. Neither the Label control nor the TextBox control are new, but this is the first time you have seen the validator in action. Many validators share some common properties. Table 12.2 lists these common properties, as well as other attributes. Table 12.2 Validator Properties Property Description ControlToCompare The input control to compare with the input control being validated. This property is valid only on the CompareValidator. ControlToValidate This property is available on every validation control. The ControlToValidate property defines the input control that is being validated. A validator that does not have this value set is not doing any validation. Display Another common property, the Display property defines how the message will be displayed. There are three options: Dynamic, None, and Static. When Display is set to Static, the area taken up by the error message being displayed is always blocked out, regardless of whether it is actually visible. In the preceding example, if the two Display properties were set to Static, there would be a space between the textbox and the second error message, assuming it were the RangeValidator that failed. Because they are dynamic, the space taken up by the first error message is not reserved and the error message from the second control can be displayed as if the first validation control is not there. Choosing None means the error message is never displayed inline, rather only in a ValidationSummary control. Static is the default value. EnableClientScript This property is available on all validation controls. Use the EnableClientScript property to specify whether clientside validation is enabled. Server-side validation is always enabled, but you can turn off client-side validation if desired. The default value is true. ErrorMessage Available on all validation controls, this property defines the message that's displayed in a ValidationSummary control when the validator determines that the content in the input box fails validation. It will also display inline if the Text property is not set. MaximumValue This property is available on the RangeValidator and is used to set the upper end of the range being used for the comparison. MinimumValue This property is available on the RangeValidator and is used to set the lower end of the range being used for the comparison. Operator Available on the CompareValidator, the Operator attribute defines the type of comparison to be done. The options are as follows:Equal: A comparison for equality between the values of the input control being validated and another control, or a constant value.NotEqual: A comparison for inequality between the values of the input control being validated and another control, or a constant value. This is the same as !=.GreaterThan: A comparison for greater than between the values of the input control being validated and another control, or a constant value. This is the same as >.GreaterThanEqual: A comparison for greater than or equal to between the values of the input control being validated and another control, or a constant value. This equates to !=.LessThan: A comparison for less than between the values of the input control being validated and another control, or a constant value. This is the same as <.LessThanEqual: A comparison for less than or equal to between the values of the input control being validated and another control, or a constant value. This is the same as <=.DataTypeCheck: A data type comparison of the value entered in the input control being validated and the data type specified by the Type property. Validation will fail if the value cannot be converted to the specified data type. Text A common property, the value assigned to Text will display inline when the validation fails. Type The data type to which the values being compared are converted to before the comparison is made. The options are String, Integer, Double, Date, and Currency. The Type property is available in the RangeValidator and the CompareValidator. The default value is String. ValidationExpression The regular expression that determines the pattern used to validate a field ValidationGroup A special property that is available on all validators. What makes it special is that it is also available on other controls as well, such as Buttons and other controls that support posting to the server. The ValidationGroup enables you to group validators and various postback mechanisms so that only a subset of validation is run when a postback to the server happens. This enables you to have different sections of the page doing different actions without having to worry about an action taken in one area causing validation to occur in another area. In this next Try It Out, you start to put various controls together to validate the input of a data entry form. TRY IT OUT: Adding Web Forms Validation In this activity you update the ManageItem form that you created earlier in the book to ensure that the values input by the user meet a certain set of criteria. 1. Ensure that Visual Studio is running and your RentMyWrox solution is open. Open your Admin &cmdarr; ManageItem.aspx page. 2. Add the following code above the first line of the form. You can do this by either typing the information directly in or dragging and dropping the control from the Toolbox. It should look something like Figure 12.2. Figure 12.2 Adding the ValidationSummary control
      3. Add a RequiredFieldValidator to tbName. You can do this by either typing in the information directly, as shown below or dragging and dropping the control from the Toolbox and filling in the required properties: 4. Add another one to tbDescription: 5. Add a CompareValidator and a RequiredFieldValidator to tbCost as shown below. When you are done, your markup should match what is shown in Figure 12.3. Figure 12.3 Adding some validation controls 6. Add a RequiredFieldValidator to the Item Number. 7. Add a RequiredFieldValidator and a CompareValidator to Acquired Date. When you are done, your markup should match what is shown in Figure 12.4. Figure 12.4 Additional validation controls 8. Run the application and select Admin &cmdarr; ManageItem. Click the Submit button without entering any information. You should see a screen like Figure 12.5. Figure 12.5 Validation displayed 9. Open the code-behind by selecting Admin &cmdarr; ManageItem.aspx.cs. Update the SaveItem_Clicked method by adding the code that is highlighted in the below snippet: protected void SaveItem_Clicked(object sender, EventArgs e) { if (IsValid) { Item item; using (RentMyWroxContext context = new RentMyWroxContext()) { if (itemId == 0) { item = new Item(); UpdateItem(item); context.Items.Add(item); } else { item = context.Items.FirstOrDefault(x => x.Id == itemId); UpdateItem(item); } context.SaveChanges(); } Response.Redirect("~/admin/ItemList"); } } How It Works In this exercise you added two different types of validators, the RequiredFieldValidator and the CompareValidator, to the data entry form that you built earlier for the Item. Because every item in the form other than the picture is required, you had to add multiple RequiredFieldValidators. The code for one of them is displayed here: The attributes all help define the rules that define the control's behavior. The most important property is ControlToValidate, which defines the input control that this validator is going to evaluate. In this case, the control is evaluating a control with the ID of "tbName“. Both the Text and ErrorMessage properties are set. Because the Text property is the one that displays inline (where the control itself is located), you would expect to see an asterisk next to the input field where validation failed. The ErrorMessage is the text that displays in the ValidationSummary control. Reviewing Figure 12.5 shows how both of these are working. The ErrorMessage is displayed in the bulleted list at the top of the page that was created by the ValidationSummary control, while each of the text boxes has an asterisk next to it that was defined by the value in the Text property. On two of the controls you also added a CompareValidator. Both of these validators are shown here: These validators are not comparing the input value to another control, but are instead ensuring that the value being input can be converted to a specific type —in these cases a date and to a numeric value that represents a valid currency amount. You can have this control handle both because of the Type parameter, which defines the parsing that the control will try against the input value. Refer back to Figure 12.5 and pay special attention to those controls that have two different validators applied to them. Note that only one message is being displayed in both the ValidationSummary and inline, and that is the validation for RequiredField. The reason why this occurs is because the default behavior for all non-RequiredFieldValidators is that they only work when the input value isn't null. Thus, leaving the value of the field blank ensures that those other validators don't. This is why they had to be combined with a RequiredFieldValidator. The RequiredFieldValidator ensures that a value is entered, and then the CompareValidator ensures that the value entered can be converted to the correct type. This client-side validation is all handled by JavaScript because that is the only language that you can be confident that the browser supports. Fortunately, you didn't have to write any of that JavaScript yourself; it was all generated from the control. Viewing the source of the rendered HTML shows how this happens. Figure 12.6 illustrates a section of the created HTML. Figure 12.6 Validation displayed If you review the HTML that was created, you will see that there are script references that you did not put into the code—mainly those that reference a WebResource.axd. WebResource.axd is a handler that enables control and page developers to download resources that are embedded in a server-side assembly to the end user. The code that is visible in Figure 12.6 requests a certain set of JavaScript to be downloaded to the client. If you went directly to that resource you would be able to download a file that is actually pure JavaScript—the JavaScript that is then used to perform the validation. When the validation fails, the submission to the server is stopped and the error messages and error text are displayed as requested. Each time there is an attempt to post information to the server, the process repeats itself until all items pass validation. Only when that occurs is the submission to the server completed. If you played with any of the fields that failed validation, you may have noticed one more interesting fact. Whenever you enter and then leave a field, the validation is again run against that input item. This means that if you make a change to a failing field, you will get an almost immediate update as to whether you pass that field's expected validation. This only affects the inline warning, however; the ValidationSummary only updates when the process attempts to post to the server, and you will not see the summary control change when you leave the individual field. Whereas the changes that you had to make in the markup to provide validation support were relatively significant, the change you had to make in the code-behind was very simple. The Page class, from which all Web Form pages inherit, contains a property that is populated when the request is received at the server. Server-side validation happens automatically. You can choose to disregard it by not looking at the IsValid property, but it will always be populated correctly based on the configured rules and the data that was input in the Web Form. As you can see, ASP.NET server controls have provided an easy and efficient way to get work done, this time by providing validation services on one or more input controls. As a bonus, this validation happens on both the client side, through the use of JavaScript, and on the server side during normal page processing. Although only two validation controls were demonstrated, most of the others work in much the same way. Understanding Request Validation Another type of validation occurring on ASP.NET Web Form pages that you probably have not even seen yet is request validation, and it is always enabled by default. Request validation is a feature in ASP.NET that examines an HTTP request to determine whether it contains potentially dangerous content. In this context, potentially dangerous content is any HTML markup or JavaScript code in the body, header, query string, or cookies of the request. ASP.NET performs this check because markup or code in the URL query string, cookies, or posted form values might have been added for malicious purposes. For example, if your site has a form on which users enter comments, a malicious user could enter JavaScript code in a script element. When you display the comments page to other users, the browser executes the JavaScript code as if the code had been generated by your website. Request validation helps prevent this kind of attack. If ASP.NET detects any markup or code in a request, it throws a “potentially dangerous value was detected” error and stops page processing, as shown in Figure 12.7. Figure 12.7 Error thrown during request validation You can see this happen yourself by simply entering some HTML type elements into the form page that you were just working with. As mentioned earlier, this validation is enabled by default but you can turn it off as needed, such as when users are expected to enter information that may contain HTML or JavaScript elements. You can control the settings by adding ValidateRequest="False" to the Page directive. This will turn off request validation for that page. There may be times when you don't want to turn off request validation for a whole page, but instead perform the validation on only a set of the controls on the page. This would be common in those instances where capturing HTML is allowed, such as the screen where you can enter the description of the Item class. In this case, you can enable or disable the check on a control level through the use of the ValidateRequestMode property: With the preceding code, the content placed in the tbDescription will always go through request validation, even if it is turned off at the page level. Validating User Input in MVC You may have noticed that your validation expectations are defined as part of the UI construction in ASP.NET Web Forms. This means that any pages that might be accepting the same type of information in the page have to implement this validation independently. Thus, changing a validation requirement requires you to make the changes in multiple pages. ASP.NET MVC takes a more centralized approach, putting control of the validation where it really belongs: on the model itself. Model Attribution Putting the validation on the model itself was a logical next step, as there is no place in the application that should better understand what values are valid or invalid. Putting these validation rules on the model also enables validation to become part of the database management process as well, by putting some of the model validation rules, such as the field's maximum length or whether a field is required at the database level too. Lastly, putting the validation at the model level ensures any data that doesn't fit the rule is not persisted. This same level of security isn't present when working with the ASP.NET Web Form validation controls—those only ensure that the values sent with the request are valid, but it does nothing to ensure that the data being persisted is valid. The validation controls are only for submission validation. However, you can also add attributes to models that are being used from Web Forms and still take advantage of the built-in validation functionality. Adding validation to a model is done by using attribution. Provided with the Entity Framework is a large set of validation attributes that ASP.NET MVC can take advantage of when interpreting the validation requirements. Some of the available attributes are listed in Table 12.3. Table 12.3 Data Attributes Used in Validation Attribute Description CreditCard Ensures that the value of the property is compatible with wellknown CreditCard number templates[CreditCard(ErrorMessage = "{0} is not a valid credit card number")] DataType Use the DataType attribute to specify the type of data that is expected for the property beyond the data type of the property. Following are the values of the supported types:CreditCard: Represents a credit card numberCurrency: Represents a currency valueCustom: Represents a custom data typeDate: Represents a date valueDateTime: Represents an instant in time, expressed as a date and time of dayDuration: Represents a continuous time during which an object existsEmailAddress: Represents an e-mail addressHtml: Represents an HTML fileImageUrl: Represents a URL to an imageMultilineText: Represents multi-line textPassword: Represents a password valuePhoneNumber: Represents a phone number valuePostalCode: Represents a postal codeText: Represents text that is displayedTime: Represents a time valueUpload: Represents file upload data typeUrl: Represents a URL value [DataType(DataType.Date)] Display The Display attribute is not really a validation attribute, but rather the value that is displayed in the UI whenever that property is referenced. This field will affect the @Html.LabelFor values used in the view and is also used in the ErrorMessages when the property name is being displayed. [Display(Name="Marital status")] EMailAddress Ensures that the value of the property is compatible with wellknown phone number templates [EmailAddress(ErrorMessage = "{0} is not a valid email address")] FileExtensions Ensures that the value of the property ends with the appropriate values listed within the Extensions property. Note that you do not add the “.”; the validation framework does that for you. You can display the string of filtered extensions as part of the ErrorMessage. [FileExtensions(Extensions = "jpg,jpeg", ErrorMessage = " {0} is not a valid extension - {1}")] MaxLength Ensures that the property's value does not exceed the number of characters defined in the attribute. This attribute becomes part of the database definition, as the column in the table is set with this same value as its width. The ErrorMessage enables you to add the value that you set as the maximum length. [MinLength(5, ErrorMessage="{0} needs to be at least {1} character")] MinLength Ensures that the property's value does not have fewer characters than the attribute defines. The ErrorMessage enables you to add the value that you set as the minimum length. [MinLength(5, ErrorMessage="{0} needs to be at least {1} character")] Phone Ensures that the value of the property is compatible with wellknown phone number templates [Phone(ErrorMessage = "{0} is not a valid phone number")] Range Ensures that the value of the property is within a known range of values. When using this validator you first define the data type and then define the string version of the range from lowest to highest. When you create the ErrorMessage that will be displayed to the user (or thrown as part of an exception), it uses the string.Format notation: {0} = the display name of the field, {1} = the bottom of the range, and {2} = the top of the range. [Range(typeof(DateTime), "1/1/1900", "12/31/2020", ErrorMessage = "{0} must be between {1} and {2}")] RegularExpression Enables you to use a RegularExpression to validate the data that is being stored RegularExpression(@"^[a-zA-Z''-'\s]{1,40}$", ErrorMessage = "Characters are not allowed.")] Required Defines a field as mandatory. This means some value must be entered into the property. The Required attribute also interacts with the database when using the code first approach because it ensures that the table being constructed defines the mapped column as not being able to support a null value. [Required(ErrorMessage = "Please tell us how many in your home")] StringLength This attribute can be used to set both the minimum and maximum length of a property that is a string. The main difference between StringLength and MinValue/MaxValue is that StringLength enables you to set both maximum and minimum values and it can only be used on properties that are of type string. [StringLength(15, MinimumLength = 2, ErrorMessage = "{0} must be between {2} and {1} characters")] Url Ensures that the value of the property is compatible with a URL format [Url(ErrorMessage = "{0} is not a valid URL")] In this next activity you update a data model to use data attribution and validation. TRY IT OUT: Adding Data Annotation In this activity you will be updating the UserDemographics class to use data annotation. Because some of this annotation will affect the database table, you also have to update the database to support the changes. 1. Ensure that Visual Studio is running and your RentMyWrox solution is open. 2. Open your UserDemograhics model class. Add the following annotations to the Birthdate property. When completed, this property should look like Figure 12.8. Figure 12.8 Attributed property [Required(ErrorMessage = "Please tell us your birth date")] [Range(typeof(DateTime), "1/1/1900", "12/31/2010", ErrorMessage = "{0} must be between {1} and {2}")] 3. Add the following attributes to the MaritalStatus property: [Display(Name="Marital status")] [Required(ErrorMessage = "Please tell us your marital status")] [StringLength(15, MinimumLength = 2)] 4. Add the following attributes to the DateMovedIntoArea property: [Display(Name = "Date you moved into area")] [Required(ErrorMessage = "Please tell us when you moved into the area")] [Range(typeof(DateTime), "1/1/1900", "12/31/2020", ErrorMessage = "Your response must be between {1} and {2}")] 5. Add the following attributes to the TotalNumberInHome property. When completed, your class should look like Figure 12.9. [Display(Name = "How many people live in your house?")] [Required(ErrorMessage = "Please tell us how many live in your home")] [Range(typeof(int), "1", "99", ErrorMessage = "Total must be between {1} and {2}")] Figure 12.9 Fully attributed class 6. Save the file. On the Visual Studio menu, click Tools &cmdarr; NuGet Package Manager &cmdarr; Package Manager Console. This should open the Package Manager Console, likely in the bottom of your screen. 7. Ensure that you are in the Package Manager Console window and type in add-migration "data annotations". It should look like Figure 12.10. Figure 12.10 Package Manager Console 8. Ensure that the Migrations directory contains a new file that has today's date and “data annotations” as part of the filename. 9. In the Package Manager Console window, type in update-database. The system should process for a bit and display a message when completed. How It Works Four different types of attributes were added to the model: DisplayAttribute, RequiredAttribute, RangeAttribute, and StringLengthAttribute. Each created different expectations on the data property to which they were applied, and each of these expectations could be stacked such that a property might have to pass multiple types of validation before it could be considered “valid.” Of the various attributes that you added, the DisplayAttribute had the least to do with the data validation being performed with the model, but it had the greatest effect in terms of making any validation failures that might be received easier to understand. When you go back into the view you will also see how the values set here show up in the UI through the use of the Html.LabelFor method. The RequiredAttribute is another relatively simple validation attribute. It notifies the validation framework that the property being attributed needs to be set, as opposed to being null. When applied to a type that is non-nullable, such as an integer whose default value is 0 rather than a null, the attribute is less useful. When you want to ensure that an integer is required, a RangeAttribute is generally used instead. The RangeAttribute is a very flexible validation tool in that it can support multiple types. In this activity you used it in two different ways: to ensure that DateTime properties fell within a useful date range and that an integer fell within an expected range. An interesting aspect of the RangeAttribute is that it takes the minimum and maximum values as strings. It is able to understand these strings because it has both the data type of the property to which it is being applied as well as a type defined in the attribute itself. The framework uses this type to attempt to parse the values that are being passed in and then uses the built-in comparer to determine whether the property value falls between the starting and ending values. By passing in a type and the range values as strings, the attribute is flexible and able to work with multiple types; otherwise, you would need a different attribute for each data type. The last attribute used in this example, StringLengthAttribute, sets a minimum and maximum length of a string property (or a byte array). If this attribute were applied to a different type, such as the integer Id property, you would get the error shown in Figure 12.11. Figure 12.11 Error caused by StringLength on the integer property The StringLengthAttribute caused one of the database changes. If you open the migration file that was just created in the Migrations directory you will see a line like the following: AlterColumn("dbo.UserDemographics", "MaritalStatus", c => c.String(nullable: false, maxLength: 15)); This sets the maximum length to 15 characters. The outcome of this line can be seen in the Server Explorer, where the properties of the MaritalStatus column will show that the column has a length of 15, as shown in Figure 12.12. Figure 12.12 Properties showing 15-character column It may strike you odd, however, that you don't see anything in the migration script for the other required fields that were set in this activity, such as DateMovedIntoArea, TotalNumberInHome, and BirthDate. That is because all those items were set as being required in the database from the very beginning. The reason becomes clear when you think about what these types— DateTime and integer—mean in .NET as opposed to what they mean in the database. The database is OK having these fields as nullable, but that's not possible in .NET. Neither DateTime nor integer are allowed to be null; they will always be set with a default value whenever they are created through a model first class, so the framework sets the database up to support that need. Therefore, adding this particular attribute to those properties did not affect the database design, but it will affect the UI and how it handles client-side validation. What do you think will happen when the following code is run from within a controller? using (RentMyWroxContext context = new RentMyWroxContext()) { var item = new UserDemographics { DateMovedIntoArea = DateTime.Now, Birthdate = DateTime.Now, TotalNumberInHome = 0, MaritalStatus = "A" }; context.UserDemographics.Add(item); context.SaveChanges(); } It appears that the item would not pass validation because it contains several items that don't pass validation—and that is what happens, as shown in Figure 12.13. Figure 12.13 Error when trying to save invalid data in the controller That the system always validates the information being persisted for that model is very important—using data annotations literally affects the values of data that can be stored in the database; this is the definition of server-side validation. Once you have added data validation rules on the server side you need to hook these rules to the UI so that you can also support client-side validation. Client-Side Validation Server-side validation is a required part of any application that is persisting data and may have expectations about the validity of the data. However, as mentioned earlier in the chapter, having client-side validation as well provides a much better overall user experience because users can get much more timely feedback when their validation fails, as the round-trip to the server isn't necessary. When you added client-side validation to the ASP.NET Web Form, all you did was set the rules for that field in the validation server control that was placed on that page, and that control handled both server and client-side validation. The control was easy to configure and using it was simple. Fortunately, the MVC framework provides a way to manage client-side validation that is almost as straightforward, once it has been properly configured and set up. Just as with validation server controls, MVC views rely on JavaScript to manage the client-side validation of information being submitted through the web browser. However, whereas the Web Forms validation relies on JavaScript being provided by a WebResource.axd file behind the scenes, the validation used within MVC relies entirely on open-source JavaScript libraries—namely, the jQuery and jQuery validation libraries. These libraries know how to interact with the information on the screen through the MVC Html.ValidationMessageFor helper. This helper takes a Lambda expression of the model field that is being validated. When the view goes through the rendering event, the validation rules are translated into a configuration supported by the validation libraries. The code for the Html.ValidationMessageFor is shown here: @Html.ValidationMessageFor(model => model.Birthdate, "", new { @class = "text-danger" }) This code snippet tells the engine to create a class to handle the validation for the BirthDate. The empty string that is being passed in represents the UI override of the validation message, while the last parameter sets the class of the element containing the validation. Notice that nothing in the helper defines the type of validation that will be occurring; instead, it just identifies the property being validated. This is possible because the control being used here relies on the validation that was defined at the model level. Rather than force the developer to create an entirely new implementation of validation, it instead simply reads the required validation of the model that was passed to the view and then builds the UI parts of the validation based on those characteristics. In this next Try It Out activity, you explore this relationship further by adding validation to an MVC view. TRY IT OUT: Adding Validation to an MVC View In this activity, you take advantage of the validation rules that you just added to the UserDemographics class by tying them to the view so that the same model attribute-based rules provide support for client-side data validation. 1. Ensure that Visual Studio is running and your RentMyWrox solution is open. 2. Open the NuGet Package Manager by right-clicking from within the Solution Explorer on the project name. Select Manage NuGet Packages. This will open a popup window. 3. Select Online &cmdarr; Microsoft and .NET on the left and search for “validation” as shown in Figure 12.14. Figure 12.14 Nuget Package Manager Window 4. You should see multiple results. Find one called jQuery Validation and click the Install button. You may have to accept some licensing agreements. When the process completes, the item that you initially selected may have a green check mark on the selection tile. 5. In this same window, look for Microsoft jQuery Unobtrusive Validation and add this package as well. 6. Go to your Solution Explorer window and expand the Scripts directory. The files it contains should be similar to those shown in Figure 12.15. Figure 12.15 Scripts directory after adding new packages 7. Open your App_Start\BundleConfig.cs file. Add the following entries to the RegisterBundles method. When completed, this file should resemble Figure 12.16. bundles.Add(new ScriptBundle("~/bundles/jquery") .Include("~/Scripts/jquery-{version}.js")); bundles.Add(new ScriptBundle("~/bundles/jqueryval") .Include("~/Scripts/jquery.validate*")); Figure 12.16 Content of the BundleConfig file 8. Open your View\Shared\_MVCLayout.cshtml file. Find the following lines and delete them: 9. Add the following line to the same spot: @Scripts.Render("~/bundles/modernizr") 10. In this same area of the page, find the following lines and move them closer to the bottom of the page, right below the @Scripts.Render lines: @RenderSection("scripts", required: false) 11. Open your Views\UserDemographics\Manage.cshtml file. Find the ValidationSummary. Change true to false. When completed, this section of the file should look like Figure 12.17. Figure 12.17 New ValidationSummary configuration 12. Open your UserDemographicsController. Update your Post version of the Create method to the code shown here: [HttpPost] public ActionResult Create(UserDemographics obj) { using (RentMyWroxContext context = new RentMyWroxContext()) { var ids = Request.Form.GetValues("HobbyIds"); if (ids != null) { obj.Hobbies = context.Hobbies.Where(x => ids.Contains(x.Id.ToString())). ToList(); } context.UserDemographics.Add(obj); var validationErrors = context.GetValidationErrors(); if (validationErrors.Count() == 0) { context.SaveChanges(); return RedirectToAction("Index"); } ViewBag.ServerValidationErrors = ConvertValidationErrorsToString(validationErrors); return View("Manage", obj); } } 13. Add the following method to your controller: private string ConvertValidationErrorsToString (IEnumerable list) { StringBuilder results = new StringBuilder(); results.Append("You had the following validation errors: "); foreach(var item in list) { foreach(var failure in item.ValidationErrors) { results.Append(failure.ErrorMessage); results.Append(" "); } } return results.ToString(); } 14. Update your Post Edit method to the following: [HttpPost] public ActionResult Edit(int id, FormCollection collection) { using (RentMyWroxContext context = new RentMyWroxContext()) { var item = context.UserDemographics.FirstOrDefault(x => x.Id == id); TryUpdateModel(item); var ids = Request.Form.GetValues("HobbyIds"); item.Hobbies = context.Hobbies.Where(x => ids.Contains(x.Id.ToString())) .ToList(); var validationErrors = context.GetValidationErrors(); if (validationErrors.Count() == 0) { context.SaveChanges(); return RedirectToAction("Index"); } ViewBag.ServerValidationErrors = ConvertValidationErrorsToString(validationErrors); return View("Manage", item); } } 15. Back in the Manage.cshtml file, add the following line to the top block of code. It should look like Figure 12.18 when completed. Figure 12.18 Updated code block string serverValidationProblems = ViewBag.ServerValidationErrors; 16. Add the following code immediately after the ValidationSummary. When finished it should look similar to Figure 12.19. Figure 12.19 Changed view page @if(!string.IsNullOrWhiteSpace(serverValidationProblems)) {
      @serverValidationProblems
      } 17. Run your application and go to \UserDemographics\Create. Without filling out any information, click the Create button. You should get output similar to that shown in Figure 12.20. Figure 12.20 Validation displayed in the browser 18. Properly fill out the data in the screen and click Create. Note that you are returned to the list page and that the item you just added is in the list. How It Works Working with data validation in ASP.NET MVC views is similar to working with validation in Web Forms since the work required by the developer is mostly getting the validation onto the page. Once the proper control, whether it is a server control or an HTML helper, is on the page, the ASP.NET page creation process takes over and builds the appropriate output so that the client browser can understand the validation requirements. An MVC view uses a jQuery-based approach to building validation. This means the code that actually performs the validation is part of the jQuery framework, so all the ASP.NET framework has to do is ensure that the output of the validation control is what is expected when working with the validation library. The following code snippets show the data elements in the view, the model definition, and the HTML output from the page that includes the information created by the validation helper: View content
      @Html.LabelFor(model => model.DateMovedIntoArea, htmlAttributes: new { @class = "control-label col-md-2" })
      @Html.EditorFor(model => model.DateMovedIntoArea, new { htmlAttributes = new { @class = "form-control" } }) @Html.ValidationMessageFor(model => model.DateMovedIntoArea, "", new { @class = "text-danger" })
      Model Definition [Display(Name = "Date you moved into area")] [Required(ErrorMessage = "Please tell us when you moved into the area")] [Range(typeof(DateTime), "1/1/1900", "12/31/2020", ErrorMessage = "Your response must be between {1} and {2}")] public DateTime DateMovedIntoArea { get; set; } HTML Output
      Looking at these three sections together shows how an element needs to be configured to work within the jQuery validation framework. The key to success when working within jQuery is the use of custom attributes on a common HTML element. These custom attributes are found in the input element and all start with “data-val” to indicate that they are data validation values. With the inclusion of the jQuery files, a method was added that intercepts the form submission. As part of that interception, the method goes through all the elements that are part of the form submission, looking for a known set of element attributes. When the jQuery method finds these attributes it examines the values they contain to determine what kind of validation needs to happen. The first attribute that it looks for is data-val. When that attribute is present and set to true, the jQuery validation framework then reviews the element to determine the type of validation to perform. In this case it finds three different validations that need to happen: datatype, range, and required. You can determine this because each of those validation types has a representative attribute. Range has additional elements because it needs to support a minimum value and a maximum value. These attributes were added because the Razor view engine understood the relationship between the EditorFor and ValidationMessageFor items and was able to create the attributes based on the settings in the model. You can see this relationship because all the values used in the validation are the same values as those used in the attribution on the model's property. You can create these attributes yourself, by hand, and take advantage of the validation framework that was provided when you added the appropriate NuGet packages. (Please note that multiple JavaScript and jQuery validation frameworks are available, each of which differs in implementation.) The Unobtrusive Native jQuery library that you added to the project enables the management of validation through the data-val approach. The data-val approach takes advantage of HTML5, which allows custom attributes to be created and analyzed by the browser. These custom attributes are then available to be analyzed through jQuery just like the standard attributes on an element. There is a whole chapter, Chapter 14, on using jQuery coming up soon, so that's all on the subject for now. You also made some changes in the controller. While not completely necessary, as you know that the Entity Framework will not allow bad data to be saved to the database, doing some work in the controller helps to create a better user experience, as a thrown exception can result in showing users the infamous ugly yellow exception screen. The primary change that you made to ensure a positive user experience was adding a validation check in the controller before the SaveChanges method is called. You may wonder why you made this effort because you also put all the validation in the view. The answer goes back to the concept of always ensuring that you try to avoid throwing exceptions—understanding that an exception will be thrown if you actually make the call enables you to avoid having the framework throw an exception. You can make this determination through the GetValidationErrors method on the context. Running this method causes the context to evaluate all the changed items against their validation rules. If there are any instances where the item fails validation, then that item is added to the list of failed validation items. One DbEntityValidationResult is returned for each item that fails validation. This is per object, not per property on the object that failed validation; the specific property that failed is listed in the ValidationErrors collection on the DbEntityValidationResult. The GetValidationErrors method runs only on items that have been added to the context, so typically it would generally be run right before the SaveChanges method is processed. However, in larger applications in which the same data context may be passed from method to method, it is considered good form to run GetValidationErrors because the method that added the bad data is the best method to handle management of the invalid data. When you run the GetValidationErrors method, you get a list of the validation issues. You added a method to the controller to translate this collection of validation errors to a string that you added to the ViewBag so that you could report back to the user any specific problems that were discovered. As you can probably surmise, there are other routes to validating your data. The Controller class has a method, ValidateModel, that validates the information returned from the request to ensure that the incoming item passes validation. This approach is good because you can do it before actually instantiating the data context, thus saving processing on the server. Using this method in the controller could look like the following: ValidateModel(obj); if (ModelState.IsValid) { using (RentMyWroxContext context = new RentMyWroxContext()) { context.UserDemographics.Add(obj); context.SaveChanges(); return RedirectToAction("Index"); } } Accessing the failed items is a little more complicated using this approach, however, as you have to iterate through each of the values in the ModelState, with each value in the ModelState corresponding to a property on the model, and then evaluate the Errors collection that was attached to that ModelState value, something like the code snippet shown here: foreach(var value in ModelState.Values) { if (value.Errors.Count > 0) { // do something with the error } } Parsing through the properties of the model to find those with errors is more complex code, which is why the code was written using the GetValidationErrors method; it is easier to understand and maintain. However, just like virtually all work that needs to be done in ASP.NET, there are multiple ways of solving a problem, each having its own sets of strengths and weaknesses. The information that is input by the user is validated against the rules that were defined for the model class. There is one more set of validation that is performed by the server when a controller handles a request. Request Validation in ASP.NET MVC Like ASP.NET Web Forms, MVC enables you to perform request validation. Request validation is a check whether a form field contains HTML elements or other potential scripting items when that field is submitted to an MVC application. As a matter of fact, request validation is occurring in every submittal unless you decide to turn it off because request validation is turned on by default. In ASP.NET Web Forms, you control request validation for the entire page. Because MVC does not really have the concept of a page, you control the settings from an attribute that can be used on a controller or on an individual action, as shown here: [ValidateInput(false)] [HttpPost] public ActionResult Create(UserDemographics obj) In the preceding snippet you can see the attribute that determines whether or not the input is validated, ValidateInput. When you do not manually set the attribute, the system treats every request as if it were attributed with ValidateInput(true). To turn off request validation, simply set the attribute to false. When the attribute is set to false, the action will not validate any of the information coming to the server. In some cases this may be acceptable, but if you have a large form with multiple fields you may not be willing to have every field open to accept HTML (the default when validation is turned off for a controller). The developers of ASP.NET MVC recognized this need and added a special type of attribute that you put on a model class, System.Web.Mvc.AllowHtml. When used on a typical model property it could look like the following code: [AllowHtml] [Display(Name="Description")] [Required(ErrorMessage = "Please enter a Description")] [StringLength(150, MinimumLength = 2)] public string Description { get; set; } By attributing only those properties where you expect HTML, you can keep input validation on—only allowing HTML to be used on specific properties and not across the entire request. Validation Tips The following list provides practical tips on validating data: Always validate all user input. Whenever you have a public website on the Internet, you lose the ability to control its users. To stop malicious users from entering bogus or malicious data into your system, always validate your users' input using the ASP.NET validation controls. All data being passed in from the client should go through some type of validation; it is easy to accidentally enter invalid data, such as using the capital “O” instead of the number 0, or a letter “l” instead of the number 1. Always provide useful error messages in your validation controls. Either assign the error message to the ErrorMessage property and leave the Text empty, or use a ValidationSummary control to show a list of error messages. The more details you can give users about a problem, the easier it will be for them to resolve the issue. Whenever possible, point to the problem data that the user is working with rather than trying to describe it through text. The most common approach is to put the validation message right next to the input that is being validated. If you have to make a choice between client-side validation or server-side validation, always choose server-side validation. Client-side validation can be voided by a malicious user. Summary Validation is the process of ensuring that the information provided by a user fits a certain set of criteria. When validating data, approaches may vary depending on where you will be performing the validation and how you will be checking the data. Where you will be performing the validation is pretty straightforward because you only have two options for this: the server and the client. You should never consider it optional to do validation on the server because only there can you be sure that the validation is applied to the information being persisted; client-side validation can be turned off or gone around. Client-side validation provides a better user experience and can eliminate unnecessary round-trips to the server, but server-side validation is responsible for checking data immediately before persistence. When you consider validation, you need to ensure not only that your system is protected from bad data, but that you provide the appropriate feedback to users should they need to fix the data. This messaging back to users tends to work best with client-side validation because they can get immediate response to problems. Because of this need for both client and server validation, ASP.NET Web Form controls provide both. They enable you to define validation rules that will be used to check the input values and then provide both JavaScript that the browser uses to validate information before submission as well as server-side code that can be checked to ensure that values are valid. Various validation controls are available, each of which supports a different approach to validating the data that is entered into the particular field with which it is linked. Validation in MVC is different, but you can perform validation on both sides based on rules that are created on the model. The view has a helper that takes advantage of the rules from the model and configures the input element in such a way that a jQuery library automatically performs validation upon submission of the form. When the data gets back to the server, the same validation can be run against the request to ensure that it is valid before making use of the information. Both Web Forms and MVC provide support to validate data on both the client and the server. They take different approaches but they both solve the same need, helping you ensure the best data possible is added to your system. Exercises 1. What would be the expected behavior of the server when a user puts HTML code only into the Title field of a view that is linked with the following code? What happens if HTML code is put only in the Description field? [ValidateInput(true)] public class TestController : Controller { [HttpPost] public ActionResult Create(MyModel model) { return View(); } public ActionResult Create() { return View(); } } public class MyModel { [Required] [StringLength(50)] public string Title { get; set; } [Required] [AllowHtml] [StringLength(5000)] public string Description { get; set; } } 2. Imagine you are working with an ASP.NET Web Forms page and you place a RangeValidator above a RequiredValidator when they are both validating the same control. What would be the difference in behavior if you switched the order of the validation controls? 3. Is it possible to put validation on a model in such a way that a model can never be valid? What You Learned in This Chapter Client-Side Validation Client-side validation is the process of ensuring that information entered by a user fits a defined template. It is called client-side because all the checking happens within the browser, before the form is submitted to the server. If validation fails, then the form information is never submitted to the server; instead, a message displaying the validation errors is generally shown to the user. Compare Validation When you are doing a compare validation you are comparing the value in one field with another value. This other value could be another field, a constant value, or some sort of calculation. The primary consideration is that the value in an element is compared against another. Data Length Validation The process of determining whether the entered information is of the appropriate length, or amount of characters. This type of validation is generally performed only on strings. It consists of a minimum length, defaulting to 0, and a maximum length. Data Type Validation A determination made against the value in a submitted element as to whether that value can be cast or parsed into a defined type ModelState A construct that contains information regarding, surprisingly enough, the state of the model. After the ValidateModel method is run, the IsValid property provides information as to whether all validation rules passed successfully. Page.IsValid This is a code-behind check, in ASP.NET Web Forms, as to whether the content of the page successfully passes all the validation rules defined in the various validation controls. It is the server-side verification that the information is valid. Range Validation Determines whether the value of an element falls between a specific set of two values. Generally used for numeric types and dates, in range validation the first check is to confirm whether the value is parseable to the appropriate type, and the second check confirms whether it is between the minimum and maximum values set for the range. Regular Expression Validation Compares the value of an element against a regular expression. If the value fits the template established by the regular expression, then the validation is successful. Request Validation A process that determines whether the data being submitted by the client contains anything that is formatted in such a way that it poses some risk when displayed directly to another user (such as JavaScript to download viruses, etc.). Request validation is typically enabled by default, which means information containing HTML-looking tags will not be allowed to be processed on the server. Required Field Ensures that an element has a value. Having a value is typically defined as being set with a value other than the default, e.g., a string defaults to NULL, so any value, even an empty string, would be considered a value for this purpose. Server-side Validation This is the most important validation because it is the final check on the server that the data the system received from the user matches all necessary requirements. Unobtrusive Validation Unobtrusive validation is the jQuery approach to validation that is used with ASP.NET MVC. It enables the developer to use predefined (by the JavaScript library) custom attributes on an input element to provide validation information to the validation subsystem. The values in these attributes help the subsystem determine what rules need to be checked as well as provide feedback to the user about the state of the process. ValidateModel A method on the controller that validates the model against the data annotations in the model. Typically used with the ModelState that contains various sets of information about the model, including whether the validation was successful. Chapter 13 ASP.NET AJAX What you will learn in this chapter: How AJAX fits into the ASP.NET Framework Taking advantage of Web Forms controls to make AJAX calls Using a Web Forms control to show status to the user Creating REST web services to support AJAX Using jQuery to support AJAX in MVC Code Downloads for this Chapter: The wrox.com code downloads for this chapter are found at www.wrox.com/go/beginningaspnetforvisualstudio on the Download Code tab. The code is in the chapter 13 download and individually named according to the names throughout the chapter. When you are talking about web development and you hear the term AJAX, it is very rarely referring to the hero from Greek mythology. Instead, it refers to a web communications approach that started to become popular in 2005 and 2006, Asynchronous JavaScript and XML. The primary purpose of AJAX is to enable communications between the user's browser and the server without having to do a full page refresh. This communication is not outside the HTTP protocol, but instead uses HTTP to communicate smaller pieces of information within sections of the web page, rather than the default “whole page” approach. This is becoming increasingly common, as it provides an experience that seems more desktop-like because pieces of information on the page are refreshed based on some condition (timing, user action, and so on) without having to go through the whole page fetch that prevents users from being able to work in the browser while the request is managed. AJAX has evolved considerably, but the main changes are related to how the JavaScript calls are managed and how the information is formatted for transfer. You will be working with these new changes throughout the next couple of chapters as you use jQuery to handle the JavaScript, and JavaScript Object Notation (JSON) to define the format for data transference, rather than XML. In other words, you won't be really doing AJAX; instead you will be doing something like JQJN (jQuery with JSON, but since that does not really roll off the tongue we will respect tradition and keep calling it AJAX. Introducing the Concept of AJAX The whole point of AJAX is to support asynchronous communication. The traditional web page approach that you have worked with to this point has been synchronous in that once the request to the server was sent, the browser tends to stop what it is doing and wait for the server to respond with the next set of content. With the synchronous approach, once you click the submit button you are sitting there waiting for a response. The waiting for a response cannot be mitigated. The whole point of a web application is communication between clients and servers that are physically separated—almost always on different networks and possibly even different continents. However, what can be controlled is the stoppage of other work while you are waiting for the server to respond. This is where asynchronous communication comes into play. Clearly, if a more asynchronous approach to communication is possible, then it's also possible for users to avoid waiting for the server to respond and can instead continue working on the client side while the communications with the server happen in the background. Admittedly, this provides a more complicated communications model, as shown in Figure 13.1, but it provides a more fluid and positive experience for the user. Figure 13.1 Classic and asynchronous models Figure 13.1 demonstrates some of the differences between the two models. There are definitely some parts in common, such as page transitions in both approaches whereby the entire page is replaced with another page. However, some extra communication is going on from the web page, through jQuery, to the server, which then responds back to the jQuery call, with jQuery taking the response and updating the UI. This represents the asynchronous part of this communication— the request sent to the server that enables the user to continue working while the processing happens behind the scenes. There are differences between the responses provided by the server. As you have seen, in some cases the response to a request is the HTML for an entire page. You have also worked with user controls and partial views that create and manage smaller sets of HTML that can be inserted into the overall page. Calling such a section again—only this section and not the rest of the page—is one form of AJAX whereby the service returns an HTML snippet that replaces another set of HTML that is already present in the web page. A third type of response, and a second AJAX approach, is returning a single object to the page, much like you pass a model to an MVC view, and then the JavaScript takes that model and parses it into the HTML elements that hold each value. This approach is common in functionality such as a stock ticker, whereby an object that contains all the information being displayed is downloaded as needed and the old values are simply replaced with the new values. The HTML elements are not replaced during the call; the JavaScript functionality instead replaces the values within the element. SINGLE-PAGE APPLICATION There is an approach to building a web application, called single-page application (SPA), whereby there is one full page refresh on the entire site, and that is when you first visit the site to download the original content. All subsequent processing is handled as AJAX, whereby resources, including HTML, data, CSS, and other items, are downloaded and displayed as necessary. A single-page application provides the closest experience to a desktop application because there are no page transitions, so the period spent waiting for the request to complete is removed throughout the site. However, you pay for it by deploying a much larger set of information at the beginning, because not only do users have to download the traditional “first page,” they also have to download the libraries to manage all the transitional work, in essence spending extra time at the beginning to eliminate the time wasted while working on the page. One of the more complex factors when doing the development work for AJAX is debugging the process and ensuring that the information you are getting back from the server is correct. All of the debugging that you have been doing up to now has been in server-side code, or perhaps looking at the HTML source code that was returned by the server; however, asynchronous communications bring in a whole different set of complications because the snippets of information that are being returned by the server do not show up in any of these approaches. You will see some of these complications, and how they can be remediated, in more detail in the next few sections. F12 Developer Tools You may not be aware of this, but most of the available web browsers include a set of development tools that you can use to understand and debug the HTML that was sent to the browser. Google Chrome's Developer tools are shown in Figure 13.2. Figure 13.2 Google Chrome Developer tools These tools with Google Chrome enable you to review the HTML elements, see how the styles are applied, and allow you to make temporary changes to see how they may affect your site's layout. They also provide the capability to obtain useful information, such as total download size, time for download, and many other pieces of information that gives you a better understanding of the HTML output from the website and how the browser will interpret that information. Mozilla Firefox has its own version of developer tools, shown in Figure 13.3. The appearance is different, but much of the base information is the same, as the information that you are interested in about a web page is the same, regardless of the browser that you are using to parse and view the content. Figure 13.3 Mozilla Firefox Developer tools As you work through the next few chapters you'll be taking advantage of a third set of development tools, Internet Explorer's F12 Developer Tools. They are cunningly called F12 Tools because you can use the F12 function key to access them. If you do not have function keys on your keyboard, you can use the Tools menu in Internet Explorer. These same tools are available in Microsoft's Windows 10 Edge browser, the Windows 10 replacement for Internet Explorer. This next Try It Out will walk you through using F12 tools using your sample application. TRY IT OUT: Using F12 Development Tools This Try It Out walks through some of the features of Internet Explorer's F12 Developer Tools that you will be using as you work through the various AJAX enhancements you add to your site. 1. Ensure that Visual Studio is running and your RentMyWrox solution is open at the home page. Start the application in Debug, ensuring that you are using Internet Explorer to view your application. 2. Use your F12 key to open the Developer Tools. You can also open the tool by selecting Tools &cmdarr; F12 Developer Tools, as shown in Figure 13.4. Figure 13.4 Opening the F12 Developer Tools through the menu 3. Verify that you are on the DOM Explorer tab. Select the element that represents one of your products. You may have to expand areas on the left to find them; they will be in the
      with an id of “section.” It should look like Figure 13.5 when you have selected the item. Figure 13.5 Dom Explorer and the Styles tab 4. Click through the Styles, Computed, and Layout tabs in the pane on the right side of the tools and notice the information that is available in each tab. 5. Select the Network tab from the right side of the Developer Tools. You should get the screen shown in Figure 13.6. Figure 13.6 Network tab 6. Click the green arrow in the tab, and then click the Full Details link of one of the items listed on the front page. The page should change similarly to what is shown in Figure 13.7. Figure 13.7 Network tab recording requests How It Works The F12 Developer tools provide a lot of information about your application and its interaction with the client's browser. Not only do you get information about how the browser is interpreting the HTML that it received, it also provides access to the communications between the client and the user; all the work that used to happen behind the scenes is now available for your review and study. Once you opened the tools you went to the DOM Explorer. The DOM, or Document Object Model, is the HTML document that the browser is displaying. When in the DOM Explorer, you selected an HTML element and were then able to get information relevant to how that element is displayed. The first tab in the Dom Explorer is the Styles tab, as shown in Figure 13.8. Figure 13.8 DOM Explorer tab showing Styles Figure 13.8 shows how the styles are being applied to the selected item. In this case it is showing that the “body” CSS style is being applied as well as the “listtitle” class. If you go to the next tab, Computed, you will see all the styles that are cascading onto that particular element, as shown in Figure 13.9. Figure 13.9 DOM Explorer tab showing the Computed tab An interesting feature of these two areas is how they support changing the values of the various CSS elements. In the Styles tab you can turn off the feature by removing the check from the checkbox to the left of the name. You can also change a value by clicking on its display and then typing in the new value. The Computed tab displays the information differently in that it shows the entire list of CSS elements that the browser applies to the highlighted item. If you expand the item you can see from where the value that is currently being displayed came. You will be able to completely remove the style property through the checkbox next to the item; however, when you try to edit the value, you will find that you cannot do so from this default screen. Instead, expand each of the top-level items to see another box with the same value. This line represents the actual value that is available for editing and supports changing. When you change the value in the window, the display will immediately update the browser using the newly changed values. Adding new values is almost as easy in the Styles tab. Clicking on the row with the opening brace will bring up a new property for which you can fill out the value as desired. You can then see how the display updates with the change, giving you immediate feedback to any changes that you want to propagate back to the application code. Switching to the Layout tab gives you a look at the spacing for that element, as shown in Figure 13.10. Figure 13.10 DOM Explorer tab showing the Layout tab Here you can see how the Layout tab shows the pixel spacing that is being used by every factor of the element. The area in the center reflects the height and width of the element itself, in this case 750 pixels wide and 29.17 pixels high. The visualization in the tab then shows the current values for padding, border, and margin, all elements that you managed in the CSS. The last item displayed on this screen is the Offset. The Offset gives you the location of the element as it relates to the screen, based on all the other CSS that may have been set around the current element. All of this relates to the CSS box model that was discussed in Chapter 3. The DOM layout information is very useful in debugging your layout. The other tab that you clicked through, the Network tab, will be important as you start working with AJAX calls because it tracks all the requests from the client and all the responses from the server. Clicking the green arrow in the F12 menu starts the monitoring process, and once the monitoring process has been started all outgoing requests will be captured. The information that is captured and available to review in this section includes the entire request and the entire response, including body content, headers, and status code. Figure 13.11 shows what this could look like. Figure 13.11 Network tab showing the Request headers The lower set of tabs shown in Figure 13.11 are the various parts of the request/response that you now have visibility into: Request headers, Request body, Response headers, Response body, Cookies, Initiator, and Timings. The tabs that you will use most often during this process include Response Body, so that you can see the information returned by the server, and the Request Body and Headers, so that you can see what information the client asked for. The other activities in this chapter spend some time in the F12 Developer tool, and these windows in particular, ensuring that the information you are expecting is what is actually returned. Now that you will be able to evaluate the data that is being transferred back and forth between the client and server, you can get started adding AJAX into your application. Using ASP.NET AJAX in Web Forms The most obvious way to tell when a site and page are not using AJAX is by the flashing, or flickering, as a new page loads. AJAX enables you to avoid that by refreshing only a part of a page. Implementing AJAX within ASP.NET Web Forms requires some new server controls. The list of AJAX controls is shown in Figure 13.12. Figure 13.12 AJAX controls available in Visual Studio The Initial AJAX Experience The most important of these AJAX-specific controls is the UpdatePanel. The UpdatePanel is used to define the section of the page that will be updated through AJAX, with the items contained within the control being the refreshed area. While the UpdatePanel may be the most important control, it cannot work without access to a ScriptManager control on the page as well. You can have any number of UpdatePanel controls in your page, each containing the area of the screen that you wish to make asynchronous. Typically there will be information to display and a way to update the content, such as a button or a dropdown list set to automatically postback upon change. No matter how many UpdatePanels you have in the page, you only need one ScriptManager control because it is designed to hold the scripts for all the panels in that same page. The only time you do not need a ScriptManager on the same page as the UpdatePanel is when you have a ScriptManager in the referenced master page. However, while in that case you do not have to ensure that you include a ScriptManager on that particular page, you do need a ScriptManagerProxy control so that the local UpdatePanels will be able to work up the line to the ScriptManager in the hosting page. Figure 13.13 shows the links between all of these controls. Figure 13.13 UpdatePanel and ScriptManager relationship All of the discussion so far has been about having UpdatePanels on a page. You are not limited to putting them on pages, or in master pages; UpdatePanels can also be added to user controls. In the next Try It Out, you update the Notifications control that you built in Chapter 11 so that you can see other notifications in the same control, through paging, without having to postback the entire page. TRY IT OUT: Adding AJAX to Support Notification Display In this exercise you add the capability to move between notifications that are visible within the application. To do that, you add the necessary AJAX controls to the User Control and change the code-behind to allow the display of the appropriate notification. 1. Ensure that Visual Studio is running and your RentMyWrox solution is open. Open the Controls\NotificationsControl.ascx markup page. 2. Add the following code above the first label: 3. Add the following code after the second label. When completed, this markup page should look like Figure 13.14.
      Figure 13.14 Updated notifications control markup page 4. Open the code-behind. Add the following method below the Page_Load method. Much of the using statement is cut and pasted from the Page_Load method, with several additions. private void DisplayInformation() { hfNumberToSkip.Value =\ numberToSkip.ToString(); using (RentMyWroxContext context =\ new RentMyWroxContext()) { var notes =\ context.Notifications .Where(x =\> x.DisplayStartDate <=\ DateForDisplay.Value && x.DisplayEndDate >=\ DateForDisplay.Value); if (Display !=\ null && Display !=\ DisplayType.Both) { notes =\ notes.Where(x =\> x.IsAdminOnly =\=\ (Display =\=\ DisplayType.AdminOnly)); } lbPrevious.Visible =\ numberToSkip > 0; lbNext.Visible =\ numberToSkip !=\ notes.Count() -1; Notification note =\ notes.OrderByDescending(x =\> x.CreateDate) .Skip(numberToSkip).FirstOrDefault(); if (note !=\ null) { NotificationTitle.Text =\ note.Title; NotificationDetail.Text =\ note.Details; } } } 5. Add a private field above the Page_Load method: private int numberToSkip; 6. Update the Page_Load method to the following: protected void Page_Load(object sender, EventArgs e) { if (!DateForDisplay.HasValue) { DateForDisplay =\ DateTime.Now; } if (!IsPostBack) { numberToSkip =\ 0; DisplayInformation(); } else { numberToSkip =\ int.Parse(hfNumberToSkip.Value); } } 7. Add a new event handler for the Previous button: protected void Previous_Click(object sender, EventArgs e) { numberToSkip--; DisplayInformation(); } 8. Add a new event handler for the Next button: protected void Next_Click(object sender, EventArgs e) { numberToSkip++; DisplayInformation(); } 9. Run the application and go to \Admin. You should see a screen similar to the one shown in Figure 13.15. Figure 13.15 Rendered Notifications control 10. Click the Next link to see the content change without doing a full page refresh. How It Works You made two major changes in this activity. The first was setting up the Notifications control to support pagination, and the second was supporting that pagination without doing a full page reload. It was important to set up the pagination so that there would be some form of interaction that required a postback to the server; however, we don't spend much time going over either the markup or the code-behind to support the pagination, as these changes should be familiar from Chapter 10. The other change that you added to the markup was the addition of the ScriptManager and the UpdatePanel. The combination of these two items led to some additional scripts that were linked into the file: As you can see, these scripts reference “AJAX” (rather than the ScriptResource link), so you can tell that they were added because of the inclusion of the AJAX server controls. Additional code was also added at the point where the ScriptManager was added: The code added here makes a little more contextual sense when you look at the HTML that was added by the UpdatePanel control. Because the UpdatePanel acts as a container, the output from the control is simply a div wrapper as shown here:
      … content here …
      You can now see how the id of the
      is referenced in the _initialize method contained within the It also added a new element in the location where the Timer control was added in the markup: However, this new HTML element is set to not display; it is simply a placeholder for the content. This element is never actually made visible, it is instead used as a placeholder so that the JavaScript that is running in the application has a DOM reference. Using AJAX in MVC The pattern of different implementation approaches between ASP.NET Web Forms and ASP.NET MVC continues when you consider bringing AJAX into your application. Web Forms implements support around the use of various server controls. MVC takes a different approach through the use of HTML helpers that are designed to support AJAX calls. The most important of these, and the one that you will be using here, is the @Ajax.ActionLink helper. This helper is designed to create a link that when clicked, calls a controller, gets a partial view, and then puts what is returned from that partial view into a particular area on the page. While it seems complicated, it is pretty easy to work through. The first thing you need is an element on the page that you want the new content to use as a reference. You can consider this to be something like the UpdatePanel from Web Forms, but it is simply an HTML element (generally a
      or a ) that you can uniquely identify, such as the following:
      content to be replaced
      Once you know where the content will be going, you can build the Ajax.ActionLink. There are quite a few different method signatures for this ActionLink, with each needing different sets of information. The various items that are part of a method signature are listed in Table 13.2. Table 13.2 Potential Items for Populating an Ajax.ActionLink Variable Description Action The Action is the method that is to be called when the item is clicked. This action needs to return a partial view in order for this to work correctly. AjaxOptions The AjaxOptions object is used to set the expectations for what will happen when the action is taken. The available properties include the following: HttpMethod: Indicates the HTTP method (GET or POST) to be used while making an AJAX request Confirm: Used to display a message to the user in a confirmation dialogue. If the user selects OK, then the call to the server is made. OnBegin: Defines the name of the JavaScript function that will be called at the beginning of the request OnComplete: Specifies the name of the JavaScript function that will be called when the request is completed OnSuccess: Specifies the name of the JavaScript function that will be called when the request is successful OnFailure: Specifies the name of the JavaScript function that is called if the request fails LoadingElementId: While an AJAX request is being made, you can display a progress message or animation to the end user. The value given to this property identifies an element in the page. This AJAX helper only displays and hides this element. UpdateTargetId: Specifies the ID of a particular DOM element. This particular element will be populated with the HTML returned by the action method. InsertionMode: Defines how the new content will be used in the screen when the call is completed. The possible values are InsertAfter, InsertBefore, and Replace. Controller The name of the controller containing the action that will be responding to the request. You do not include the “Controller” part of the string. If the controller is not provided, the referenced action is on the same controller that created the current view. Route Values The route values are the items that need to be added into the route for use within the action. These items will be either URL values or query string values, depending upon your setup and need. Text to Display This item is the text that should be displayed—the words that appear on the screen such that clicking on them causes the call to the action. Thus, adding a section for which the content will be replaced as well as the part of the page that updates the section to be replaced would look like the following code:
      content to be replaced
      @AJAX.ActionLink("Click Me", "Details", "ClickMe", new { @Model.Id }, new AJAXOptions { UpdateTargetId =\ " elementtobeupdated", InsertionMode =\ InsertionMode.Replace, HttpMethod =\ "GET" }) The
      element contains the content that will be replaced. Both of these references, the element with which to interact and what to do with the content (in this case replace), are set within the AJAXOption class. If you compare this ActionLink to the Html.ActionLink that you worked with before, you will see that the only difference is this AJAXOption class; all the other parameters are the same as those you might use if you were building a simple ActionLink. All the other work that is going on throughout this whole process is also work that you have done before; you are just wrapping all of this work into AJAX-based functionality. You will see this all in the next Try It Out. TRY IT OUT: Add AJAX Calls to Add Items to the Shopping Cart In this activity you will add AJAX calls that add items to a shopping cart and display an updated summary of the cart. However, because there is not yet any functionality around the shopping cart, you will have to add all of the supporting functionality as you add the AJAX functionality. Be aware, there is a lot of this! 1. Ensure that Visual Studio is running and your RentMyWrox solution is open. Expand your Models folder. Add a new class called ShoppingCart. Add the using statements and properties listed here: using System; using System.ComponentModel.DataAnnotations; namespace RentMyWrox.Models { public class ShoppingCart { [Key] public int Id { get; set; } [Required] public Item Item { get; set; } [Required] public Guid UserId { get; set; } [Required] [Range(1,100)] public int Quantity { get; set; } [Required] public DateTime DateAdded { get; set; } } } 2. Add a new class, ShoppingCartSummary. Add the following properties: public int Quantity { get; set; } public double TotalValue { get; set;} 3. Add a new class, OrderDetail. Add the following properties with attributes: [Key] public int Id { get; set; } [Required] public Item Item { get; set; } [Required] [Range(1, 100)] public int Quantity { get; set; } public Double PricePaidEach { get; set; } 4. Add a new class, Order. Add the following properties and attributes: [Key] public int Id { get; set; } [Required] public Guid UserId { get; set; } public DateTime OrderDate { get; set; } public DateTime PickupDate { get; set; } public string HowPaid { get; set; } public List OrderDetails { get; set; } public double DiscountAmount { get; set; } 5. Open the Models\RentMyWroxContext file and add the following DbSets. When completed, your context file should look similar to Figure 13.25. public virtual DbSet ShoppingCarts { get; set; } public virtual DbSet Orders { get; set; } Figure 13.25 Updated context file 6. Build the solution (Build &cmdarr; Build Solution). Once complete, select Tools &cmdarr; NuGet Package Manager &cmdarr; Package Manager Console window. Type in the following line to create the new database migration and then click Enter: add-migration "order and shoppingcart" 7. Type in update-database to process the migration script and click Enter. 8. Right-click on the Views\Shared directory and add a new view named _ShoppingCartSummary using the settings shown in Figure 13.26. Figure 13.26 Configuration for a new partial view 9. Add the following to the new file. It should look like Figure 13.27 when completed. @model RentMyWrox.Models.ShoppingCartSummary @if(Model !=\ null && Model.Quantity > 0) { # in Cart: @Model.Quantity Value: @Model.TotalValue.ToString("C") } else { Your cart is empty } Figure 13.27 New partial view content 10. Right-click on the Controllers directory and add a new Empty Controller named ShoppingCartController. 11. Add the following using statement at the top of the page you just created. using RentMyWrox.Models; 12. Add a new private property inside the ShoppingCartController class as shown in the following example. This part of your page should look similar to Figure 13.28. private Guid UserID =\ Guid.Empty; Figure 13.28 New Controller with private variable 13. Add a new private method: private ShoppingCartSummary GetShoppingCartSummary(RentMyWroxContext context) { ShoppingCartSummary summary =\ new ShoppingCartSummary(); var cartList =\ context.ShoppingCarts.Where(x =\> x.UserId =\=\ UserID); if (cartList !=\ null && cartList.Count() > 0) { summary.TotalValue =\ cartList.Sum(x =\> x.Quantity * x.Item.Cost); summary.Quantity =\ cartList.Sum(x =\> x.Quantity); } return summary; } 14. Add a new action to the controller, above the method you just added: public ActionResult Index() { using(RentMyWroxContext context =\ new RentMyWroxContext()) { ShoppingCartSummary summary =\ GetShoppingCartSummary(context); return PartialView("_ShoppingCartSummary", summary); } } 15. Add a new method to the controller, above the private method: public ActionResult AddToCart(int id) { using (RentMyWroxContext context =\ new RentMyWroxContext()) { Item addedItem =\ context.Items.FirstOrDefault(x =\> x.Id =\=\ id); // now that we know it is a valid ID if (addedItem !=\ null) { // Check to see if this item was already added var sameItemInShoppingCart =\ context.ShoppingCarts .FirstOrDefault(x =\> x.Item.Id =\=\ id && x.UserId =\=\ UserID); if (sameItemInShoppingCart =\=\ null) { // if not already in cart then add it ShoppingCart sc =\ new ShoppingCart { Item =\ addedItem, UserId =\ UserID, Quantity =\ 1, DateAdded =\ DateTime.Now }; context.ShoppingCarts.Add(sc); } else { // increment the quantity of the existing shopping cart item sameItemInShoppingCart.Quantity++; } context.SaveChanges(); } ShoppingCartSummary summary =\ GetShoppingCartSummary(context); return PartialView("_ShoppingCartSummary", summary); } } 16. Right-click on your RentMyWrox project and select Manage NuGet Packages. Ensure that you are in the Online and Microsoft and .NET areas of the window and search for “unobtrusive.” Your results should be similar to those in Figure 13.29. Figure 13.29 Search results in NuGet Package Manager 17. Click the Install button in the tile named Microsoft jQuery Unobtrusive AJAX and accept any license agreements that may appear. 18. Once the package installation is complete, open your App_Start\BundleConfig.cs file and add the following line: bundles.Add(new ScriptBundle("~/bundles/jqueryajax").Include( "~/Scripts/jquery.unobtrusive-ajax*")); 19. Open your Views\Item\Index.cshtml file. Find the code Add to Cart and replace it with the following: @Ajax.ActionLink("Add to Cart", "AddToCart", "ShoppingCart", new { @item.Id }, new AJAXOptions { UpdateTargetId =\ "shoppingcartsummary", InsertionMode =\ InsertionMode.Replace, HttpMethod =\ "GET" }, new { @class =\ "inlinelink" }) 20. Make the same change in the Views\Item\Details.cshtml file, but use { @Model.Id } in place of { @item.Id }. The code should look like: @Ajax.ActionLink("Add to Cart", "AddToCart", "ShoppingCart", new { @Model.Id }, new AjaxOptions { UpdateTargetId =\ "shoppingcartsummary", InsertionMode =\ InsertionMode.Replace, HttpMethod =\ "GET", OnBegin =\ "fadeOutShoppingCartSummary", OnSuccess =\ "fadeInShoppingCartSummary" }, new { @class =\ "inlinelink" }) 21. Open your Views\Shared\_MVCLayout file. Locate your header and add the following code immediately after the logo image: @Html.Action("Index", "ShoppingCart") 22. At the bottom of the file you will see some @Scripts.Render commands. Add the following to that same area: @Scripts.Render("~/bundles/jqueryajax") 23. Open the Content\RentMyCrox.css file and add the following styles: .moveLeft { margin-left: 15px; } #shoppingcartsummary { vertical-align: middle; text-align:right; margin-left: 100px; } 24. Run the application and navigate to your home page. You should get a screen similar to the one shown in Figure 13.30. Figure 13.30 Screen with empty shopping cart 25. Click one of the Add to Cart links. The top part of your page should change without the entire page refreshing, as shown in Figure 13.31. Figure 13.31 Screen with updated shopping cart How It Works Many different things happened within this activity. The first few steps were building out the object model that you need to manage a shopping cart for the user. You built the model classes, attributing them as necessary, and then added them to the context so that the Entity Framework understands that there is an expectation that those items will be persisted. Two classes were not directly added to the context, ShoppingCartSummary and OrderDetail, but they were not added for different reasons. The ShoppingCartSummary class was not added because it is not intended to be something that is persisted; it is a class that is designed to pass information, in this case summary information, to the view. This approach is also known as using a ViewModel. The OrderDetail class was not added to the context file because, while it needs to be persisted, the class has no meaning outside of its parent Order. If you recall back to Order, that class has an OrderDetails property that contains a collection of OrderDetail objects. With the approach that you took, you can always access the OrderDetail from the Order, but you will not be able to access it directly because you don't have a property in the context. The following code is part of the content from the migration script that was created to get these model changes into the database: CreateTable( "dbo.OrderDetails", c =\> new { Id =\ c.Int(nullable: false, identity: true), Quantity =\ c.Int(nullable: false), PricePaidEach =\ c.Double(nullable: false), Item_Id =\ c.Int(nullable: false), Order_Id =\ c.Int(), }) .PrimaryKey(t =\> t.Id) .ForeignKey("dbo.Items", t =\> t.Item_Id, cascadeDelete: true) .ForeignKey("dbo.Orders", t =\> t.Order_Id) .Index(t =\> t.Item_Id) .Index(t =\> t.Order_Id); If you compare the content within the new object you will see that there are two items that do not appear in your model definition, the Item_Id and Order_Id properties. These table columns were added by the Entity Framework to manage the relationship to the Item table and the Order table respectively, and are what the Entity Framework uses to link to the various objects. Once the necessary work to get the new models into the application and database was completed, you were able to start working on the real AJAX implementation. The business need you are solving is the capability to add an item to the shopping cart and see an area on the page display some information about the shopping cart, including the number of items in the cart and their total value. The approach that you took to solve the business need was to use a partial view to manage the display of the content; the partial view is called directly in the initial page load, and then the HTML from that initial load of the partial view is replaced by the content of a response from an AJAX call to the server. This partial view was added to the top of the template page and will be visible on every MVC page in the application. The code that did this part is shown here: @Html.Action("Index", "ShoppingCart") There are two parts to note. The first is the Html.Action method that is calling the partial view that was output from the Index method in the ShoppingCartController. This was added to ensure that the content is added to the page as part of the initial page download. The second is that the element containing the output from the partial view has an id so that it can be identified. This identification is important so that the browser can find the element that will have its content replaced by the output from the AJAX call. You'll learn more about this later. The initial partial view that was being created is very simple. The controller action that performs the work is simple as well, and is shown here: public ActionResult Index() { using(RentMyWroxContext context =\ new RentMyWroxContext()) { ShoppingCartSummary summary =\ GetShoppingCartSummary(context); return PartialView("_ShoppingCartSummary", summary); } } private ShoppingCartSummary GetShoppingCartSummary(RentMyWroxContext context) { ShoppingCartSummary summary =\ new ShoppingCartSummary(); var cartList =\ context.ShoppingCarts.Where(x =\> x.UserId =\=\ UserID); if (cartList !=\ null && cartList.Count() > 0) { summary.TotalValue =\ cartList.Sum(x =\> x.Quantity * x.Item.Cost); summary.Quantity =\ cartList.Sum(x =\> x.Quantity); } return summary; } The Index method calls another method that finds all of the items in the ShoppingCart table for a particular user and then counts the items and totals the Costs to create a single class with both of those values, a ShoppingCartSummary. This ShoppingCartSummary is then passed to the partial view as the model that will be used for display. Using the class like this is why you didn't have to add it to the context; it is not data that should be directly persisted in the database. A note about the UserId: You are currently using an empty GUID, or a GUID that has zeroes (0s) in every position. This means that all of the items that you add to the shopping cart will be entered with a single value and will thus always be added and available. This is obviously not how you would want to go into production, but at this point you don't have users. You will change these when you get to the chapter on authentication, Chapter 15. Now that you have your partial view you can add the AJAX that will do all the work of sending information to the server, getting a response, and then replacing a part of the downloaded page with that response. You did not directly add any AJAX code; you instead used an AJAX helper as shown here: 1 @Ajax.ActionLink("Add to Cart", 2 "AddToCart", 3 "ShoppingCart", 4 new { @item.Id }, 5 new AJAXOptions 8 { 7 UpdateTargetId =\ "shoppingcartsummary", 8 InsertionMode =\ InsertionMode.Replace, 9 HttpMethod =\ "GET" // <-- HTTP method 10 }, 11 new { @class =\ "inlinelink" }) Lines 1–4 and line 11 of the preceding snippet build the link that becomes visible to the user, with line 1 adding the text that is being displayed, and lines 2, 3, and 4 adding the action, controller, and Url variables necessary for building the URL that will be called when the link is clicked. If this link is on an item with an Id of 10, the URL that will be built is \ShoppingCart\AddToCart\10. Line 11 assigns the CSS class to the element. All of those lines are common with the Html.ActionLink HTML helper. Lines 5–10 are what sets this apart from the HTML helper, the AJAXOptions. Table 13.2 included the definitions of the various properties, but in this case you are using only three of them: UpdateTargetId, InsertionMode, and HttpMethod. The UpdateTargetId property is used to define the DOM element that is going to be affected by this AJAX call. The string value that is assigned here, “shoppingcartsummary”, is the same as the Id from the element that surrounds the partial view. The next property, InsertionMode, defines what is going to happen with the results from the AJAX request; in this case it is going to replace the content of the element that was just identified. The other options are to insert the results either immediately before or immediately after the identified element. The HttpMethod defines the method to be used in the AJAX call back to the server. The HTML that was created by this control is shown here: Add to Cart If you remember back to the validation that you did in Chapter 12 you will see some commonalities, especially in the use of custom attributes to change the behavior of the item being clicked. If you removed all the attributes that are prefaced with data-ajax you would have a simple anchor element that causes a complete postback and page replacement. However, the addition of the attributes turns the click into an event that the jQuery Unobtrusive library is able to parse and understand. You can see the attributes in this element refer almost directly back to the values that you set in the AJAXOptions. In order to get this functionality you had to add the new NuGet package, to get the JavaScript libraries that support this approach. You then needed to add the JavaScript libraries that were downloaded into your Scripts directory to a bundle, which was then added to the page. This ensured that the scripts you added to the project were downloaded to the client so that they were available for the client to use when conducting the AJAX calls. Once the anchor element was created, a click on the visible text would fire off an asynchronous call to the server. Unlike the AJAX call that was performed by the Web Forms control, this is a GET call that contains no request body. This means that the size of the request is minimal. Compare that to the POST request that contained every form value on the page, including ViewState, that was sent by the Web Forms control. Just as with the Web Forms call, the content being returned is minimal, as shown in Figure 13.32. Figure 13.32 F12 Developer Tool showing the response body The most complicated code that you had to add is the action that responds to this AJAX request. The process happening within this code is as follows: 1. The URL is parsed to identify the Id of the item being added to the shopping cart. 2. The database is queried to ensure that the Id being sent is valid. 3. The ShoppingCart collection is then queried to determine whether there is already an item in the shopping cart for this user that has this same Id. If so, this means that the item was already added to the cart. Rather than add the item again, thus loading two rows into the database with the same item, when the item is already in the shopping cart the action merely increments the quantity. 4. If there is not a matching ShoppingCart with that Id, then a new one is created and added to the context's collection. 5. Changes to the database are saved. 6. A call is made to determine the ShoppingCartSummary. 7. The ShoppingCartSummary is returned to the same partial view that was used when creating the initial page load, thus replacing the content with the output from a different action. 8. The partial view is rendered into HTML and then returned to the client, as shown in Figure 13.32. In this activity you were able to take advantage of the built in ASP.NET MVC support for AJAX helpers that tie into the Unobtrusive JavaScript library to allow the simple coding to support AJAX-based requests. In both of the instances that you have worked through in this chapter you have been sending HTML content back and forth and replacing preexisting content with the new information. There are other approaches than sending HTML when doing work with AJAX. In the next section, you will examine one of those other approaches. Using Web Services in AJAX Websites Sending HTML content through AJAX is a simple approach that requires minimal work on both the client and the server. However, there is redundancy in the information that is being transmitted back to the client. In the last activity, you created an AJAX call that returned an abbreviated set of information, shown here again: # in Cart: 2Value: $50.00 This is a total of almost 70 characters that would be downloaded every time a user added an item to the shopping cart. However, only six characters are actually important: the number of items (two in this case) and the value (50.00). You can make a change that will decrease the typical response size of adding an item to the shopping cart by a significant amount. While this may not seem important in the context of this application, imagine what this could mean to a company such as Amazon that handles thousands of these responses a minute; it could lead to a substantial savings in bandwidth usage, which could directly affect the profitability of the company. Making this change requires that rather than download the HTML, you instead download the values that need to be displayed. This can be done by converting the information that you need, in this case the ShoppingCartSummary object, into a JSON string and returning that string, which is shown here in its default format: {"Quantity":2,"TotalValue":50} This transfer set is 30 characters, but you can modify it by shortening the property names on the class being converted to JSON to smaller property names, such as Qty and Val, which would remove an additional 12 characters from the download. The other change that you have to make is related to how you handle the item coming down. When using the HTML approach, you simply replace existing content with a new set of content. Obviously, you cannot take that same approach here because there is a lot of intermediate content that you will want to maintain, and instead just replace bits and pieces of the content. But before getting into how you will manage that information once it gets to the client, first you will learn how to get an object from the server, rather than HTML snippets. The most common approach to getting an object from the server is through a web service. Technically, a web service is generally defined as a method of communication between two computers over a network. However, that would mean that everything you have done so far has been based on web services because you are building a system that enables one computer, the client, to communicate with another computer, the server. That is why we are using a more specific definition whereby a web service is a method of communicating object information between two computers. This object is not HTML, but rather a serialized version of an object. SERIALIZATION AND DESERIALIZATION Serialization is the process of translating an object into a transferrable format. It is usually understood to mean the translation of an object into a string such that the string can be converted back into an object at the end of the transference. This is especially important when you are looking at web communications because the protocol is based upon sending strings back and forth between the client and the server. When an object is serialized, the serializer (the software that does the work) generally goes through all the properties of the object and converts them into a series of key/value pairs, where the key is the name of the property and the value is the string version of the property value. If the property is not a simple type, then the serializer will serialize the property value into its own set of key/value pairs. The serializer does this same work for every property on the object, going as deeply as necessary into the object to get to the base values. In deserialization the reverse happens. The object is constructed, then the list of key/value pairs is gone through and the string is parsed as necessary to get the appropriate type. The same happens with any complex types that are properties on the object; those auxiliary key/value pairs are gone through and those subordinate objects are created and the values populated. In the current .NET environment there are three different ways to create a web service: Windows Communication Foundation (WCF), ASP.NET Web API, and ASP.NET MVC. Each of these approaches differs in terms of how it works and what it tends to be used for within a development project. WCF is a complete framework for supporting communications between different computers. It provides a huge set of functionality and it supports many different protocols, including protocols other than HTTP. It is Microsoft's enterprise-level area of the .NET Framework that supports communication. As you can guess, there are a lot of different capabilities within WCF, and in some cases using WCF is mission critical. This is not one of those cases. The next approach to creating a web service in .NET is through the use of ASP.NET Web API. Web API is a much slimmer web service management system; it supports only the creation of REST services, whereas WCF supports the creation of many different types of services. Using Web API enables developers to build URLs that are very similar to the URLs that you created when working with ASP.NET MVC. Speaking of ASP.NET MVC, you can also create web services in MVC through actions on a controller. You can change an MVC action into a web service by changing the return value. Most of the actions that you have worked with up to this point have returned some type of view, either full or partial. However, you can just as easily return a serialized object rather than HTML from a View, as shown here: public ActionResult Details(int id) { using (RentMyWroxContext context =\ new RentMyWroxContext()) { Item item =\ context.Items.FirstOrDefault(x =\> x.Id =\=\ id); return Json(item, JsonRequestBehavior.AllowGet); } } This code snippet should be familiar; the only difference is rather than return View(item), the method instead returns the results of a method that converts an object into JSON. Also, the URL to get this object would be \Item\Details\5 to get an Item with an Id of 5. Web API also uses a controller and action process, with routing, just as MVC does. However, the naming process is different, as the URL and HTTP methods are fully integrated so that the intermediate descriptor that you tend to see in MVC URLs is left out. Thus, in a Web API application, the default URL that you would use is \Item\5 because a GET against that URL means that you want to see the item. A PUT or a POST to that URL would be either creating or updating an Item object. Web API is able to avoid this intermediate descriptor because it does not have to worry about creating HTML. If you look at MVC you will see that this intermediate descriptor is generally more about the view that you will be using by default (through convention) than it is anything else; thus the \Item\Details\5 call would, by default, expect to call an Action named Details and return a view that is also named Details. Web API doesn't have to worry about that, so it takes a different approach. The following snippet shows a complete controller that covers all of the available methods for an object, in this case an Item: public class ItemsController : ApiController { // GET api/items public IEnumerable Get() { using (RentMyWroxContent context =\ new RentMyWroxContent()) { return context.Items.OrderBy(x =\> x.Name); } } // GET api/items/5 public Item Get(int id) { using (RentMyWroxContent context =\ new RentMyWroxContent()) { return context.Items.FirstOrDefault(x =\> x.Id =\=\ id); } } // POST api/item public void Post(Item item) { using (RentMyWroxContent context =\ new RentMyWroxContent()) { var savedItem =\ context.Items.Add(item); context.SaveChanges(); } } // PUT api/items/5 public void Put(int id, [FormValues] values) { using (RentMyWroxContent context =\ new RentMyWroxContent()) { var item =\ context.Items.FirstOrDefault(x =\> x.Id =\=\ id); TryUpdateModel(item); context.SaveChanges(); } } // DELETE api/items/5 public void Delete(int id) { using (RentMyWroxContent context =\ new RentMyWroxContent()) { var item =\ context.Items.FirstOrDefault(x =\> x.Id =\=\ id); if (item !=\ null) { context.Items.Remove(item); context.SaveChanges(); } } } } One of the Web API default features that should leap out at you is how the names of the Actions correspond to an HTTP method. If you look at the comments, you can see how each of these methods relates directly to the typical action that you would take on an object: Get a list of objects. See a particular object. Create a new object. Update an existing object. Delete an object. Thus, anything you would want to do with an object would be available on that controller. Another difference between ASP.NET MVC and ASP.NET Web API is that using Web API to manage the process allows some flexibility out of the box. Because Web API is built solely to provide serialized objects, it handles the serialization process for you. There are multiple formats in which this object can be returned, with the most common being JSON and XML. When you are building this in ASP.NET MVC, you define the format of the item being returned. That means if you want to support both JSON and XML formats so that different requesters will get their preferred format, you have to code for both approaches. When you do the same in Web API, you don't need to worry about serializing into the appropriate format; Web API takes care of that for you based on the request headers; all you have to worry about is returning the correct object. While Web API offers additional features that are not supported by default through MVC, most of those features do not matter in this case. Since you, as the site developer, are the one who is going to be consuming the services, a lot of the flexibility offered by Web API (and WCF for that matter) are not needed; the code that you will be writing on both the client and the server simply need to be able to talk together. In the next activity, you will be writing a web service that provides information to your client. TRY IT OUT: Add the Store Hours to Your Application There is a popular feature on many brick-and-mortar store websites that informs visitors whether the store is open, and if not when it will next be open. In this activity you create a web service that returns such information as a serialized JSON object. 1. Ensure that Visual Studio is running and your RentMyWrox solution is open. 2. Expand your Models folder. Add a new class called StoreOpen. Add the properties shown here: public bool IsStoreOpenNow { get; set; } public string Message { get; set; } 3. Right-click on your Controllers folder and add a new Empty MVC controller named StoreOpenController. 4. Fill out the Index action as shown here: // GET: StoreOpen public ActionResult Index() { StoreOpen results =\ new StoreOpen(); DateTime now =\ DateTime.Now; if (now.DayOfWeek =\=\ DayOfWeek.Sunday || (now.DayOfWeek =\=\ DayOfWeek.Saturday && now.TimeOfDay > new TimeSpan(18,0,0))) { results.IsStoreOpenNow =\ false; results.Message =\ "We open Monday at 9:00 am"; } else if (now.TimeOfDay >=\ new TimeSpan(9,0,0) && now.TimeOfDay <=\ new TimeSpan(18,0,0)) { results.IsStoreOpenNow =\ true; TimeSpan difference =\ new TimeSpan(18,0,0) - now.TimeOfDay; results.Message =\ string.Format("We close in {0} hours and {1} minutes", difference.Hours, difference.Minutes); } else if (now.TimeOfDay <=\ new TimeSpan(9,0,0)) { results.IsStoreOpenNow =\ false; results.Message =\ "We will open at 9:00 am"; } else { results.IsStoreOpenNow =\ false; results.Message =\ "We will open tomorrow at 9:00 am"; } return Json(results, JsonRequestBehavior.AllowGet); } 5. Run the application. Go to \StoreOpen. You should be prompted to download a file as shown in Figure 13.33. Figure 13.33 Downloading the StoreOpen.json file 6. Select Open, and if necessary choose to view the file in Notepad. You should get a response similar to the following snippet (your values may differ based on day and time): {"IsStoreOpenNow":false,"Message":"We open Monday at 9:00 am"} How It Works You created a new model and controller just as you have done multiple times; nothing unusual about those steps. The Index action that you created in this controller constructs a new StoreOpen object and then populates the values based on the day and time of the request. It is assumed that the store is open Monday through Saturday from 9:00 a.m. to 6:00 p.m. The logic checks for four different possibilities: After closing time on Saturday and Sunday the user gets a message that the store opens Monday morning. Between opening and closing times Monday through Saturday the user gets a message displaying the amount of time until the store closes. If it is after closing time but before midnight, then the user gets a message saying the store opens tomorrow morning. If it is after midnight but before opening time, then the user gets a message saying the store opens at 9:00 a.m. All of this logic is used to populate the StoreOpen object that is returned to the user. The object is returned through the Json method, which serializes the object that was passed in as a parameter. The second parameter in the method is a JsonRequestBehavior. There are two potential behaviors, AllowGet and DenyGet. The default behavior is to disallow the return of a JSON object through a GET request. The reason why the default turns off the capability to retrieve a JSON object through a GET is because it is important for the developer to remember that information being passed through this approach is not secure, as demonstrated by the fact that you were able to download and open a file containing the JSON information. This default behavior forces you, as the developer, to consider the data you are exposing over the HTTP GET method and then make a conscious decision that it is OK to publicize. It is always OK to return JSON data from a POST or PUT method request because those HTTP verbs always assume that you have created or changed some information. In this activity you created a controller and an action that returned a JSONserialized object. What can you do with this object? JQuery in AJAX Creating a web service enables you to download information to a client application. However, at this point, the information is simply a string that represents an object. Using this item to affect the UI is where the power of jQuery comes into play. The next chapter provides a more in-depth look at the functionality available with jQuery. This section goes over only those parts that are necessary to support an object-based AJAX call. One part in particular is necessary when using jQuery in AJAX, and that is the code that makes the server call. The jQuery method used to make a GET request that expects to get JSON back is the getJSON method, shown here: $.getJSON("url to call") One of the most important things that delineates jQuery is the $. This isn't a reference to all the money you can make if you are good at jQuery; it is similar to a namespace that defines the action that it precedes as being part of the jQuery library. The $ can be confusing. In the previous example, it is used to represent jQuery mostly as a namespace. However, it is also used to identify a selection, such as the following: $("#someDOMelement").html("some content"); In this example the $() represents a way to identify some content in the DOM, in this case an element with the id of “someDOMelement”. The selector acts just like the selectors in CSS, so in this case you can tell that it is an id you are trying to match because of the “#” that is part of the selection identifier. The only way to differentiate the usage is whether the $ immediately precedes a set of parentheses containing a selector or whether it precedes a period. When it precedes the period you know that the $ refers to a core method, in this case getJSON. What is not clear from the preceding usage is how to work with the data that is returned from the call. The getJSON method has several different callbacks that you can use to manage the outcome of the call. The full definition is shown here: $.getJSON("url to call") .done(function (data) {}) .failure() .always(); These all take advantage of jQuery's Promise Framework (more on that in the next chapter), and you can actually chain as many of the different callbacks together as you need—whether it is multiple instances of the same callback, such as done, or one of each as you need it. The done callback defines the work that you want done on the JSON object returned from the call. This work can be done in an anonymous function or in a well-defined function. The failure callback is designed to allow the client to manage problems in the request. If the server returned a server error, for example, the failure callback would be processed, as opposed to the done callback. The always callback is called every time the request is completed, whether it was a success and went through the done callback or whether it failed and went through the failure callback. In this next activity you create jQuery code that will both call the server and manipulate items in the DOM. This means you will see both approaches that use the $ preface. TRY IT OUT: Calling the Server and Displaying Retrieved Information In this activity you make the call to the server to get the information regarding store hours that you built in the last activity. After you download the information you will then display it in the UI. 1. Ensure that Visual Studio is running and your RentMyWrox solution is open. 2. Open your Views\Shared\_MVCLayout.cshtml file. In the LeftNavigation section, above the request for “Notifications”, add the following line. When you are done this section should look like Figure 13.34.
      Figure 13.34 Addition of area to display store hours message 3. Near the bottom of the page are some script elements containing the datepicker. Add the following within those script elements. When you are done it should look like Figure 13.35. function getStoreHours() { $.getJSON("/StoreOpen") .done(function (data) { var message =\ data.Message; $("#storeHoursMessage").html(message); $("#storeHoursMessage").removeClass(); if (data.IsStoreOpenNow =\=\ false) { $("#storeHoursMessage").addClass("storeClosed"); } else { $("#storeHoursMessage").addClass("storeOpen"); } setTimeout(function () { getStoreHours(); }, 20000); }); }; $(document).ready(function () { getStoreHours(); }); Figure 13.35 JavaScript added to the page 4. Add the following styles to the RentMyWrox.css file: .storeOpen { background-color:green; color:white; text-align:center; font-size: small; font-weight: bold; width:125px; } .storeClosed { background-color:#F8B6C9; color:red; text-align:center; font-size: small; font-weight: bold; width:125px; } 5. Run the application and go to the home page. You should see a new addition on the left section of the screen. The content that you see will vary according to the day and time when you are running the app. Figure 13.36 shows the output on a Sunday. Figure 13.36 Running the new changes How It Works In this activity you performed two main activities. The first was adding some new HTML, including a new element to your left menu and a couple of new styles. The new element will be used to store content that comes from the server, while the styles will be used to display the message appropriately. Unlike the previous AJAX approach, however, you did not fill the content from the server; these
      tags simply act as containers for when you make your independent server calls. The second activity was to add some JavaScript code. In summary, the JavaScript that you added took the following steps: 1. Called the server using the URL for the controller that you added in the last exercise 2. Took the information that comes back and puts the message into the
      tags 3. Evaluated the IsStoreOpenNow property to determine which style to apply to the message: either a style for when the store is open or a different style if the store is closed 4. Set a timer to query the server again in 20 seconds so that the value being displayed is frequently refreshed Now consider how each step was performed. Two different items were added to the page. The first was a function, getStoreHours. The second was code that is run as soon as the engine got to the line. This code is shown again here: $(document).ready(function () { getStoreHours(); }); The $() indicates that the content is a selector. In this case, the selector is the document, or the containing DOM. You are telling the browser that you want to run the anonymous function when the document is ready, or was finished loading into the browser. This processing occurs simultaneously with the loading of images and other downloadable items, after the document is processed. The anonymous function that you are running has one line, a call to the getStoreHours function. In a nutshell, this code runs the other method as soon as the document is loaded. The getStoreHours JavaScript function performs the work of making the call to the server and then updating the UI based on the results. This code is repeated here with line numbers for easier reference: 1 function getStoreHours() { 2 $.getJSON("/StoreOpen") 3 .done(function (data) { 4 var message =\ data.Message; 5 $("#storeHoursMessage").html(message); 6 $("#storeHoursMessage").removeClass(); 7 if (data.IsStoreOpenNow =\=\ false) 8 { 9 $("#storeHoursMessage").addClass("storeClosed"); 10 } 11 else { 12 $("#storeHoursMessage").addClass("storeOpen"); 13 } 14 setTimeout(function () { 15 getStoreHours(); 16 }, 20000); 17 }); 18 }; Line #1 is the function definition. Note that there is no defined return type such as you may be used to with C#; instead this simply delineates a set of code that needs to be run. The contents of the function is a getJSON method that fetches a set of data from the URL defined in line 2. Once the data is collected, the done callback is used to handle the data, as shown by the anonymous function defined on line 3. The data that is returned from the call is passed into the anonymous function where it is available as if it were a standard object (which it is, but more on that in the next chapter!). Lines 4 and 5 are getting a specific value, the Message property, from the returned data and setting the html content of the element that has an id of “storeHoursMessage”, which coincidentally enough is the
      element that you added in the left navigation panel. After setting the message, line 6 clears the class that is currently assigned to that element. It is done this way because it is simpler to just remove the class and add a new class than to evaluate the class value to ensure that it is correct. You cleared the class value because the next few lines of the method are setting the appropriate style based on the value of the IsStoreOpenNow property. If the store is open, the green background with white text style will be displayed, highlighting that the store is open and indicating how long before it closes. The last part of the method, in lines 14−16, uses the setTimeout method that is built into the window, or browser. This method acts like a timer that sets an amount of milliseconds before it goes off and an anonymous function that will be run when the timer expires. In this case the anonymous function is running the getStoreHours function, thus ensuring that every 20 seconds the method is called again so that the server is queried and the response is redisplayed. One thing that you need to understand is that while you added this logic to an ASP.NET MVC view, you could just as easily have added the exact same information to a page that was created from a Web Forms response— especially because none of the information being displayed was added at the server, it was all defined based on the results of the call to the web service. Adding this same functionality would require the exact same client-side steps, but in an .aspx (or .ascx) page rather than the .cshtml page. Hand-coding AJAX calls is certainly more work that using either Web Forms server controls or MVC AJAX helpers, but the capability to use the jQuery library in your ASP.NET application makes writing AJAX code in JavaScript very straightforward. Obviously there are more complex approaches to performing AJAX interactions, such as performing a POST with a populated object that is being passed into the action, but those are more differences in degree as opposed to significantly more work; jQuery makes your job easy, just like the other helpers you used previously. Practical AJAX Tips The following tips will help you get the most out of using AJAX in your website: UpdatePanels may seem like functionality that you would want to add everywhere, but use them only when needed and not as a default approach. There is still a lot of communication going to the server, so using multiple UpdatePanels on a data entry page may be problematic, as every form element is submitted multiple times. It also means that you have to ensure when you write your code-behind that you do not reference those properties in such a way that these multiple posts cause a problem, perhaps by saving incomplete information to the database. When you use an UpdatePanel you should also use an UpdateProgress control as well. This helps your users understand that something is changing on the screen. It's especially important when the change is happening because of a user request. Because the page is not being posted back to the server, it is more difficult to determine when a button click did anything, as all the processing is happening in the background and is not automatically shown in the UI. This is where UpdateProgress controls help; they provide visual cues to the changes. When working with AJAX in an MVC application, using AJAX helpers is a time-saver. These helpers demonstrate the use of the Unobtrusive JavaScript libraries in support of AJAX. While this chapter described how to write AJAX interaction using JavaScript and jQuery, you could just as easily have added the appropriate attributes onto the element and included the Unobtrusive JavaScript libraries to get an AJAX experience. When you consider your approach to getting asynchronous information from the server, you have two real options. The first is bringing down HTML snippets that you can place into various areas of the UI. This is the solution that is used by both of the built-in AJAX supports. However, your particular need may steer you away from this approach and toward one in which it makes more sense to download the elements once and then update the values within the elements. Both of these are equally valid approaches; you need to weigh the extra effort of building the second approach against the limitations of the first approach. Summary ASP.NET's support of AJAX makes it much easier to implement AJAX within your application. Whether you are implementing an AJAX approach in Web Forms or MVC, there is built-in functionality that makes your implementation process much cleaner and simpler. The capability to customize the AJAX process using jQuery and JavaScript makes the development process more uniform and supportable. To use AJAX in Web Forms requires several different server controls. The most important control is the UpdatePanel, which contains the content that will be replaced during the AJAX call. The UpdatePanel is unusable unless there is also a ScriptManager server control. The ScriptManager is used to manage the JavaScript files that are downloaded to the client in order to support the client-side firing of the AJAX call. If you are working in ASP.NET MVC and need to use AJAX then you will likely take advantage of the AJAX helpers that do the work of formatting the HTML so that the jQuery Unobtrusive AJAX library will properly work. The helper enables you to determine which HTML element will be affected by the results of a call. Typically this approach is used to display a partial view. If the default helpers and server controls do not provide the behavior that you are looking for, you can still use jQuery and JavaScript to perform any kind of server call for any kind of response type with which you can pretty much do anything in the browser. This is certainly more effort than using one of the other approaches, but it is also completely customizable to solve your needs. Exercises 1. What would you have to do differently if you wanted to put the functionality from the last activity, for store hours, on an ASP.NET Web Forms page? 2. What steps would you need to take if you wanted to implement the Unobtrusive AJAX jQuery library in an ASP.NET Web Form page? 3. What are some of the challenges with adding a timer to a web page for which the results from the call update a section of the page? What You Learned in This Chapter AJAX AJAX stands for Asynchronous JavaScript and XML and refers to a design where the browser does not necessarily replace the entire page every time there is a need for information from the server. The browser instead replaces a part of the page in such a way that the user can continue work. AJAX.ActionLink A helper method in ASP.NET MVC that builds out an element so that it can take advantage of the Unobtrusive AJAX library. This method helps the developer easily implement an AJAX approach to replacing HTML content. AJAXOptions A class that manages all the configuration of the AJAX part of the AJAX.ActionLink. There is a direct relationship between the properties in the class and the output in the element that is used for Unobtrusive AJAX. AsyncPostBackTrigger A setting on the UpdatePanel whereby you link a clientside action to the UpdatePanel and define that action as the one that will cause an asynchronous postback ContentTemplate An UpdatePanel does not actually hold the content that is going to be updated. It instead contains a ContentTemplate, which is the attribute containing the actual elements that are going to be updated. Deserialization The process of turning a string value back into the object that it represents F12 Developer Tools A toolkit that ships with Microsoft Internet Explorer. It provides developers with a lot of support, including CSS and styling support, and request and response information and details, including headers and body, and the speed of the server response. getJSON A utility method in jQuery that handles a GET call to a web service. By definition, the response that comes back from the server is expected to be in JSON format. Json method A method available on an ASP.NET MVC controller. It takes in an object and serializes it as it returns the serialized object back to the client. Mozilla Firefox Developer Tools Like the F12 Developer tools that ship with Internet Explorer, the Mozilla Firefox Developer Tools are available with every Mozilla Firefox installation. They provide much of the same support as the F12 tools. PostBackTrigger ScriptManager This is linked to an UpdatePanel, but rather than cause a partial page callback it instead causes a full page postback, just as if AJAX were not being used at all. A required part of using AJAX in ASP.NET Web Forms. Necessary whenever an UpdatePanel is present, it holds the links to the supporting JavaScript files. ScriptManagerProxy Enables you to put the ScriptManager on a master page and then handles the linking from an UpdatePanel on the content page to the ScriptManager on the master page. Serialization The conversion of an object to a string representation. This is necessary so that you can transfer the object over the Internet. Single-Page Application A single-page application is an approach to building a website whereby the user downloads the initial page and all of the JavaScript files necessary to manage all interaction between the user and the server. There is no full page request; all updates happen using AJAX. Unobtrusive AJAX A JavaScript and jQuery library that allows for the management of AJAX requirements through attribution on the affected elements. It eliminates much of the custom scripting that generally has to be done when using AJAX. UpdatePanel An ASP.NET Web Forms server control that defines a particular set of content as being available for replacement through an AJAX call. The content to be replaced is stored in the ContentTemplate. UpdateProgress This server control provides user feedback when an AJAX call is being processed. This is especially important when the user clicks a button and expects something to happen. If the effect were a full-page fetch, the user would know something is happening because a new page would be downloading; but because it is an asynchronous request, the updateProgress control provides that information. Web Service An approach in which the server handles a request and sends information back to the client. Technically a web service is just a way to allow two computers to communicate over the network, but we have modified that definition to mean the transmission of an object over the network. Chapter 14 jQuery What you will learn in this chapter: The history of jQuery and why it is so important Features available in jQuery Using jQuery to work within your page Deeper integration of the jQuery framework Code Downloads for this Chapter: The wrox.com code downloads for this chapter are found at www.wrox.com/go/beginningaspnetforvisualstudio on the Download Code tab. The code is in the chapter 14 download and individually named according to the names throughout the chapter. Earlier in the book, you were concentrating on other areas of the application that were not specific to jQuery, but you have come across some mentions of it in bits and pieces. There have been examples using jQuery to support client-side validation as well as support AJAX calls and displaying the results on the page. A jQuery UI widget was also pulled into the application so that you could invoke a date picker. This should give you an idea of how jQuery ends up being intertwined throughout the client side of a website. This chapter clarifies why jQuery is so prevalent in modern web development, and provides more exposure to the functionality that is available within the jQuery libraries. An Introduction to JQuery jQuery is a JavaScript library that best estimates say is now used in about two out of three websites on the Internet. It is called a JavaScript library because it is completely written in JavaScript. This enables jQuery to be used within a JavaScript method just like a core JavaScript method; it is simply an additional set of objects and methods that are made available in JavaScript, much like how the Entity Framework adds a separate set of functionality to .NET. In order to understand the history of jQuery, you need to understand the evolution of JavaScript. Early JavaScript Now on version 6, released in June 2015, JavaScript was first included in Netscape Navigator 2, shipped in late 1995. By 1996, Microsoft started including JavaScript in Internet Explorer, starting with IE 3. At this point, both implementations were different, which made it difficult to provide a dynamic experience across both browsers. This differentiation lead to those dreaded phrases such as “best viewed in Internet Explorer” or “best viewed in Netscape.” Even though the language itself was standardized in 1997 when Ecma International (an international standards organization) published ECMAScript, which was based on JavaScript, that did not mean that the same scripts would work the same way with different browsers. By itself, a JavaScript method is pointless; it only becomes useful when it is somehow interacting with the user. This was another major problem—each of the major browser companies had built its own enhancements to the DOM, and these enhancements were what JavaScript had to interact with, so different approaches to defining the DOM meant different code to interact with each. These DOM definitions were not part of the Ecma standardizations; they were defined in a separate standardization effort by the W3C. HTML 5, the newest version of HTML, was updated to better define the DOM and its interaction points, and it marks the best attempt to offer standardization across DOM elements so that the JavaScript standards will be able to consistently, and in a standard fashion, identify and interact with DOM elements regardless of the browser being used. Even as browsers moved toward implementing both JavaScript and the DOM in a standardized fashion, there were some problems with the universal adoption of JavaScript. The language is sufficiently different from other common development languages that it's necessary to learn a second language when working with web applications. Because JavaScript typically relies on a runtime environment, such as the web browser, its behavior is still not completely 100% consistent between each environment. It is necessary to include some processing code (JavaScript) within the display code (HTML) to ensure that they work together. The mixing of processing code and display code is the same problem that led to ASP.NET being created to replace classic ASP. Whereas ASP.NET Web Forms are a much cleaner approach than Classic ASP, they still had their own sets of problems related to the linking of processing and display, which led to the development of ASP.NET MVC. JavaScript has the same problem. In order for JavaScript to be the most efficient, it had to be bound to HTML elements so that events from the element would lead to running a set of JavaScript. This means that not only does the JavaScript implementation have to understand the DOM, the DOM has to understand the JavaScript method(s). jQuery's Role Released in 2006, jQuery is a library that was introduced to solve all three of the aforementioned problems. While at its core jQuery is a DOM-manipulation library, it also provides a completely new way to manage events and event handling by providing event assignment and event callback definition in a single step in a single location. That means that using the jQuery library makes it easy to add event handlers to the DOM by using JavaScript, rather than adding HTML event attributes throughout the page to call JavaScript functions. This completely eliminates the need for the circular reference, instead allowing the display code to be ignorant of the processing code. Another advantage of jQuery is the level of abstraction that it offers compared to JavaScript. Much of the code that developers were writing on the client side was related to selecting a part of the screen and doing something with that area. jQuery provides a way to do the same thing while enabling the developer to avoid JavaScript for much of the work—instead, for example, using a one-line jQuery command to take the place of 15 lines of JavaScript. This means that developers do not necessarily have to become experts in JavaScript to be effective UI developers; understanding a few different commands in jQuery enables them to get much of their work done. The last problem mentioned regarding JavaScript usage in the browser involves cross-browser incompatibilities. jQuery understands that the various JavaScript engines from the major browsers can be different, so as part of the abstraction just mentioned, the jQuery library handles all of these incompatibilities when it builds out its interfaces. This means that the functionality offered by jQuery is standardized across browsers in a way that straight JavaScript code is not. The core jQuery library supports a lot of features: DOM element selection DOM element manipulation AJAX Events Animations and other effects Asynchronous processing (separate from AJAX) Data, especially JSON, parsing Additional plugins, extensibility Some of the additional plugins have grown into significant libraries of their own. A selection of the more important libraries is listed in Table 14.1. Table 14.1 Additional jQuery Modules Module Description jQuery UI A set of user interface components. These components include user interactions, effects, themes, and widgets. An example of a jQuery widget is the date picker that you added in Chapter 11. jQuery Mobile The growth of mobile devices being used to access the Internet has led to the need for HTML5- based UI systems that are both extremely small (data transfer to a mobile device can be expensive) and flexible —especially in terms of determining viewable space and scripting support. QUnit A JavaScript unit testing framework. While not based on jQuery itself, it is used by the jQuery, jQuery UI, and jQuery Mobile projects for testing. QUnit is capable of testing any JavaScript code, not just jQuery. T can also be used to test itself. jQuery This framework supports client-side validation. It makes standard Validation validation trivial while also offering numerous options for customization. It includes multiple validation methods that validate against different types of data, including e-mail address or URL, as well as the capability to write your own validation methods. Globalize Content on the Internet is accessible to visitors anywhere in the world as long as they have an Internet connection. This has made globalization and internationalization increasingly important, as enterprises want to provide access and communication to people who don't speak the native language of the website. jQuery Mouse Wheel Plugin This is a very specialized library, but it solves a surprisingly complex problem: interacting with specialized hardware on the client that was not even imagined when JavaScript came out but soon became a standard piece of hardware. Because jQuery is open source, you have also seen other implementations that take advantage of the functionality it provides. Microsoft, for example, provides the capability to install (as a package) many different parts of the jQuery framework as well as some customizations to it that are now built in to output generated in a project, such as Web Forms AJAX and validation. The scripts that are used by Microsoft in these cases use parts of the jQuery framework as well. OPEN SOURCE The term open source is generally used to refer to a set of functionality, either an application or a library, whereby the source code is available for download and usage by developer. Each set of functionality generally has a licensing agreement that instructs users as to what they can and cannot do with the project's source code. Some of the licenses are very open, allowing users to do almost anything they want, while other agreements are much more restrictive and limit how the application or library may be used. Some of these licenses include the following: MIT license: Permits reuse within proprietary software provided that all copies of the licensed software include a copy of the MIT License terms and the copyright notice. jQuery uses an MIT license. GNU General Public license: In a GPL situation, users have the right to freely distribute copies and modified versions of a work with the stipulation that the same rights be preserved in derivative works. This means that a developer cannot sell a non–open source version of a product that uses a GPL licensed product or library. Apache license: This type of license gives users of the software the freedom to use the software for any purpose, to distribute it, to modify it, and to distribute modified versions of the software, under the terms of the license, without concern for royalties. This is the license under which ASP.NET is available. Each of the different jQuery libraries is available for use within your ASP.NET application, be it Web Forms or MVC. Including these items in your application depends upon the library that you will be using, where it will be used, and other considerations regarding its usage. However, the mechanics of interacting with the libraries are the same across all the jQuery libraries, even the standard library. Including the jQuery Library Once you determine that the best way to fulfill a set of business requirements in your application is through the use of jQuery, you have to determine which jQuery parts you want and how you will make them available in your application. Because you are working within Visual Studio, the default way to add third-party libraries is through the use of NuGet packages, and indeed you have already added several jQuery packages using that approach. The items with the checkmark in Figure 14.1 are the jQuery items that are already installed in your sample application. Figure 14.1 Installed jQuery packages At this point you have installed the jQuery core libraries, the jQuery UI package, and the jQuery Validation framework, as well as several Microsoft-specific Unobtrusive jQuery libraries. As you discovered in earlier chapters, the Microsoft libraries are necessary so that the various ASP.NET helpers are available to handle creation of the appropriate HTML elements with the appropriate attributes. The attributes enable the JavaScript library to be called “unobtrusive.” These libraries are slightly misnamed in that they make it seem as if jQuery and unobtrusive are different. Unobtrusive is simply an approach to using JavaScript whereby the separation of functionality from the presentation layer is enforced. Using this definition means that jQuery is unobtrusive as well because that is one of the points of the jQuery library. Although it has been mentioned several times, it may not be completely clear how JavaScript and the DOM can be mixed together and what this problem looks like. An example of this mixed-up approach is shown here: The onchange attribute is where the mix-up happens—where the code calls a JavaScript function from within the HTML element, forever linking these two items together. The unobtrusive solution is to perform the linking in code so that the HTML\ DOM content does not reference the JavaScript; instead, all references are from JavaScript to the DOM element. The unobtrusive approach enables any JavaScript changes, such as changing the name of a function, to be limited to occurring within JavaScript, without having to change any HTML. This change in approach means that the linking would happen as follows: HTML JavaScript window.onload = function() { document.getElementById('date').onchange = validateDate; }; In short, all the default jQuery packages that you need are already attached to your solution. Therefore, your real concern is ensuring that the jQuery library files are available for download to the client's machine and that they are available to use within your UI code. There are a couple of different ways to ensure that the web page knows to download the script; either adding a reference directly to the page or using bundles to group multiple scripts together into a single reference. The first approach is to add a reference directly to your page. This is the approach you took when you added the initial jQuery UI script to support the date picker. This code is an HTML script element whereby you set the src attribute to download the script file as shown here: SELECTED name=‘the-news’> SELECTED SELECTED SELECTED Attribute Equals Selector Selects elements that have the specified attribute with a value exactly equal to a certain value, including case. Attribute Not Equal ToSelector Selects elements that either don't have the specified attribute or do have the specified attribute but not with a certain value. Class Selector Selects elements that are labeled with this particular class, regardless of the type of element. Even Selector Selects even elements, zero-indexed. Greater Than Selector Selects all elements at an index greater than the index within the matched set. Id Selector Selects all elements where the “id” attribute of an HTML element matches the provided value. Less Than Selector Selects all elements at an index less than the index within the matched set. SELECTED SELECTED SELECTED SELECTED SELECTED SELECTED SELECTED Odd Selector Selects odd elements, zero-indexed. SELECTED Only Child Selector Selects all elements that are the only child of their parent. Only Of Type Selector Selects all elements that have no siblings with the same element name. Parent Selector Selects all elements that have no siblings with the same element name. Universal Selector Selects all elements.
      SELECTED
      SELECTED
      Determining the best approach to creating the selectors that you will use in your jQuery is going to depend on what you are trying to do. Each separate requirement may need a different selector. An element can be targeted by multiple selectors, based on different criteria that may match that particular element, including class, element type, id, and any of the other items that were discussed in the preceding table. Modifying the DOM with JQuery Once you have one or more elements selected, there are many different things that you can do with them. You can perform calculations or perform submissions with their values; you can ignore their values and change their appearance and display. After selecting the DOM element, you can perform any action supported by JavaScript on that element, its attributes, and its value. Changing Appearance with jQuery Changing the display of a DOM element using jQuery goes far beyond making the text bold or changing the background color, though you can certainly do those changes as well. Probably one of the first things you think of when someone mentions appearance and HTML pages is CSS, and jQuery supports a set of functions for manipulating the CSS on elements. Some of these methods are shown in Table 14.4. Table 14.4 CSS Methods in jQuery Method Description addClass Adds the specified class(es) to each element in the set of matched elements.$( ‘p’ ).addClass( ‘myClass yourClass’ ); css Gets the value of a style property for the first element in the set of matched elements or sets one or more CSS properties for every matched element.var color = $( ‘p’ ).css( ‘background-color’ ); hasClass Determines whether any of the matched elements are assigned the given class. $( ‘p’ ).hasClass( ‘myClass’ ); height Gets the current computed height for the first element in the set of matched elements or sets the height of every matched element. It returns a value in pixels, but without the attached unit, i.e., 400 instead of 400px. $( ‘p’ ).height( ) = 100; position Gets the current coordinates of the first element in the set of matched elements, relative to the offset parent. You cannot set these values, you can only get them as needed. These elements must be visible and the results do not account for borders, margins, or padding. var selectedElement = $( ‘p:last’ ); var position = selectedElement.position(); $( ‘p:first’ ).val = position.left + position.top; removeClass Removes a single class, multiple classes, or all classes from each element in the set of matched elements. $( ‘p’ ).removeClass( ‘myClass yourClass’ ) toggleClass Adds or removes one or more classes from each element in the set of matched elements, depending on the presence of the class. If the class exists, it is removed. If the class is missing, it is added. $( ‘p’ ).toggleClass( ‘myClass’ ); width Gets the current computed width for the first element in the set of matched elements or sets the width of every matched element. It returns a value in pixels, but without the attached unit, i.e., 400 instead of 400px. $( ‘p’ ).width( ) = 100; There are other ways to change the appearance of DOM elements after you have selected them. As just shown, changing the assigned styles is one approach to changing the display. Style changes, however, are generally static changes. You can also use JavaScript, thus jQuery, to provide simple animations or other visual effects to DOM elements. Table 14.5 describes the various animation and other effects methods available in jQuery. Table 14.5 Animation and Other Effects in jQuery Method Description animate Performs a custom animation of a set of CSS properties. The typical usage is with the method signature of animate( properties, options ). $( ‘#someelement’ ).click(function() { $( ‘#anotherelement’ ).animate({ left: ‘+=50’ // move it left everytime there is a click }, 5000, function() { // do something when the animation has completed }); }); delay Sets a timer to delay execution of subsequent items in the queue. This value is usually chained with other animation items. $( ‘#someelement’ ).click(function() { $( ‘#anotherelement’ ).slideUp(300).delay(800).fadeIn(400); }); fadeIn Displays the matched elements by fading them to opaque. The function takes a duration in milliseconds, defaulting to 400, or two string values of “slow” or “fast”; or 600 and 500 milliseconds, respectively. $( ‘#someelement’ ).click(function() { $( ‘#anotherelement’ ).fadeIn(‘slow’); }); fadeOut Hides the matched elements by fading them to transparent. The function takes a duration in milliseconds, defaulting to 400, or two string values of “slow” or “fast”; or 600 and 500 milliseconds respectively. $( ‘#someelement’ ).click(function() { $( ‘#anotherelement’ ).fadeOut (‘slow’); }); fadeToggle Displays or hides the matched elements by animating their opacity. The function takes a duration in milliseconds, defaulting to 400, or two string values of “slow” or “fast”; or 600 and 500 milliseconds, respectively. $( ‘#someelement’ ).click(function() { $( ‘#anotherelement’ ).fadeToggle (‘slow’); }); hide Hides the matched elements. There is no animation involved, nor any arguments that can be passed into the method. $( ‘#someelement’ ).click(function() { $( ‘#anotherelement’ ).hide(); }); show Displays the matched elements There is no animation involved, nor any arguments that can be passed into the method. $( ‘#someelement’ ).click(function() { $( ‘#anotherelement’ ).show(); }); slideDown Displays the matched elements with a sliding motion. This method animates the height of the matched elements. This causes lower parts of the page to slide down, making way for the revealed items. The function takes a duration in milliseconds, defaulting to 400, or two string values of “slow” or “fast”; or 600 and 500 milliseconds, respectively. $( ‘#someelement’ ).click(function() { $( ‘#anotherelement’ ).slideDown(1000); }); slideToggle Displays or hides the matched elements with a sliding motion. This method animates the height of the matched elements, acting as if slideDown were called if the element is hidden or slideUp if the element is visible. The function takes a duration in milliseconds, defaulting to 400, or two string values of “slow” or “fast”; or 600 and 500 milliseconds, respectively. $( ‘#someelement’ ).click(function() { $( ‘#anotherelement’ ).slideToggle(1000); }); slideUp Hides the matched elements with a sliding motion. This method animates the height of the matched elements. This causes lower parts of the page to slide up as the items are hidden. The function takes a duration in milliseconds, defaulting to 400, or two string values of “slow” or “fast”; or 600 and 500 milliseconds, respectively. $( ‘#someelement’ ).click(function() { $( ‘#anotherelement’ ).slideUp(1000); }); toggle Displays or hides the matched elements. This method can be thought of as running the show method when an item is hidden, or running the hide method if the item is visible. $( ‘#someelement’ ).click(function() { $( ‘#anotherelement’ ).toggle(); }); Animation enables you to move areas of the screen to grab the user's attention. Using animation, for example, to slide out old content and slide in new content informs the user that there has been a change in an area. This becomes more important as you use AJAX approaches whereby information on the screen can change at any time. The changing of information is generally the result of a user activity, such as clicking a button or selecting an item in the drop-down box. However, many other actions can cause a programmatic reaction. These actions are known as JavaScript and jQuery events. Handling Events A lot of different events are occurring within JavaScript that you can take advantage of within jQuery. These events are different from the events that you interacted with when doing the code-behinds in ASP.NET Web Form controls and pages, but the concept behind them is the same. An event provides a way to interact with either the user of the system or the system itself in order to learn that a state has changed and that something may need to happen because of this change. Once you recognize that acknowledgment of an action is required—whether it is a button click or a timer expiring—you need an event handler, or the action to be taken upon that action, which you can attach to that action. After you have completed the creation of the event handler and the linking of that event handler to that event, you have created a way to monitor, and react to, that particular action. You can then do this across all the actions you care about. As shown in Table 14.6, there are many different potential events that you can interact with as needed. It's unlikely that you will need to interact with each, but if you do you have that capability. There is no limit to the number of events that you can handle; nor is there a limit to how many handlers are attached to an event. Table 14.6 Common JavaScript Events Event Description change Binds an event handler to the change JavaScript event, or triggers that event on an element. $( ‘#someelement’ ).change(function() { $( ‘#anotherelement’ ).toggle(); }); click Binds an event handler to the change JavaScript event, or triggers that event on an element. $( ‘#someelement’ ).click(function() { $( ‘#anotherelement’ ).toggle(); }); dblclick Binds an event handler to the dblclick JavaScript event, or triggers that event on an element. This event is triggered only after this exact series of events: The mouse button is depressed while the pointer is inside the element. The mouse button is released while the pointer is inside the element. The mouse button is depressed again while the pointer is inside the element, within a time window that is system-dependent. The mouse button is released while the pointer is inside the element. $( ‘#someelement’ ).dblclick(function() { $( ‘#anotherelement’ ).toggle(); }); focus Binds an event handler to the focus JavaScript event, or triggers that event on an element. Elements with focus are usually highlighted in some way by the browser—for example, with a dotted line surrounding the element. The focus is used to determine which element is the first to receive keyboard-related events. $( ‘#someelement’ ).focus(function() { $( ‘#anotherelement’ ).toggle(); }); hover Binds two handlers to the matched elements, to be executed when the mouse pointer enters and leaves the elements. The hover method binds handlers for both the mouseenter and mouseleave events. You can use it to simply apply behavior to an element during the time the mouse is within the element. $( ‘#someelement’ ).hover( function() { $( ‘#anotherelement’ ).show(); }, function() { $( ‘#anotherelement’ ).hide(); }); keypress Binds an event handler to the keypress JavaScript event, or triggers that event on an element. The keypress event is sent to an element when the browser registers keyboard input that is not a modifier or non-printing key such as Shift, Esc, and Delete. $( ‘#someelement’ ).keypress(function() { $( ‘#anotherelement’ ).toggle(); }); mousedown Binds an event handler to the mousedown JavaScript event, or triggers that event on an element. This event is sent to an element when the mouse pointer is over the element, and the mouse button is pressed. $( ‘#someelement’ ).mousedown(function() { $( ‘#anotherelement’ ).toggle(); }); mouseenter Binds an event handler to be fired when the mouse enters an element, or triggers that handler on an element. This JavaScript event is proprietary to Internet Explorer; but because of the event's general utility, jQuery simulates it so that it can be used regardless of browser. $( ‘#someelement’ ).mouseenter(function() { $( ‘#anotherelement’ ).toggle(); }); mouseleave Binds an event handler to be fired when the mouse leaves an element, or triggers that handler on an element. This JavaScript event is proprietary to Internet Explorer, but because of the event's general utility, jQuery simulates it so that it can be used regardless of browser. $( ‘#someelement’ ).mouseenter(function() { $( ‘#anotherelement’ ).toggle(); }); mousemove Binds an event handler to the mousemove JavaScript event, or triggers that event on an element. This event is sent to an element when the mouse pointer moves inside the element. $( ‘#someelement’ ).mousemove(function() { var msg = ‘Handler for .mousemove() called at ’; msg += event.pageX + ‘, ’ + event.pageY; $( ‘#anotherelement’ ).append(‘
      ’ + msg + ‘
      ’); }); mouseout Binds an event handler to the mouseout JavaScript event, or triggers that event on an element. This event is sent to an element when the mouse pointer leaves the element. $( ‘#someelement’ ).mouseout(function() { $( ‘#anotherelement’ ).toggle(); }); mouseover Binds an event handler to the mouseover JavaScript event, or triggers that event on an element. This event is sent to an element when the mouse pointer enters the element. $( ‘#someelement’ ).mouseover(function() { $( ‘#anotherelement’ ).toggle(); }); mouseup Binds an event handler to the mouseup JavaScript event, or triggers that event on an element. This event is sent to an element when the mouse pointer is over the element, and the mouse button is released. $( ‘#someelement’ ).mouseup(function() { $( ‘#anotherelement’ ).toggle(); }); ready This event is executed when the DOM is fully loaded. It is fired when the DOM has been loaded but it doesn't wait for all the scripts and images to download, so there may be some conflict between using large scripts and ready functions. It is one of the most commonly used jQuery functions, and it can only be applied to the document element. This enables you to reference the ready function in multiple ways, as shown in the following examples. Each line is calling the same function as soon as the ready event is fired. $( document ).ready( handler ) $().ready( handler ) $( handler ) submit Binds an event handler to the submit JavaScript event, or triggers that event on an element. This event is sent to an element when the user is attempting to submit a form, and it can only be attached to a form element. The event handler function is called before the actual submission, so the form submission can be handled by calling the preventDefault method on the event.
      $( ‘#thisForm’ ).submit(function( event ) { $( ‘#anotherelement’ ).toggle(); Event.preventDefault(); }); Not only can you use JavaScript and jQuery to assign an event handler to an event so that the event handler will be called as necessary, you can also use jQuery to call an event on an element, thus enabling you to programmatically act as the user if necessary. This enables you to use exactly the same approach regardless of how you want to perform the work, rather than write one set of code for interacting with the user and a second set of code to support system interaction. The ready method is so important because of how jQuery links the code and the user interface, especially when using the unobtrusive approach. The expectation from this approach is that any relating of code and display would only happen in the code, meaning any time you care about a change of state in a DOM element, you need to map the relationship in code. Therefore, the most frequently used concept in jQuery is the capability to select an element; otherwise, how would you be able to instruct it to manage some specific event? As you can see, there are many different interactions that you can work with on the client side to capture input, whether it be direct, such as clicking a button or a key, or indirect, such as through mouse movement. You can then create jQuery and JavaScript functions to respond to those interactions as needed. In this Try It Out, you put together various selectors, events, and display changes to add interactivity to your sample application. TRY IT OUT: Adding jQuery to Your Application In this exercise you use jQuery to enhance the user experience of interacting with your sample application. 1. Ensure that Visual Studio is running and your RentMyWrox solution is open. Open the MainPageManagement.js file that you created in the last activity. 2. Add the following functions: function fadeOutShoppingCartSummary() { $("#shoppingcartsummary").fadeOut(250); } function fadeInShoppingCartSummary() { $("#shoppingcartsummary").fadeIn(1000); } 3. Open the Views\Item\Details.cshtml page. In the AjaxOptions object within the ‘Add to Cart’ Ajax.ActionLink, add the following properties. It should look like Figure 14.11 when completed. Ensure that you add a comma at the end of the property that appears before the ones you are adding. OnBegin = "fadeOutShoppingCartSummary", OnSuccess = "fadeInShoppingCartSummary" Figure 14.11 Updated Ajax.ActionLink 4. Add the following code at the bottom of the page: @section Scripts { } 5. Open the View\Items\Index.cshtml page. Update the AjaxOptions with the same changes that you made to the Details.cshtml page as shown here: OnBegin = "fadeOutShoppingCartSummary", OnSuccess = "fadeInShoppingCartSummary" 6. Add the class ‘listitem’ to the
      element that is within the foreach loop. 7. As shown in Figure 14.12, add the following at the bottom of the page: @section Scripts { } Figure 14.12 Updating the Index page 8. Run the application and go to the home page. Mouse over items in the list and note how the background changes. 9. Add an item to the cart and note how the shopping cart area fades out and then fades back in with the new values. 10. Go into the details page of an item to which you have added a picture. Click the picture to see how it grows, and note how clicking on it again shrinks it back to the original size. How It Works In this activity you made several simple jQuery changes that improve the user's interaction with your sample application. One of the first items that you added is shown here: function fadeOutShoppingCartSummary() { $("#shoppingcartsummary").fadeOut(250); } When this function is called, it runs a selector for an element with the id of ‘shoppingcartsummary’ and then performs a fadeout method on it with a duration of .25 seconds. The other method makes the same selection but performs the opposite fading, a fadein, to change the element from transparent back to visible. These new methods were hooked into the UI by the changes you made to the link that adds an item to the cart. The new AjaxOption that you updated is shown here: new AjaxOptions { UpdateTargetId = "shoppingcartsummary", InsertionMode = InsertionMode.Replace, HttpMethod = "GET", OnBegin = "fadeOutShoppingCartSummary", OnSuccess = "fadeInShoppingCartSummary" } The two methods that you created are linked by setting two different properties. The OnBegin property on the AjaxOptions object takes a string value that corresponds to the name of a JavaScript function that is run when that event is fired. The two that you wired up are OnBegin and OnSuccess. The OnBegin event is fired when the Request object is created but before it is sent to the server. The OnSuccess event is fired when the call is completed successfully. Two other events can be managed: OnFailure and OnComplete are fired if an exception is thrown during the AJAX call and when the entire experience is completed (even after OnSuccess or OnFailure), respectively. The next set of jQuery that you added was an event handler for a click event. The selector that you chose used a class selector that looked for a class of ‘textwrap’. The selector is shown here: $(".textwrap").click(… The work going on in the method is dictated by the value of a separate JavaScript variable that is used to indicate whether the item selected is expanded. This variable was defined as var isLarge = false. Definition is different in JavaScript than it is in C# or VB.NET because JavaScript is not a type-safe language—the var represents a variant, or simply a container that could be of any type. The function evaluates the value in the isLarge variable and branches based on the result. It then toggles IsLarge to the updated value. The function then updates the style height to either the large or the small height, and updates the title attribute, or value shown on hover, as necessary based on the image's size. The two lines of code are shown here: $(this).css('height', '150'); $(this).attr("title", "Click to expand"); One thing to consider is the use of the $(this), which, when used within a selector, refers to the item that is causing the event to be fired. Thus, when you use a selector that results in multiple items being wired up, it demonstrates how the event being called is specific to the individual item being affected, rather than the entire range of items matching that particular selector. The two items that were run on the selected item are the css and attr functions. The css function overwrites a particular variable that is available for CSS styling—in this case, the height key. The attr method enables you to override an attribute on the element—in this case, the title attribute. You added the last set of jQuery to use the hover event to change the background of an item. This could have been done just as easily in CSS, as done with the items in the left menu, but for many developers it's easy to understand, find, and maintain the simple jQuery code that was added, rather than manipulate complex CSS. The capability to use jQuery to manage complex styling is an important consideration. One of the primary reasons to do this in jQuery instead is because it enables you to debug jQuery processing, whereas you can't do that in CSS. Debugging JQuery Debugging in jQuery is a little different from any of the debugging that you have done so far. It is different because it is pure client-side debugging, whereas the other debugging you have done has been all server-side. Even when you are debugging within a view, you are still debugging processing that is being done on the server. When you are debugging jQuery, you are debugging on the client, in the browser. This results in a completely different experience. There are two different approaches to client-side debugging: One uses debugging tools in Visual Studio, whereas the other uses debugging tools that are part of the browser. In the next Try It Out, you practice each of these techniques for debugging JavaScript and jQuery code. TRY IT OUT: Debugging JavaScript Code In this exercise you configure your local browser to support debugging of your local JavaScript code. You also practice debugging the jQuery code that you already wrote. After that, you have the opportunity to add custom debugging code to the jQuery functions and see how that helps to support your debugging efforts. The following directions assume that you are using Internet Explorer for debugging. 1. Ensure that Visual Studio is running and your RentMyWrox solution is open. Open Microsoft Internet Explorer and ensure that it is set up to debug. In IE, select Tools Internet Options Advanced. Under the Browsing section, find Disable Script Debugging (Internet Explorer) and ensure that it is unchecked, as shown in Figure 14.13. Click OK or Apply when you are done. Figure 14.13 Enabling debugging in Internet Explorer 2. Stop debugging the application. Open the MainPageManagement.js file that you created earlier in the chapter. Add breakpoints to each of the named functions, as shown in Figure 14.14. Figure 14.14 Adding breakpoints in jQuery/JavaScript 3. Run the application, noting how it stops at the first breakpoint and how the debugger is able to show the JSON value that was downloaded from the server. It should look like Figure 14.15. Figure 14.15 Hitting a breakpoint in JavaScript 4. Continue the application past the breakpoint and click the link to add an item. You should see the debugger stop at your breakpoint in the fadeOutShoppingCartSummary method. Close the browser and stop debugging the application. 5. Restart the application by using Ctrl+F5, or start without debugging. 6. Go to the home page in Internet Explorer and access the F12 Developer tools. From the Debugger tab, find the hover function at the bottom of the page. 7. Add a breakpoint as shown in Figure 14.16. Figure 14.16 Setting a breakpoint in the browser tools 8. Mouse over an item in the list. You should see the breakpoint hit, as shown in Figure 14.17. Figure 14.17 Hitting a breakpoint in the browser tools 9. Expand the Watches window in the top right-hand corner of the Browser tools. Scroll down through the items in the window to get an idea of the information that is available to you through these tools. 10. Close the browser and stop running the application. How It Works When JavaScript tools and jQuery first came out it was difficult to debug through the code. However, as JavaScript and jQuery became increasingly prevalent, development tools such as Visual Studio started to add more support for debugging client-side code. In Visual Studio 2015, the integration is complete. Debugging JavaScript and jQuery code in Visual Studio is virtually the same as debugging your C# code. You can set breakpoints, and when the code is stopped you can evaluate the values of variables and selections as desired, just as you can with C# and VB.NET code. The biggest difference is the additional capability to debug in the browser. You have already seen how the F12 Browser tools enable you to get information about the HTML elements, including styling and layout affects. Another piece of functionality that is supported is the capability to debug through JavaScript. As you saw, when you hit a breakpoint, you have visibility into many different items. If you have selected an element, you can see everything about that element. You can see the values of its attributes, and you can access its value, even child elements. You can then examine those child elements and their attributes and values, including children, and so forth. As you work with the F12 debugger, you will notice a few things. First, you cannot run the application in debug mode and debug within Internet Explorer. If you try to debug in the browser you will get an error, as shown at the bottom of Figure 14.18. Figure 14.18 Error in browser when trying to debug The easiest way to debug in the browser and still run the application locally is through the approach that you used, running the application but without debugging. You can do this by selecting Ctrl+F5 or the upper menu, using Debug Start Without Debugging. These approaches start the application without attaching the debugger. This enables the browser debugger to interact with the process. Debugging is important when working with any programming language, and especially when you are just starting to work with it. This is particularly true when working with jQuery and JavaScript, simply because it is different from most of the other languages. This difference can cause you to make simple errors, such as incorrect selectors (using the hashtag when you should have used the period) or not setting up the functions correctly so that they are never run. Debugging will help you gather information about what you may be doing wrong. Practical Tips on JQuery Working in jQuery can be an interesting experience for developers who are used to working in C# or VB.NET environments. The difference in approaches can be startling, especially the lack of type-safe variables and working with the results from a selector as opposed to a known, named variable. Following is a short list of tips that will help you when working with jQuery in your own applications: Practice your jQuery, especially something that you will be working with in the future. Getting the selectors correct, especially with more complex scenarios, can take some time to get right—especially because many of the differences are a single character. Don't be afraid to use multiple approaches to help you when debugging your client code. You may often be able to use the debugger when running locally, but at other times you may have to use other approaches. Use the jQuery.org website as a resource for understanding how to use jQuery. It contains full documentation about the various functions as well as multiple source code examples. Search out other jQuery learning tools. It has become so popular across the Internet that many different sites provide interesting and useful information about implementing jQuery in your web application. Summary jQuery has quietly become the most frequently used client-side framework. It is an open-source framework that offers abstraction over JavaScript, or ECMAScript, which is available in nearly all client-side web browsers, be they desktop or mobile devices. Because jQuery is a JavaScript abstraction, it is “linked” to a web page as is a JavaScript file, so you don't ne