在Asp.Net MVC中可以用继承ValidationAttribute的方式,自定制实现Model两个中两个属性值的比较验证

具体应用场景为:要对两个属性值的大小进行验证

代码如下所示:

    /// <summary>
    /// Specifies that the field must compare favourably with the named field, if objects to check are not of the same type
    /// false will be return
    /// </summary>
    public class CompareValuesAttribute : ValidationAttribute
    {
        /// <summary>
        /// The other property to compare to
        /// </summary>
        public string OtherProperty { get; set; }

        public CompareValues Criteria { get; set; }

        /// <summary>
        /// Creates the attribute
        /// </summary>
        /// <param name="otherProperty">The other property to compare to</param>
        public CompareValuesAttribute(string otherProperty, CompareValues criteria)
        {
            if (otherProperty == null)
                throw new ArgumentNullException("otherProperty");

            OtherProperty = otherProperty;
            Criteria = criteria;
        }

        /// <summary>
        /// Determines whether the specified value of the object is valid.  For this to be the case, the objects must be of the same type
        /// and satisfy the comparison criteria. Null values will return false in all cases except when both
        /// objects are null.  The objects will need to implement IComparable for the GreaterThan,LessThan,GreatThanOrEqualTo and LessThanOrEqualTo instances
        /// </summary>
        /// <param name="value">The value of the object to validate</param>
        /// <param name="validationContext">The validation context</param>
        /// <returns>A validation result if the object is invalid, null if the object is valid</returns>
        protected override ValidationResult IsValid(object value, ValidationContext validationContext)
        {
            // the the other property
            var property = validationContext.ObjectType.GetProperty(OtherProperty);

            // check it is not null
            if (property == null)
                return new ValidationResult(String.Format("Unknown property: {0}.", OtherProperty));

            // check types
            var memberName = validationContext.ObjectType.GetProperties().Where(p => p.GetCustomAttributes(false).OfType<DisplayAttribute>().Any(a => a.Name == validationContext.DisplayName)).Select(p => p.Name).FirstOrDefault();
            if (memberName == null)
            {
                memberName = validationContext.DisplayName;
            }
            if (validationContext.ObjectType.GetProperty(memberName).PropertyType != property.PropertyType)
                return new ValidationResult(String.Format("The types of {0} and {1} must be the same.", memberName, OtherProperty));

            // get the other value
            var other = property.GetValue(validationContext.ObjectInstance, null);

            // equals to comparison,
            if (Criteria == CompareValues.EqualTo)
            {
                if (Object.Equals(value, other))
                    return null;
            }
            else if (Criteria == CompareValues.NotEqualTo)
            {
                if (!Object.Equals(value, other))
                    return null;
            }
            else
            {
                // check that both objects are IComparables
                if (!(value is IComparable) || !(other is IComparable))
                    return new ValidationResult(String.Format("{0} and {1} must both implement IComparable", validationContext.DisplayName, OtherProperty));

                // compare the objects
                var result = Comparer.Default.Compare(value, other);

                switch (Criteria)
                {
                    case CompareValues.GreaterThan:
                        )
                            return null;
                        break;
                    case CompareValues.LessThan:
                        )
                            return null;
                        break;
                    case CompareValues.GreatThanOrEqualTo:
                        )
                            return null;
                        break;
                    case CompareValues.LessThanOrEqualTo:
                        )
                            return null;
                        break;
                }
            }

            // got this far must mean the items don't meet the comparison criteria
            return new ValidationResult(ErrorMessage);
        }
    }

    /// <summary>
    /// Indicates a comparison criteria used by the CompareValues attribute
    /// </summary>
    public enum CompareValues
    {
        EqualTo,
        NotEqualTo,
        GreaterThan,
        LessThan,
        GreatThanOrEqualTo,
        LessThanOrEqualTo
    }

应用的时候直接在指定的属性上添加此CompareValuesAttribute标签即可

【注:第一个参数是要与之比较的属性名,第二个参数表示两个属性值之间的大小关系,第三个参数表示错误提示信息】

