using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace ValidationSample
{
public class ConventionMetadataProvider : AssociatedMetadataProvider
    {
public ConventionMetadataProvider() : base()
        {
        }

protected override ModelMetadata CreateMetadata(IEnumerable<Attribute> attributes, Type containerType, Func<object> modelAccessor, Type modelType, string propertyName)
        {
            var metadata = new ModelMetadata(this, containerType, modelAccessor, modelType, propertyName);

if (propertyName == null)
return metadata;

if (propertyName.EndsWith("Id"))
            {
                metadata.TemplateHint = "HiddenInput";
                metadata.HideSurroundingChrome = true;
            }

if (propertyName.EndsWith("X"))
            {
                metadata.IsRequired = true;
            }

            metadata.DisplayName = propertyName.TrimEnd('X').Wordify();

return metadata;
        }
    }    

public static class Extensions
    {
public static string Wordify(this string str)
        {
string newString = "";
foreach(char c in str) {
                newString += char.IsUpper(c) ? " " + c : c.ToString();
            }

return newString;
        }
    }

}

using System;
using System.Collections.Generic;
using System.Web.Mvc;

namespace ValidationSample
{
public class ConventionValidatorProvider : AssociatedValidatorProvider
    {
protected override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context,
                                                                     IEnumerable<Attribute> attributes)
        {
if (metadata.IsRequired)
            {
yield return new MyRequiredValidator(metadata, context);
            }
        }

#region Nested type: MyRequiredValidator

public class MyRequiredValidator : ModelValidator
        {
internal MyRequiredValidator(ModelMetadata metadata, ControllerContext context)
                : base(metadata, context)
            {
            }

public override IEnumerable<ModelValidationResult> Validate(object container)
            {
                var result = new List<ModelValidationResult>();
if (Metadata.Model == null)
                    result.Add(new ModelValidationResult
                                   {
                                       MemberName = Metadata.PropertyName,
                                       Message = string.Format("{0} is required", Metadata.DisplayName)
                                   });

return result;
            }

public override IEnumerable<ModelClientValidationRule> GetClientValidationRules()
            {
yield return new ModelClientValidationRequiredRule("This field is required");
            }
        }

#endregion
    }    
}

        protected void Application_Start()
        {
            ModelMetadataProviders.Current = new ConventionMetadataProvider();
            ModelValidatorProviders.Current = new ConventionValidatorProvider();

            RegisterRoutes(RouteTable.Routes);
        }