/// <summary>
/// Builds a validator selector from the options specified in the attribute's properties.
/// </summary>
public IValidatorSelector ToValidatorSelector() {
IValidatorSelector selector;
if(! string.IsNullOrEmpty(RuleSet)) {
var rulesets = RuleSet.Split(',', ';');
selector = new RulesetValidatorSelector(rulesets);
}
else if(! string.IsNullOrEmpty(Properties)) {
var properties = Properties.Split(',', ';');
selector = new MemberNameValidatorSelector(properties);
}
else {
selector = new DefaultValidatorSelector();
}
return selector;
}
/// <summary>
/// Builds a validator selector from the options specified in the attribute's properties.
/// </summary>
public IValidatorSelector ToValidatorSelector()
{
IValidatorSelector selector;
if (!string.IsNullOrEmpty(RuleSet))
{
var rulesets = RuleSet.Split(',', ';');
selector = new RulesetValidatorSelector(rulesets);
}
else if (!string.IsNullOrEmpty(Properties))
{
var properties = Properties.Split(',', ';');
selector = new MemberNameValidatorSelector(properties);
}
else
{
selector = new DefaultValidatorSelector();
}
return(selector);
}
/// <summary>
/// Attempts to validate a single field or property of a form model or child object model.
/// </summary>
/// <param name="validator"></param>
/// <param name="editContext"></param>
/// <param name="fieldIdentifier"></param>
/// <returns></returns>
private async Task <ValidationResult> TryValidateField(IValidator validator, EditContext editContext, FieldIdentifier fieldIdentifier)
{
try
{
var vselector = new MemberNameValidatorSelector(new[] { fieldIdentifier.FieldName });
var vctx = CreateValidationContext(fieldIdentifier.Model, validatorSelector: vselector);
return(await validator.ValidateAsync(vctx));
}
catch (Exception ex)
{
var msg = $"An unhandled exception occurred when validating field name: '{fieldIdentifier.FieldName}'";
if (editContext.Model != fieldIdentifier.Model)
{
msg += $" of a child object of type: {fieldIdentifier.Model.GetType()}";
}
msg += $" of <EditForm> model type: '{editContext.Model.GetType()}'";
throw new UnhandledValidationException(msg, ex);
}
}
public static ValidationResult Validate <T>(this IValidator <T> validator, T instance, IValidatorSelector selector = null, string ruleSet = null, string[] properties = null)
{
if (selector != null && ruleSet != null)
{
throw new InvalidOperationException("Cannot specify both an IValidatorSelector and a RuleSet.");
}
if (selector != null && properties != null)
{
throw new InvalidOperationException("Cannot specify both an IValidatorSelector and properties to include.");
}
if (properties != null && ruleSet != null)
{
throw new InvalidOperationException("Cannot specify both properties to include and a RuleSet.");
}
if (selector == null)
{
selector = new DefaultValidatorSelector();
}
if (properties != null)
{
selector = new MemberNameValidatorSelector(properties);
}
if (ruleSet != null)
{
selector = new RulesetValidatorSelector(ruleSet);
}
var context = new ValidationContext <T>(instance, new PropertyChain(), selector);
return(validator.Validate(context));
}
/// <summary>
/// 验证对象数据，可指定验证某些属性
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="validator"></param>
/// <param name="instance"></param>
/// <param name="propertyExpressions"></param>
/// <returns></returns>
public ValidationResult Validate <TEntity>(IDatabase database, TEntity instance, params Expression <Func <TEntity, object> >[] propertyExpressions)
{
ValidInstance(instance, false);
var selector = ValidatorOptions.ValidatorSelectors.MemberNameValidatorSelectorFactory(MemberNameValidatorSelector.MemberNamesFromExpressions(propertyExpressions));
var context = new ValidationContext <TEntity>(database, instance, new PropertyChain(), selector);
return(ValidateInternal(context));
}
/// <summary>
/// Validates certain properties of the specified instance.
/// </summary>
/// <param name="validator">The current validator</param>
/// <param name="instance">The object to validate</param>
/// <param name="propertyExpressions">Expressions to specify the properties to validate</param>
/// <returns>A ValidationResult object containing any validation failures</returns>
public static ValidationResult Validate <T>(this IValidator <T> validator, T instance, params Expression <Func <T, object> >[] propertyExpressions)
{
var context = new ValidationContext <T>(instance, new PropertyChain(), MemberNameValidatorSelector.FromExpressions(propertyExpressions));
return(validator.Validate(context));
}
public void MemberNameValidatorSelector_returns_true_when_property_name_matches()
{
var selector = new MemberNameValidatorSelector(new[] { "SomeProperty" });
var rule = CreateRule(x => x.SomeProperty);
selector.CanExecute(rule, "SomeProperty").ShouldBeTrue();
}
public void MemberNameValidatorSelector_returns_false_when_property_name_does_not_match()
{
var selector = new MemberNameValidatorSelector(new[] { "SomeProperty" });
var rule = CreateRule(x => x.SomeOtherProperty);
selector.CanExecute(rule, "SomeOtherProperty").ShouldBeFalse();
}
/// <summary>
/// Validates certain properties of the specified instance asynchronously.
/// </summary>
/// <param name="validator">The current validator</param>
/// <param name="instance">The object to validate</param>
/// <param name="cancellationToken"></param>
/// <param name="properties">Expressions to specify the properties to validate</param>
public static void Validate <T> (this IReactiveValidator <T> validator, T instance, CancellationToken cancellationToken = default, params Expression <Func <T, object?> > [] properties) where T : class
{
var selector = ValidatorOptions.Global.ValidatorSelectors.MemberNameValidatorSelectorFactory(MemberNameValidatorSelector.MemberNamesFromExpressions(properties));
var context = new ValidationContext <T> (instance, new PropertyChain( ), selector);
validator.Validate(context, cancellationToken);
}