public class EricSunModel
{
    [Display(Name = "Ready Time")]
    public string ReadyTime { get; set; }

    [CompareValues("ReadyTime", CompareValues.GreaterThan, ErrorMessage = "Close time must be later than ready time")]
    [Display(Name = "Close Time")]
    public string CloseTime { get; set; }

}

更多细节可以参考如下链接:

http://cncrrnt.com/blog/index.php/2011/01/custom-validationattribute-for-comparing-properties/

这里提供一个我自己的增强版本,可以添加另外一个依赖条件。

代码如下:

    public class CompareValuesAttribute : ValidationAttribute
    {
        /// <summary>
        /// The other property to compare to
        /// </summary>
        public string OtherProperty { get; set; }
        public CompareCriteria Criteria { get; set; }

        /// <summary>
        /// The other dependent rule
        /// </summary>
        public string RulePropertyName { get; set; }
        public CompareCriteria RuleCriteria { get; set; }
        public object RulePropertyValue { get; set; }

        public bool CustomErrorMessage { get; set; }

        /// <summary>
        /// Compare values with other property based on other rules or not
        /// </summary>
        /// <param name="otherProperty">other property.</param>
        /// <param name="criteria">criteria</param>
        /// <param name="rulePropertyName">rule property name. (if don't based on other rules, please input null)</param>
        /// <param name="ruleCriteria">rule criteria. (if don't based on other rules, please input null)</param>
        /// <param name="rulePropertyValue">rule property value. (if don't based on other rules, please input null)</param>
        /// <param name="customErrorMessage">custom error message. (if don't need customize error message format, please input null)</param>
        public CompareValuesAttribute(string otherProperty, CompareCriteria criteria, string rulePropertyName, CompareCriteria ruleCriteria, object rulePropertyValue, bool customErrorMessage)
        {
            OtherProperty = otherProperty;
            Criteria = criteria;
            RulePropertyName = rulePropertyName;
            RuleCriteria = ruleCriteria;
            RulePropertyValue = rulePropertyValue;
            CustomErrorMessage = customErrorMessage;
        }

        /// <summary>
        ///  Compare values with other property
        /// </summary>
        /// <param name="otherProperty"></param>
        /// <param name="criteria"></param>
        /// <param name="customErrorMessage"></param>
        public CompareValuesAttribute(string otherProperty, CompareCriteria criteria, bool customErrorMessage)
        {
            OtherProperty = otherProperty;
            Criteria = criteria;
            RulePropertyName = null;
            CustomErrorMessage = customErrorMessage;
        }

        protected override ValidationResult IsValid(object value, ValidationContext validationContext)
        {
            if (ValidateDependentRule(validationContext) == null)   //validate dependent rule successful
            {
                if (OtherProperty == null)
                {
                    return new ValidationResult(String.Format("Orther property is null."));
                }

                // the the other property
                var property = validationContext.ObjectType.GetProperty(OtherProperty);

                // check it is not null
                if (property == null)
                {
                    return new ValidationResult(String.Format("Unknown property: {0}.", OtherProperty));
                }

                // check types
                var memberName = validationContext.ObjectType.GetProperties().Where(p => p.GetCustomAttributes(false).OfType<DisplayAttribute>().Any(a => a.Name == validationContext.DisplayName)).Select(p => p.Name).FirstOrDefault();
                if (memberName == null)
                {
                    memberName = validationContext.DisplayName;
                }
                if (validationContext.ObjectType.GetProperty(memberName).PropertyType != property.PropertyType)
                {
                    return new ValidationResult(String.Format("The types of {0} and {1} must be the same.", memberName, OtherProperty));
                }

                // get the other value
                var other = property.GetValue(validationContext.ObjectInstance, null);

                if (CompareValues(value, other, Criteria, validationContext) == null)
                {
                    return null;
                }
                else
                {
                    // got this far must mean the items don't meet the comparison criteria
                    if (CustomErrorMessage)
                    {
                        return new ValidationResult(string.Format(ErrorMessage, other));
                    }
                    else
                    {
                        return new ValidationResult(ErrorMessage);
                    }
                }
            }
            else
            {
                return null;    //dependent rule isn't exist or validate dependent rule failed
            }
        }

        private ValidationResult ValidateDependentRule(ValidationContext validationContext)
        {
            ValidationResult validateRuleResult = null;

            // has dependent rule
            if (RulePropertyName != null)
            {
                var rulePropertyName = validationContext.ObjectType.GetProperty(RulePropertyName);
                if (rulePropertyName == null)
                    return new ValidationResult(String.Format("Unknown rule property name: {0}.", RulePropertyName));

                var rulePropertyRealValue = rulePropertyName.GetValue(validationContext.ObjectInstance, null);

                validateRuleResult = CompareValues(rulePropertyRealValue, RulePropertyValue, RuleCriteria, validationContext);
            }

            return validateRuleResult;
        }

        private ValidationResult CompareValues(object targetValue, object otherValue, CompareCriteria compareCriteria, ValidationContext validationContext)
        {
            ValidationResult compareResult = new ValidationResult("Compare Values Failed.");

            // equals to comparison,
            if (compareCriteria == CompareCriteria.EqualTo)
            {
                if (Object.Equals(targetValue, otherValue)) compareResult = null;
            }
            else if (compareCriteria == CompareCriteria.NotEqualTo)
            {
                if (!Object.Equals(targetValue, otherValue)) compareResult = null;
            }
            else
            {
                // check that both objects are IComparables
                if (!(targetValue is IComparable) || !(otherValue is IComparable))
                    compareResult = new ValidationResult(String.Format("{0} and {1} must both implement IComparable", validationContext.DisplayName, OtherProperty));

                // compare the objects
                var result = Comparer.Default.Compare(targetValue, otherValue);

                switch (compareCriteria)
                {
                    case CompareCriteria.GreaterThan:
                        ) compareResult = null;
                        break;
                    case CompareCriteria.LessThan:
                        ) compareResult = null;
                        break;
                    case CompareCriteria.GreatThanOrEqualTo:
                        ) compareResult = null;
                        break;
                    case CompareCriteria.LessThanOrEqualTo:
                        ) compareResult = null;
                        break;
                }
            }

            return compareResult;
        }
    }

    public enum CompareCriteria
    {
        EqualTo,
        NotEqualTo,
        GreaterThan,
        LessThan,
        GreatThanOrEqualTo,
        LessThanOrEqualTo
    }

