In this article, I’m going to “speak” about the validation, probably one of the most boring stuff a developer needs do during the programming.

That’s what I mean with “boring stuff”

public class UserService
{
  public void CreateUser(string username, string email, string website)
  {
    if(string.IsNullOrEmpty(username))
    {
      throw new ArgumentException("The username must contain a valida value");
    }

    if(string.IsNullOrEmpty(email))
    {
      throw new ArgumentException("The email must contain a valida value");
    }

    if(!Regex.IsMatch(email,"^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$"))
    {
      throw new ArgumentException("The specified email is not valid.");
    }

   if(!string.IsNullOrEmpty(website) && !Regex.IsMatch(website,"^http(s)?://([\w-]+.)+[\w-]+(/[\w- ./?%&=])?$"))
   {
     throw new ArgumentException("The specified website is not valid.");
   }

   //DO YOUR CODE

  }
}

As you can see in the method above there are four parameters and I need to validate three of them before starting to do anything (in the example website is validated only if it has a value).
Probably you, and also me, wrote this code thousand and thousand times …. ok It’s time to remove that.

My idea is to use the Data Annotation Attributes for the parameters and, using the AOP (Aspect Oriented Programming) and Interceptor Pattern, run automatically the validation for all ours layer.

Probably all of you use a Dependency Injection Framework (if you don’t use it, you have to) like Castle Windsor, Ninject, Unity and so on.
All of these offers the opportunity to inject some code before calling a method for a registered service (Interceptor Pattern).
In my example I’m using Castle (I love it), but the code it’s easy to move to another framework.

Stop speaking and let’s start coding.

The first thing to do is to understand how to run manually the validation: K. Scott Allen wrote a good article here, so I’m starting from this.

Now we have to create a container class for all the parameters and to add the Data Annotations. That’s important because we can’t use the Data Annotations directly on the parameter.
If you did everything correct, your class now should looks like this:

public class CreateUserRequest
{
  [Required]
  public string Username { get; set; }

  [Required]
  [EmailAddress]
  public string Email { get; set; }

  [Url]
  public string Website { get; set; }
}

Because a method could have more than one parameter, and we don’t really need to validate all of these, it could be important to tell to the validation service (our interceptor) what needs to be validated and what doesn’t.
For this reason I’ve created a custom attribute, ValidateAttribute:

[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = true)]
public class ValidateAttribute : Attribute
{
}

No comments for this code, it is used only like a marker.

Now change the signature of your method using the attribute and the input class like this:

public class UserService
{
  public void CreateUser([Validate] CreateUserRequest request)
  {
    //DO SOMETHING
  }
}

Good, everything is ready except for the interceptor, it’s time to create it:

public class ValidationInterceptor : IInterceptor
{
  #region Fields

  private readonly IObjectValidator validator;

  #endregion

  #region Constructors and Destructors

  public ValidationInterceptor() : this(new DataAnnotationsValidator())
  {
  }

  public ValidationInterceptor(IObjectValidator validator)
  {
    this.validator = validator;
  }

  #endregion

  #region Public Methods and Operators

  public void Intercept(IInvocation invocation)
  {
    ParameterInfo[] parameters = invocation.Method.GetParameters();
    for (int index = 0; index < parameters.Length; index++)
    {
      ParameterInfo paramInfo = parameters[index];
      object[] attributes = paramInfo.GetCustomAttributes(typeof(ValidateAttribute), false);

      if (attributes.Length == 0)
      {
        continue;
      }

      this.validator.Validate(invocation.Arguments[index]);
    }

    invocation.Proceed();
  }

  #endregion
}

The interceptor logic is really simple. It iterates all parameters and, only for these who have my custom attribute, it calls the Validate method.

To use an interceptor is important to register it and add to your service:

IWindsorContainer container = new WindsorContainer();

container.Register(Component.For<IInterceptor>().ImplementedBy<ValidationInterceptor>());

container.Register(Component.For<UserService>()
                  .ImplementedBy<UserService>()
                  .Interceptors<ValidationInterceptor>());

That’s all, run the this code to have the validation:

private static void Main(string[] args)
{
  IWindsorContainer container = new WindsorContainer();

  container.InizializeAttributeValidation();

  container.Register(Component.For<IUserService>()
                    .ImplementedBy<UserService>()
                    .EnableValidation());

  IUserService userService = container.Resolve<IUserService>();

  try
  {
    userService.CreateUser(new CreateUserRequest());
  }
  catch (ImperugoValidatorException e)
  {
    //Validation exception
    Console.WriteLine(e.Message);
  }
  finally
  {
    Console.ReadLine();
  }
}

