The .NET Framework version 4 includes enhancements for ASP.NET 4 in targeted areas. Visual Studio 2010
and Microsoft Visual Web Developer Express also include enhancements
and new features for improved Web development. This document provides an overview of many of
the new features that are included in
the upcoming release. This topic contains
the following sections: ASP.NET Core Services ASP.NET Web Forms ASP.NET MVC Dynamic Data ASP.NET Chart Control Visual Web Developer Enhancements Web Application Deployment with Visual Studio 2010 Enhancements to ASP.NET Multi-Targeting ASP.NET Core Services ASP.NET 4 introduces many features that improve core ASP.NET services such as output caching
and session state storage. Extensible Output Caching Since
the time that ASP.NET 1.0 was released, output caching has enabled developers to store
the generated output of pages, controls,
and HTTP responses in memory. On subsequent Web requests, ASP.NET can serve content more quickly by retrieving
the generated output from memory instead of regenerating
the output from scratch. However, this approach has a limitation — generated content always has to be stored in memory. On servers that experience heavy traffic,
the memory requirements for output caching can compete with memory requirements for other parts of a Web application. ASP.NET 4 adds extensibility to output caching that enables you to configure one or more custom output-cache providers. Output-cache providers can use any storage mechanism to persist HTML content. These storage options can include local or remote disks, cloud storage,
and distributed cache engines. Output-cache provider extensibility in ASP.NET 4 lets you design more aggressive
and more intelligent output-caching strategies for Web sites. For example, you can create an output-cache provider that caches
the "Top 10" pages of a site in memory, while caching pages that get lower traffic on disk. Alternatively, you can cache every vary-by combination for a rendered page, but use a distributed cache so that
the memory consumption is offloaded from front-end Web servers. You create a custom output-cache provider as a class that derives from
the OutputCacheProvider type. You can then configure
the provider in
the Web.config file by using
the new providers subsection of
the outputCache element For more information
and for examples that show how to configure
the output cache, see outputCache Element for caching (ASP.NET Settings Schema). For more information about
the classes that support caching, see
the documentation for
the OutputCache
and OutputCacheProvider classes. By default, in ASP.NET 4, all HTTP responses, rendered pages,
and controls use
the in-memory output cache.
The defaultProvider attribute for ASP.NET is AspNetInternalProvider. You can change
the default output-cache provider used for a Web application by specifying a different provider name for defaultProvider attribute. In addition, you can select different output-cache providers for individual control
and for individual requests
and programmatically specify which provider to use. For more information, see
the HttpApplication.GetOutputCacheProviderName(HttpContext) method.
The easiest way to choose a different output-cache provider for different Web user controls is to do so declaratively by using
the new providerName attribute in a page or control directive, as shown in
the following example: <%@ OutputCache Duration="60" VaryByParam="None" providerName="DiskCache" %> Preloading Web Applications Some Web applications must load large amounts of data or must perform expensive initialization processing before serving
the first request. In earlier versions of ASP.NET, for these situations you had to devise custom approaches to "wake up" an ASP.NET application
and then run initialization code during
the Application_Load method in
the Global.asax file. To address this scenario, a new application preload manager (autostart feature) is available when ASP.NET 4 runs on IIS 7.5 on Windows Server 2008 R2.
The preload feature provides a controlled approach for starting up an application pool, initializing an ASP.NET application,
and then accepting HTTP requests. It lets you perform expensive application initialization prior to processing
the first HTTP request. For example, you can use
the application preload manager to initialize an application
and then signal a load-balancer that
the application was initialized
and ready to accept HTTP traffic. To use
the application preload manager, an IIS administrator sets an application pool in IIS 7.5 to be automatically started by using
the following configuration in
the applicationHost.config file: <applicationPools> <add name="MyApplicationPool" startMode="AlwaysRunning" /> </applicationPools> Because a single application pool can contain multiple applications, you specify individual applications to be automatically started by using
the following configuration in
the applicationHost.config file: <sites> <site name="MySite" id="1"> <application path="/" serviceAutoStartEnabled="true" serviceAutoStartProvider="PrewarmMyCache" > <!-- Additional content --> </application> </site> </sites> <!-- Additional content --> <serviceAutoStartProviders> <add name="PrewarmMyCache" type="MyNamespace.CustomInitialization, MyLibrary" /> </serviceAutoStartProviders> When an IIS 7.5 server is cold-started or when an individual application pool is recycled, IIS 7.5 uses
the information in
the applicationHost.config file to determine which Web applications have to be automatically started. For each application that is marked for preload, IIS7.5 sends a request to ASP.NET 4 to start
the application in a state during which
the application temporarily does not accept HTTP requests. When it is in this state, ASP.NET instantiates
the type defined by
the serviceAutoStartProvider attribute (as shown in
the previous example)
and calls into its public entry point. You create a managed preload type that has
the required entry point by implementing
the IProcessHostPreloadClient interface, as shown in
the following example: public class CustomInitialization : System.Web.Hosting.IProcessHostPreloadClient { public void Preload(string[] parameters) { // Perform initialization. } } After your initialization code runs in
the Preload method
and after
the method returns,
the ASP.NET application is ready to process requests. Permanently Redirecting a Page Content in Web applications is often moved over
the lifetime of
the application. This can lead to links to be out of date, such as
the links that are returned by search engines. In ASP.NET, developers have traditionally handled requests to old URLs by using
the Redirect method to forward a request to
the new URL. However,
the Redirect method issues an HTTP 302 (Found) response (which is used for a temporary redirect). This results in an extra HTTP round trip. ASP.NET 4 adds a RedirectPermanent helper method that makes it easy to issue HTTP 301 (Moved Permanently) responses, as in
the following example: RedirectPermanent("/newpath/foroldcontent.aspx"); Search engines
and other user agents that recognize permanent redirects will store
the new URL that is associated with
the content, which eliminates
the unnecessary round trip made by
the browser for temporary redirects. Session State Compression By default, ASP.NET provides two options for storing session state across a Web farm.
The first option is a session state provider that invokes an out-of-process session state server.
The second option is a session state provider that stores data in a Microsoft SQL Server database. Because both options store state information outside a Web application's worker process, session state has to be serialized before it is sent to remote storage. If a large amount of data is saved in session state,
the size of
the serialized data can become very large. ASP.NET 4 introduces a new compression option for both kinds of out-of-process session state providers. By using this option, applications that have spare CPU cycles on Web servers can achieve substantial reductions in
the size of serialized session state data. You can set this option using
the new compressionEnabled attribute of
the sessionState element in
the configuration file. When
the compressionEnabled configuration option is set to true, ASP.NET compresses (and decompresses) serialized session state by using
the .NET Framework GZipStreamclass.
The following example shows how to set this attribute. <sessionState mode="SqlServer" sqlConnectionString="data source=dbserver;Initial Catalog=aspnetstate" allowCustomSqlDatabase="true" compressionEnabled="true" /> ASP.NET Web Forms Web Forms has been a core feature in ASP.NET since
the release of ASP.NET 1.0. Many enhancements have been in this area for ASP.NET 4, such as
the following:
The ability to set meta tags. More control over view state. Support for recently introduced browsers
and devices. Easier ways to work with browser capabilities. Support for using ASP.NET routing with Web Forms. More control over generated IDs.
The ability to persist selected rows in data controls. More control over rendered HTML in
the FormView
and ListView controls. Filtering support for data source controls. Enhanced support for Web standards
and accessibility Setting Meta Tags with
the Page.MetaKeywords
and Page.MetaDescription Properties Two properties have been added to
the Page class: MetaKeywords
and MetaDescription. These two properties represent corresponding meta tags in
the HTML rendered for a page, as shown in
the following example: <head id="Head1" runat="server"> <title>Untitled Page</title> <meta name="keywords" content="keyword1, keyword2' /> <meta name="description" content="Description of my page" /> </head> These two properties work like
the Title property does,
and they can be set in
the @ Page directive. For more information, see Page.MetaKeywords
and Page.MetaDescription. Enabling View State for Individual Controls A new property has been added to
the Control class: ViewStateMode. You can use this property to disable view state for all controls on a page except those for which you explicitly enable view state. View state data is included in a page's HTML
and increases
the amount of time it takes to send a page to
the client
and post it back. Storing more view state than is necessary can cause significant decrease in performance. In earlier versions of ASP.NET, you could reduce
the impact of view state on a page's performance by disabling view state for specific controls. But sometimes it is easier to enable view state for a few controls that need it instead of disabling it for many that do not need it. For more information, see Control.ViewStateMode. Support for Recently Introduced Browsers
and Devices ASP.NET includes a feature that is named browser capabilities that lets you determine
the capabilities of
the browser that a user is using. Browser capabilities are represented by
the HttpBrowserCapabilities object which is stored in
the HttpRequest.Browser property. Information about a particular browser's capabilities is defined by a browser definition file. In ASP.NET 4, these browser definition files have been updated to contain information about recently introduced browsers
and devices such as Google Chrome, Research in Motion BlackBerry smart phones,
and Apple iPhone. Existing browser definition files have also been updated. For more information, see How to: Upgrade an ASP.NET Web Application to ASP.NET 4
and ASP.NET Web Server Controls
and Browser Capabilities.
The browser definition files that are included with ASP.NET 4 are shown in
the following list: •blackberry.browser •chrome.browser •Default.browser •firefox.browser •gateway.browser •generic.browser •ie.browser •iemobile.browser •iphone.browser •opera.browser •safari.browser A New Way to Define Browser Capabilities ASP.NET 4 includes a new feature referred to as browser capabilities providers. As
the name suggests, this lets you build a provider that in turn lets you write custom code to determine browser capabilities. In ASP.NET version 3.5 Service Pack 1, you define browser capabilities in an XML file. This file resides in a machine-level folder or an application-level folder. Most developers do not need to customize these files, but for those who do,
the provider approach can be easier than dealing with complex XML syntax.
The provider approach makes it possible to simplify
the process by implementing a common browser definition syntax, or a database that contains up-to-date browser definitions, or even a Web service for such a database. For more information about
the new browser capabilities provider, see
the What's New for ASP.NET 4 White Paper. Routing in ASP.NET 4 ASP.NET 4 adds built-in support for routing with Web Forms. Routing is a feature that was introduced with ASP.NET 3.5 SP1
and lets you configure an application to use URLs that are meaningful to users
and to search engines because they do not have to specify physical file names. This can make your site more user-friendly
and your site content more discoverable by search engines. For example,
the URL for a page that displays product categories in your application might look like
the following example: http://website/products.aspx?categoryid=12 By using routing, you can use
the following URL to render
the same information: http://website/products/software
The second URL lets
the user know what to expect
and can result in significantly improved rankings in search engine results.
the new features include
the following:
The PageRouteHandler class is a simple HTTP handler that you use when you define routes. You no longer have to write a custom route handler.
The HttpRequest.RequestContext
and Page.RouteData properties make it easier to access information that is passed in URL parameters.
The RouteUrl expression provides a simple way to create a routed URL in markup.
The RouteValue expression provides a simple way to extract URL parameter values in markup.
The RouteParameter class makes it easier to pass URL parameter values to a query for a data source control (similar to FormParameter). You no longer have to change
the Web.config file to enable routing. For more information about routing, see
the following topics: ASP.NET Routing Walkthrough: Using ASP.NET Routing in a Web Forms Application How to: Define Routes for Web Forms Applications How to: Construct URLs from Routes How to: Access URL Parameters in a Routed Page Setting Client IDs
The new ClientIDMode property makes it easier to write client script that references HTML elements rendered for server controls. Increasing use of Microsoft Ajax makes
the need to do this more common. For example, you may have a data control that renders a long list of products with prices
and you want to use client script to make a Web service call
and update individual prices in
the list as they change without refreshing
the entire page. Typically you get a reference to an HTML element in client script by using
the document.GetElementById method. You pass to this method
the value of
the id attribute of
the HTML element you want to reference. In
the case of elements that are rendered for ASP.NET server controls earlier versions of ASP.NET could make this difficult or impossible. You were not always able to predict what id values ASP.NET would generate, or ASP.NET could generate very long id values.
The problem was especially difficult for data controls that would generate multiple rows for a single instance of
the control in your markup. ASP.NET 4 adds two new algorithms for generating id attributes. These algorithms can generate id attributes that are easier to work with in client script because they are more predictable
and that are easier to work with because they are simpler. For more information about how to use
the new algorithms, see
the following topics: ASP.NET Web Server Control Identification Walkthrough: Making Data-Bound Controls Easier to Access from JavaScript Walkthrough: Making Controls Located in Web User Controls Easier to Access from JavaScript How to: Access Controls from JavaScript by ID Persisting Row Selection in Data Controls
The GridView
and ListView controls enable users to select a row. In previous versions of ASP.NET, row selection was based on
the row index on
the page. For example, if you select
the third item on page 1
and then move to page 2,
the third item on page 2 is selected. In most cases, is more desirable not to select any rows on page 2. ASP.NET 4 supports Persisted Selection, a new feature that was initially supported only in Dynamic Data projects in
the .NET Framework 3.5 SP1. When this feature is enabled,
the selected item is based on
the row data key. This means that if you select
the third row on page 1
and move to page 2, nothing is selected on page 2. When you move back to page 1,
the third row is still selected. This is a much more natural behavior than
the behavior in earlier versions of ASP.NET. Persisted selection is now supported for
the GridView
and ListView controls in all projects. You can enable this feature in
the GridView control, for example, by setting
the EnablePersistedSelection property, as shown in
the following example: <asp:GridView id="GridView2" runat="server" PersistedSelection="true"> </asp:GridView> FormView Control Enhancements
The FormView control is enhanced to make it easier to style
the content of
the control with CSS. In previous versions of ASP.NET,
the FormView control rendered it contents using an item template. This made styling more difficult in
the markup because unexpected table row
and table cell tags were rendered by
the control.
The FormView control supports RenderOuterTable, a property in ASP.NET 4. When this property is set to false, as show in
the following example,
the table tags are not rendered. This makes it easier to apply CSS style to
the contents of
the control. <asp:FormView ID="FormView1" runat="server" RenderTable="false"> For more information, see FormView Web Server Control Overview. ListView Control Enhancements
The ListView control, which was introduced in ASP.NET 3.5, has all
the functionality of
the GridView control while giving you complete control over
the output. This control has been made easier to use in ASP.NET 4.
The earlier version of
the control required that you specify a layout template that contained a server control with a known ID.
The following markup shows a typical example of how to use
the ListView control in ASP.NET 3.5. <asp:ListView ID="ListView1" runat="server"> <LayoutTemplate> <asp:PlaceHolder ID="ItemPlaceHolder" runat="server"></asp:PlaceHolder> </LayoutTemplate> <ItemTemplate> <% Eval("LastName")%> </ItemTemplate> </asp:ListView> In ASP.NET 4,
the ListView control does not require a layout template.
The markup shown in
the previous example can be replaced with
the following markup: <asp:ListView ID="ListView1" runat="server"> <ItemTemplate> <% Eval("LastName")%> </ItemTemplate> </asp:ListView> For more information, see ListView Web Server Control Overview. Filtering Data with
the QueryExtender Control A very common task for developers who create data-driven Web pages is to filter data. This traditionally has been performed by building Where clauses in data source controls. This approach can be complicated,
and in some cases
the Where syntax does not let you take advantage of
the full functionality of
the underlying database. To make filtering easier, a new QueryExtender control has been added in ASP.NET 4. This control can be added to EntityDataSource or LinqDataSource controls in order to filter
the data returned by these controls. Because
the QueryExtender control relies on LINQ, but you do not to need to know how to write LINQ queries to use
the query extender.
The QueryExtender control supports a variety of filter options.
The following lists QueryExtender filter options. Term Definition SearchExpression Searches a field or fields for string values
and compares them to a specified string value. RangeExpression Searches a field or fields for values in a range specified by a pair of values. PropertyExpression Compares a specified value to a property value in a field. If
the expression evaluates to true,
the data that is being examined is returned. OrderByExpression Sorts data by a specified column
and sort direction. CustomExpression Calls a function that defines custom filter in
the page. For more information, see QueryExtenderQueryExtender Web Server Control Overview. Enhanced Support for Web Standards
and Accessibility Earlier versions of ASP.NET controls sometimes render markup that does not conform to HTML, XHTML, or accessibility standards. ASP.NET 4 eliminates most of these exceptions. For details about how
the HTML that is rendered by each control meets accessibility standards, see ASP.NET Controls
and Accessibility. CSS for Controls that Can be Disabled In ASP.NET 3.5, when a control is disabled (see WebControl.Enabled), a disabled attribute is added to
the rendered HTML element. For example,
the following markup creates a Label control that is disabled: <asp:Label id="Label1" runat="server" Text="Test" Enabled="false" /> In ASP.NET 3.5,
the previous control settings generate
the following HTML: <span id="Label1" disabled="disabled">Test</span> In HTML 4.01,
the disabled attribute is not considered valid on span elements. It is valid only on input elements because it specifies that they cannot be accessed. On display-only elements such as span elements, browsers typically support rendering for a disabled appearance, but a Web page that relies on this non-standard behavior is not robust according to accessibility standards. For display-only elements, you should use CSS to indicate a disabled visual appearance. Therefore, by default ASP.NET 4 generates
the following HTML for
the control settings shown previously: <span id="Label1" class="aspNetDisabled">Test</span> You can change
the value of
the class attribute that is rendered by default when a control is disabled by setting
the DisabledCssClass property. CSS for Validation Controls In ASP.NET 3.5, validation controls render a default color of red as an inline style. For example,
the following markup creates a RequiredFieldValidator control: <asp:RequiredFieldValidator ID="RequiredFieldValidator1" runat="server" ErrorMessage="Required Field" ControlToValidate="RadioButtonList1" /> ASP.NET 3.5 renders
the following HTML for
the validator control: <span id="RequiredFieldValidator1" style="color:Red;visibility:hidden;">RequiredFieldValidator</span> By default, ASP.NET 4 does not render an inline style to set
the color to red. An inline style is used only to hide or show
the validator, as shown in
the following example: <span id="RequiredFieldValidator1" style"visibility:hidden;">RequiredFieldValidator</span> Therefore, ASP.NET 4 does not automatically show error messages in red. For information about how to use CSS to specify a visual style for a validation control, see Validating User Input in ASP.NET Web Pages. CSS for
the Hidden Fields Div Element ASP.NET uses hidden fields to store state information such as view state
and control state. These hidden fields are contained by a div element. In ASP.NET 3.5, this div element does not have a class attribute or an id attribute. Therefore, CSS rules that affect all div elements could unintentionally cause this div to be visible. To avoid this problem, ASP.NET 4 renders
the div element for hidden fields with a CSS class that you can use to differentiate
the hidden fields div from others.
The new classvalue is shown in
the following example: <div class="aspNetHidden"> CSS for
the Table, Image,
and ImageButton Controls By default, in ASP.NET 3.5, some controls set
the border attribute of rendered HTML to zero (0).
The following example shows HTML that is generated by
the Table control in ASP.NET 3.5: <table id="Table2" border="0">
The Image control
and the ImageButton control also do this. Because this is not necessary
and provides visual formatting information that should be provided by using CSS,
the attribute is not generated in ASP.NET 4. CSS for
the UpdatePanel
and UpdateProgress Controls In ASP.NET 3.5,
the UpdatePanel
and UpdateProgress controls do not support expando attributes. This makes it impossible to set a CSS class on
the HTMLelements that they render. In ASP.NET 4 these controls have been changed to accept expando attributes, as shown in
the following example: <asp:UpdatePanel runat="server" class="myStyle"> </asp:UpdatePanel>
The following HTML is rendered for this markup: <div id="ctl00_MainContent_UpdatePanel1" class="expandoclass"> </div> Eliminating Unnecessary Outer Tables In ASP.NET 3.5,
the HTML that is rendered for
the following controls is wrapped in a table element whose purpose is to apply inline styles to
the entire control: FormView Login PasswordRecovery ChangePassword If you use templates to customize
the appearance of these controls, you can specify CSS styles in
the markup that you provide in
the templates. In that case, no extra outer table is required. In ASP.NET 4, you can prevent
the table from being rendered by setting
the new RenderOuterTable property to false. Layout Templates for Wizard Controls In ASP.NET 3.5,
the Wizard
and CreateUserWizard controls generate an HTML table element that is used for visual formatting. In ASP.NET 4 you can use a LayoutTemplate element to specify
the layout. If you do this,
the HTML table element is not generated. In
the template, you create placeholder controls to indicate where items should be dynamically inserted into
the control. (This is similar to how
the template model for
the ListView control works.) For more information, see
the Wizard.LayoutTemplate property. New HTML Formatting Options for
the CheckBoxList
and RadioButtonList Controls ASP.NET 3.5 uses HTML table elements to format
the output for
the CheckBoxList
and RadioButtonList controls. To provide an alternative that does not use tables for visual formatting, ASP.NET 4 adds two new options to
the RepeatLayout enumeration: UnorderedList. This option causes
the HTML output to be formatted by using ul
and li elements instead of a table. OrderedList. This option causes
the HTML output to be formatted by using ol
and li elements instead of a table. For examples of HTML that is rendered for
the new options, see
the RepeatLayout enumeration. Header
and Footer Elements for
the Table Control In ASP.NET 3.5,
the Table control can be configured to render thead
and tfoot elements by setting
the TableSection property of
the TableHeaderRow class
and the TableFooterRow class. In ASP.NET 4 these properties are set to
the appropriate values by default. CSS
and ARIA Support for
the Menu Control In ASP.NET 3.5,
the Menu control uses HTML table elements for visual formatting,
and in some configurations it is not keyboard-accessible. ASP.NET 4 addresses these problems
and improves accessibility in
the following ways:
The generated HTML is structured as an unordered list (ul
and li elements). CSS is used for visual formatting.
The menu behaves in accordance with ARIA standards for keyboard access. You can use arrow keys to navigate menu items. (For information about ARIA, see Accessibility in Visual Studio
and ASP.NET.) ARIA role
and property attributes are added to
the generated HTML. (Attributes are added by using JavaScript instead of included in
the HTML, to avoid generating HTML that would cause markup validation errors.) Styles for
the Menu control are rendered in a style block at
the top of
the page, instead of inline with
the rendered HTML elements. If you want to use a separate CSS file so that you can modify
the menu styles, you can set
the Menu control's new IncludeStyleBlock property to false, in which case
the style block is not generated. Valid XHTML for
the HtmlForm Control In ASP.NET 3.5,
the HtmlForm control (which is created implicitly by
the <form runat="server"> tag) renders an HTML form element that has both name
and id attributes.
The name attribute is deprecated in XHTML 1.1. Therefore, this control does not render
the name attribute in ASP.NET 4. Maintaining Backward Compatibility in Control Rendering An existing ASP.NET Web site might have code in it that assumes that controls are rendering HTML
the way they do in ASP.NET 3.5. To avoid causing backward compatibility problems when you upgrade
the site to ASP.NET 4, you can have ASP.NET continue to generate HTML
the way it does in ASP.NET 3.5 after you upgrade
the site. To do so, you can set
the controlRenderingCompatibilityVersion attribute of
the pages element to "3.5" in
the Web.config file of an ASP.NET 4 Web site, as shown in
the following example: <system.web> <pages controlRenderingCompatibilityVersion="3.5"/> </system.web> If this setting is omitted,
the default value is
the same as
the version of ASP.NET that
the Web site targets. (For information about multi-targeting in ASP.NET, see .NET Framework Multi-Targeting for ASP.NET Web Projects.) ASP.NET MVC ASP.NET MVC helps Web developers build compelling standards-based Web sites that are easy to maintain because it decreases
the dependency among application layers by using
the Model-View-Controller (MVC) pattern. MVC provides complete control over
the page markup. It also improves testability by inherently supporting Test Driven Development (TDD). Web sites created using ASP.NET MVC have a modular architecture. This allows members of a
team to work independently on
the various modules
and can be used to improve collaboration. For example, developers can work on
the model
and controller layers (data
and logic), while
the designer work on
the view (presentation). For tutorials, walkthroughs, conceptual content, code samples,
and a complete API reference, see ASP.NET MVC 2. Dynamic Data Dynamic Data was introduced in
the .NET Framework 3.5 SP1 release in mid-2008. This feature provides many enhancements for creating data-driven applications, such as
the following: A RAD experience for quickly building a data-driven Web site. Automatic validation that is based on constraints defined in
the data model.
The ability to easily change
the markup that is generated for fields in
the GridView
and DetailsView controls by using field templates that are part of your Dynamic Data project. For ASP.NET 4, Dynamic Data has been enhanced to give developers even more power for quickly building data-driven Web sites. For more information, see ASP.NET Dynamic Data Content Map. Enabling Dynamic Data for Individual Data-Bound Controls in Existing Web Applications You can use Dynamic Data features in existing ASP.NET Web applications that do not use scaffolding by enabling Dynamic Data for individual data-bound controls. Dynamic Data provides
the presentation
and data layer support for rendering these controls. When you enable Dynamic Data for data-bound controls, you get
the following benefits: Setting default values for data fields. Dynamic Data enables you to provide default values at run time for fields in a data control. Interacting with
the database without creating
and registering a data model. Automatically validating
the data that is entered by
the user without writing any code. For more information, see Walkthrough: Enabling Dynamic Data in ASP.NET Data-Bound Controls. New Field Templates for URLs
and E-mail Addresses ASP.NET 4 introduces two new built-in field templates, EmailAddress.ascx
and Url.ascx. These templates are used for fields that are marked as EmailAddress or Url using
the DataTypeAttribute attribute. For EmailAddress objects,
the field is displayed as a hyperlink that is created by using
the mailto: protocol. When users click
the link, it opens
the user's e-mail client
and creates a skeleton message. Objects typed as Url are displayed as ordinary hyperlinks.
The following example shows how to mark fields. [DataType(DataType.EmailAddress)] public object HomeEmail { get; set; } [DataType(DataType.Url)] public object Website { get; set; } Creating Links with
the DynamicHyperLink Control Dynamic Data uses
the new routing feature that was added in
the .NET Framework 3.5 SP1 to control
the URLs that users see when they access
the Web site.
The new DynamicHyperLink control makes it easy to build links to pages in a Dynamic Data site. For information, see How to: Create Table Action Links in Dynamic Data Support for Inheritance in
the Data Model Both
the ADO.NET Entity Framework
and LINQ to SQL support inheritance in their data models. An example of this might be a database that has an InsurancePolicy table. It might also contain CarPolicy
and HousePolicy tables that have
the same fields as InsurancePolicy
and then add more fields. Dynamic Data has been modified to understand inherited objects in
the data model
and to support scaffolding for
the inherited tables. For more information, see Walkthrough: Mapping Table-per-Hierarchy Inheritance in Dynamic Data. Support for Many-to-Many Relationships (Entity Framework Only)
The Entity Framework has rich support for many-to-many relationships between tables, which is implemented by exposing
the relationship as a collection on an Entity object. New field templates (ManyToMany.ascx
and ManyToMany_Edit.ascx) have been added to provide support for displaying
and editing data that is involved in many-to-many relationships. For more information, see Working with Many-to-Many Data Relationships in Dynamic Data. New Attributes to Control Display
and Support Enumerations
The DisplayAttribute has been added to give you additional control over how fields are displayed.
The DisplayNameAttribute attribute in earlier versions of Dynamic Data enabled you to change
the name that is used as a caption for a field.
The new DisplayAttribute class lets you specify more options for displaying a field, such as
the order in which a field is displayed
and whether a field will be used as a filter.
The attribute also provides independent control of
the name that is used for
the labels in a GridView control,
the name that is used in a DetailsView control,
the help text for
the field,
and the watermark used for
the field (if
the field accepts text input).
The EnumDataTypeAttribute class has been added to let you map fields to enumerations. When you apply this attribute to a field, you specify an enumeration type. Dynamic Data uses
the new Enumeration.ascx field template to create UI for displaying
and editing enumeration values.
The template maps
the values from
the database to
the names in
the enumeration. Enhanced Support for Filters Dynamic Data 1.0 had built-in filters for Boolean columns
and foreign-key columns.
The filters did not let you specify
the order in which they were displayed.
The new DisplayAttribute attribute addresses this by giving you control over whether a column appears as a filter
and in what order it will be displayed. An additional enhancement is that filtering support has been rewritten to use
the new QueryExtender feature of Web Forms. This lets you create filters without requiring knowledge of
the data source control that
the filters will be used with. Along with these extensions, filters have also been turned into template controls, which lets you add new ones. Finally,
the DisplayAttribute class mentioned earlier allows
the default filter to be overridden, in
the same way that UIHint allows
the default field template for a column to be overridden. For more information, see Walkthrough: Filtering Rows in Tables That Have a Parent-Child Relationship
and QueryableFilterRepeater. ASP.NET Chart Control
The ASP.NET chart server control enables you to create ASP.NET pages applications that have simple, intuitive charts for complex statistical or financial analysis.
The chart control supports
the following features: Data series, chart areas, axes, legends, labels, titles,
and more. Data binding. Data manipulation, such as copying, splitting, merging, alignment, grouping, sorting, searching,
and filtering. Statistical formulas
and financial formulas. Advanced chart appearance, such as 3-D, anti-aliasing, lighting,
and perspective. Events
and customizations. Interactivity
and Microsoft Ajax. Support for
the Ajax Content Delivery Network (CDN), which provides an optimized way for you to add Microsoft Ajax Library
and jQuery scripts to your Web applications. For more information, see Chart Web Server Control Overview. Visual Web Developer Enhancements
The following sections provide information about enhancements
and new features in Visual Studio 2010
and Visual Web Developer Express.
The Web page designer in Visual Studio 2010 has been enhanced for better CSS compatibility, includes additional support for HTML
and ASP.NET markup snippets,
and features a redesigned version of IntelliSense for JScript. Improved CSS Compatibility
The Visual Web Developer designer in Visual Studio 2010 has been updated to improve CSS 2.1 standards compliance.
The designer better preserves HTML source code
and is more robust than in previous versions of Visual Studio. HTML
and JScript Snippets In
the HTML editor, IntelliSense auto-completes tag names.
The IntelliSense Snippets feature auto-completes whole tags
and more. In Visual Studio 2010, IntelliSense snippets are supported for JScript, alongside C#
and Visual Basic, which were supported in earlier versions of Visual Studio. Visual Studio 2010 includes over 200 snippets that help you auto-complete common ASP.NET
and HTML tags, including required attributes (such as runat="server")
and common attributes specific to a tag (such as ID, DataSourceID, ControlToValidate,
and Text). You can download additional snippets, or you can write your own snippets that encapsulate
the blocks of markup that you or your
team use for common tasks. For more information on HTML snippets, see Walkthrough: Using HTML Snippets. JScript IntelliSense Enhancements In Visual 2010, JScript IntelliSense has been redesigned to provide an even richer editing experience. IntelliSense now recognizes objects that have been dynamically generated by methods such as registerNamespace
and by similar techniques used by other JavaScript frameworks. Performance has been improved to analyze large libraries of script
and to display IntelliSense with little or no processing delay. Compatibility has been significantly increased to support almost all third-party libraries
and to support diverse coding styles. Documentation comments are now parsed as you type
and are immediately leveraged by IntelliSense. Web Application Deployment with Visual Studio 2010 For Web application projects, Visual Studio now provides tools that work with
the IIS Web Deployment Tool (Web Deploy) to automate many processes that had to be done manually in earlier versions of ASP.NET. For example,
the following tasks can now be automated: Creating an IIS application on
the destination computer
and configuring IIS settings. Copying files to
the destination computer. Changing Web.config settings that must be different in
the destination environment. Propagating changes to data or data structures in SQL Server databases that are used by
the Web application. For more information about Web application deployment, see ASP.NET Deployment Content Map. Enhancements to ASP.NET Multi-Targeting ASP.NET 4 adds new features to
the multi-targeting feature to make it easier to work with projects that target earlier versions of
the .NET Framework. Multi-targeting was introduced in ASP.NET 3.5 to enable you to use
the latest version of Visual Studio without having to upgrade existing Web sites or Web services to
the latest version of
the .NET Framework. In Visual Studio 2008, when you work with a project targeted for an earlier version of
the .NET Framework, most features of
the development environment adapt to
the targeted version. However, IntelliSense displays language features that are available in
the current version,
and property windows display properties available in
the current version. In Visual Studio 2010, only language features
and properties available in
the targeted version of
the .NET Framework are shown. For more information about multi-targeting, see
the following topics: .NET Framework Multi-Targeting for ASP.NET Web Projects ASP.NET Side-by-Side Execution Overview How to: Host Web Applications That Use Different Versions of
the .NET Framework on
the Same Server How to: Deploy Web Site Projects Targeted for Earlier Versions of
the .NET Framework
