Example #1
0
 /// <summary>Returns true if the postal code is valid for the specified country, otherwise false.</summary>
 /// <param name="postalcode">
 /// The postal code to test.
 /// </param>
 /// <remarks>
 /// Returns false if the country does not have postal codes.
 /// </remarks>
 public bool IsValid(string postalcode)
 {
     return
         (!string.IsNullOrEmpty(postalcode) &&
          HasPostalCode &&
          ValidationPattern.IsMatch(Parsing.ClearSpacingAndMarkup(postalcode)));
 }
Example #2
0
        /// <summary>
        /// 验证类型验证
        /// </summary>
        /// <param name="value"></param>
        /// <param name="validationOptionss">验证方式</param>
        /// <param name="validationTypes"></param>
        /// <returns></returns>
        public static DataValidationResult TryValidateValue(object value, ValidationPattern validationOptionss, params object[] validationTypes)
        {
            // 存储验证结果
            ICollection <ValidationResult> results = new List <ValidationResult>();

            // 如果值未null,验证失败
            if (value == null)
            {
                results.Add(new ValidationResult("The Value is required"));

                // 返回验证结果
                return(new DataValidationResult
                {
                    IsValid = false,
                    ValidationResults = results
                });
            }

            // 验证标识
            bool?isValid = null;

            foreach (var validationType in validationTypes)
            {
                // 解析名称和正则表达式
                var(validationName, validationItemMetadata) = GetValidationTypeValidationItemMetadata(validationType);

                // 验证结果
                var validResult = TryValidateValue(value, validationItemMetadata.RegularExpression, validationItemMetadata.RegexOptions);

                // 判断是否需要同时验证通过才通过
                if (validationOptionss == ValidationPattern.AtLeastOne)
                {
                    // 只要有一个验证通过,则跳出
                    if (validResult)
                    {
                        isValid = true;
                        break;
                    }
                }

                if (!validResult)
                {
                    if (isValid != false)
                    {
                        isValid = false;
                    }
                    // 添加错误消息
                    results.Add(new ValidationResult(
                                    string.Format(validationItemMetadata.DefaultErrorMessage, value, validationName)));
                }
            }

            // 返回验证结果
            return(new DataValidationResult
            {
                IsValid = isValid ?? true,
                ValidationResults = results
            });
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="ResourceGroupOperations"/> class.
        /// </summary>
        /// <param name="options"> The client parameters to use in these operations. </param>
        /// <param name="rgName"> The name of the resource group to use. </param>
        internal ResourceGroupOperations(SubscriptionOperations options, string rgName)
            : base(options, $"{options.Id}/resourceGroups/{rgName}")
        {
            if (rgName.Length > 90)
            {
                throw new ArgumentOutOfRangeException("ResourceGroupName cannot be longer than 90 characters.");
            }

            if (!ValidationPattern.IsMatch(rgName))
            {
                throw new ArgumentException("The name of the resource group can include alphanumeric, underscore, parentheses, hyphen, period (except at end), and Unicode characters that match the allowed characters.");
            }
        }
 /// <summary>
 /// 构造函数
 /// </summary>
 /// <param name="validationPattern">验证逻辑</param>
 /// <param name="validationTypes"></param>
 public DataValidationAttribute(ValidationPattern validationPattern, params object[] validationTypes)
 {
     ValidationPattern = validationPattern;
     ValidationTypes   = validationTypes;
 }
 /// <summary>
 /// 拓展方法,验证单个值
 /// </summary>
 /// <param name="value">单个值</param>
 /// <param name="validationOptionss">验证逻辑</param>
 /// <param name="validationTypes">验证类型</param>
 /// <returns></returns>
 public static DataValidationResult TryValidate(this object value, ValidationPattern validationOptionss, params object[] validationTypes)
 {
     return(DataValidator.TryValidateValue(value, validationOptionss, validationTypes));
 }
 /// <summary>
 /// 拓展方法,验证单个值
 /// </summary>
 /// <param name="value">单个值</param>
 /// <param name="validationOptionss">验证逻辑</param>
 /// <param name="validationTypes">验证类型</param>
 public static void Validate(this object value, ValidationPattern validationOptionss, params object[] validationTypes)
 {
     DataValidator.TryValidateValue(value, validationOptionss, validationTypes).AddError();
 }
 public IRuleConfiguration Pattern(ValidationPattern pattern)
 {
     _data.Validators.Add(new CannedPatternValidator(pattern));
     return this;
 }
 /// <summary>
 /// 拓展方法,验证单个值
 /// </summary>
 /// <param name="value">单个值</param>
 /// <param name="validationOptionss">验证逻辑</param>
 /// <param name="validationTypes">验证类型</param>
 public static void Validate(this object value, ValidationPattern validationOptionss, params object[] validationTypes)
 {
     DataValidator.TryValidateValue(value, validationOptionss, validationTypes).ThrowValidateFailedModel();
 }
 public CannedPatternValidator(ValidationPattern pattern)
 {
     _pattern = pattern;
 }