CompareAttribute.cs

using System;
using System.ComponentModel.DataAnnotations;

namespace Sage.ES.S50.ValidationsAttribute
{
    [AttributeUsage(AttributeTargets.Property|AttributeTargets.Field)]
    public class CompareAttribute : ValidationAttribute
    {
        #region Enumns
        public enum OperatorType
        {
            LessThan,
            LessOrEqualThan,
            GreatherThan,
            GreatherOrEqualThan,
            Equal,
            Distinct
        }
        #endregion

        #region Members
        private readonly string _comparisonProperty;
        private readonly OperatorType _operatorType;
        #endregion

        #region Constructor
        public CompareAttribute( OperatorType operatorType, string comparisonProperty)
        {
            _comparisonProperty = comparisonProperty;
            _operatorType = operatorType;
        }
        #endregion

        #region Private Methods
        protected override ValidationResult IsValid(object value, ValidationContext validationContext)
        {
            ErrorMessage = ErrorMessageString;

            var property = validationContext.ObjectType.GetProperty(_comparisonProperty);

            if (property == null)
            {
                throw new ArgumentException("Comparison property with this name not found");
            }

            var comparisonValue = property.GetValue(validationContext.ObjectInstance,null);

            // Si el tipo es una fecha, realizamos un caso especial para los valores nulos
            if (comparisonValue.GetType() == typeof(DateTime) && value == null)
            {
                // Si el valor a comparar es nulo, no hay que realizar las validaciones
                return ValidationResult.Success;
            }


            if (comparisonValue.GetType() == typeof(IComparable))
            {
                throw new ArgumentException("Comparison property has not implemented IComparable interface");
            }

            if (value.GetType() == typeof(IComparable))
            {
                throw new ArgumentException("value has not implemented IComparable interface");
            }

            var currentValue = (IComparable)value;

            if (!ReferenceEquals(value.GetType(), comparisonValue.GetType()))
            {
                throw new ArgumentException("The properties types must be the same");
            }
            bool validation = false;
            int retCompare = currentValue.CompareTo((IComparable)comparisonValue);
            switch (_operatorType)
            {
                case OperatorType.LessThan:
                    validation = retCompare < 0;
                    break;
                case OperatorType.LessOrEqualThan:
                    validation = retCompare <= 0;
                    break;
                case OperatorType.GreatherThan:
                    validation = retCompare > 0;
                    break;
                case OperatorType.GreatherOrEqualThan:
                    validation = retCompare >= 0;
                    break;
                case OperatorType.Equal:
                    validation = retCompare == 0;
                    break;
                case OperatorType.Distinct:
                    validation = retCompare != 0;
                    break;
                default:
                    break;
            }
            if (!validation)
            {
                return new ValidationResult(ErrorMessage, new string[] { validationContext.MemberName });
            }

            return ValidationResult.Success;
        }
        #endregion
    }
}