Marcin On ASP.NET

Keeping my eye on the dot

January, 2011

  • Marcin On ASP.NET

    MVC 3 Project Upgrade Tool


    We have just released the final version of ASP.NET MVC 3. Read the official MVC 3 release information or download MVC 3.

    To help you upgrade your MVC 2 projects to MVC 3 we have released an upgrade tool. You can download it here: (This is an update of the tool that Eilon Lipton previously previewed on his blog and now we are giving it a more permanent home on our CodePlex site).

    April 11 Update: We made a small update to the tool that allows you to skip the backup step. You might want to consider skipping the backup step if you use source control or if your solution is very big.

    January 14 Update: We have updated the file on codeplex to fix an issue with converting solutions that had Web Sites or other solution items. If you are having problems please make sure you download the tool again from the codeplex site.

    The upgrade tool only supports Visual Studio 2010 projects targeting .NET 4. Upgrading both MVC 2 and MVC 3 Beta (or RC) projects is supported.

    The tool does not support Visual Studio 2008 solutions, MVC 1 projects, or projects targeting .NET 3.5. Those projects will first have to be upgraded using Visual Studio 2010 and/or retargeted for .NET 4:

    • If you have a Visual Studio 2008 solution you can simply open it with Visual Studio 2010 to initiate the solution upgrade process.
    • If your projects are targetting .NET 3.5 read how to target .NET 4.
    • If you have a MVC 1.0 project you can use the old version of this tool to convert it to MVC 2.

    MVC upgrade tool screenshot

    The usage of the tool is quite simple:

    1. If you use a source control system make sure your files are checked out and writable
    2. Run the executable
    3. Select your Visual Studio 2010 solution file that contains your project
    4. Review the changes for each item in the Item details pane
    5. Click on the Convert button to initiate the conversion process
    6. Review the results in the Conversion log pane

    During the conversion process the tool will:

    1. Create a backup of the entire solution.
    2. Update all class library projects (including Test projects) that reference System.Web.Mvc.dll to reference version 3.0.
    3. Update all Web Application projects that reference System.Web.Mvc to reference version 3.0 and add references to System.Web.Helpers.dll and System.Web.WebPages.dll.
    4. Change all MVC 2 Web Application projects to be MVC 3 projects (this affects which version of the 'Add View' dialog you get etc) 
    5. Update all MVC Web Application root Web.config files:
      1. Update references to System.Web.Mvc version 3.0.
      2. Add an assembly binding redirect entry for System.Web.Mvc.
      3. Add assembly and namespace references to System.Web.Helpers and System.Web.WebPages.
      4. Add the “ClientValidationEnabled” and “UnobtrusiveJavaScriptEnabled” settings to the <appSettings> element with value “false” if they were not already present (these settings can be used to control the unobtrusive client validation and unobtrusive Ajax features).
    6. Update all MVC Web Application views Web.config files (~\Views\Web.config as well as the views Web.config files for all Areas):
      1. Update references to System.Web.Mvc version 3.0
      2. Add a <configSections> entry required for Razor configuration in MVC
      3. Add the <system.web.webPages.razor> entry required for Razor support in MVC
      4. Add the “webPages:enabled” setting to the <appSettings> element with value “false” (required to prevent .cshtml or .vbhtml files in the Views folder from being directly accessible from a web browser)
    7. Add the following JavaScript libraries to the MVC Web Applications (only if they did not already exist):
      • jQuery 1.4.4 (jquery-1.4.4.js, jquery-1.4.4-vsdoc.js, jquery-1.4.4.min.js)
      • jQuery UI 1.8.7 (jquery-ui.js, jquery-ui.min.js)
      • jQuery Validation 1.7 (jquery-validate.js, jquery-validate-vsdoc.js, jquery-validate.min.js)
      • Microsoft Ajax (MicrosoftAjax.js, Microsoft.Ajax.debug.js)
    8. Overwrite MVC-specific JavaScript files in MVC Web Applications:
      • MicrosoftMvcAjax.js, MicrosoftMvcAjax.debug.js, MicrosoftMvcValidation.js, MicrosoftMvcValidation.debug.js, jquery.unobtrusive-ajax.js, jquery.unobtrusive-ajax.min.js, jquery.validate.unobtrusive.js, jquery.validate.unobtrusive.min.js
    9. Add jQuery UI theme files (stylesheet and images)

    This is an unsupported utility and there is a possibility that it might not work correctly for your solution. Specifically, the tool has the following limitations:

    • Read-only project files are not supported (make sure you check out your solution if you use source control)
    • Very long file paths might cause problems
    • Solutions with project files outside of the solution folder might cause problems
    • The tool will not upgrade your application code to account for any potential runtime breaking changes
    • Non-standard project files (e.g. missing MVC project type GUID) will not be handled correctly
    • Once again, VS 2008 solutions, MVC 1 or .NET 3.5 projects are not supported
    • The tool will also not modify any Web Sites in your solution

    However, if you run into problems let me know and I will see if we can get them addressed.

  • Marcin On ASP.NET

    ASP.NET MVC 3 Performance – on par with MVC 2


    Now that the final version of MVC 3 has been released I think information about the performance characteristics of this latest installment would be very useful for those weighing the pros and cons of updating their MVC 2 applications. In this post I will talk about what you might expect when moving to MVC 3. The short answer is things should be about the same.

    Of course that short statement is not accurate because the only correct answer to such performance questions is: “it depends”. It depends on what your application does and which features it is using: database connections, business logic, output caching, html helpers, etc. I say this because in a moment I will present some numbers and they might not correspond to what you would see in your application. But they should provide you with a good starting point.

    The more detailed answer is that some applications will perform better while others will perform worse. That is because as we added new features (dependency injection, improved filters, etc.) some components of MVC 3 got slower than in MVC 2 simply because they are now doing more work. At the same time we have introduced targeted performance optimizations which improved other components. The only definite way you can know the impact on your application is if you carefully measure performance yourself. At the end of this post I will provide a rough list of some of the things that have gotten faster or slower.

    The Setup

    The application I will use for the tests is the default “Internet Application” project template that ships with every installation of MVC. While quite small, it is still a pretty good choice because it uses a wide variety of MVC features. This means that the test exercises a large part of the framework without focusing on any individual features.

    For my tests I have the following applications:

    1. MVC 2 Aspx Internet Application project running against MVC 2 runtime
    2. MVC 2 Aspx Internet Application project running against MVC 3 runtime
    3. MVC 3 Aspx Internet Application project running against MVC 3 runtime
    4. MVC 3 Razor Internet Application project running against MVC 3 runtime

    I modified each of these applications in the following ways to ensure consistency and remove unnecessary noise from the results:

    • Set debug=”false” in the root Web.config file.
    • Changed application to build in Release mode.
    • Changed the FormsAuthenticationService and MembershipService classes to return hardcoded values (I do not want to test database connection latency).

    For each of the applications I executed the following sequence of requests and recorded the throughput (number of requests per second). The sequence ran for about 1 hour in our performance testing lab (meaning that the results should be amortized with respect to any other OS tasks that might have occurred on the server).

    1. GET /Home/Index (arrive at site)
    2. GET /Account/LogOn (click on “log on” link)
    3. POST /Account/LogOn (attempt to log on with invalid credentials)
    4. GET /Account/Register (click on “register” link)
    5. POST /Account/Register (submit the registration form)

    The Results

    ApplicationRequests/second (higher is better)% change (wrt baseline)
    1. MVC 2 Aspx on v2 8135 (baseline) n/a
    2. MVC 2 Aspx on v3 7987 -1.82%
    3. MVC 3 Aspx on v3 7457 -8.33%
    4. MVC 3 Razor on v3 7136 -12.28%

    Note: The above results were captured on a 12-core server and should only be used for comparative purposes. Absolute RPS values on your own machine might de vastly different but their relative distribution should remain the same. 

    Applications 1 vs. 2

    As you can see from comparing the results for Application 1 and Application 2 the difference is quite small. In fact –1.82% falls within the margin of error. Application 1 and Application 2 are the same identical application, except 1. references System.Web.Mvc.dll version 2.0 and 2. references System.Web.Mvc.dll version 3.0. These results are why we say that MVC 3 is on par with the performance characteristics of MVC 2.

    Of course followers of Scott Guthrie will point out that with the RC2 release he claimed that MVC 3 was faster than MVC 2. While that was true at the time it is not correct any longer for RTM. We had to undo a pretty significant performance fix related to model metadata caching because it caused some functional bugs (after all it does not matter how fast your application is if it does not actually work correctly). However, we will have that improvement available as an add-on in MVC Futures and we will roll it into MVC 4.

    Applications 2 vs. 3

    Comparing Application 2 with Application 3 shows that 3. is –6.64% slower. However, in this case the runtimes are the same. The difference is in the project templates used. The project template that ships with MVC 3 has more functionality enabled by default. Most notably it has unobtrusive client-side validation enabled; MVC 2 project templates did not have client-side validation enabled. The extra time is taken up inspecting the model metadata and emitting additional markup and javascript code. Of course while page rendering will be slower, the overall result of enabling client-side validation should be reduced load on the server as the majority of invalid inputs will be caught on the client thus avoiding the need for unnecessary roundtrips.

    Applications 3 vs. 4

    The comparison of Application 3 and Application 4 will be of interest to those looking at adopting the new Razor view engine. Application 4 is –4.3% slower than Application 3. This shows that using Razor does have a performance cost. However, that difference is not that big and is outweighed by the elegance and increased readability of the new view engine. Razor is also a new technology and I am sure that as it matures we will be able to optimize it even further.

    The Changes

    At the beginning of this post I promised that I would list how the various features or components of MVC changed in their performance characteristics. This list is compiled from our internal performance tests as well as change logs. It is meant to be taken as informational only. Your results may vary and depends on how you actually use each feature and what else you have happening in your application

    Things that got faster (in no particular order):

    • Expression caching (internal subsystem that helps in the performance of methods that accept lambdas)
    • URL generation
    • Action lookup
    • Filter invocation
    • TagBuilder

    Things that got slower (also in no particular order):

    • Things for which Dependency Injection entry points have been exposed
    • Auto-generated editor and display helpers
    • Model binding

    Of course I am not going to tell you by how much things have changed because it depends... you will have to measure yourself.

Page 1 of 1 (2 items)