public IFluentRuleBuilder <T, TProperty> RuleFor <TProperty>(Expression <Func <T, TProperty> > expression)
{
ParamHelper.CheckParamNull(expression, "expression", "Can't be null");
var builder = Validation.Provider.GetService <IRuleBuilder <T, TProperty> >();
builder.SetValueGetter(expression);
Builders.Add(builder as IValidateRuleBuilder);
return(builder);
}
public static IRuleMessageBuilder <T, TProperty> When <T, TProperty>(this IRuleMessageBuilder <T, TProperty> builder, Func <TProperty, bool> func)
{
ParamHelper.CheckParamNull(func, "func", "Can't be null");
var ruleBuilder = builder as IRuleBuilder <T, TProperty>;
ruleBuilder.Condition = (context) =>
{
var value = ruleBuilder.ValueGetter(context.ValidateObject);
return(func(value));
};
return(builder);
}
public virtual IRuleMessageBuilder <T, TProperty> SetValidate(IFluentRuleBuilder <T, TProperty> builder)
{
ParamHelper.CheckParamNull(builder, "builder", "Can't be null");
var build = builder as IRuleBuilder <T, TProperty>;
build.ValidateAsyncFunc = async(context, name, error) =>
{
var value = build.ValueGetter(context.ValidateObject);
var result = Validation.Provider.GetService <IValidateResult>();
return(await ValidateAsync(result, value, name, error));
};
return(build as IRuleMessageBuilder <T, TProperty>);
}
public override IRuleMessageBuilder <T, IEnumerable <TProperty> > SetValidate(IFluentRuleBuilder <T, IEnumerable <TProperty> > builder)
{
ParamHelper.CheckParamNull(builder, "builder", "Can't be null");
var build = builder as IRuleValueGetterBuilder <T, IEnumerable <TProperty> >;
build.ValidateAsyncFunc = async(context, name, error) =>
{
ValidateRule.ValueName = name;
var value = build.ValueGetter(context.ValidateObject);
var result = Validation.Provider.GetService <IValidateResult>();
var ct = Validation.CreateContext(value, context.Option, context.RuleSetList.ToArray());
return(await ValidateRule.ValidateAsync(ct));
};
return(build as IRuleMessageBuilder <T, IEnumerable <TProperty> >);
}
public override Task <IValidateResult> ValidateAsync(ValidateContext context)
{
ParamHelper.CheckParamNull(context, "context", "Can't be null");
IValidateResult result = Validation.Provider.GetService <IValidateResult>();
var list = context.ValidateObject as IEnumerable;
if (Condition == null || Condition(context))
{
if (list != null)
{
ValidateElementList(context, result, list);
}
}
return(Task.FromResult(result));
}
public void Test_CheckParamNull()
{
ParamHelper.CheckParamNull("", "test3", "info3");
ParamHelper.CheckParamNull(string.Empty, "test3", "info3");
ParamHelper.CheckParamNull(1, "test3", "info3");
ParamHelper.CheckParamNull(1d, "test3", "info3");
ParamHelper.CheckParamNull(1m, "test3", "info3");
ParamHelper.CheckParamNull(new ParamHelper(), "test3", "info3");
var ex = Assert.Throws <ArgumentNullException>(() => ParamHelper.CheckParamNull(null, "test", "info"));
Assert.NotNull(ex);
Assert.Equal("test", ex.ParamName);
Assert.True(ex.Message.Contains("info"));
Assert.True(ex.Message.Contains("test"));
}
public async virtual Task <IValidateResult> ValidateAsync(ValidateContext context)
{
ParamHelper.CheckParamNull(ValidateAsyncFunc, nameof(ValidateAsyncFunc), "Can't be null");
ParamHelper.CheckParamNull(context, nameof(context), "Can't be null");
IValidateResult result = null;
if (Condition == null || Condition(context))
{
result = await ValidateAsyncByFunc(context);
}
else
{
result = Validation.Provider.GetService <IValidateResult>();
}
return(result);
}
public void RuleSet(string ruleSet, Action <IValidatorBuilder <T> > action)
{
ParamHelper.CheckParamEmptyOrNull(ruleSet, "ruleSet", "Can't be null");
ParamHelper.CheckParamNull(action, "action", "Can't be null");
var upRuleSet = ruleSet.ToUpper();
var updateRuleSet = new NotifyCollectionChangedEventHandler <IValidateRuleBuilder>((o, e) =>
{
if (e.Action != NotifyCollectionChangedAction.Add)
{
return;
}
foreach (var item in e.NewItems)
{
item.RuleSet = upRuleSet;
}
});
Builders.CollectionChanged += updateRuleSet;
action(this);
Builders.CollectionChanged -= updateRuleSet;
}
public Task <IValidateResult> ValidateAsync(ValidateContext context)
{
ParamHelper.CheckParamNull(context, "context", "Can't be null");
var list = context.RuleSetList;
if (!list.IsEmptyOrNull())
{
context.RuleSetList = list.Where(i => !string.IsNullOrEmpty(i)).Select(i => i.ToUpper()).ToArray();
}
var rules = m_Rules.Where(i => context.RuleSelector.CanExecute(i, context)).ToArray();
var result = Validation.Provider.GetService <IValidateResult>();
if (!rules.IsEmptyOrNull())
{
var tasks = rules.Select(async i => await i.ValidateAsync(context)).ToArray();
var failures = tasks.Where(i => i.IsCompleted)
.SelectMany(i => i.Result.Failures);
result.Merge(failures);
}
return(Task.FromResult(result));
}
public InListChecker(IEnumerable <TProperty> value, Validation validation)
: base(default(TProperty), validation)
{
ParamHelper.CheckParamNull(value, "value", "Can't be null");
m_Value = value;
}
public CustomChecker(Func <TProperty, IEnumerable <ValidateFailure> > func, Validation validation) : base(validation)
{
ParamHelper.CheckParamNull(func, nameof(func), "Can't be null");
m_Func = func;
}
public void SetRules(IEnumerable <IValidateRule> rules)
{
ParamHelper.CheckParamNull(rules, "rules", "Can't be null");
m_Rules.AddRange(rules);
}
public MustChecker(Func <TProperty, bool> func, Validation validation) : base(validation)
{
ParamHelper.CheckParamNull(func, nameof(func), "Can't be null");
m_MustBeTrue = func;
}
