1: public class ValidatorContext

   2: {

   3:     [ThreadStatic]

   4:     private static ValidatorContext current;

   5:  

   6:     public string RuleName { get; private set; }

   7:     public CultureInfo Culture { get; private set; }

   8:     public IDictionary<string, object> Properties { get; private set; }

   9:  

  10:     public ValidatorContext(string ruleName, CultureInfo culture=null)

  11:     {

  12:         this.RuleName = ruleName;

  13:         this.Properties = new Dictionary<string, object>();

  14:         this.Culture = culture??CultureInfo.CurrentUICulture;

  15:     }

  16:  

  17:     public static ValidatorContext Current

  18:     {

  19:         get { return current; }

  20:         set { current = value; }

  21:     }

  22: }

   1: public class ValidatorContextScope : IDisposable

   2: {

   3:     private ValidatorContext current = ValidatorContext.Current;

   4:     public ValidatorContextScope(string ruleName, CultureInfo culture = null)

   5:     {

   6:         ValidatorContext.Current = new ValidatorContext(ruleName, culture);

   7:     }

   8:     public void Dispose()

   9:     {

  10:         if (null == current)

  11:         {

  12:             foreach (object property in ValidatorContext.Current.Properties.Values)

  13:             {

  14:                 IDisposable disposable = property as IDisposable;

  15:                 if (null != disposable)

  16:                 {

  17:                     disposable.Dispose();

  18:                 }

  19:             }

  20:         }

  21:         ValidatorContext.Current = current;

  22:     }

  23: }

   1: [AttributeUsage( AttributeTargets.Class| AttributeTargets.Method)]

   2: public class ValidationRuleAttribute:Attribute

   3: {

   4:     public string Name { get; private set; }

   5:     public ValidationRuleAttribute(string name)

   6:     {

   7:         this.Name = name;

   8:     }

   9: }

   1: public class ExtendedControllerActionInvoker : ControllerActionInvoker

   2: {

   3:     public ExtendedControllerActionInvoker()

   4:     { 

   5:         this.CurrentCultureAccessor= (context=>

   6:             {

   7:                 string culture = context.RouteData.GetRequiredString("culture");

   8:                 if(string.IsNullOrEmpty(culture))

   9:                 {

  10:                     return null;

  11:                 }

  12:                 else

  13:                 {

  14:                     return new CultureInfo(culture);

  15:                 }

  16:             });

  17:     }

  18:     public virtual Func<ControllerContext, CultureInfo> CurrentCultureAccessor { get; set; }

  19:     public override bool InvokeAction(ControllerContext controllerContext, string actionName)

  20:     {

  21:         CultureInfo originalCulture = CultureInfo.CurrentCulture;

  22:         CultureInfo originalUICulture = CultureInfo.CurrentUICulture;

  23:         try

  24:         {

  25:             CultureInfo culture = this.CurrentCultureAccessor(controllerContext);

  26:             if (null != culture)

  27:             {

  28:                 Thread.CurrentThread.CurrentCulture = culture;

  29:                 Thread.CurrentThread.CurrentUICulture = culture;

  30:             }

  31:             var controllerDescriptor = this.GetControllerDescriptor(controllerContext);

  32:             var actionDescriptor = this.FindAction(controllerContext, controllerDescriptor, actionName);

  33:             ValidationRuleAttribute attribute = actionDescriptor.GetCustomAttributes(true).OfType<ValidationRuleAttribute>().FirstOrDefault() as ValidationRuleAttribute;

  34:             if (null == attribute)

  35:             {

  36:                 attribute = controllerDescriptor.GetCustomAttributes(true).OfType<ValidationRuleAttribute>().FirstOrDefault() as ValidationRuleAttribute;

  37:             }

  38:             string ruleName = (null == attribute) ? string.Empty : attribute.Name;

  39:             using (ValidatorContextScope contextScope = new ValidatorContextScope(ruleName))

  40:             {

  41:                 return base.InvokeAction(controllerContext, actionName);

  42:             }

  43:         }

  44:         catch

  45:         {

  46:             throw;

  47:         }

  48:         finally

  49:         {

  50:             Thread.CurrentThread.CurrentCulture = originalCulture;

  51:             Thread.CurrentThread.CurrentUICulture = originalUICulture;

  52:         }

  53:     }

  54: }

   1: public abstract class BaseController: Controller

   2: {

   3:     public BaseController()

   4:     {

   5:         this.ActionInvoker = new ExtendedControllerActionInvoker();

   6:     }

   7: }

   1: [AttributeUsage(AttributeTargets.Class|AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false)]

   2: public abstract class ValidatorBaseAttribute : ValidationAttribute, IClientValidatable

   3: {

   4:     

   5:     public string RuleName { get; set; }

   6:     public string MessageCategory { get; private set; }

   7:     public string MessageId { get; private set; }

   8:     public string Culture { get; set; }

   9:  

  10:     public ValidatorBaseAttribute(MessageManager messageManager, string messageCategory, string messageId, params object[] args)

  11:         : base(() => messageManager.FormatMessage(messageCategory, messageId, args))

  12:     {

  13:         this.MessageCategory = messageCategory;

  14:         this.MessageId = messageId;

  15:     }

  16:  

  17:     public ValidatorBaseAttribute(string messageCategory, string messageId, params object[] args)

  18:         : this(MessageManagerFactory.GetMessageManager(), messageCategory, messageId, args)

  19:     { }

  20:  

  21:     public virtual bool Match(ValidatorContext context, IEnumerable<ValidatorBaseAttribute> validators)

  22:     {

  23:         if (!string.IsNullOrEmpty(this.RuleName))

  24:         {

  25:             if (this.RuleName != context.RuleName)

  26:             {

  27:                 return false;

  28:             }

  29:         }

  30:  

  31:         if (!string.IsNullOrEmpty(this.Culture))

  32:         {                

  33:             if (string.Compare(this.Culture, context.Culture.Name, true) != 0)

  34:             {

  35:                 return false;

  36:             }

  37:         }

  38:  

  39:         if (string.IsNullOrEmpty(this.Culture))

  40:         {

  41:             if (validators.Any(validator => validator.GetType() == this.GetType() && string.Compare(validator.Culture, context.Culture.Name, true) == 0))

  42:             {

  43:                 return false;

  44:             }

  45:         }

  46:         return true;

  47:     }

  48:     public abstract IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context);

  49:     private object typeId;

  50:     public override object TypeId

  51:     {

  52:         get { return (null == typeId) ? (typeId = new object()) : typeId; }

  53:     }

  54: }

   1: public class ExtendedDataAnnotationsModelValidatorProvider : DataAnnotationsModelValidatorProvider

   2: {

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

   4:     {

   5:         var validators = attributes.OfType<ValidatorBaseAttribute>();

   6:         var allAttributes = attributes.Except(validators).ToList();

   7:         foreach (ValidatorBaseAttribute validator in validators)

   8:         {

   9:             if (validator.Match(ValidatorContext.Current, validators))

  10:             {

  11:                 allAttributes.Add(validator);

  12:             }

  13:         }

  14:         return base.GetValidators(metadata, context, allAttributes);

  15:     }

  16: }

   1: protected void Application_Start()

   2: {

   3:      //...

   4:     var provider = ModelValidatorProviders.Providers.OfType<DataAnnotationsModelValidatorProvider>().FirstOrDefault();

   5:     if (null != provider)

   6:     {

   7:         ModelValidatorProviders.Providers.Remove(provider);

   8:     }

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

  10: }

   1: [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = true)]

   2: public class RequiredValidatorAttribute : ValidatorBaseAttribute

   3: {

   4:     public RequiredValidatorAttribute(string messageCategory, string messageId, params object[] args)

   5:         : base(messageCategory, messageId, args)

   6:     { }   

   7:  

   8:     public override bool IsValid(object value)

   9:     {

  10:         if (value == null)

  11:         {

  12:             return false;

  13:         }

  14:         string str = value as string;

  15:         if (str != null)

  16:         {

  17:             return (str.Trim().Length != 0);

  18:         }

  19:         return true;

  20:     }

  21:  

  22:     public override IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)

  23:     {

  24:         return new ModelClientValidationRequiredRule[] { new ModelClientValidationRequiredRule(this.ErrorMessageString) };

  25:     }

  26: }