What we want to achieve:

• We do not want to duplicate validation rules into many places
• We want to have as much as possible validated on the client
• We do not want to have tons of boilerplate custom javascript

And the solution consists of the following elements:

• ValidationAttributes (System.ComponentModel.DataAnnotations)
• jQuery Validate
• Unobtrusive extension to jQuery Validate

The basics of attribute-based validation

Namespace System.ComponentModel.DataAnnotations contains many attributes that you can use to validate user input. Specifically, you have DataTypeAttribute, RangeAttribute, RegularExpressionAttribute, RequiredAttribute and StringLengthAttribute. I guess the names are pretty self-explanatory.

In addition, System.Web.Mvc namespace contains CompareAttribute which allows you to define that the values of two different fields must be the same (for example, password and passwordConfirmation) and RemoteAttribute which allows you to have complex validation rules executed on the client. In practice, you can define a controller and action which is executed by an AJAX call.

ScottGu explains the basics pretty well: http://weblogs.asp.net/scottgu/archive/2010/01/15/asp-net-mvc-2-model-validation.aspx.

Unobtrusive client validation

ScottGu’s example uses Microsoft’s own validation framework (MicrosoftMvcValidation.js) but in ASP.NET MVC 3 Microsoft allows us to use jQuery Validate and has implemented a nice addition on top of that. Brad Wilson posted a nice article about enabling unobtrusive validation: http://bradwilson.typepad.com/blog/2010/10/mvc3-unobtrusive-validation.html.

Extending the validation

It’s likely that sooner or later you find yourself having a custom validation rule that is not available in the previously mentioned framework. Most probably you’ll be missing the attribute on server side as jQuery Validate plugin actually contains a lot more validation methods than .NET Framework’s attributes represent, for example email validation for which the support is implemented below. You can find the list of all supported validation rules on the jQuery Validate’s documentation.

Custom attribute

It turns out that implementing a custom attribute is really an easy task. You implement your own class that inherits System.ComponentModel.DataAnnotations.ValidationAttribute and implements System.Web.Mvc.IClientValidatable. So you need to do three things.

1) Override public bool IsValid(object value)
This method will be run when the validation is done on the server (for example, if the client does not have javascript enabled). This is all you need to do if you don’t need client validation.

2) Create a class that inherits from ModelClientValidationRule. This is usually very simple. Here’s an example how to enable email validation on the client:

public class ModelClientValidationEmailRule : ModelClientValidationRule
{
    public ModelClientValidationEmailRule(string errorMessage)
    {
        base.ErrorMessage = errorMessage;
        base.ValidationType = "email";
    }
}

3) Implement public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)

This is also usually very easy to implement, here’s the example on email validation:

public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
{
    yield return new ModelClientValidationEmailRule(FormatErrorMessage(metadata.GetDisplayName()));
}

This is all you need do to write your own attribute to enable validation using the readymade validation rules on jQuery Validate plugin. But there will be times when you invent new ways to do validation on client so you’ll need to write your own validation method for jQuery Validate.

Custom client validator

As you can guess, custom validators are not that hard to implement either. In the simple case (your validator doesn’t have any parameters) here’s all you need:

(function ($) {
    $.validator.addMethod(
        "your-method-name",
        function (value, element) {
            return (!value && this.optional(element)) || /*place your validation logic here*/;
        },
        "your own error message");
    $.validator.unobtrusive.adapters.addBool("your-method-name");
} (jQuery));

And to use this, you need to write your own custom attribute (and when implementing the ModelClientValidationRule, you need to set base.ValidationType = “your-method-name”).

NOTE: Usually it is good practice to first check whether the input is empty and whether the element is not marked as required. Otherwise using your own validator would also make the field required which is unexpected. The same applies to implementing server-side attribute’s IsValid method.

Conclusion and FAQ

This way we have a single solution for performing validation both on the client and on the server, and the usage of HTML 5 (yay!!!) data attributes for this kind of tasks is simply beautiful.

Q1: I have everything set up, but I still don’t get the validation happening on the client, it still goes to the server everytime.

A1.1: You do not have client validation enabled. Check that you have the following values on your web.config:

<appSettings>
    <add key="ClientValidationEnabled" value="true" />
    <add key="UnobtrusiveJavaScriptEnabled" value="true" />
</appSettings>

A1.2: You do not have the required javascript libraries loaded. You need to have jquery, jquery.validate and jquery.validate.unobtrusive included on your page.

