Mixing ASP.NET Webforms and ASP.

NET MVC
Ever since Microsoft started working on the ASP.NET MVC framework, one of the primary concerns was
the framework's ability to re-use as many features as possible from ASP.NET Webforms. In this article
by Maarten Balliauw, we will see how we can mix ASP.NET Webforms and ASP.NET MVC in one
application and how data is shared between both these technologies.
Not every ASP.NET MVC web application will be built from scratch. Several projects will probably end up migrating
from classic ASP.NET to ASP.NET MVC. The question of how to combine both technologies in one application arises—is
it possible to combine both ASP.NET Webforms and ASP.NET MVC in one web application? Luckily, the answer is yes.
Combining ASP.NET Webforms and ASP.NET MVC in one application is possible—in fact, it is quite easy. The reason
for this is that the ASP.NET MVC framework has been built on top of ASP.NET. There's actually only one crucial
difference: ASP.NET lives in System.Web, whereas ASP.NET MVC lives in System.Web, System.Web.Routing,
System.Web.Abstractions, and System.Web.Mvc. This means that adding these assemblies as a reference in an
existing ASP.NET application should give you a good start on combining the two technologies.
Another advantage of the fact that ASP.NET MVC is built on top of ASP.NET is that data can be easily shared between
both of these technologies. For example, the Session state object is available in both the technologies, effectively
enabling data to be shared via the Session state.

Plugging ASP.NET MVC into an existing

ASP.NET application
An ASP.NET Webforms application can become ASP.NET MVC enabled by following some simple steps. First of all, add
a reference to the following three assemblies to your existing ASP.NET application:
System.Web.Routing

System.Web.Abstractions

System.Web.Mvc

After adding these assembly references, the ASP.NET MVC folder structure should be created. Because the ASP.NET
MVC framework is based on some conventions (for example, controllers are located in Controllers), these
conventions should be respected. Add the folder Controllers, Views, and Views | Shared to your existing ASP.NET
application.
The next step in enabling ASP.NET MVC in an ASP.NET Webforms application is to update the web.config file, with the
following code:
< ?xml version="1.0"?>
<configuration>
<system.web>
<compilation debug="false">
<assemblies>
<add assembly="System.Core, Version=3.5.0.0, Culture=neutral,
PublicKeyToken=B77A5C561934E089"/>
<add assembly="System.Web.Extensions,
Version=3.5.0.0, Culture=neutral,
PublicKeyToken=31BF3856AD364E35"/>
<add assembly="System.Web.Abstractions,
Version=3.5.0.0, Culture=neutral,
PublicKeyToken=31BF3856AD364E35"/>
<add assembly="System.Web.Routing,
Version=3.5.0.0, Culture=neutral,
PublicKeyToken=31BF3856AD364E35"/>
</assemblies>
</compilation>
<pages>
<namespaces>
<add namespace="System.Web.Mvc"/>
<add namespace="System.Web.Mvc.Ajax"/>
<add namespace="System.Web.Mvc.Html" />
<add namespace="System.Web.Routing"/>
<add namespace="System.Linq"/>
<add namespace="System.Collections.Generic"/>
</namespaces>
</pages>
<httpModules>
<add name="UrlRoutingModule"
type="System.Web.Routing.UrlRoutingModule,
 System.Web.Routing, Version=3.5.0.0,
Culture=neutral, PublicKeyToken=31BF3856AD364E35" />
</httpModules>
</system.web>
</configuration>
Note that your existing ASP.NET Webforms web.config should not be replaced by the above web.config! The
configured sections should be inserted into an existing web.config file in order to enable ASP.NET MVC.
There's one thing left to do: configure routing. This can easily be done by adding the default ASP.NET MVC's global
application class contents into an existing (or new) global application class, Global.asax.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;

namespace MixingBothWorldsExample
{
public class Global : System.Web.HttpApplication
{
public static void RegisterRoutes(RouteCollection routes)
{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
routes.IgnoreRoute("{resource}.aspx/{*pathInfo}");
routes.MapRoute(
"Default",
// Route name
"{controller}/{action}/{id}",
// URL with parameters
new { controller = "Home", action = "Index", id = "" }
// Parameter defaults
);
}
protected void Application_Start()
{
RegisterRoutes(RouteTable.Routes);
}
}
}
This code registers a default ASP.NET MVC route, which will map any URL of the form /Controller/Action/Idinto a
controller instance and action method. There's one difference with an ASP.NET MVC application that needs to be
noted—a catch-all route is defined in order to prevent a request for ASP.NET Webforms to be routed into ASP.NET
MVC. This catch-all route looks like this:
routes.IgnoreRoute("{resource}.aspx/{*pathInfo}");
This is basically triggered on every request ending in .aspx. It tells the routing engine to ignore this request and leave
it to ASP.NET Webforms to handle things.
With the ASP.NET MVC assemblies referenced, the folder structure created, and the necessary configurations in place,
we can now start adding controllers and views. Add a new controller in the Controllers folder, for example, the
following simpleHomeController:
using System.Web.Mvc;
namespace MixingBothWorldsExample.Controllers
{
public class HomeController : Controller
{
public ActionResult Index()
{
ViewData["Message"] = "This is ASP.NET MVC!";
return View();
}
}
}
The above controller will simply render a view, and pass it a message through the ViewData dictionary. This view,
located in Views | Home | Index.aspx, would look like this:
 <%@ Page Language="C#"
