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