<script src="/Scripts/jquery-1.4.3.min.js" type="text/javascript" />
<script src="/Scripts/jquery.validate.min.js" type="text/javascript"/>
<script src="/Scripts/jquery.validate.unobtrusive.min.js" type="text/javascript"/>

Q2: I have validation rules that I cannot express by static attributes. How to use more complex validation rules?

A2: On your action method you can have arbitrary validation logic. To put the error messages into the same output system, use ModelState.AddModelError("<fieldname>", "ErrorMessage");

Now, at the release of Sharepoint 2010, the lite version formerly known as Windows Sharepoint Services, will be renamed to Sharepoint Foundation.

Finally, the naming of these fundamental technologies will achieve it’s closure: The programming framework and paradigm that we originally called Lightning, was released under the name .NET Framework. Now, at the release of version 4.0 the framework will also be renamed to conform to this naming convention and as expected, the new name will be Windows Technology Foundation. To celebrate this remarkable milestone, Microsoft has acquired the well known site and will continue to bring daily news about all WTF technologies.

Premium edition is like a boosted Team Edition for Developers. It has all the advanced features from previous Developer and Database editions and some features from the tester edition.

Ultimate is the  – should I say – ultimate version with everything you can imagine. Like Team Suite was at 2005-2008 timeframe. Af course there are some new features, like IntelliTrace – a new historical debugger which enables debugging events that ran previously on your machine. It also has the Test case management and lab manger tools built-in – in addition to new architectere and UML (yes, UML) modeling tools.

One notable benefit is that all these versions come with some Azure computing time.

VSTS exists no more?

The brand name Team System seems to be removed from the universe. It is not in any product name anymore. TFS accessibility (and team work) is considered an entry-level feature today, so it’s bundled with all editions of VS.

There is even a light version of TFS coming out, TFS Basic which aims to finally kill VSS.

Visual Studio 2010 SKUs

Visual Studio 2010 Ultimate
- Visual Studio IDE
- Test and Lab Manager

Visual Studio 2010 Premium
- Visual Studio IDE

Visual Studio 2010 Professional
- Visual Studio IDE

Visual Studio Test Elements 2010
- Test and Lab Manager

Visual Studio Team Foundation Server 2010
- Server/CAL licensing

Visual Studio Team Lab Management 2010
- Server/per processor licensing
- Requires Test Elements or Ultimate

Visual Studio Load Test Virtual User Pack 2010
- 1,000 virtual users

And finally, there are also the free Express editions for C#, VB, C++ and web development.

Oh, in case you didn’t know already, official launch of VS 2010 will be 22.3.2010. More information available at: http://www.microsoft.com/visualstudio/en-us/products/2010/default.mspx

And finally, some information in more detail for those interested:

Following eXtreme Programming principles, I wanted first to have it work doing the simplest possible solution. Just add a plain required attribute and test. Voilá, it works! Great, so let’s add the localization in place. I added the attribute properties and suddenly the validation didn’t work anymore. Why is that? After close examination with debugger and Reflector I found that:

• According to reflector the attributes are there and their properties are correctly set
• According to VS debuggerTypeDescriptor.GetProperties(myModelObject).Cast().ToList()[0].Attributes doesn’t contain the RequiredAttribute!

That’s interesting. No exceptions were raised, no error messages were given. The attribute was plain missing and thus validation didn’t work.

OK, let’s try it another way. Inspect the object using ordinary reflection methods using the following code:

foreach (var pi in instance.GetType().GetProperties())
{
 Console.WriteLine(“Propertyname: {0}\r\n “, pi.Name);
 foreach (var a in pi.GetCustomAttributes(true))
{
  Console.WriteLine(” “ + a.GetType().ToString());
}
}

This code raised runtime exception “Unhandled Exception: System.Reflection.CustomAttributeFormatException: ‘ErrorMessageResourceName’ property specified was not found.” Whaaat!? I just checked that it is there. Reading the stacktrace more closely, I found ystem.InvalidOperationException: The resource type ‘MetadataTest.ModelValidationResource’ does not have a publicly visible static property named ‘XXX’.

Ok, so the resource should be public? Indeed, resources are generated as internal by default. Luckily the resource editor allows me to set the access modifier as public. Let’s retest. Now the new code goes through correctly. How about the code using TypeDescriptor? Now it works too! So, a few things to remember when using localized model validation

• Remember to set resources as public
• Do not trust TypeDescriptor as it silently sucks all exceptions and errors

I guess I need to ask Microsoft whether this is by design. Basically this kind of errors should never be ignored.