在Asp.Net MVC中实现CompareValues标签对Model中的属性进行验证的更多相关文章

  1. CompareValues标签对Model中的属性进行验证

    在Asp.Net MVC中实现CompareValues标签对Model中的属性进行验证   在Asp.Net MVC中可以用继承ValidationAttribute的方式,自定制实现Model两个 ...

  2. 在Asp.Net MVC中实现RequiredIf标签对Model中的属性进行验证

    在Asp.Net MVC中可以用继承ValidationAttribute的方式,自定制实现RequiredIf标签对Model中的属性进行验证 具体场景为:某一属性是否允许为null的验证,要根据另 ...

  3. 在.Net MVC中自定义ValidationAttribute标签对Model中的属性做验证

    写一个继承与ValidationAttribute类的自定义的验证方法 MVC中传递数据时,大多数都会用Model承载数据,并且在传到控制器后,对Model进行一系列的验证. 我平时经常使用的判断方法 ...

  4. Asp.net mvc + .net ef database first 或 model first 时如何添加验证特性

    今天有个同事问到,在使用Entity Framework 的Database frist或model first时,怎么在model上添加验证的特性? 因为此时的Model是是VS 工具怎么生成的,直 ...

  5. 返璞归真 asp.net mvc (8) - asp.net mvc 3.0 新特性之 Model

    原文:返璞归真 asp.net mvc (8) - asp.net mvc 3.0 新特性之 Model [索引页][源码下载] 返璞归真 asp.net mvc (8) - asp.net mvc ...

  6. mvc中动态给一个Model类的属性设置验证

    原文:mvc中动态给一个Model类的属性设置验证 在mvc中有自带的验证机制,比如如果某个字段的类型是数字或者日期,那么用户在输入汉字或者英文字符时,那么编译器会自动验证并提示用户格式不正确,不过这 ...

  7. 总结ASP.NET MVC Web Application中将数据显示到View中的几种方式

    当我们用ASP.NET MVC开发Web应用程序的时候,我们都是将需要呈现的数据通过"Controllers"传输到"View"当中,怎么去实现,下面我介绍一下 ...

  8. Asp.Net MVC 从客户端&lt;a href=&quot;http://www....&quot;)中检测到有潜在危险的 Request.Form 值

    Asp.Net MVC应用程序, Framework4.0: 则需要在webconfig文件的 <system.web> 配置节中加上 <httpRuntime requestVal ...

  9. asp.net mvc 3.0 知识点整理 ----- (2).Controller中几种Action返回类型对比

    通过学习,我们可以发现,在Controller中提供了很多不同的Action返回类型.那么具体他们是有什么作用呢?它们的用法和区别是什么呢?通过资料书上的介绍和网上资料的查询,这里就来给大家列举和大致 ...

