public static Validator GetPropertyValidatorFromAttributes(Type type, PropertyInfo propertyInfo, string ruleset,
                                                                   MemberAccessValidatorBuilderFactory memberAccessValidatorBuilderFactory)
        {
            Validator validator = null;

            lock (AttributeOnlyPropertyValidatorsCache)
            {
                var key = new PropertyValidatorCacheKey(type, propertyInfo.Name, ruleset);
                if (!AttributeOnlyPropertyValidatorsCache.TryGetValue(key, out validator))
                {
                    validator = new MetadataValidatorBuilder(memberAccessValidatorBuilderFactory, ValidationFactory.DefaultCompositeValidatorFactory).CreateValidatorForProperty(propertyInfo, ruleset);

                    AttributeOnlyPropertyValidatorsCache[key] = validator;
                }
            }

            return(validator);
        }
        public static Validator GetPropertyValidator(Type type, PropertyInfo propertyInfo, string ruleset,
                                                     ValidationSpecificationSource validationSpecificationSource,
                                                     MemberAccessValidatorBuilderFactory memberAccessValidatorBuilderFactory)
        {
            if (null == type)
            {
                throw new InvalidOperationException(Translations.ExceptionTypeNotFound);
            }
            if (null == propertyInfo)
            {
                throw new InvalidOperationException(Translations.ExceptionPropertyNotFound);
            }
            if (!propertyInfo.CanRead)
            {
                throw new InvalidOperationException(Translations.ExceptionPropertyNotReadable);
            }

            var validators = new List <Validator>();

            if (validationSpecificationSource.IsSet(ValidationSpecificationSource.Attributes))
            {
                validators.Add(GetPropertyValidatorFromAttributes(type, propertyInfo, ruleset, memberAccessValidatorBuilderFactory));
            }
            if (validationSpecificationSource.IsSet(ValidationSpecificationSource.DataAnnotations))
            {
                validators.Add(GetPropertyValidatorFromValidationAttributes(type, propertyInfo, ruleset, memberAccessValidatorBuilderFactory));
            }

            var effectiveValidators = validators.Where(v => v != null).ToArray();

            if (effectiveValidators.Length == 1)
            {
                return(effectiveValidators[0]);
            }
            if (effectiveValidators.Length > 1)
            {
                return(new AndCompositeValidator(effectiveValidators));
            }

            return(null);
        }
        public static Validator GetPropertyValidatorFromValidationAttributes(Type type, PropertyInfo propertyInfo, string ruleset,
                                                                             MemberAccessValidatorBuilderFactory memberAccessValidatorBuilderFactory)
        {
            Validator validator;

            lock (ValidationAttributeOnlyPropertyValidatorsCache)
            {
                var key = new PropertyValidatorCacheKey(type, propertyInfo.Name, ruleset);
                if (!ValidationAttributeOnlyPropertyValidatorsCache.TryGetValue(key, out validator))
                {
                    validator =
                        string.IsNullOrEmpty(ruleset)
                            ? new ValidationAttributeValidatorBuilder(memberAccessValidatorBuilderFactory, ValidationFactory.DefaultCompositeValidatorFactory).CreateValidatorForProperty(propertyInfo)
                            : new AndCompositeValidator();

                    ValidationAttributeOnlyPropertyValidatorsCache[key] = validator;
                }
            }

            return(validator);
        }
 public ValidatorBuilderBase(MemberAccessValidatorBuilderFactory memberAccessValidatorFactory,
                             ValidatorFactory validatorFactory)
 {
     _memberAccessValidatorFactory = memberAccessValidatorFactory;
     _validatorFactory             = validatorFactory;
 }
 public ValidationAttributeValidatorBuilder(MemberAccessValidatorBuilderFactory memberAccessValidatorFactory,
                                            ValidatorFactory validatorFactory) : base(memberAccessValidatorFactory, validatorFactory)
 {
 }
 public MetadataValidatorBuilder(MemberAccessValidatorBuilderFactory memberAccessValidatorFactory,
                                 ValidatorFactory validatorFactory) : base(memberAccessValidatorFactory, validatorFactory)
 {
 }
 public MetadataValidatorBuilder(MemberAccessValidatorBuilderFactory memberAccessValidatorFactory)
     : this(memberAccessValidatorFactory, ValidationFactory.DefaultCompositeValidatorFactory)
 {
 }