Extending EntLib VAB - Part 1: Enable client side support EntLib VAB and align the validation error keys with MVC ModelState keys

Note: Thank you for visiting my blog. However, this blog is not maintained actively anymore. This post is now also in my new blog. Feel free to leave a comment there.

As discussed in my last post EntLib VAB doesn't support client side validation (in js/jQuery) out-of-the-box. And also while validating object graph, EntLib VAB generate Validation Result keys which are different from the ModelState keys in MVC.

In this post we will discuss on this problem.

Solution to this problem is simple. We just need to create an adapter for EntLib VAB validator to MVC ValidationAttribute, i.e. a piece of code is needed that will read the EntLib Validation configuration xml and for each validator it will return the MVC counterpart of the validator, i.e. ValidationAttribute.

As for aligning the validation error keys with MVC ModelState keys, we need to leverage the default model validation of ASP.NET MVC.

And the great news is that one single piece of code addresses combines these two solutions.

So what is the story behind the scene? 

Check the below process flow:

1. On receiving request from client, default MVC Model Binder tries to bind model from various value providers. After the model binding is done, it raises Model Updated event.
2. Model Updated event handler in turn calls ModelValidator.GetModelValidator().Validate() method.
3. Inside Validate() method, ModelMetaData.GetValidators() is invoked which in turn invokes ModelValidatorProviders.Providers.GetValidators(). 
4. ModelValidatorProviders holds a collection of three built-in validators [DataAnnotationsModelValidatorProvider(), DataErrorInfoModelValidatorProvider(), and ClientDataTypeModelValidatorProvider()], out of which DataAnnotationsModelValidatorProvider is our guy. It is this class, which provides default model validation for MVC.

So long story short, all we have to do is to override DataAnnotationsModelValidatorProvider class, which will hold our adapter logic inside it and after that to register our own Validator Provider to ModelValidatorProviders.Providers.

If we do this far, we have fairly done the job of addressing the two issues as said above: enabling client side validation and getting appropriate validation error keys (Keys are taken care of at the time of model binding process itself. Hence as we are just hooking in our custom implementation in the default processing of model binding, we don't need to do anything additional on top of this.). Note that in this process, we also do not need to make explicit call to the Validator.Validate() method which people usually do with EntLib VAB to make server side validation as the DefaultModelBinder does that by invoking all the registered Validator Providers.

Cool Right?

Ok enough of theory… Lets see some code now, because a piece of code says a lot more than thousand words... ;)

Disclaimer: I personally like to create the validation config xml file in a separate file other than web.config/app.config as I find the same to be a lot more cleaner approach. Hence all the code example shown below consider the same. If you are more comfortable working with defining the same in app.config/web.config

• So first we are creating our own custom Data Annotation provider inheriting from DataAnnotationsModelValidatorProvider (remember the guy who provides default model validation for MVC). It has a method GetValidators() which we need to override. Inside this function we are invoking a custom extension function that reads the EntLib VAB configuration xml file and retrieve the defined validators for the model. And then the custom adapter functions are invoked that translate EntLib VAB validators to MVC Validation attributes.
• Below code sample shows how to do the translation for two of EntLib VAB validators(NotNullValidator and RegExValidator), but that will be enough to give you the idea of how to do the translation for other validators as well. It also shows how to work with composite EntLib VAB validators, sample includes example for OrCompositeValidator. Being a composite validator, OrCompositeValidator holds a collection of other validators; the trick is to extract those validators and make recursive calls to the adapter methods so that those validators gets translated to MVC validation attributes.