随机推荐

  1. 【jmeter】参数化User Defined Variables与User Parameters

    偶然发现JMeter中有两个元件(User Defined Variables与User Parameters)很相近,刚开始时我也没注意,两者有什么不同.使用时却发现两者使用场景有些不同,现在小结一 ...

  2. zz 如何在Linux下创建与解压zip, tar, tar.gz和tar.bz2文件

    January 2nd, 2009 at 10:31 pm Linux 解压, Linux, tar, tar.bz2, tar.gz, tgz, zip, 压缩, 打包, 文档 这么多年来,数据压缩 ...

  3. (C学习基础)一,CMD的使用

    以后考研要考数据结构,所以系统的整理一下C学习笔记.这里开发用VS2013  CMD资料在这里下载 首先就是DOS系统的CMD的使用,是不是觉得会命令行语句的人特别牛呢,有时候使用命令行总是事半功倍, ...

  4. python之装饰器详解

    这几天翻看python语法,看到装饰器这里着实卡了一阵,最初认为也就是个函数指针的用法,但仔细研究后发现,不止这么简单. 首先很多资料将装饰器定义为AOP的范畴,也就是Aspect Oriented ...

  5. Oracle约束操作

    约束的概念: 约束是在表中定义的用于维护数据库完整性的一些规则.通过为表中的字段定义约 束,可以防止将错误的数据插入到表中. 注意: 1.如果某个约束只作用于单独的字段,既可以在字段级定义约束,也可以 ...

  6. Netflix工程总监眼中的分类算法:深度学习优先级最低

    Netflix工程总监眼中的分类算法:深度学习优先级最低 摘要:不同分类算法的优势是什么?Netflix公司工程总监Xavier Amatriain根据奥卡姆剃刀原理依次推荐了逻辑回归.SVM.决策树 ...

  7. Java引用数据类型

    值传递:方法调用时,实际参数把它的值传递给对应的形式参数,方法执行中形式参数值的改变不影响实际参 数的值.引用传递:也称为传地址.方法调用时,实际参数的引用(地址,而不是参数的值)被传递给方法中相对应 ...

  8. (五)Cluster Health

    Let’s start with a basic health check, which we can use to see how our cluster is doing. We’ll be us ...

  9. Linux Centos 删除除某(多)个文件之外的所有文件

    好久没有写东西了.通常我们通过rm -rf  *可以直接强制删除当前文件夹里面的所有内容,但是有些时候我们需要保留一些文件,就比如,网站转移更新需要保留程序压缩包等就需要用到在linux centos ...

  10. Oracle minus用法详解及应用实例

    本文转载:https://blog.csdn.net/jhon_03/article/details/78321937 Oracle minus用法 “minus”直接翻译为中文是“减”的意思,在Or ...