public ValidationStatus Validate(
TisValidationPolicy validationPolicy,
TisValidationsResult validationsResult)
{
((TisValidationsResult)validationsResult).Clear();
ValidationStatus validationStatus = m_validationManager.Validate(
m_validators,
validationPolicy,
validationsResult);
return(validationStatus);
}
public ValidationStatus Validate(
List <TisValidator> validators,
TisValidationPolicy validationPolicy,
TisValidationsResult validationsResult)
{
foreach (TisValidator validator in validators)
{
ValidationStatus lastValidationStatus = Validate(
validator.ValidationsProvider,
validator.ValidationsSource,
validator.ValidationTarget,
validationPolicy,
validationsResult);
if (ShouldStopValidation(lastValidationStatus, validationPolicy.StopPolicy, validationPolicy.ResultPolicy))
{
return(ValidationStatus.Invalid);
}
}
return(TisValidationsResult.GetFinalValidationStatus(
validationsResult,
validationPolicy.ResultPolicy));
}
public ValidationStatus Validate(
ITisValidationProvider validationsProvider,
TisValidationsSource validationsSource,
object validationsTarget,
TisValidationPolicy validationPolicy,
TisValidationsResult validationsResult)
{
if (validationsSource == null)
{
throw new TisException("Validations source does not exist.");
}
if (validationsResult == null)
{
throw new TisException("Validations result is not allocated.");
}
ParallelCall parallelCall = new ParallelCall();
List <TisValidationMethod> supportedValidations =
GetSupportedValidations(validationsProvider);
parallelCall.ThreadsToUse = supportedValidations.Count;
TisValidationMethodResult validationMethodResult;
List <TisValidationMethod> performedValidations = new List <TisValidationMethod>();
List <ITisValidationContext> validationContexts =
m_validationContextMngr.GetValidationContextsByType(validationsSource.ValidationType);
foreach (TisValidationMethod supportedValidation in supportedValidations)
{
if (IsValidationConfirmed(supportedValidation, validationContexts))
{
if (validationPolicy.RunPolicy == ValidationRunPolicy.Sync)
{
validationMethodResult = ExecuteValidationMethod(
supportedValidation,
validationsSource.Source,
validationsTarget,
validationContexts);
validationsResult.Add(supportedValidation, validationMethodResult);
if (ShouldStopValidation(
validationMethodResult.Status,
validationPolicy.StopPolicy,
validationPolicy.ResultPolicy))
{
break;
}
}
else
{
performedValidations.Add(supportedValidation);
parallelCall.Add(
new ExecuteValidationMethodDelegate(ExecuteValidationMethod),
new object[] { supportedValidation,
validationsSource.Source,
validationsTarget,
validationContexts });
}
}
else
{
parallelCall.ThreadsToUse--;
}
}
if (validationPolicy.RunPolicy == ValidationRunPolicy.Async)
{
object[] asyncValidationResults = parallelCall.Perform(true);
for (int i = 0; i < performedValidations.Count; i++)
{
validationsResult.Add(performedValidations[i], (TisValidationMethodResult)asyncValidationResults[i]);
}
}
return(TisValidationsResult.GetFinalValidationStatus(
validationsResult,
validationPolicy.ResultPolicy));
}