AutoEventWireup="true"
CodeBehind="Index.aspx.cs"
Inherits="MixingBothWorldsExample.Views.Home.Index" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head id="Head1" runat="server">
<title></title>
</head>
<body>
<div>
<h1><%=Html.Encode(ViewData["Message"]) %></h1>
</div>
</body>
</html>
The above view renders a simple HTML page and renders the ViewData dictionary's message as the page title.

ASP.NET MVC 1.0 Quickly

Plugging ASP.NET into an existing ASP.NET

MVC application
The road to enabling an existing ASP.NET MVC web application to serve ASP.NET Webforms contents is actually quite
easy. Because the ASP.NET MVC framework is built on top of ASP.NET Webforms, any classic web form will
automatically be available from an ASP.NET MVC web application. This means that any ASPX file will be rendered
using ASP.NET Webforms, unless the route table contains a matching route for handling an ASP.NET MVC request.
To avoid strange results in a mixed application, consider adding a catch-all route to the route table for ASPX pages,
which will ignore any requests to ASP.NET Webforms, and will route only ASP.NET MVC requests. This can be done in
the global application class, Global.asax.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;
 namespace MixingBothWorldsExample
{
public class Global : System.Web.HttpApplication
{

public static void RegisterRoutes(RouteCollection routes)

{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
routes.IgnoreRoute("{resource}.aspx/{*pathInfo}");
routes.MapRoute(
"Default",
// Route name
"{controller}/{action}/{id}",
// URL with parameters
new { controller = "Home", action = "Index", id = "" }
// Parameter defaults
);
}
protected void Application_Start()
{
RegisterRoutes(RouteTable.Routes);
}
}
}
The above code registers a default ASP.NET MVC route, which will map any URL in the form /Controller/Action/Id into
a controller instance and action method. The catch-all route for ASP.NET Webforms looks like this:
routes.IgnoreRoute("{resource}.aspx/{*pathInfo}");

Sharing data between ASP.NET and

ASP.NET MVC
Whether you are creating a new mixed ASP.NET Webforms-ASP.NET MVC application—or doing a migration, the
chances are that you will need to share data between the two technologies. For example, a form can be posted by an
ASP.NET Webforms page to an ASP.NET MVC action method.
Because the ASP.NET MVC framework is built on top of ASP.NET Webforms, the following objects are always available
in both technologies:

1. HttpContext

2. Session
3. Server
4. Request
5. Response
6. Cookies
This way, it is easy to set a Session state item in classic ASP.NET Webforms and read it in ASP.NET MVC.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace MixingBothWorldsExample
{
public partial class _Default : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
Session["SharedData"] = "This message is set by classic
ASP.NET.";
}
}
}
The above code is a "codebehind" for a classic ASP.NET page. As you can see, it sets the SharedData dictionary item
of Session to a string value. This data can easily be read easily in an ASP.NET MVC controller, for example:
using System.Web.Mvc;
namespace MixingBothWorldsExample.Controllers
{
public class HomeController : Controller
{
public ActionResult Index()
{
ViewData["Message"] = "This is ASP.NET MVC!";
ViewData["SharedData"] = Session["SharedData"] ?? "";
return View();
}
}
}
The Index action method tries to read data from the SharedData dictionary item of Session. If it has been set by
ASP.NET Webforms or ASP.NET MVC, it is assigned to the ViewData dictionary. In other cases, an empty string is
passed in.

Building views at compile time

By default, the views in ASP.NET MVC applications are built the first time that a request comes in. This means that if
there is a compilation error in a view, it will only be visible the first time that a user requests for that view to be
rendered. To overcome this issue, views can be compiled whenever the ASP.NET MVC application is compiled.
To build views at compile time, the following steps should be executed:

1. Open the project file in a text editor. For example, start Notepad and open the project file for your ASP.NET
MVC application (that is, MyMvcApplication.csproj).

2. Find the top-most <PropertyGroup> element and add a new element named <MvcBuildViews>:

<MvcBuildViews>:

<PropertyGroup>
...
<MvcBuildViews>true</MvcBuildViews>

</PropertyGroup>

3. Scroll down to the end of the file and uncomment the <Target Name="AfterBuild"> element. Update its
contents to match the following:
<Target Name="AfterBuild"
Condition="'$(MvcBuildViews)'=='true'">

<AspNetCompiler VirtualPath="temp"
PhysicalPath="$(ProjectDir)..$(ProjectName)"/>

</Target>
4. Save the file and reload the project in Visual Studio.
Enabling view compilation may add some extra time to the build process. It is recommended that this
is not enabled during development as a lot of compilation is typically involved during the development
process.

Summary
In this article, we mixed ASP.NET Webforms and ASP.NET MVC in one application and shared data between both
these technologies. We also added a post-build action to a project file to make sure that all views can be compiled.