From now, every time you call the method CreateUser (resolved by Castle), the validation will be automatically raised and, for the parameter with a wrong value, an ImperugoValidationExcpetion will throw, you can catch them and choose how to show the message.

It’s not finished yet . If you prefer, I’ve created a NuGet Package that helps to reduce the code. There are two packages:

1. Imperugo.Validation
2. Imperugo.Validation.Castle

The first one contains only the necessary stuff to create the right interceptor; the second one is the Castle implementation (soon I’ll release also a package for Ninject, Unity and so on).

The first thing to do is to install the package (Castle in this case):

Now change the Castle code like this:

IWindsorContainer container = new WindsorContainer();

container.InizializeAttributeValidation();

container.Register(Component.For<UserService>()
                  .ImplementedBy<UserService>()
                  .EnableValidation());

If you use a different Framework and you like this validation, fork the repo here, add the new Framework, and create a “pull request”.

All my code is available here.

I’m working on the next release that is really faster because include a cache strategy, so stay tuned.

Chris’s idea is to collect the most useful articles for each section (Action Filters, Deploy, and so on) of the framework, with an introduction to each topic.
Personally, I worked on the Deploy topic (it’s easy to recognize, it’s the article with the worst English).

I really like that approach because it is very helpful for all people who want to learn MVC, but also for those who already know it but want to increase their knowledge.

If you have feedback or you think there are some missing arguments, you can contact directly Chris (or write me here and I will do for you).

Enjoy the guide here.

Before seeing the code, it’s important to understand what does it mean “manage the caching policy” and why we should do that.

The class HttpClient is created for web requests and it has all problems/features of a browser without the render and Javascript stuff.

All the modern browsers has an aggressive cache policy with the purpose of reducing the network traffic and increase the performances. The last point is really important: to execute operations faster browsers read a set of information from the response header (Etag, Cache-Control and Date), and, based on their values, it decides to take the data from the response or from the cache.

In one of the latest projects we are working in my company (I spoke about that here), we have to call some rest services which totally ignore the cache header values. To be clear I’ve the same headers values for different results so I’ve to disable the cache for my request to that endpoint because the default behavior use the cache:

Default cache policy (from MSDN)

Satisfies a request for a resource either by using the cached copy of the resource or by sending a request for the resource to the server. The action taken is determined by the current cache policy and the age of the content in the cache. This is the cache level that should be used by most applications.

To change the cache policy we need to do something like that:

using (WebRequestHandler handler = new WebRequestHandler())
{
  handler.CachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.BypassCache);

  using (HttpClient client = new HttpClient(handler))
  {
    response = await client.GetAsync("http://www.mysite.com/api/something/");
  }
}

As you can see is really simple and really important so, be careful using the right Header values in your response J

The first step to try this cool feature is to install the Visual Studio plugin so, download it from here

After the installation Visual Studio offers you new features that are not available in the standalone version. In fact, after right clicking on a web resource (css, js, etc) in the solution explorer, you have a new “item” named Web Essential:

What I love most in this extension is the easy way to create the combined and minified resources (really, I’m not in love with the web optimization packages included in ASP.NET MVC 4).

What does it give us?

• Javascript and Css minification with SourceMap;
• Javascript and Css bundle with SourceMap;

As you can see in both items there is the SourceMap, but what is it?
Source Map is a cool feature, actually supported just by Google Chrome, that allows you to understand the correct position (i.e. line of an error) in a Javascript file starting from a combined file.

I think that feature is a killer feature for frontend developers because some errors happened in production and, in some cases, you are not able to reproduce them during the tests.

The first things is to enable that features in chrome, so:

From now, everything is easier, select your javascript files, right click and, from WebEssential Items, select “Create Javascript Bundle File”.

Drag you bundle into your page, MyExampleJavascriptBundle.min.js in my example, and everything is ready.

From now, every time you change and save the files you selected for the bundle, Visual Studio will automatically update it; it means that minified and source map will always be up to date with the original resources without doing anything special (How f..ing cool is that?).

As you can see in the image below there are more files that I’ve included in my page (see previous screenshots).

In fact, I didn’t added the files 001.js and 002.js but only the MyExampleJavascriptBundle.min.js.

