Microsoft released the .
NET Runtime 4.0 and with it comes a brand spanking new version of
ASP.
NET – version 4.0 – which provides an incremental set of improvements
to an already powerful platform. .
NET 4.0 is a full release of the .
NET Framework, unlike version 3.5, which was merely a set of library updates on top of the .
NET Framework version 2.0. Because of this full framework revision, there has been a welcome bit of consolidation of assemblies and configuration settings. The full runtime version change
to 4.0 also means that you have
to explicitly pick version 4.0 of the runtime when you create a new Application Pool in IIS, unlike .
NET 3.5, which actually requires version 2.0 of the runtime.
In this first of two parts I'll take a look at some of the changes in the core
ASP.
NET runtime. In the next edition I'll go over improvements in Web Forms and Visual Studio.
Core Engine Features
Most of the high profile improvements in
ASP.
NET have
to do with Web Forms, but there are a few gems in the core runtime that should make life easier for
ASP.
NET developers. The following list describes some of the things I've found useful among the new features.
Clean web.config Files Are Back!
If you've been using
ASP.
NET 3.5, you probably have noticed that the web.config file has turned into quite a mess of configuration settings between all the custom handler and module mappings for the various web server versions. Part of the reason for this mess is that .
NET 3.5 is a collection of add-on components running on top of the .
NET Runtime 2.0 and so almost all of the new features of .
NET 3.5 where essentially introduced as custom modules and handlers that had
to be explicitly configured in the config file. Because the core runtime didn't rev with 3.5, all those configuration options couldn't be moved up
to other configuration files in the system chain. With version 4.0 a consolidation was possible, and the result is a much simpler web.config file by default.
A default empty
ASP.
NET 4.0 Web Forms project looks like this:
<?xml
version="1.0"?>
<configuration>
<system.web>
<compilation
debug="true"
targetFramework="4.0" />
</system.web>
</configuration>
Need I say more?
Configuration Transformation Files
to Manage Configurations and Application Packaging
ASP.
NET 4.0 introduces the ability
to create multi-target configuration files. This means it's possible
to create a single configuration file that can be transformed based on relatively simple replacement rules using a Visual Studio and WebDeploy provided XSLT syntax. The idea is that you can create a 'master' configuration file and then create customized versions of this master configuration file by applying some relatively simplistic search and replace, add or remove logic
to specific elements and attributes in the original file.
To give you an idea, here's the example code that Visual Studio creates for a default web.Release.config file, which replaces a connection string, removes the debug attribute and replaces the CustomErrors section:
<?xml
version="1.0"?>
<configuration
xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
<connectionStrings>
<add
name="MyDB"
connectionString="Data Source=ReleaseSQLServer;Initial
Catalog=MyReleaseDB;Integrated Security=True"
xdt:Transform="SetAttributes"
xdt:Locator="Match(name)"/>
</connectionStrings>
<system.web>
<compilation
xdt:Transform="RemoveAttributes(debug)" />
<customErrors
defaultRedirect="GenericError.htm"
mode="RemoteOnly"
xdt:Transform="Replace">
<error
statusCode="500"
redirect="InternalError.htm"/>
</customErrors>
</system.web>
</configuration>
You can see the XSL transform syntax that drives this functionality. Basically, only the elements listed in the override file are matched and updated – all the rest of the original web.config file stays intact.
Visual Studio 2010 supports this functionality directly in the project system so it's easy
to create and maintain these customized configurations in the project tree. Once you're ready
to publish your application, you can then use the Publish <yourWebApplication> option on the Build menu which allows publishing
to disk, via FTP or
to a Web Server using Web Deploy. You can also create a deployment package as a .zip file which can be used by the WebDeploy tool
to configure and install the application. You can manually run the Web Deploy tool or use the IIS Manager
to install the package on the server or other machine.
You can find out more about WebDeploy and Packaging here: http://tinyurl.com/2anxcje.
Improved Routing
Routing provides a relatively simple way
to create clean URLs with
ASP.
NET by associating a template URL path and routing it
to a specific
ASP.
NET HttpHandler. Microsoft first introduced routing with
ASP.
NET MVC and then they integrated routing with a basic implementation in the core
ASP.
NET engine via a separate
ASP.
NET routing assembly.
In
ASP.
NET 4.0, the process of using routing functionality gets a bit easier. First, routing is now rolled directly into System.Web, so no extra assembly reference is required in your projects
to use routing. The RouteCollection class now includes a MapPageRoute() method that makes it easy
to route
to any
ASP.
NET Page requests without first having
to implement an IRouteHandler implementation. It would have been nice if this could have been extended
to serve *any* handler implementation, but unfortunately for anything but a Page derived handlers you still will have
to implement a custom IRouteHandler implementation.
ASP.
NET Pages now include a RouteData collection that will contain route information. Retrieving route data is now a lot easier by simply using this.RouteData.Values["routeKey"] where the routeKey is the value specified in the route template (i.e., "users/{userId}" would use Values["userId"]).
The Page class also has a GetRouteUrl() method that you can use
to create URLs with route data values rather than hardcoding the URL:
<%=
this.GetRouteUrl("users",new { userId="ricks" }) %>
You can also use the new Expression syntax using <%$RouteUrl %>
to accomplish something similar, which can be easier
to embed into Page or MVC View code:
<a
runat="server"
href='<%$RouteUrl:RouteName=user, id=ricks %>'>Visit User</a>
Finally, the Response object also includes a new RedirectToRoute() method
to build a route url for redirection without hardcoding the URL.
Response.RedirectToRoute("users", new { userId = "ricks" });
All of these routines are helpers that have been integrated into the core
ASP.
NET engine
to make it easier
to create routes and retrieve route data, which hopefully will result in more people taking advantage of routing in
ASP.
NET.
To find out more about the routing improvements you can check out Dan Maharry's blog which has a couple of nice blog entries on this subject: http://tinyurl.com/37trutj and http://tinyurl.com/39tt5w5.
Session State Improvements
Session state is an often used and abused feature in
ASP.
NET and version 4.0 introduces a few enhancements geared towards making session state more efficient and
to minimize at least some of the ill effects of overuse. The first improvement affects out of process session state, which is typically used in web farm environments or for sites that store application sensitive data that must survive AppDomain restarts (which in my opinion is just about any application). When using OutOfProc session state,
ASP.
NET serializes all the data in the session statebag into a blob that gets carried over the network and stored either in the State server or SQL Server via the Session provider.
Version 4.0 provides some improvement in this serialization of the session data by offering an enableCompression option on the web.Config <Session> section, which forces the serialized session state
to be compressed. Depending on the type of data that is being serialized, this compression can reduce the size of the data travelling over the wire by as much as a third. It works best on string data, but can also reduce the size of binary data.
In addition,
ASP.
NET 4.0 now offers a way
to programmatically turn session state on or off as part of the request processing queue. In prior versions, the only way
to specify whether session state is available is by implementing a marker interface on the HTTP handler implementation. In
ASP.
NET 4.0, you can now turn session state on and off programmatically via HttpContext.Current.SetSessionStateBehavior() as part of the
ASP.
NET module pipeline processing as long as it occurs before the AquireRequestState pipeline event.
Output Cache Provider
Output caching in
ASP.
NET has been a very useful but potentially memory intensive feature. The default OutputCache mechanism works through in-memory storage that persists generated output based on various lifetime related parameters. While this works well enough for many intended scenarios, it also can quickly cause runaway memory consumption as the cache fills up and serves many variations of pages on your site.
ASP.
NET 4.0 introduces a provider model for the OutputCache module so it becomes possible
to plug-in custom storage strategies for cached pages. One of the goals also appears
to be
to consolidate some of the different cache storage mechanisms used in .
NET in general
to a generic Windows AppFabric framework in the future, so various different mechanisms like OutputCache, the non-Page specific
ASP.
NET cache and possibly even session state eventually can use the same caching engine for storage of persisted data both in memory and out of process scenarios.
For developers, the OutputCache provider feature means that you can now extend caching on your own by implementing a custom Cache provider based on the System.Web.Caching.OutputCacheProvider class. You can find more info on creating an Output Cache provider in Gunnar Peipman's blog at: http://tinyurl.com/2vt6g7l.
Response.RedirectPermanent
ASP.
NET 4.0 includes features
to issue a permanent redirect that issues as an HTTP 301 Moved Permanently response rather than the standard 302 Redirect respond. In pre-4.0 versions you had
to manually create your permanent redirect by setting the Status and Status code properties – Response.RedirectPermanent() makes this operation more obvious and discoverable. There's also a Response.RedirectToRoutePermanent() which provides permanent redirection of route Urls.
Preloading of Applications
ASP.
NET 4.0 provides a new feature
to preload
ASP.
NET applications on startup, which is meant
to provide a more consistent startup experience. If your application has a lengthy startup cycle it can appear very slow
to serve data
to clients while the application is warming up and loading initial resources. So rather than serve these startup requests slowly in
ASP.
NET 4.0, you can force the application
to initialize itself first before even accepting requests for processing.
This feature works only on IIS 7.5 (Windows 7 and Windows Server 2008 R2) and works in combination with IIS. You can set up a worker process in IIS 7.5
to always be running, which starts the Application Pool worker process immediately.
ASP.
NET 4.0 then allows you
to specify site-specific settings by setting the serverAutoStartEnabled on a particular site along with an optional serviceAutoStartProvider class that can be used
to receive "startup events" when the application starts up. This event in turn can be used
to configure the application and optionally pre-load cache data and other information required by the app on startup.
The configuration settings need
to be made in applicationhost.config:
<sites>
<site
name="WebApplication2"
id="1">
<application
path="/"
serviceAutoStartEnabled="true"
serviceAutoStartProvider="PreWarmup" />
</site>
</sites>
<serviceAutoStartProviders>
<add
name="PreWarmup"
type="PreWarmupProvider,MyAssembly" />
</serviceAutoStartProviders>
Hooking up a warm up provider is optional so you can omit the provider definition and reference. If you do define it here's what it looks like:
public
class
PreWarmupProvider
System.Web.Hosting.IProcessHostPreloadClient
{
public
void Preload(string[] parameters)
{
// initialization for app
}
}
This code fires and while it's running,
ASP.NET/IIS will hold requests from hitting the pipeline. So until this code completes the application will not start taking requests. The idea is that you can perform any pre-loading of resources and cache values so that the first request will be ready
to perform at optimal performance level without lag.
Runtime Performance Improvements
According
to Microsoft, there have also been a number of invisible performance improvements in the internals of the
ASP.
NET runtime that should make
ASP.
NET 4.0 applications run more efficiently and use less resources. These features come without any change requirements in applications and are virtually transparent, except that you get the benefits by updating
to ASP.
NET 4.0.
Summary
The core feature set changes are minimal which continues a tradition of small incremental changes
to the
ASP.
NET runtime.
ASP.
NET has been proven as a solid platform and I'm actually rather happy
to see that most of the effort in this release went into stability, performance and usability improvements rather than a massive amount of new features. The new functionality added in 4.0 is minimal but very useful.
A lot of people are still running pure .
NET 2.0 applications these days and have stayed off of .
NET 3.5 for some time now. I think that version 4.0 with its full .
NET runtime rev and assembly and configuration consolidation will make an attractive platform for developers
to update
to.
If you're a Web Forms developer in particular,
ASP.
NET 4.0 includes a host of new features in the Web Forms engine that are significant enough
to warrant a quick move
to .
NET 4.0. I'll cover those changes in my next column. Until then, I suggest you give
ASP.
NET 4.0 a spin and see for yourself how the new features can help you out.
© Rick Strahl, West Wind Technologies, 2005-2010Posted in
ASP.NET
