private static async Task <ValidationResult> ValidateInternal <T>(IValidationRuleSet <T> ruleSet, T instance, ValidationContext context)
{
var validationMap = new Dictionary <RuleIdentity, ValidationResult>();
var result = new ValidationResult();
var chain = ruleSet.GetValidationChain();
try
{
foreach (var validationChainMember in chain)
{
if (await CheckDependsOnMembers(chain, instance, validationChainMember, validationMap, result, context))
{
await ProcessRule(instance, validationChainMember, validationMap, result, context);
}
}
}
catch (AggregateException ex) when(ex.InnerException is ValidationStoppedException valException)
{
result.MergeResult(valException.Result);
}
catch (ValidationStoppedException ex)
{
result.MergeResult(ex.Result);
}
return(result);
}
/// <summary>
/// Валидирует объект набором правил и генерирует исключение,
/// если результат содержит ошибки
/// </summary>
/// <typeparam name="T">Тип объекта валидации</typeparam>
/// <param name="validator">Валидатор</param>
/// <param name="ruleSet">Набор правил валидации</param>
/// <param name="instance">Ссылка на объект валидации</param>
/// <param name="context">Контекст валидации</param>
public static void ValidateAndThrow <T>(
this IValidator validator, IValidationRuleSet <T> ruleSet, T instance, ValidationContext context)
{
var result = validator.Validate(ruleSet, instance, context);
ThrowIfIsNotValid(result);
}
protected IValidationChainMemberBuilder <T> SetCollectionContext <TEntity>(
Expression <Func <T, IEnumerable <TEntity> > > expression, IValidationRuleSet <TEntity> ruleSet)
{
var member = AddCollectionMemberToChain(expression, new[] { ruleSet });
return(new ValidationChainMemberBuilder <T>(this, member));
}
/// <summary>
/// Валидирует объект набором правил и генерирует исключение,
/// если результат содержит ошибки
/// </summary>
/// <typeparam name="T">Тип объекта валидации</typeparam>
/// <param name="validator">Валидатор</param>
/// <param name="ruleSet">Набор правил валидации</param>
/// <param name="instance">Ссылка на объект валидации</param>
/// <param name="context">Контекст валидации</param>
public static Task ValidateAndThrowAsync <T>(
this IValidatorAsync validator, IValidationRuleSet <T> ruleSet, T instance, ValidationContext context)
{
var result = validator.ValidateAsync(ruleSet, instance, context);
return(ThrowIfIsNotValid(result));
}
/// <inheritdoc />
public ValidationResult Validate <T>(IValidationRuleSet <T> ruleSet, T instance, ValidationContext context)
{
if (ruleSet == null)
{
throw new ArgumentNullException(nameof(ruleSet));
}
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
return(ValidateInternal(ruleSet, instance, context));
}
private static ValidationResult ValidateInternal <T>(IValidationRuleSet <T> ruleSet, T instance, ValidationContext context)
{
var validationMap = new Dictionary <RuleIdentity, ValidationResult>();
var result = new ValidationResult();
var chain = ruleSet.GetValidationChain();
try
{
foreach (var validationChainMember in chain.Where(validationChainMember =>
CheckDependsOnMembers(chain, instance, validationChainMember, validationMap,
result, context)))
{
ProcessRule(instance, validationChainMember, validationMap, result, context);
}
}
catch (ValidationStoppedException e)
{
result.MergeResult(e.Result);
}
return(result);
}
public BlockValidator(ILogger <BlockValidator> logger,
IConsensusParameters consensusParameters,
IChainState chainState,
IValidationRuleSet <IBlockValidationRule> blockValidationRules,
IBlockValidationContextFactory blockValidationContextFactory,
IPeriodicWork validationLoop,
IEventBus eventBus)
{
_logger = logger;
_validationLoop = validationLoop;
_chainState = chainState;
_blockValidationRules = blockValidationRules;
_blockValidationContextFactory = blockValidationContextFactory;
_eventBus = eventBus;
_blocksToValidate = Channel.CreateUnbounded <BlockToValidate>(new UnboundedChannelOptions {
SingleReader = true, SingleWriter = false
});
_genesisHash = consensusParameters.GenesisHeader.Hash !;
_validationLoop.Configure(false, this);
}
/// <summary>
/// Валидирует заданный объект набором правил валидации
/// </summary>
/// <typeparam name="T">Тип объекта для валидации</typeparam>
/// <param name="ruleSet">Набор правил валидации</param>
/// <param name="instance">Ссылка на объект валидации</param>
/// <param name="context">Контекст валидации</param>
/// <returns>Результат валидации</returns>
public static ValidationResult Validate <T>(IValidationRuleSet <T> ruleSet, T instance, ValidationContext context = null)
{
return(validator.Validate(ruleSet, instance, context));
}
/// <summary>
/// Валидирует заданный объект набором правил валидации
/// </summary>
/// <typeparam name="T">Тип объекта для валидации</typeparam>
/// <param name="ruleSet">Набор правил валидации</param>
/// <param name="instance">Ссылка на объект валидации</param>
/// <param name="context">Контекст валидации</param>
/// <returns>Результат валидации</returns>
public static Task <ValidationResult> ValidateAsync <T>(IValidationRuleSet <T> ruleSet, T instance, ValidationContext context = null)
{
return(validator.ValidateAsync(ruleSet, instance, context));
}
public ValidatableBase(IValidationRuleSet rules)
{
_rules = rules;
}