How is it possible? The reason is really simple; inside the MyExampleJavascriptBundle.min.js, Visual Studio added a line with the path of Source Map that includes the original not combined files.

Chrome understands this behavior and shows you the source files (only if you use the developer tools bar).

If you like it and you want to understand more about Source Map, take a look here and, if you like Web Essential like me you have to follow Mads on twitter

Stay tuned!

One of the pillars request by the Java services (really is not a technology request but just from the implementation made by the external company) is to read all cookies from the response and then send them back to the next requests (like a proxy).

To make more clear where my app is, I realized the following chart:

As you can see the communication between my application and the Java Rest endpoint is based on the client library released with Web API.
In fact, Web API is more than a service library used just to expose data; it includes a client library that makes very easy to execute a REST call, so let’s start to install the client package named “Microsoft ASP.NET Web API Client Libraries” from NuGet!

From now on, if you need to create a web request, you should do something like in the code below:

HttpClient client = new HttpClient();

HttpResponseMessage response = await client.GetAsync(requestUrl);

//response contains all you need

My problem was to manage the cookie from the response, since I needed to read the cookies and then store them somewhere for the next request.
Obviously, the example above is really simple and it’s not enough for me because I need to read all the cookies and then send them to the browser.

Fortunately, there is an easy way to read the cookies from an Http Response using Web Api client library.
The first thing to do is to create an instance of HttpClientHandler, inizialize the CookieContainer collection and then use it the HttpClient Constructor:

HttpClientHandler handler = new HttpClientHandler
                              {
                                UseCookies = true, 
                                UseDefaultCredentials = true, 
                                CookieContainer = new CookieContainer()
                              };

HttpClient client = new HttpClient(handler);

HttpResponseMessage response = await client.GetAsync(requestUrl);

// hanlder.CookieContainer contains your cookies

Now, after the request, the CookieContainer should contain the correct cookies.  Now we need to manage the cookie’s type, since we have two different kind of responses: one for ASP.NET MVC and one for Web API.

The two frameworks have no shared assemblies, it means that the cookies are represented by different classes in different namespaces with the same kind of data and I’m in a weird situation:

• The Cookiecontainer contains a list of System.Net.Cookie;
• The Web Api server request use System.Net.Http.Headers.CookieHeaderValue;
• ASP.NET MVC uses System.Web.HttpCookie;

Three different classes, the first one comes from the client and the others for the response to the browsers.

For this reason, I created a Cookie manager class that moves the data from a cookie class to another one.
To use the cookie in ASP.NET MVC is really simple, we just need to use the HttpContext (Request or response, depends if you need to add or read a cookie) like the code below:

//reading
HttpContext.Request.Cookies["cookieName"];

//writing
HttpContext.Response.Cookies.Add(new HttpCookie("cookieName"));

For the Web API the approach is different. In fact, into the controller, there isn’t the HttpContext class like into MVC, so we need to manage the data using the HttpHeader like this:

//reading
var cookies = actionContext.Request.Headers.GetCookies();

/adding
response.Headers.AddCookies(cookies);

Now I’m able to read cookies from everywhere and my last goal is to find a valid entry point where to manage the cookie read/write for MVC and Web API (easy ActionInvoker J)