The custom ModelValidatorProvider:

   1: namespace Validation

   2: {

   3:     public class EntLibDataAnotationProvider : DataAnnotationsModelValidatorProvider

   4:     {

   5:         #region Fields

   6:         private static Dictionary<Type, DataAnnotationsModelValidationFactory> AttributeFactories = new Dictionary<Type, DataAnnotationsModelValidationFactory> 

   7:         {         

   8:             { 

   9:                 typeof(RequiredAttribute), 

  10:                 (metadata, context, attribute) => new RequiredAttributeAdapter(metadata, context, (RequiredAttribute)attribute) 

  11:             }, 

  12:             { 

  13:                 typeof(RegularExpressionAttribute), 

  14:                 (metadata, context, attribute) => new RegularExpressionAttributeAdapter(metadata, context, (RegularExpressionAttribute)attribute)             

  15:             } 

  16:         };

  17:         #endregion

  18:  

  19:         protected override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context, IEnumerable<Attribute> attributes)

  20:         {

  21:             List<ModelValidator> validators = nw List<ModelValidator>();

  22:             List<ValidatorData> validatorDataList = metadata.ContainerType != null ? metadata.ContainerType.ExtractRules(metadata.PropertyName) : new List<ValidatorData>();

  23:             return GetValidators(metadata, context, validatorDataList);

  24:         }

  25:  

  26:         #region Private Methods

  27:         private IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context, IEnumerable<ValidatorData> validatorData)

  28:         {

  29:             List<ModelValidator> validators = new List<ModelValidator>();

  30:             foreach (var item in validatorData)

  31:             {

  32:                 if (item.GetType().Name == "OrCompositeValidatorData")

  33:                 {

  34:                     validators.AddRange(GetValidators(metadata, context, ((OrCompositeValidatorData)item).Validators.Where(v => !((ValueValidatorData)v).Negated)));

  35:                 }

  36:                 else

  37:                     validators.Add(GetValidator(metadata, context, item));

  38:             }

  39:  

  40:             return validators.Where(item => item != null);

  41:         }

  42:         /// <summary>

  43:         /// The mapper method that translates EntLib validator to ASP.NET MVC Validation Attribute

  44:         /// </summary>

  45:         private ModelValidator GetValidator(ModelMetadata metadata, ControllerContext context, ValidatorData item)

  46:         {

  47:             DataAnnotationsModelValidationFactory factory;

  48:             if (item.GetType().Name == "NotNullValidatorData")//So for a EntLib NotNullValidator what we really need in MVC is a RequiredAttribute.

  49:             {

  50:                 ValidationAttribute attribute = new RequiredAttribute { ErrorMessage = item.MessageTemplate };

  51:                 if (AttributeFactories.TryGetValue(attribute.GetType(), out factory))

  52:                     return factory(metadata, context, attribute);

  53:             }

  54:             else if (item.GetType().Name == "RegexValidatorData")//Likewise for a EntLib RegExValidator we need RegularExpressionAttribute in MVC.

  55:  

  56:             {

  57:                 RegexValidatorData regexData = (RegexValidatorData)item;

  58:  

  59:                 RegularExpressionAttribute regexAttribute = new RegularExpressionAttribute(regexData.Pattern) { ErrorMessage = item.GetMessageTemplate() };

  60:  

  61:                 if (AttributeFactories.TryGetValue(regexAttribute.GetType(), out factory))

  62:                     return factory(metadata, context, regexAttribute);

  63:             }           

  64:  

  65:             return null;

  66:         }

  67:         #endregion

  68:     }

  69: }

The extension method to extract defined validation settings:

   1: public static List<ValidatorData> ExtractRules(this Type targetType, string propertyName)

   2: {

   3:     FileConfigurationSource fileConfigurationsource = new FileConfigurationSource(validationFilePath);

   4:     ValidationSettings settings = (ValidationSettings)fileConfigurationsource.GetSection("validation");

   5:  

   6:     ValidatedTypeReference rules = settings.Types.FirstOrDefault(item => item.Name.Equals(targetType.FullName));

   7:  

   8:     return rules.Rulesets.SelectMany(item => item.Properties).Where(item => item.Name.Equals(propertyName)).SelectMany(item => item.Validators).ToList();

   9: }

Now the final step: register our custom ModelValidatorProvider to ModelValidatorProviders.Providers in Application_Start() in Global.asax:

   1: using Validation;

   2:  

   3: public class MvcApplication : System.Web.HttpApplication

   4: {

   5:     protected void Application_Start()

   6:     {

   7:         /*Usual code removed for the sake of Brevity*/

   8:  

   9:         ModelValidatorProviders.Providers.Add(new EntLibDataAnotationProvider());

  10:     }

  11: }

And now you are good to go. Try this on your own now.

Happy Coding.

Sayan

P.S: Don’t forget to add the jQuery unobtrusive validation libraries in the master layout (view). Also this is written based on my personal experience, if there is a better way to do it, please don't hesitate to leave your comments.

Edit: Next in this series: Extending EntLib VAB - Part 2.1: Create custom validators and integrate that with EntLib CABC