C# IValidator.GetType方法代码示例

 /// <summary>
 /// Emit implementation starting point
 /// </summary>
 /// <param name="v">The v.</param>
 /// <param name="sb">The sb.</param>
 /// <returns></returns>
 protected StringBuilder DoEmit(IValidator v, StringBuilder sb)
 {
     if (v.GetType().IsGenericType && typeof(ValidationSite<,>).IsAssignableFrom(v.GetType().GetGenericTypeDefinition()))
         return EmitSites(v, sb);
     else
         return EmitNamespace(v, sb);
 }

        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);
                        }
                    }
                }
            }
        }

        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);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Gets the validator. If the field is <c>null</c>, it will query the service locator.
        /// </summary>
        /// <returns>IValidator.</returns>
        private IValidator GetValidator()
        {
            if (_validator == null)
            {
                if (!_hasRetrievedValidatorOnce)
                {
                    var dependencyResolver = this.GetDependencyResolver();
                    var validatorProvider = dependencyResolver.TryResolve<IValidatorProvider>();
                    if (validatorProvider != null)
                    {
                        _validator = validatorProvider.GetValidator(GetType());
                        if (_validator != null)
                        {
                            Log.Debug("Found validator '{0}' for view model '{1}' via the registered IValidatorProvider", _validator.GetType().FullName, GetType().FullName);
                        }
                    }

                    _hasRetrievedValidatorOnce = true;
                }
            }

            return _validator;
        }

        /// <summary>
        /// Adds a new validation.
        /// </summary>
        /// <param name="source">The source that will provide the value to be validated.</param>
        /// <param name="validator">The <see cref="IValidator"/> that will validate the value.</param>
        /// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="validator"/> is null.</exception>
        public void AddValidation(string source, IValidator validator)
        {
            if (string.IsNullOrEmpty(source))
                throw new ArgumentNullException("source");

            if ((object)validator == null)
                throw new ArgumentNullException("validator");

            m_validations.Add(string.Format("{0}+{1}", source, validator.GetType().Name), validator);
        }

 public ChildCollectionValidatorAdaptor(IValidator childValidator)
 {
     this.childValidatorProvider = (_) => childValidator;
     this.childValidatorType = childValidator.GetType();
 }

        /// <summary>
        /// Gets the simple name of the type.
        /// </summary>
        /// <param name="child">The child.</param>
        /// <returns></returns>
        private string GetSimpleTypeName(IValidator child)
        {
            var name = child.GetType().FullName;
            var ind = name.IndexOf('`');

            if (ind > -1)
                return name.Substring(0, ind);

            return name;
        }