One of the big difficult I found, is to create the right model. I said big because I’m used to design the model for relation database and here is really different. For example we do not have the join and we also need to denormalize the references (http://ravendb.net/docs/faq/denormalized-references).

It is mandatory because each document must be independent as Oren wrote on the site:

One of the design principals that RavenDB adheres to is the idea that documents are independent, that all the data required to process a document is stored within the document itself

Fortunately, Raven makes easy some stuff like update and loading, respectively using Patch API (http://ravendb.net/docs/client-api/partial-document-updates) and Include.

The Include command is absolutely cool, it makes easy to load two documents with one roundtrip and it means only one thing, Faster!
For the NHibernate users it reminds me a little the Future command, with an important different, here you can load only document that has a key to another one, in NH you can load also objects completely unlinked.

Let’s see my domain:

It seems more complex that it really is. There is a Post class and ItemComments. The first one includes all you need to have in the aggregate view; the second one, combined with the first one, has all you need to show in the detail view or admin area (in the most blog enginea you don’t need to show the comments in the main page, otherwise you need in the permalink).

The only common thing between them is the property CommentsId into Post class (It’s called Id in ItemComments). With it, you can easily load both documents in the same time.
Let’s see how to use it:

Post item = new Post()
//populate the properties with your values

this.Session.Store(item);

ItemComments comments = new ItemComments
                          {
                            Approved = new List<Comment>(), 
                            Pending = new List<Comment>(), 
                            Spam = new List<Comment>(), 
                            Item = new ItemReference
                                     {
                                       Id = post.Id, 
                                       Status = post.Status, 
                                       ItemPublishedAt = post.PublishAt
                                     }
                          };

this.Session.Store(comments);
post.CommentsId = comments.Id;

this.Session.SaveChanges();

//To read both with only one request:

Post post = this.Session
				.Include<Post>(x => x.CommentsId)
				.Load(id);

ItemComments comments = this.Session.Load<ItemComments>(post.CommentsId);

As you see in the diagram, the key for the Post is a simple integer but in the ItemComments it is a string. That is mandatory if you want to use the Include because in the string there is all Raven needs to load the document (the ID and the type, in this case ItemComments/12345 where 12345 is the id).

Different CLR types for the key means to extend the base class for all entities. Typically I have a base class (EntityBase in this model) that includes the ID, Creation Date and a calculate property to check the status of the entity.

public class EntityBase<T>
	{
		#region Public Properties

		public DateTimeOffset CreatedAt { get; set; }

		public T Id { get; set; }

		public bool IsTransient
		{
			get
			{
				return this.Id == 0;
			}
		}

		#endregion
	}

The property IsTransient could be helpful to understand if you have to execute some path or not.
Using a generic CLR type for the ID the base class must be extended like this:

public class EntityBase<T>
	{
		#region Public Properties

		public DateTimeOffset CreatedAt { get; set; }

		public T Id { get; set; }

		public bool IsTransient
		{
			get
			{
				return EqualityComparer<T>.Default.Equals(Id, default(T));
			}
		}

		#endregion
	}

Now you can still use a base class with the same features having fun with RavenDB.

The atmosphere was really cool and I met some incredible speakers. Rui had a wonderful speech about tiny frameworks, Massimiliano has hypnotized all people with his magic on JavaScript, Alessandro shocked his room using WebSockets and SignalR, Raf with TypeScript and WebAPI and the same happened with the others speakers (unfortunately I cannot see other sessions because the organization made me very busy).

What more? A very nice Chris Massey!

Another incredible news is the conference drop. There were 165 people on 173 available sits, we are almost “dropless” and for me that means “ok the conference is really cool, keep on working”.

We are thinking to replicate the conference somewhere in the Europe (probably during the spring), but one thing is for sure, next year we will still be here.

You rock!

Several pictures:

I’m not a front end developer so my part in this adventure is to manage the project and to make easy the integration of Less/Sass with an ASP.NET MVC application.

My first question was something like – “Which is the best way to integrate Less or SaaS in an ASP.NET MVC application?” -

If you choose Less everything is easy, you can install “dotless” from nuget and create that bundle (this example is for MVC 4) transformation:

public class LessTransform : IBundleTransform
{
  public void Process(BundleContext context, BundleResponse response)
  {
    response.Content = dotless.Core.Less.Parse(response.Content);
    response.ContentType = "text/css";
  }
}

var myBundle = new StyleBundle("~/Content/css")
                  .Include("~/Content/site.css")
                  .Include("~/Content/Scss1.less");

myBundle.Transforms.Add(new LessTransform());
myBundle.Transforms.Add(new CssMinify());

About Compass? …. mmmmm What is Compass?

Compass is another framework built using Sass: if you want to use Compass you need Sass, so my first problem was to integrate Sass into my MVC application.
In my previous post “Schmulik Raskin” suggested me Mindscape’s Web Workbench, a cool extension that offers you some features like Syntax Highlighting, Intellisense and Compilation not only for Sass but also for Less and CoffeeScript. That’s awesome.

Unfortunately after few hours I choose to use Web Workbench only like an editor and I disabled the compilationL.

Right now the extension doesn’t include some features that I need, like Compass support and output path customization. In spite of all, if you don’t need these features, probably Web Workbench still remains the best solution for .NET developer.

How did I sort out the problem?
Using ruby and MS-Build together of course. If you want to do the same, follow the step below:

• Download and install the latest version of Ruby and add it to your environment path (I suggest you to use Ruby Installer, it has a wizard and asks you if you prefer to add ruby to your paths – say yes).
• From a new prompt window check ruby installation: type “ruby –v” (in my case I got ruby 1.9.3p194 (2012-04-20) [i386-mingw32]);
• Type “gem install compass” (it download compass and its dependencies);
• Disable Web Workbench in your project “Menu => Mindscape => Web Workbench Settings” and uncheck your .scss files;
• Right click on your ASP.NET MVC application and “Unload Project”;
• Right click again on the unload project “Edit projectname.csproj”;

Under Project section add the follows code:

<Target Name="AfterCompile" Condition=" '$(Configuration)' == 'Release' ">
  <Exec Command="compass compile --output-style compressed --force" />
  <ItemGroup>
    <Content Include="Styles\*.css" />
  </ItemGroup>
</Target>
<Target Name="AfterCompile" Condition=" '$(Configuration)' == 'Debug' ">
  <Exec Command="compass compile" />
  <ItemGroup>
    <Content Include="Styles\*.css" />
  </ItemGroup>
</Target>

• Right click on the project for the last time and push “Reload Project”;

Here we go! Your application is ready to use Ruby with Compass and Sass. How to use it? Just compile your website, MS-Build creates your “.css” from Compass for you.

The first part of the code (debug condition) just create a css file, the second one also minify the file (–output-style compressed –force).
Moreover if you need to customize the compilation path and other stuff you can add a file config.rb into your project root and ruby will use that configuration for Compass.
My file looks like that:

# Require any additional compass plugins here.

# NORMALIZE: https://github.com/jzorn/compass-normalize-plugin
#require "normalize"

# set environment
environment = :development

# Set this to the root of your project when deployed:
http_path = '/'

css_dir = "Styles/Shared"
sass_dir = "Styles/SCSS"
fonts_dir = "Styles/fonts"
images_dir = "Images"
javascripts_dir = "Scripts"

# Set image path only
http_images_path = (environment == :production) ? 'http://tostring.it/' + images_dir : '/' + images_dir

output_style = (environment == :production) ? :compressed : :expanded

Amazing! You have the power of Compass inside a .NET application without using command line for compiling.

I’m not a big fan of extensions because they often make Visual Studio unstable and/or slow, but I’ll make an exception because it this case it’s incredibly cool!

Resharper 7

It doesn’t need presentation. It’s absolutely the best Add-On for Visual Studio (I use it probably from the first version);

Below a cool video by Hadi Hariri

More info: http://www.jetbrains.com/resharper/
Download: http://www.jetbrains.com/resharper/download/index.html
Cost: Free for opensource and MVP, 47€$ academic, 189€ Personal License, 332€ Commercial (+VAT for all licenses)

Vs Commands

Like Resharper I really love it because introduces some interesting features like Settings Synchronization (using DropBox, Skydrive or whatever you want). Moreover it highlights important messages in Output Windows (red for errors, yellow for warning, etc.), shows branch name into the solution, locate in solution and my favorite feature : Attacch To IIS Process.

If you need to debug your web application, a simple click on a button (or a shortcut if you prefer) and you got the IIS process attached into Visual Studio.

More info: http://vscommands.squaredinfinity.com/features
Download: http://visualstudiogallery.msdn.microsoft.com/a83505c6-77b3-44a6-b53b-73d77cba84c8
Cost: Free

StyleCop

It’s a incredible tool that improves your code quality. In fact, combined with R#, it analyzes C# source code to enforce a set of style and consistency rules (naming convention, code documentation, maintainability, spacing, etc.). If you don’t use R# you can use also StyleCop inside Visual Studio or jut at compile time with MsBuild.

More info: http://stylecop.codeplex.com/
Download: http://stylecop.codeplex.com/releases/view/79972
Cost: Free

Ghost Doc

It’s a cool extensions that helps you to document your methods starting from naming convention or copying from base method.
Unluckily there isn’t yet a stable version for VS2012 but I’m using the beta and it seems to work well.

More info: http://submain.com/products/ghostdoc.aspx
Download: http://submain.com/blog/GhostDocV4Beta2IsAvailable.aspx
Cost: Free for the basic version and from 25% to 50$ for the Pro

Image Optimizer

It’s a cool extension made by Mads Kristensen (http://madskristensen.net/) that optimizes your images directly inside Visual Studio. Right click on the folder or on the image and “Optimize Image”. You can see the compression result into the output window of Visual Studio.

More info and Download: http://visualstudiogallery.msdn.microsoft.com/a56eddd3-d79b-48ac-8c8f-2db06ade77c3
Cost: Free

SlowCheetah – XML Transforms

Is another interesting extension. It adds xml transformation for all xml files (not just for .config) and, only for the client application, applies the transformation directly when you push F5 from Visual Studio.

More info and Download: http://visualstudiogallery.msdn.microsoft.com/69023d00-a4f9-4a34-a6cd-7e854ba318b5/view/Discussions/1
Cost: Free

Web Essentials 2012

I’m not a web designer and I’m absolutely away to be a guru of CSS but that extension is really cool. Something I’ve to change a css color, class, or add a fallback for and old browser or a new no-standard feature (webkit, moz, prefixes for example).

More info and Download: http://visualstudiogallery.msdn.microsoft.com/07d54d12-7133-4e15-becb-6f451ea3bea6/
Cost: Free

Which is your favorite?

The version 4 of ASP.NET MVC introduces several cool features; most of them was available with the Beta and RC versions (Web API, Bundling, Mobile Projects Templates, etc.), but the RTM is not a “fixed version” of the RC, it has other interesting things.

After the installation, the first thing I noticed is a set of helpers inside the folder App_Start:

That makes the code much cleaner and maintainable, but it’s not enough J

From my point of view the most cool feature introduced with the RTM is the integration with the social network.

In the RTM, there are new packages in the default templates:

<package id="DotNetOpenAuth.AspNet" version="4.0.3.12153" targetFramework="net45" />
<package id="DotNetOpenAuth.Core" version="4.0.3.12153" targetFramework="net45" />
<package id="DotNetOpenAuth.OAuth.Consumer" version="4.0.3.12153" targetFramework="net45" />
<package id="DotNetOpenAuth.OAuth.Core" version="4.0.3.12153" targetFramework="net45" />
<package id="DotNetOpenAuth.OpenId.Core" version="4.0.3.12153" targetFramework="net45" />
<package id="DotNetOpenAuth.OpenId.RelyingParty" version="4.0.3.12153" targetFramework="net45" />

These packages make simple the integration with the most social networks like Facebook, Twitter, LinkedIn, Yahoo, Google and Microsoft Client.

Obviously you can extend this with other providers but we’ll take a look in another post. Right now just testing the commons social.

Facebook integration:

First step for Facebook is retrieve the ConsumerKey and ConsumerSecret (it is based on oAuth 2.0), so register you application on https://developers.facebook.com/apps

Now, inside the method RegisterAuth into the class AuthConfig (App_Start/AuthConfig.cs), write that code:

OAuthWebSecurity.RegisterFacebookClient(appId: "yourAppId", appSecret: "yourAppSecret");

Twitter integration:

Twitter is based on oAuth 1.x and, exactly like Facebook, it needs the ConsumerKey and ConsumerSecret so, register your app here https://dev.twitter.com/

Now,  add this line of code into AuthConfig:

OAuthWebSecurity.RegisterTwitterClient(consumerKey: " yourConsumerKey", consumerSecret: "yourConsumerSecret");

LinkedIn integration:

As the previous socials, register your app here https://www.linkedin.com/secure/developer?newapp=

In AuthConfig add this:

OAuthWebSecurity.RegisterLinkedInClient("yourKey", "yourSecret");

Yahoo Integration:

That is really simple, just add this line of code:

OAuthWebSecurity.RegisterYahooClient();

into AuthConfig

Google Integration:

Like Yahoo, Google integration doesn’t require any key or secret, so just add this:

OAuthWebSecurity.RegisterGoogleClient();

in AuthConfig.cs

Microsot Account (formely known as Live ID):

It is based on oAuth, so you need to register your application here https://manage.dev.live.com/AddApplication.aspx (not so easy to find the url )

Into AuthConfig add this:

OAuthWebSecurity.RegisterMicrosoftClient(clientId: “yourClientId”,clientSecret: “yourClientSecret”);

Start the application.
Now, all your social networks are registered, so you just need to run the application and test it.
Push F5 and everything should work automatically.

Just few notes about the login page.

As you probably noticed we called a set of static method for the class OAuthWebSecurity. Each time we add a provider, the login page changes showing the available social.
If you want to retrieve the list you just have to call the method OAuthWebSecurity.RegisteredClientData to obtain a collection of AuthenticationClientData with all information (provider name, authentication data, extra data and so on).

Is it cool?
I think so. Stay tuned for other cool stuff about ASP.NET MVC 4