There are a number of ways of implementing a pattern for using custom view model attributes, the following is similar
to something I’m using at work which works pretty well. The classes I’m going
to create are really simple: 1. Abstract base attribute 2. Custom ModelMetadata provider which will derive from the DataAnnotationsModelMetadataProvider Base Attribute MetadataAttribute using System; using System.Web.Mvc; namespace Mvc2Templates.Attributes { /// <summary> /// Base class for custom MetadataAttributes. /// </summary> public abstract class MetadataAttribute : Attribute { /// <summary> /// Method for processing custom attribute data. /// </summary> /// <param name="modelMetaData">A ModelMetaData instance.</param> public abstract void Process(ModelMetadata modelMetaData); } } As you can see, the class simple has one method – Process. Process accepts the ModelMetaData which will allow any derived custom attributes
to set properties on the model meta data and add items
to its AdditionalValues collection. Custom Model Metadata Provider For a quick explanation of the Model Metadata and how it fits in
to the MVC 2 framework, it is basically a set of properties that are usually set via attributes placed above properties on a view model, for example the ReadOnly and HiddenInput attributes. When EditorForModel, DisplayForModel or any of the other EditorFor/DisplayFor methods are called, the ModelMetadata information is used
to determine how
to display the properties. All of the information available within the model metadata is also available through ViewData.ModelMetadata. The following class derives from the DataAnnotationsModelMetadataProvider built into the mvc 2 framework. I’ve overridden the CreateMetadata method in order
to process any custom attributes that may have been placed above a property in a view model. CustomModelMetadataProvider using System; using System.Collections.Generic; using System.Linq; using System.Web.Mvc; using Mvc2Templates.Attributes; namespace Mvc2Templates.Providers { public class CustomModelMetadataProvider : DataAnnotationsModelMetadataProvider { protected override ModelMetadata CreateMetadata( IEnumerable<Attribute> attributes, Type containerType, Func<object> modelAccessor, Type modelType, string propertyName) { var modelMetadata = base.CreateMetadata(attributes, containerType, modelAccessor, modelType, propertyName); attributes.OfType<MetadataAttribute>().ToList().ForEach(x => x.Process(modelMetadata)); return modelMetadata; } } } As you can see, once the model metadata is created through the base method, a check for any attributes deriving from our new abstract base attribute MetadataAttribute is made, the Process method is then called on any existing custom attributes with the model meta data for the property passed in. Hooking it up The last thing you need
to do
to hook it up is set the new CustomModelMetadataProvider as the current ModelMetadataProvider, this is done within the Global.asax Application_Start method. Global.asax protected void Application_Start() { AreaRegistration.RegisterAllAreas(); RegisterRoutes(RouteTable.Routes); ModelMetadataProviders.Current = new CustomModelMetadataProvider(); } In my next post, I’m going
to demonstrate a cool custom attribute that turns a textbox into an ajax driven AutoComplete text box. Hope this is useful. Kind Regards, Sean McAlinden.
