public IValidationEntry SetMemberRulePackage(string name, VerifyMemberRulePackage package, VerifyRuleMode mode = VerifyRuleMode.Append)
{
if (package is null)
{
throw new ArgumentNullException(nameof(package));
}
CorrectRuleChain.RegisterMemberRulePackage(_visitor.SourceType, name, package, mode);
_needToBuild = true;
return(this);
}
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 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 IValueFluentValidationRegistrar WithMemberRulePackage(VerifyMemberRulePackage package, VerifyRuleMode mode = VerifyRuleMode.Append)
{
ValueRuleBuilder.Use(package, mode);
return(this);
}
/// <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();
}
public IValueRuleBuilder<T, TVal> Use(VerifyMemberRulePackage package)
{
throw new NotImplementedException();
}
public IValueRuleBuilder<T, TVal> Use(VerifyMemberRulePackage package, VerifyRuleMode mode = VerifyRuleMode.Append)
{
throw new NotImplementedException();
}
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());
}
}
public IValidationEntry SetMemberRulePackage(string name, VerifyMemberRulePackage package, VerifyRuleMode mode = VerifyRuleMode.Append)
{
RuleChainRef.RegisterMemberRulePackage(_declaringType, name, package, mode);
return(this);
}
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);
}
