C# IValidator.CreateDescriptor方法代码示例

        private void GetValue(IValidator inputValidator, ValidationMetaData metaData, string parentKey)
        {
            var descriptor = inputValidator.CreateDescriptor();
            var members = descriptor.GetMembersWithValidators();
            
            foreach (var member in members)
            {

                var rules = descriptor.GetRulesForMember(member.Key);
                foreach (var rule in rules)
                {
                    foreach (var validator in rule.Validators)
                    {
                        var currentKey = string.IsNullOrEmpty(parentKey) ? member.Key : string.Format("{0}.{1}", parentKey, member.Key.ToCamelCase());
                        if (validator is ChildValidatorAdaptor)
                        {
                            var childValidator = (validator as ChildValidatorAdaptor).Validator;
                            GetValue(childValidator, metaData, currentKey);
                        }
                        else if(validator is IPropertyValidator)
                            GenerateFor(metaData, currentKey, validator as IPropertyValidator);
                    }
                }
            }
        }

        void GenerateForValidator(IValidator inputValidator, TypeMetaData metaData, string parentKey, bool isParentConcept = false, bool isParentModelRule = false)
        {
            var inputValidatorType = inputValidator.GetType();
            var genericArguments = inputValidatorType.BaseType.GetGenericArguments();

            var descriptor = inputValidator.CreateDescriptor();
            var members = descriptor.GetMembersWithValidators();
            
            foreach (var member in members)
            {
                var rules = descriptor.GetRulesForMember(member.Key);
                foreach (var rule in rules)
                {
                    foreach (var validator in rule.Validators)
                    {
                        var isModelRule = member.Key == ModelRule<string>.ModelRulePropertyName;
                        var currentKey = GetKeyForMember(parentKey, isParentConcept, isParentModelRule, member, isModelRule);

                        if (validator is ChildValidatorAdaptor)
                        {
                            GenerateForChildValidator(metaData, genericArguments, member, validator, isModelRule, currentKey);
                        }
                        else if (validator is IPropertyValidator)
                        {
                            GenerateFor(metaData, currentKey, validator);
                        }
                    }
                }
            }
        }

        void GetValue(IValidator inputValidator, ValidationMetaData metaData, string parentKey, bool isParentConcept = false, bool isParentModelRule = false)
        {
            var inputValidatorType = inputValidator.GetType();
#if(NETFX_CORE)
            var genericArguments = inputValidatorType.GetTypeInfo().BaseType.GenericTypeArguments;
#else
            var genericArguments = inputValidatorType.BaseType.GetGenericArguments();
#endif

            var descriptor = inputValidator.CreateDescriptor();
            var members = descriptor.GetMembersWithValidators();
            
            foreach (var member in members)
            {
                var rules = descriptor.GetRulesForMember(member.Key);
                foreach (var rule in rules)
                {
                    foreach (var validator in rule.Validators)
                    {
                        var isModelRule = member.Key == ModelRule<string>.ModelRulePropertyName;
                        var currentKey = string.Empty;
                        if (isParentConcept || isParentModelRule || isModelRule)
                            currentKey = parentKey;
                        else
                            currentKey = string.IsNullOrEmpty(parentKey) ? member.Key : string.Format("{0}.{1}", parentKey, member.Key.ToCamelCase());

                        if (validator is ChildValidatorAdaptor)
                        {
                            var isConcept = false;
                            
                            if (genericArguments.Length == 1)
                            {
                                var type = isModelRule ? genericArguments[0] : GetPropertyInfo(genericArguments[0], member.Key).PropertyType;
                                isConcept = type.IsConcept();
                            }

                            var childValidator = (validator as ChildValidatorAdaptor).Validator;
                            GetValue(childValidator, metaData, currentKey, isConcept, isModelRule);
                        }
                        else if (validator is IPropertyValidator)
                        {
                            GenerateFor(metaData, currentKey, validator as IPropertyValidator);
                        }
                    }
                }
            }
        }

