Introduction A lot has been said on Web Forms and MVC, but since I was recently asked about my opinion on
the subject, here it is. First, I have to say that I really like both technologies and I don’t think
any is going away – just remember SharePoint, which is built on top of Web Forms. I see them as complementary, targeting different needs and leveraging different skills. Let’s go through some of their differences. Rapid Application Development Rapid Application Development (RAD) is
the development process by which you have an Integrated Development Environment (IDE), a visual design surface and a toolbox, and you drag components from
the toolbox to
the design surface and set their properties through a property inspector. It was introduced with some of
the earliest Windows graphical IDEs such as Visual Basic and Delphi. With Web Forms you have RAD out of
the box. Visual Studio offers a generally good (and extensible) designer for
the layout of pages and web user controls. Designing a page may simply be about dragging controls from
the toolbox, setting their properties and wiring up some
events to event handlers, which are implemented in code behind .NET classes. Most people will be familiar with this kind of development and enjoy it. You can see what you are doing from
the beginning. MVC also has designable pages – called views in MVC terminology –
the problem is that they can be built using different technologies, some of which, at
the moment (MVC 4) do not support RAD – Razor, for example. I believe it is just a matter of time for that to be implemented in Visual Studio, but it will mostly consist on HTML editing, and until that day comes, you have to live with source editing. Development Model Web Forms features
the same development model that you are used to from Windows Forms and other similar technologies:
events fired by controls and automatic persistence of their properties between postbacks. For that, it uses concepts such as view state, which some may love and others may hate, because it may be misused quite easily, but otherwise
does its job well. Another fundamental concept is data binding, by which a collection of data can be fed to a
control and have it render that data somehow – just thing of
the GridView
control.
The focus is on
the page, that’s where it all starts, and you can place everything in
the same code behind class: data access, business logic, layout, etc.
The controls take care of generating a great part of
the HTML and JavaScript for you. With MVC there is no free lunch when it comes to data persistence between requests, you have to implement it yourself. As for event handling, that is at
the core of MVC, in
the form of controllers and action methods, you just don’t think of them as event handlers. In MVC you need to think more in HTTP terms, so action methods such as POST and GET are relevant to you, and may write actions to handle one or
the other. Also of crucial importance is model binding:
the way by which MVC converts your posted data into a .NET class. This is something that ASP.NET 4.5 Web Forms has introduced as well, but it is a cornerstone in MVC. MVC also has built-in validation of these .NET classes, which out of
the box uses
the Data Annotations API. You have full
control of
the generated HTML - except for that coming from
the helper methods, usually small fragments - which requires a greater familiarity with
the specifications. You normally rely much more on JavaScript APIs, they are even included in
the Visual Studio template, that is because much less is done for you. Reuse It is difficult to accept a professional company/project that
does not employ reuse. It can save a lot of time thus cutting costs significantly. Code reused in several projects matures as time goes by and helps developers learn from past experiences. ASP.NET Web Forms was built with reuse in mind, in
the form of controls. Controls encapsulate functionality and are generally portable from project to project (with
the notable exception of web user controls, those with an associated .ASCX markup file). ASP.NET has dozens of controls and it is very easy to develop new ones, so I believe this is a great advantage. A
control can inject JavaScript code and external references as well as generate HTML an CSS. MVC on
the other hand
does not use controls – it is possible to use them, with some view engines like ASPX, but it is just not advisable because it breaks
the flow – where do Init, Load, PreRender, etc, fit?
The most similar to controls is extension methods, or helpers. They serve
the same purpose – generating HTML, CSS or JavaScript – and can be reused between different projects. What differentiates them from controls is that there is no inheritance and no context – an extension method is just a static method which doesn’t know where it is being called. You also have partial views, which you can reuse in
the same project, but there is no inheritance as well. This, in my view, is a weakness of MVC. Architecture Both technologies are highly extensible. I have writtenstarted writing a series of posts on ASP.NET Web Forms extensibility and will probably write another series on MVC extensibility as well. A number of scenarios are covered in
any of these models, and some extensibility points apply to both, because, of course both stand upon ASP.NET. With Web Forms, if you’re like me, you start by defining you master pages, pages and controls, with some helper classes to glue everything. You may as well throw in some JavaScript, but probably you’re main work will be with plain old .NET code.
The controls you define have
the chance to inject JavaScript code and references, through either
the ScriptManager or
the page’s ClientScript object, as well as generating HTML and CSS code.
The master page and page model with code behind classes offer a number of “hooks” by which you can change
the normal way of things, for example, in a page you can access
any control on
the master page, add script or stylesheet references to its head and even change
the page’s title. Also, with Web Forms, you typically have URLs in
the form “/SomePath/SomePage.aspx?SomeParameter=SomeValue”, which isn’t really SEO friendly, no to mention
the HTML that some controls produce, far from standards, optimization and best practices. In MVC, you also normally start by defining
the master page (or layout) and views, which are
the visible parts, and then define controllers on separate files. These controllers do not know anything about
the views, except
the names and types of
the parameters that will be passed to and from them.
The controller will be responsible for
the data access and business logic, eventually relying on additional classes for this purpose. On a controller you only receive parameters and return a result, which may be a request for
the rendering of a view, a redirection to another URL or a JSON object, to name just a few.
The controller class
does not know anything about
the web, so you can effectively reuse it in a non-web project. This separation and
the lack of programmatic access to
the UI elements, makes it very difficult to implement, for example, something like SharePoint with MVC. OK, I know about Orchard, but it isn’t really a general purpose development framework, but instead, a CMS that happens to use MVC. Not having controls render HTML for you gives you in turn much more
control over it – it is your responsibility to create it, which you can either consider a blessing or a curse, in
the later case, you probably shouldn’t be using MVC at all. Also MVC URLs tend to be much more SEO-oriented, if you design your controllers and actions properly. Testing In a well defined architecture, you should separate business logic, data access logic and presentation logic, because these are all different things and it might even be
the need to switch one implementation for another: for example, you might design a system which includes a data access layer, a business logic layer and two presentation layers, one on top of ASP.NET and
the other with WPF; and
the data access layer might be implemented first using NHibernate and later on switched for Entity Framework Code First. These changes are not that rare, so care should be taken in designing
the system to make them possible. Web Forms are difficult to test, because it relies on event handlers which are only fired in web contexts, when a form is submitted or a page is requested. You can call them with reflection, but you have to set up a number of mocking objects first, HttpContext.Current first coming to my mind. MVC, on
the other hand, makes testing controllers a breeze, so much that it even includes a template option for generating boilerplate unit test classes up from start. A well designed – from
the unit test point of view - controller will receive everything it needs to work as parameters to its action methods, so you can pass whatever values you need very easily. That doesn’t mean, of course, that everything can be tested: views, for instance, are difficult to test without actually accessing
the site, but MVC offers
the possibility to compile views at build time, so that, at least, you know you don’t have syntax errors beforehand. Myths Some popular but unfounded myths around MVC include: You cannot use controls in MVC: not true, actually, you can, at least with
the Web Forms (ASPX) view engine;
the declaration and usage is exactly
the same as with Web Forms; You cannot specify a base class for a view: with
the ASPX view engine you can use
the Inherits Page directive, with this and all
the others you can use
the pageBaseType and userControlBaseType attributes of
the <page> element; MVC shields you from doing “bad things” on your views: well, you can place
any code on a code block, at least with
the ASPX view engine (you may be starting to see a pattern here), even data access code;
The model is
the entity model, tied to an O/RM:
the model is actually
any class that you use to pass values to a view, including (but generally not recommended) an entity model; Unit tests come with no cost: unit tests generally don’t cover
the UI, although there are frameworks just for that (see WatiN, for example); also, for some tests, you will have to mock or replace either
the HttpContext.Current property or
the HttpContextBase class yourself; Everything is testable: views aren’t, without accessing
the site; MVC relies on HTML5/some_cool_new_javascript_framework: there is no relation whatsoever, MVC renders whatever you want it to render and
does not require
any framework to be present.
The thing is,
the subsequent releases of MVC happened in a time when Microsoft has become much more involved in standards, so
the files and technologies included in
the Visual Studio templates reflect this, and it just happens to work well with jQuery, for example. Conclusion Well, this is how I see it. Some folks may think that I am being too rude on MVC, probably because I don’t like it, but that’s not true: like I said, I do like MVC and I am starting my new projects with it. I just don’t want to go along with that those that say that MVC is much superior to Web Forms, in fact, some things you can do much more easily with Web Forms than with MVC. I will be more than happy to hear what you think on this!
