public static IValidationRule AddRequiredRule([NotNull] this ValidationHelper validator, [NotNull] Expression <Func <object> > propertyExpression, [NotNull] string errorMessage) { Guard.NotNull(validator, nameof(validator)); Guard.NotNull(propertyExpression, nameof(propertyExpression)); Guard.NotNullOrEmpty(errorMessage, nameof(errorMessage)); Func <object> propertyGetter = propertyExpression.Compile(); return(validator.AddRule(PropertyName.For(propertyExpression, false), () => { object propertyValue = propertyGetter(); var stringPropertyValue = propertyValue as string; if (propertyValue == null || (stringPropertyValue != null && string.IsNullOrEmpty(stringPropertyValue))) { return RuleResult.Invalid(errorMessage); } return RuleResult.Valid(); })); }
public static RuleResult Combine([NotNull] this RuleResult firstRuleResult, [NotNull] RuleResult secondRuleResult) { Contract.Requires(firstRuleResult != null); Contract.Requires(secondRuleResult != null); Contract.Ensures(Contract.Result <RuleResult>() != null); var result = new RuleResult(); foreach (string error in firstRuleResult.Errors) { result.AddError(error); } foreach (string error in secondRuleResult.Errors) { if (!result.Errors.Contains(error)) { result.AddError(error); } } return(result); }
public static RuleResult Combine([NotNull] this RuleResult firstRuleResult, [NotNull] RuleResult secondRuleResult) { Guard.NotNull(firstRuleResult, nameof(firstRuleResult)); Guard.NotNull(secondRuleResult, nameof(secondRuleResult)); var result = new RuleResult(); foreach (string error in firstRuleResult.Errors) { result.AddError(error); } foreach (string error in secondRuleResult.Errors) { if (!result.Errors.Contains(error)) { result.AddError(error); } } return(result); }
public static IAsyncValidationRule AddChildValidatable([NotNull] this ValidationHelper validator, [NotNull] Expression <Func <IValidatable> > childValidatableGetter) { Contract.Requires(validator != null); Contract.Requires(childValidatableGetter != null); Contract.Ensures(Contract.Result <IAsyncValidationRule>() != null); Func <IValidatable> getter = childValidatableGetter.Compile(); return(validator.AddAsyncRule(PropertyName.For(childValidatableGetter), () => { IValidatable validatable = getter(); if (validatable != null) { #if SILVERLIGHT_4 validatable.Validate(result => { #else return validatable.Validate().ContinueWith(r => { ValidationResult result = r.Result; #endif var ruleResult = new RuleResult(); foreach (ValidationError error in result.ErrorList) { ruleResult.AddError(error.ErrorText); } return ruleResult; }); } return Task.Factory.StartNew(() => RuleResult.Valid()); })); }
private Task <bool> ExecuteNextRuleFromQueueAsync(Queue <ValidationRule> rulesQueue, ISet <object> failedTargets, ValidationResult validationResultAccumulator, SynchronizationContext syncContext) { if (rulesQueue.Count == 0) { return(TaskEx.FromResult(false)); } var rule = rulesQueue.Dequeue(); // Skip rule if the target is already invalid if (failedTargets.Contains(rule.Target)) { // Assume that the rule is valid at this point because we are not interested in this error until // previous rule is fixed. SaveRuleValidationResultAndNotifyIfNeeded(rule, RuleResult.Valid(), syncContext); return(TaskEx.FromResult(true)); } return(ExecuteRuleCoreAsync(rule).ContinueWith(t => { RuleResult ruleResult = t.Result; SaveRuleValidationResultAndNotifyIfNeeded(rule, ruleResult, syncContext); AddErrorsFromRuleResult(validationResultAccumulator, rule, ruleResult); if (!ruleResult.IsValid) { failedTargets.Add(rule.Target); } return true; })); }
public static IValidationRule AddRequiredRule([NotNull] this ValidationHelper validator, [NotNull] Expression <Func <object> > propertyExpression, [NotNull] string errorMessage) { Contract.Requires(validator != null); Contract.Requires(propertyExpression != null); Contract.Requires(!string.IsNullOrEmpty(errorMessage)); Contract.Ensures(Contract.Result <IValidationRule>() != null); Func <object> propertyGetter = propertyExpression.Compile(); return(validator.AddRule(propertyExpression, () => { object propertyValue = propertyGetter(); var stringPropertyValue = propertyValue as string; if (propertyValue == null || (stringPropertyValue != null && string.IsNullOrEmpty(stringPropertyValue))) { return RuleResult.Invalid(errorMessage); } return RuleResult.Valid(); })); }
public static IAsyncValidationRule AddChildValidatableCollection([NotNull] this ValidationHelper validator, [NotNull] Expression <Func <IEnumerable <IValidatable> > > validatableCollectionGetter) { Contract.Requires(validator != null); Contract.Requires(validatableCollectionGetter != null); Contract.Ensures(Contract.Result <IAsyncValidationRule>() != null); Func <IEnumerable <IValidatable> > getter = validatableCollectionGetter.Compile(); return(validator.AddAsyncRule(PropertyName.For(validatableCollectionGetter), () => { IEnumerable <IValidatable> items = getter(); if (items == null) { return Task.Factory.StartNew(() => RuleResult.Valid()); } return Task.Factory.StartNew(() => { var result = new RuleResult(); // Execute validation on all items at the same time, wait for all // to fininish and combine the results. var results = new List <ValidationResult>(); var syncEvent = new ManualResetEvent(false); var itemsArray = items as IValidatable[] ?? items.ToArray(); int[] numerOfThreadsNotYetCompleted = { itemsArray.Length }; foreach (var item in itemsArray) { #if SILVERLIGHT_4 item.Validate(r => { Exception ex = null; #else item.Validate().ContinueWith(tr => { ValidationResult r = tr.Result; AggregateException ex = tr.Exception; #endif lock (results) { // ReSharper disable ConditionIsAlwaysTrueOrFalse if (ex == null && r != null) // ReSharper restore ConditionIsAlwaysTrueOrFalse { results.Add(r); } if (Interlocked.Decrement(ref numerOfThreadsNotYetCompleted[0]) == 0) { syncEvent.Set(); } } }); } if (numerOfThreadsNotYetCompleted[0] > 0) { // Wait for all items to finish validation syncEvent.WaitOne(); // Add errors from all validation results foreach (ValidationResult itemResult in results) { foreach (ValidationError error in itemResult.ErrorList) { result.AddError(error.ErrorText); } } } return result; }); })); }
public static IAsyncValidationRule AddChildValidatableCollection([NotNull] this ValidationHelper validator, [NotNull] Expression <Func <IEnumerable <IValidatable> > > validatableCollectionGetter) { Guard.NotNull(validator, nameof(validator)); Guard.NotNull(validatableCollectionGetter, nameof(validatableCollectionGetter)); Func <IEnumerable <IValidatable> > getter = validatableCollectionGetter.Compile(); return(validator.AddAsyncRule(PropertyName.For(validatableCollectionGetter), () => { IEnumerable <IValidatable> items = getter(); if (items == null) { return TaskEx.FromResult(RuleResult.Valid()); } items = items as IValidatable[] ?? items.ToArray(); if (!items.Any()) { return TaskEx.FromResult(RuleResult.Valid()); } var result = new RuleResult(); // Execute validation on all items at the same time, wait for all // to finish and combine the results. var results = new List <ValidationResult>(); var tasks = new List <Task <ValidationResult> >(); foreach (var item in items) { var task = item.Validate().ContinueWith(tr => { ValidationResult r = tr.Result; AggregateException ex = tr.Exception; lock (results) { if (ex == null && r != null) { results.Add(r); } } return tr.Result; }); tasks.Add(task); } var resultTask = TaskEx.WhenAll(tasks).ContinueWith(tr => { if (tr.Exception == null) { // Add errors from all validation results foreach (ValidationResult itemResult in results) { foreach (ValidationError error in itemResult.ErrorList) { result.AddError(error.ErrorText); } } return result; } throw new AggregateException(tr.Exception); }); return resultTask; })); }