#pragma warning disable 1591 // Xml Comments
        public ValidationMetaData GenerateFrom(IValidator inputValidator)
        {
            var metaData = new ValidationMetaData();
            var descriptor = inputValidator.CreateDescriptor();
            var members = descriptor.GetMembersWithValidators();
            foreach (var member in members)
            {
                var rules = descriptor.GetRulesForMember(member.Key);
                foreach (var rule in rules)
                {
                    foreach (var validator in rule.Validators)
                    {
                        if (validator is IPropertyValidator)
                            GenerateFor(metaData, member.Key, validator as IPropertyValidator);
                    }
                }
            }

            return metaData;
        }

        public static ConstraintsAndMappers GetValidators(IValidator self, Func<IPropertyValidator, Type> getMapperFor)
        {
            if (self == null)
            {
                return new ConstraintsAndMappers(new List<ConstraintsAndMappers.Item>());
            }

            var parameters = self.CreateDescriptor()
                .GetMembersWithValidators()
                .Select(validators =>
                {
                    var constraints = validators
                        .Select(c => new ConstraintsAndMappers.Item.Entry(getMapperFor(c), c))
                        .Where(c => c.RuleGeneratorType != null)
                        .ToList();
                    return new ConstraintsAndMappers.Item(validators.Key, constraints);
                }).Where(p => p.Constraints.Any()).ToList();

            return new ConstraintsAndMappers(parameters);
        }

        private IEnumerable<ModelValidator> GetValidatorsForProperty(ModelMetadata metadata, IEnumerable<ModelValidatorProvider> validatorProviders, IValidator validator)
        {
            var modelValidators = new List<ModelValidator>();

            if (validator != null)
            {
                var descriptor = validator.CreateDescriptor();

                var validatorsWithRules = from rule in descriptor.GetRulesForMember(metadata.PropertyName)
                                          let propertyRule = (PropertyRule)rule
                                          let validators = rule.Validators
                                          where validators.Any()
                                          from propertyValidator in validators
                                          let modelValidatorForProperty = GetModelValidator(metadata, validatorProviders, propertyRule, propertyValidator)
                                          where modelValidatorForProperty != null
                                          select modelValidatorForProperty;

                modelValidators.AddRange(validatorsWithRules);
            }

            //if (validator != null && metadata.IsRequired && AddImplicitRequiredValidator)
            //{
            //    bool hasRequiredValidators = modelValidators.Any(x => x.IsRequired);

            //    //If the model is 'Required' then we assume it must have a NotNullValidator.
            //    //This is consistent with the behaviour of the DataAnnotationsModelValidatorProvider
            //    //which silently adds a RequiredAttribute

            //    if (!hasRequiredValidators)
            //    {
            //        modelValidators.Add(CreateNotNullValidatorForProperty(metadata, context));
            //    }
            //}

            return modelValidators;
        }

        void GenerateForValidator(
            IValidator inputValidator,
            TypeMetaData metaData,
            string parentKey,
            bool shouldUseParentKey = false)
        {
            var inputValidatorType = inputValidator.GetType();
            var genericArguments = inputValidatorType.BaseType.GetGenericArguments();

            var descriptor = inputValidator.CreateDescriptor();
            var members = descriptor.GetMembersWithValidators();

            foreach (var member in members)
            {
                var isModelRule = member.Key == ModelRule<string>.ModelRulePropertyName || member.Key == string.Empty;
                var currentKey = (shouldUseParentKey || isModelRule) ? parentKey : GetKeyForMember(parentKey, member);
                var isConcept = new Lazy<bool>(() => IsConcept(genericArguments, isModelRule, member));

                foreach (var rule in descriptor.GetRulesForMember(member.Key))
                {
                    foreach (var validator in rule.Validators)
                    {
                        var childValidatorAdaptor = validator as ChildValidatorAdaptor;
                        if (childValidatorAdaptor != null)
                        {
                            var childValidator = childValidatorAdaptor.GetValidator(NullContext);
                            GenerateForValidator(childValidator, metaData, currentKey, isModelRule || isConcept.Value);
                        }
                        else
                        {
                            GenerateFor(metaData, currentKey, validator);
                        }
                    }
                }
            }
        }

 private IEnumerable<PropertyValidatorResult> GetPropertyValidators(IValidator baseValidator, List<PropertyInfo> properties)
 {
     var desc = baseValidator.CreateDescriptor();
     var validators = GetNestedPropertyValidators(desc, properties, 0).ToList();
     return validators;
 }

        IEnumerable<ModelValidator> GetValidatorsForProperty(ModelMetadata metadata, ControllerContext context, IValidator validator)
        {
            var modelValidators = new List<ModelValidator>();

            if (validator != null) {
                var descriptor = validator.CreateDescriptor();

                var validatorsWithRules = from rule in descriptor.GetRulesForMember(metadata.PropertyName)
                                          let propertyRule = (PropertyRule)rule
                                          // Only want to include rules that allow standalone clientside validation.
                                          let validators = rule.Validators.Where(x => x.SupportsStandaloneValidation)
                                          where validators.Any()
                                          from propertyValidator in validators
                                          select new { validator = propertyValidator, rule = propertyRule };

                foreach(var validatorWithRule in validatorsWithRules) {
                    modelValidators.Add(GetModelValidator(metadata, context, validatorWithRule.rule, validatorWithRule.validator));
                }
            }

            if(metadata.IsRequired && AddImplicitRequiredValidator) {
                bool hasRequiredValidators = modelValidators.Any(x => x.IsRequired);

                //Is the model is 'Required' then we assume it must have a NotNullValidator.
                //This is consistent with the behaviour of the DataAnnotationsModelValidatorProvider
                //which silently adds a RequiredAttribute

                if(! hasRequiredValidators) {
                    modelValidators.Add(CreateNotNullValidatorForProperty(metadata, context));
                }
            }

            return modelValidators;
        }

        IEnumerable<ModelValidator> GetValidatorsForProperty(ModelMetadata metadata, ControllerContext context, IValidator validator)
        {
            var modelValidators = new List<ModelValidator>();

            if (validator != null) {
                var descriptor = validator.CreateDescriptor();

                var validators = descriptor.GetValidatorsForMember(metadata.PropertyName)
                    .Where(x => x.SupportsStandaloneValidation);

                foreach(var propertyValidator in validators) {
                    modelValidators.Add(GetModelValidator(metadata, context, propertyValidator));
                }
            }

            if(metadata.IsRequired && AddImplicitRequiredValidator) {
                bool hasRequiredValidators = modelValidators.Any(x => x.IsRequired);

                //Is the model is 'Required' then we assume it must have a NotNullValidator.
                //This is consistent with the behaviour of the DataAnnotationsModelValidatorProvider
                //which silently adds a RequiredAttribute

                if(! hasRequiredValidators) {
                    modelValidators.Add(CreateNotNullValidatorForProperty(metadata, context));
                }
            }

            return modelValidators;
        }

        IEnumerable<ModelValidator> GetValidatorsForProperty(ModelMetadata metadata, ControllerContext context, IValidator validator)
        {
            var modelValidators = new List<ModelValidator>();

            if (validator != null) {
                var descriptor = validator.CreateDescriptor();

                var validators = descriptor.GetValidatorsForMember(metadata.PropertyName);
                    //Equal validator with MemberInfo not support standalone
                    //.Where(x => x.SupportsStandaloneValidation);

                foreach(var propertyValidator in validators) {
                    modelValidators.Add(GetModelValidator(metadata, context, propertyValidator));
                }
            }

            return modelValidators;
        }