Beruflich Dokumente
Kultur Dokumente
Selecting data
Value providers
Smart Tasks
WAI-ARIA support
Automatic renaming of matching tag when you rename an opening or closing tag
Smart indent
Code outlining
Brace matching
Go to Definition
ECMAScript5 support
DOM IntelliSense
Implicit references
CSS Editor
Hierarchical indentation.
Color picker
Snippets
Custom regions
Page Inspector
Publishing
Publish profiles
ASP.NET precompilation and merge
IIS Express
Disclaimer
The .NET Framework 4 introduced an asynchronous programming concept referred to as a task. Tasks are represented by
the Task type and related types in the System.Threading.Tasks namespace. The .NET Framework 4.5 builds on this with compiler
enhancements that make working with Task objects simple. In the .NET Framework 4.5, the compilers support two new
keywords: await and async. The await keyword is syntactical shorthand for indicating that a piece of code should asynchronously
wait on some other piece of code. The async keyword represents a hint that you can use to mark methods as task-based
asynchronous methods.
The combination of await, async, and the Task object makes it much easier for you to write asynchronous code in .NET 4.5. ASP.NET
4.5 supports these simplifications with new APIs that let you write asynchronous HTTP modules and asynchronous HTTP handlers
using the new compiler enhancements.
AntiXSS Library
Due to the popularity of the Microsoft AntiXSS Library, ASP.NET 4.5 now incorporates core encoding routines from version 4.0 of that
library.
The encoding routines are implemented by the AntiXssEncoder type in the new System.Web.Security.AntiXssnamespace. You can
use the AntiXssEncoder type directly by calling any of the static encoding methods that are implemented in the type. However, the
easiest approach for using the new anti-XSS routines is to configure an ASP.NET application to use the AntiXssEncoder class by
default. To do this, add the following attribute to the Web.config file:
<httpRuntime ...
encoderType="System.Web.Security.AntiXss.AntiXssEncoder,System.Web, Version=4.0.0.0, Culture=neutral,
PublicKeyToken=b03f5f7f11d50a3a" />
When the encoderType attribute is set to use the AntiXssEncoder type, all output encoding in ASP.NET automatically uses the new
encoding routines.
These are the portions of the external AntiXSS library that have been incorporated into ASP.NET 4.5:
jquery-ui.js
3.
jquery.tools.js
4.
a.js
CSS files are also sorted alphabetically and then reorganized so that reset.css and normalize.css come before any other file. The
final sorting of the bundling of the Styles folder shown above will be this:
1.
reset.css
2.
content.css
3.
forms.css
4.
globals.css
5.
menu.css
6.
styles.css
The time it takes for a site to restart after an app pool recycles. This is the time it takes to launch a web server process for
the site when the site assemblies are no longer in memory. (The platform assemblies are still in memory, since they are used by
other sites.) This situation is referred to as "cold site, warm framework startup" or just "cold site startup."
How much memory the site occupies. Terms for this are "per-site memory consumption" or "unshared working set."
Improvements that require the .NET Framework 4.5 but can run on any version of Windows.
Improvements that are available only with .NET Framework 4.5 running on Windows 8.
Performance increases with each level of improvement that you are able to enable.
Some of the .NET Framework 4.5 improvements take advantage of broader performance features that apply to other scenarios as
well.
</EditItemTemplate>
</asp:FormView>
Most controls in the ASP.NET Web Forms framework that support data binding have been updated to support theItemType property.
Model Binding
Model binding extends data binding in ASP.NET Web Forms controls to work with code-focused data access. It incorporates concepts
from the ObjectDataSource control and from model binding in ASP.NET MVC.
Selecting data
To configure a data control to use model binding to select data, you set the control's SelectMethod property to the name of a method
in the page's code. The data control calls the method at the appropriate time in the page life cycle and automatically binds the
returned data. There's no need to explicitly call the DataBind method.
In the following example, the GridView control is configured to use a method named GetCategories:
<asp:GridView ID="categoriesGrid"
runat="server"
ItemType="WebApplication1.Model.Category"
SelectMethod="GetCategories" AutoGenerateColumns="false">
<Columns>
<asp:BoundField DataField="CategoryID" HeaderText="ID" />
<asp:BoundField DataField="CategoryName" HeaderText="Name" />
<asp:BoundField DataField="Description" HeaderText="Description" />
<asp:TemplateField HeaderText="# of Products">
<ItemTemplate><%# Item.Products.Count %></ItemTemplate>
</asp:TemplateField>
</Columns>
</asp:GridView>
You create the GetCategories method in the page's code. For a simple select operation, the method needs no parameters and should
return an IEnumerable or IQueryable object. If the new ItemType property is set (which enables strongly typed data-binding
expressions, as explained under Strongly Typed Data Controls earlier), the generic versions of these interfaces should be returned
IEnumerable<T> or IQueryable<T>, with the T parameter matching the type of the ItemType property (for
example, IQueryable<Category>).
The following example shows the code for a GetCategories method. This example uses the Entity Framework Code First model with
the Northwind sample database. The code makes sure that the query returns details of the related products for each category by
way of the Include method. (This ensures that the TemplateField element in the markup displays the count of products in each
category without requiring an n+1 select.)
public IQueryable<Category>
GetCategories()
{
var db = new Northwind();
return db.Categories.Include(c => c.Products);
}
When the page runs, the GridView control calls the GetCategories method automatically and renders the returned data using the
configured fields:
Because the select method returns an IQueryable object, the GridView control can further manipulate the query before executing it.
For example, the GridView control can add query expressions for sorting and paging to the returned IQueryable object before it is
executed, so that those operations are performed by the underlying LINQ provider. In this case, Entity Framework will ensure those
operations are performed in the database.
The following example shows the GridView control modified to allow sorting and paging:
<asp:GridView ID="categoriesGrid"
runat="server"
AutoGenerateColumns="false"
AllowSorting="true" AllowPaging="true" PageSize="5"
ItemType="WebApplication1.Model.Category" DataKeyNames="CategoryID"
SelectMethod="GetCategories"
UpdateMethod="UpdateCategory">
<Columns>
<asp:BoundField DataField="CategoryID" HeaderText="ID" SortExpression="CategoryID" />
<asp:BoundField DataField="CategoryName" HeaderText="Name" SortExpression="CategoryName" />
<asp:BoundField DataField="Description" HeaderText="Description" />
<asp:TemplateField HeaderText="# of Products">
<ItemTemplate><%# Item.Products.Count %></ItemTemplate>
</asp:TemplateField>
</Columns>
<EmptyDataTemplate>No categories found with a product count of
<%# minProductsCount.SelectedValue %></EmptyDataTemplate>
</asp:GridView>
Now when the page runs, the control can make sure that only the current page of data is displayed and that its ordered by the
selected column:
To filter the returned data, parameters have to be added to the select method. These parameters will be populated by the model
binding at run time, and you can use them to alter the query before returning the data.
For example, assume that you want to let users filter products by entering a keyword in the query string. You can add a parameter
to the method and update the code to use the parameter value:
public IQueryable<Product>
GetProducts(string keyword)
{
IQueryable<Product> query = _db.Products;
if (!String.IsNullOrWhiteSpace(keyword))
{
query = query.Where(p => p.ProductName.Contains(keyword));
}
return query;
}
This code includes a Where expression if a value is provided for keyword and then returns the query results.
Value providers
The previous example was not specific about where the value for the keyword parameter was coming from. To indicate this
information, you can use a parameter attribute. For this example, you can use the QueryStringAttributeclass thats in
the System.Web.ModelBinding namespace:
public IQueryable<Product>
GetProducts([QueryString]string keyword)
{
IQueryable<Product> query = _db.Products;
if (!String.IsNullOrWhiteSpace(keyword))
{
query = query.Where(p => p.ProductName.Contains(keyword));
}
return query;
}
This instructs model binding to try to bind a value from the query string to the keyword parameter at run time. (This might involve
performing type conversion, although it doesn't in this case.) If a value cannot be provided and the type is non-nullable, an
exception is thrown.
The sources of values for these methods are referred to as value providers, and the parameter attributes that indicate which value
provider to use are referred to as value provider attributes. Web Forms will include value providers and corresponding attributes for
all of the typical sources of user input in a Web Forms application, such as the query string, cookies, form values, controls, view
state, session state, and profile properties. You can also write custom value providers.
By default, the parameter name is used as the key to find a value in the value provider collection. In the example, the code will look
for a query-string value named keyword (for example, ~/default.aspx?keyword=chef). You can specify a custom key by passing it as
an argument to the parameter attribute. For example, to use the value of the query-string variable named q, you could do this:
public IQueryable<Product>
GetProducts([QueryString("q")]string keyword)
{
IQueryable<Product> query = _db.Products;
if (!String.IsNullOrWhiteSpace(keyword))
{
query = query.Where(p => p.ProductName.Contains(keyword));
}
return query;
}
If this method is in the page's code, users can filter the results by passing a keyword using the query string:
Model binding accomplishes many tasks that you would otherwise have to code by hand: reading the value, checking for a null
value, attempting to convert it to the appropriate type, checking whether the conversion was successful, and finally, using the value
in the query. Model binding results in far less code and in the ability to reuse the functionality throughout your application.
Unobtrusive Validation
You can now configure the built-in validator controls to use unobtrusive JavaScript for client-side validation logic. This significantly
reduces the amount of JavaScript rendered inline in the page markup and reduces the overall page size. You can configure
unobtrusive JavaScript for validator controls in any of these ways:
Globally by adding the following setting to the <appSettings> element in the Web.config file:
<add name="ValidationSettings:UnobtrusiveValidationMode" value="WebForms" />
HTML5 Updates
Some improvements have been made to Web Forms server controls to take advantage of new features of HTML5:
The TextMode property of the TextBox control has been updated to support the new HTML5 input types
likeemail, datetime, and so on.
The FileUpload control now supports multiple file uploads from browsers that support this HTML5 feature.
Validator controls now support validating HTML5 input elements.
New HTML5 elements that have attributes that represent a URL now support runat="server". As a result, you can use
ASP.NET conventions in URL paths, like the ~ operator to represent the application root (for example, <video runat="server"
src="~/myVideo.wmv" />).
The UpdatePanel control has been fixed to support posting HTML5 input fields.
ASP.NET MVC 4
ASP.NET MVC 4 Beta is now included with Visual Studio 11 Beta. ASP.NET MVC is a framework for developing highly testable and
maintainable Web applications by leveraging the Model-View-Controller (MVC) pattern. ASP.NET MVC 4 makes it easy to build
applications for the mobile Web and includes ASP.NET Web API, which helps you build HTTP services that can reach any device. For
more information, see the ASP.NET MVC 4 Release Notes.
Enabling logins from Facebook and other sites using OAuth and OpenID.
For more information about these features and full-page code examples, see The Top Features in Web Pages 2 Beta.
FileUpgradeFlags
UpgradeBackupLocation
OldToolsVersion
VisualStudioVersion
VSToolsPath
FileUpgradeFlags, UpgradeBackupLocation, and OldToolsVersion are used by the process that upgrades the project file. They have no
impact on working with the project in Visual Studio 2010.
VisualStudioVersion is a new property used by MSBuild 4.5 that indicates the version of Visual Studio for the current project. Because
this property didnt exist in MSBuild 4.0 (the version of MSBuild that Visual Studio 2010 SP1 uses), we inject a default value into the
project file.
The VSToolsPath property is used to determine the correct .targets file to import from the path represented by the
MSBuildExtensionsPath32 setting.
There are also some changes related to Import elements. These changes are required in order to support compatibility between both
versions of Visual Studio.
Note: If a project is being shared between Visual Studio 2010 SP1 and Visual Studio 11 Beta on two different computers, and if the
project includes a local database in the App_Data folder, you must make sure that the version of SQL Server used by the database is
installed on both computers.
In the <httpRuntime> element, the encoderType attribute is now set by default to use the AntiXSS types that were added
to ASP.NET. For details, see AntiXSS Library.
Also in the <httpRuntime> element, the requestValidationMode attribute is set to "4.5". This means that by default,
request validation is configured to use deferred ("lazy") validation. For details, see New ASP.NET Request Validation Features.
Install the update that's described in the Microsoft Support article listed previously.
Set runAllManagedModulesForAllRequests to true in that website's Web.config file. Note that this will add some
overhead to requests.
HTML Editor
Smart Tasks
In Design view, complex properties of server controls often have associated dialog boxes and wizards to make it easy to set them.
For example, you can use a special dialog box to add a data source to a Repeater control or add columns to a GridView control.
However, this type of UI help for complex properties has not been available in Source view. Therefore, Visual Studio 11 introduces
Smart Tasks for Source view. Smart Tasks are context-aware shortcuts for commonly used features in the C# and Visual Basic
editors.
For ASP.NET Web Forms controls, Smart Tasks appear on server tags as a small glyph when the insertion point is inside the element:
The Smart Task expands when you click the glyph or press CTRL+. (dot), just as in the code editors. It then displays shortcuts that
are similar to the Smart Tasks in Design view.
For example, the Smart Task in the previous illustration shows the GridView Tasks options. If you choose Edit Columns, the following
dialog box is displayed:
Filling in the dialog box sets the same properties you can set in Design view. When you click OK, the markup for the control is
updated with the new settings:
WAI-ARIA support
Writing accessible websites is becoming increasingly important. The WAI-ARIA accessibility standard defines how developers should
write accessible websites. This standard is now fully supported in Visual Studio.
For example, the role attribute now has full IntelliSense:
The WAI-ARIA standard also introduces attributes that are prefixed with aria- that let you add semantics to an HTML5 document.
Visual Studio also fully supports these aria- attributes:
To invoke the snippet, press Tab twice when the element is selected in IntelliSense:
In large web pages, it can be a good idea to move individual pieces into user controls. This form of refactoring can help increase the
readability of the page and can simplify the page structure.
To make this easier, when you edit Web Forms pages in Source view, you can now select text in a page, right-click it, and then
choose Extract to User Control:
This helps avoid the error where you forget to change a closing tag or change the wrong one.
By default, the event handler will use the control's ID for the name of the event-handling method:
The resulting event handler will look like this (in this case, in C#):
Smart indent
When you press Enter while inside an empty HTML element, the editor will put the insertion point in the right place:
If you press Enter in this location, the closing tag is moved down and indented to match the opening tag. The insertion point is also
indented:
IntelliSense also filters based on the title case of the individual words in the IntelliSense list. For example, if you type "dl", both dl
and asp:DataList are displayed:
This feature makes it faster to get statement completion for known elements.
JavaScript Editor
The JavaScript editor in Visual Studio 2012 Release Candidate is completely new and it greatly improves the experience of working
with JavaScript in Visual Studio.
Code outlining
Outlining regions are now automatically created for all functions, allowing you to collapse parts of the file that arent pertinent to
your current focus.
Brace matching
When you put the insertion point on an opening or closing brace, the editor highlights the matching one.
Go to Definition
The Go to Definition command lets you jump to the source for a function or variable.
ECMAScript5 support
The editor supports the new syntax and APIs in ECMAScript5, the latest version of the standard that describes the JavaScript
language.
DOM IntelliSense
IntelliSense for DOM APIs has been improved, with support for many new HTML5 APIs including querySelector, DOM Storage, crossdocument messaging, and canvas. DOM IntelliSense is now driven by a single simple JavaScript file, rather than by a native type
library definition. This makes it easy to extend or replace.
Implicit references
You can now add JavaScript files to a central list that will be implicitly included in the list of files that any given JavaScript file or
block references, meaning youll get IntelliSense for its contents. For example, you can add jQuery files to the central list of files,
and youll get IntelliSense for jQuery functions in any JavaScript block of file, whether youve referenced it explicitly (using ///
<reference />) or not.
CSS Editor
Auto-reduce statement completion
The IntelliSense list for CSS now filters based on the CSS properties and values supported by the selected schema.
Hierarchical indentation
The CSS editor uses indentation to display hierarchical rules, which gives you an overview of how the cascading rules are logically
organized. In the following example, the #list a selector is a cascading child of list and is therefore indented.
The indentation of a rule is determined by its parent rules. Hierarchical indentation is enabled by default, but you can disable it the
Options dialog box (Tools, Options from the menu bar):
Analysis of hundreds of real-world CSS files shows that CSS hacks are very common, and now Visual Studio supports the most widely
used ones. This support includes IntelliSense and validation of the star (*) and underscore (_) property hacks:
Typical selector hacks are also supported so that hierarchical indentation is maintained even when they are applied. A typical
selector hack used to target Internet Explorer 7 is to prepend a selector with *:first-child + html. Using that rule will maintain the
hierarchical indentation:
Color picker
In previous versions of Visual Studio, IntelliSense for color-related attributes consisted of a drop-down list of named color values.
That list has been replaced by a full-featured color picker.
When you enter a color value, the color picker is displayed automatically and presents a list of previously used colors followed by a
default color palette. You can select a color using the mouse or the keyboard.
The list can be expanded into a complete color picker. The picker lets you control the alpha channel by automatically converting any
color into RGBA when you move the opacity slider:
Snippets
Snippets in the CSS editor make it easier and faster to create cross-browser styles. Many CSS3 properties that require browserspecific settings have now been rolled into snippets.
CSS snippets support advanced scenarios (like CSS3 media queries) by typing the at-symbol (@), which shows the IntelliSense list.
When you select @media value and press Tab, the CSS editor inserts the following snippet:
As with snippets for code, you can create your own CSS snippets.
Custom regions
Named code regions, which are already available in the code editor, are now available for CSS editing. This lets you easily group
related style blocks.
Page Inspector
Page Inspector is a tool that renders a web page (HTML, Web Forms, ASP.NET MVC, or Web Pages) in the Visual Studio IDE and lets
you examine both the source code and the resulting output. For ASP.NET pages, Page Inspector lets you determine which server-side
code has produced the HTML markup that is rendered to the browser.
For more information about Page Inspector, see the Page Inspector Release Notes.
Publishing
Publish profiles
In Visual Studio 2010, publishing information for Web application projects is not stored in version control and is not designed for
sharing with others. In Visual Studio 2012 Release Candidate, the format of the publish profile has been changed. It has been made
a team artifact, and it is now easy to leverage from builds based on MSBuild. Build configuration information is in the Publish dialog
box so that you can easily switch build configurations before publishing.
Publish profiles are stored in the PublishProfiles folder. The location of the folder depends on what programming language you are
using:
C#: Properties\PublishProfiles
Visual Basic: My Project\PublishProfiles
Each profile is an MSBuild file. During publishing, this file is imported into the project's MSBuild file. In Visual Studio 2010, if you
want to make changes to the publish or package process, you have to put your customizations in a file
named ProjectName.wpp.targets. This is still supported, but you can now put your customizations in the publish profile itself. That
way, the customizations will be used only for that profile.
You can now also leverage publish profiles from MSBuild. To do so, use the following command when you build the project:
msbuild.exe project.csproj /t:WebPublish /p:PublishProfile=ProfileName
The project.csproj value is the path of the project, and ProfileName is the name of the profile to publish. Alternatively, instead of
passing the profile name for the PublishProfile property, you can pass in the full path to the publish profile.
When this option is selected, Visual Studio precompiles the application whenever you publish or package the web application. If you
want to control how the site is precompiled or how assemblies are merged, click the Advanced button to configure those options.
IIS Express
The default web server for testing web projects in Visual Studio is now IIS Express. The Visual Studio Development Server is still an
option for local web server during development, but IIS Express is now the recommended server. The experience of using IIS Express
in Visual Studio 11 Beta is very similar to using it in Visual Studio 2010 SP1.
Disclaimer
This is a preliminary document and may be changed substantially prior to final commercial release of the software described herein.
The information contained in this document represents the current view of Microsoft Corporation on the issues discussed as of the
date of publication. Because Microsoft must respond to changing market conditions, it should not be interpreted to be a commitment
on the part of Microsoft, and Microsoft cannot guarantee the accuracy of any information presented after the date of publication.
This White Paper is for informational purposes only. MICROSOFT MAKES NO WARRANTIES, EXPRESS, IMPLIED OR STATUTORY, AS TO
THE INFORMATION IN THIS DOCUMENT.
Complying with all applicable copyright laws is the responsibility of the user. Without limiting the rights under copyright, no part of
this document may be reproduced, stored in or introduced into a retrieval system, or transmitted in any form or by any means
(electronic, mechanical, photocopying, recording, or otherwise), or for any purpose, without the express written permission of
Microsoft Corporation.
Microsoft may have patents, patent applications, trademarks, copyrights, or other intellectual property rights covering subject
matter in this document. Except as expressly provided in any written license agreement from Microsoft, the furnishing of this
document does not give you any license to these patents, trademarks, copyrights, or other intellectual property.
Unless otherwise noted, the example companies, organizations, products, domain names, e-mail addresses, logos, people, places
and events depicted herein are fictitious, and no association with any real company, organization, product, domain name, email
address, logo, person, place or event is intended or should be inferred.
2012 Microsoft Corporation. All rights reserved.
Microsoft and Windows are either registered trademarks or trademarks of Microsoft Corporation in the United States and/or other
countries.
The names of actual companies and products mentioned herein may be the trademarks of their respective owners.
By Microsoft ASP.NET Team, ASP.NET is a free web framework for building great Web sites and Web
applications using HTML, CSS and JavaScript.