public void RegisterRulePackage <T>(VerifyRulePackage package, VerifyRuleMode mode = VerifyRuleMode.Append) { if (package is not null && typeof(T) == package.DeclaringType) { UpdateRegisterHandler(registrar => registrar.ForType <T>().WithRulePackage(package, mode).TakeEffectAndBack()); } }
public static CorrectValueRuleMode X(this VerifyRuleMode mode) { return(mode switch { VerifyRuleMode.Append => CorrectValueRuleMode.Append, VerifyRuleMode.Overwrite => CorrectValueRuleMode.Overwrite, _ => CorrectValueRuleMode.Append });
public IValueFluentValidationRegistrar <T> AndForMember(string memberName, VerifyRuleMode mode = VerifyRuleMode.Append) { //step 1: build this register BuildMySelf(); //step 2: create a new register return(_parentRegistrar.ForMember(memberName, mode)); }
public IValueFluentValidationRegistrar AndForMember(FieldInfo fieldInfo, VerifyRuleMode mode = VerifyRuleMode.Append) { //step 1: build this register BuildMySelf(); //step 2: create a new register return(_parentRegistrar.ForMember(fieldInfo, mode)); }
public ValueValidationRegistrar( VerifiableMemberContract verifiableMemberContract, List <CorrectValueRule> rules, VerifyRuleMode mode, IFluentValidationRegistrar <T> parentRegistrar, IValidationRegistrar rootRegistrar) : base(verifiableMemberContract, rules, mode, parentRegistrar, rootRegistrar) { ValueRuleBuilder = new CorrectValueRuleBuilder <T, TVal>(verifiableMemberContract, mode); }
public IValidationEntry SetRulePackage(VerifyRulePackage package, VerifyRuleMode mode = VerifyRuleMode.Append) { if (package is null) { throw new ArgumentNullException(nameof(package)); } CorrectRuleChain.RegisterRulePackage(_visitor.SourceType, package, mode); _needToBuild = true; return(this); }
public IValueFluentValidationRegistrar ForMember(string memberName, VerifyRuleMode mode = VerifyRuleMode.Append) { var valueContract = _verifiableObjectContract.GetMemberContract(memberName); if (valueContract is null) { throw new InvalidOperationException($"Cannot match such Member named '{memberName}'."); } return(new ValueValidationRegistrar(valueContract, Rules, mode, this, _parentRegistrar)); }
public ValueValidationRegistrar( VerifiableMemberContract verifiableMemberContract, List <CorrectValueRule> rules, VerifyRuleMode mode, IFluentValidationRegistrar parentRegistrar, IValidationRegistrar rootRegistrar) { _rootRegistrar = rootRegistrar ?? throw new ArgumentNullException(nameof(rootRegistrar)); _parentRegistrar = parentRegistrar ?? throw new ArgumentNullException(nameof(parentRegistrar)); _verifiableMemberContract = verifiableMemberContract ?? throw new ArgumentNullException(nameof(verifiableMemberContract)); ValueRuleBuilder = new CorrectValueRuleBuilder(verifiableMemberContract, mode); _parentRulesRef = rules; }
public IValueFluentValidationRegistrar ForMember(FieldInfo fieldInfo, VerifyRuleMode mode = VerifyRuleMode.Append) { if (fieldInfo is null) { throw new ArgumentNullException(nameof(fieldInfo)); } var valueContract = _verifiableObjectContract.GetMemberContract(fieldInfo); if (valueContract is null) { throw new InvalidOperationException($"Cannot match such Field named '{fieldInfo.Name}'."); } return(new ValueValidationRegistrar(valueContract, Rules, mode, this, _parentRegistrar)); }
public IFluentValidationRegistrar WithRulePackage(VerifyRulePackage package, VerifyRuleMode mode = VerifyRuleMode.Append) { if (package is null) { throw new ArgumentNullException(nameof(package)); } if (SourceType != package.DeclaringType) { return(this); } foreach (var rule in package.ExposeMemberRulePackages()) { ForMember(rule.MemberName).WithMemberRulePackage(rule, mode).TakeEffect(); } return(this); }
public IValueRuleBuilder Use(VerifyMemberRulePackage package, VerifyRuleMode mode = VerifyRuleMode.Append) { if (package is null) { throw new ArgumentNullException(nameof(package)); } if (_contract.DeclaringType != package.DeclaringType) { return(this); } if (_contract.MemberType != package.MemberType) { return(this); } if (_contract.MemberName != package.MemberName) { return(this); } var rule = package.ExposeRule(); if (rule is not null) { if (mode == VerifyRuleMode.Overwrite) { Reset(); } foreach (var token in rule.Tokens) { State.CurrentToken = token; } } return(this); }
public new IValueRuleBuilder <T, TVal> Use(VerifyMemberRulePackage package, VerifyRuleMode mode = VerifyRuleMode.Append) { if (package is null) { throw new ArgumentNullException(nameof(package)); } var rule = package.ExposeRule(); if (rule is not null) { if (mode == VerifyRuleMode.Overwrite) { Reset(); } foreach (var token in rule.Tokens) { State.CurrentToken = token; } } return(this); }
public IValidationEntry SetMemberRulePackage(string name, VerifyMemberRulePackage package, VerifyRuleMode mode = VerifyRuleMode.Append) { RuleChainRef.RegisterMemberRulePackage(_declaringType, name, package, mode); return(this); }
public IValueFluentValidationRegistrar AndForMember(FieldInfo fieldInfo, VerifyRuleMode mode = VerifyRuleMode.Append) { return(WithMessage(string.Empty).AndForMember(fieldInfo, mode)); }
public IValueFluentValidationRegistrar AndForMember(string memberName, VerifyRuleMode mode = VerifyRuleMode.Append) { return(WithMessage(string.Empty).AndForMember(memberName, mode)); }
/// <summary> /// Use a member rule package <br /> /// 使用一条成员验证规则包 /// </summary> /// <param name="memberName"></param> /// <param name="package"></param> /// <param name="name"></param> /// <param name="mode"></param> public void ForMemberRulePackage(string memberName, VerifyMemberRulePackage package, string name, VerifyRuleMode mode = VerifyRuleMode.Overwrite) { Registrar.ForType(package.DeclaringType, name).ForMember(memberName, mode).WithMemberRulePackage(package, mode).TakeEffect(); }
/// <summary> /// Use a rule package <br /> /// 使用一个验证规则包 /// </summary> /// <param name="package"></param> /// <param name="name"></param> /// <param name="mode"></param> public void ForRulePackage(VerifyRulePackage package, string name, VerifyRuleMode mode = VerifyRuleMode.Overwrite) { Registrar.ForRulePackage(package, name, mode).TakeEffect(); }
public IValueFluentValidationRegistrar <T, TVal> AndForMember <TVal>(Expression <Func <T, TVal> > expression, VerifyRuleMode mode = VerifyRuleMode.Append) { //step 1: build this register BuildMySelf(); //step 2: create a new register return(_parentRegistrar.ForMember(expression, mode)); }
public CorrectValueRuleBuilder(VerifiableMemberContract contract, VerifyRuleMode mode) : base(contract, mode) { }
IValueFluentValidationRegistrar IMayRegisterForMember.ForMember(FieldInfo fieldInfo, VerifyRuleMode mode) { var valueContract = _verifiableObjectContract.GetMemberContract(fieldInfo); if (valueContract is null) { throw new InvalidOperationException($"Cannot match such Field named '{fieldInfo.Name}'."); } return(new ValueValidationRegistrar(valueContract, Rules, mode, this, _parentRegistrar)); }
public IValueRuleBuilder<T, TVal> Use(VerifyMemberRulePackage package, VerifyRuleMode mode = VerifyRuleMode.Append) { throw new NotImplementedException(); }
public void RegisterMemberRulePackage <T>(string memberName, VerifyMemberRulePackage package, VerifyRuleMode mode = VerifyRuleMode.Append) { if (!string.IsNullOrWhiteSpace(memberName) && package is not null && typeof(T) == package.DeclaringType && memberName == package.MemberName) { UpdateRegisterHandler(registrar => registrar.ForType <T>().ForMember(memberName).WithMemberRulePackage(package, mode).TakeEffectAndBack()); } }
public CorrectValueRuleBuilder(VerifiableMemberContract contract, VerifyRuleMode mode) { _contract = contract; State = new CorrectValueRuleState(contract); Mode = mode.X(); }
public IValidationEntry <T> SetMemberRulePackage <TVal>(Expression <Func <T, TVal> > expression, VerifyMemberRulePackage package, VerifyRuleMode mode = VerifyRuleMode.Append) { if (package is null) { throw new ArgumentNullException(nameof(package)); } CorrectRuleChain.RegisterMemberRulePackage(expression, package, mode); _needToBuild = true; return(this); }
public IValueFluentValidationRegistrar WithMemberRulePackage(VerifyMemberRulePackage package, VerifyRuleMode mode = VerifyRuleMode.Append) { ValueRuleBuilder.Use(package, mode); return(this); }
public IValueFluentValidationRegistrar <T, TVal> ForMember <TVal>(Expression <Func <T, TVal> > expression, VerifyRuleMode mode = VerifyRuleMode.Append) { if (expression is null) { throw new ArgumentNullException(nameof(expression)); } var memberName = PropertySelector.GetPropertyName(expression); var valueContract = _verifiableObjectContract.GetMemberContract(memberName); if (valueContract is null) { throw new InvalidOperationException($"Cannot match such Member named '{memberName}'."); } return(new ValueValidationRegistrar <T, TVal>(valueContract, Rules, mode, this, _parentRegistrar)); }
public IValidationEntry <T> SetMemberRulePackage(string memberName, VerifyMemberRulePackage package, VerifyRuleMode mode = VerifyRuleMode.Append) { if (package is null) { throw new ArgumentNullException(nameof(package)); } CorrectRuleChain.RegisterMemberRulePackage <T>(memberName, package, mode); _needToBuild = true; return(this); }
public void RegisterMemberRulePackage <T, TVal>(Expression <Func <T, TVal> > expression, VerifyMemberRulePackage package, VerifyRuleMode mode = VerifyRuleMode.Append) { if (expression is not null && package is not null && typeof(T) == package.DeclaringType) { UpdateRegisterHandler(registrar => registrar.ForType <T>().ForMember(expression).WithMemberRulePackage(package, mode).TakeEffectAndBack()); } }