private void OnCanceled(string propertyName, AsyncValidationMessage message) { lock (_validatingMembers) _validatingMembers.Add(propertyName); message.SetCompleted(null, true); TraceAsync(false, propertyName); lock (_validatingMembers) _validatingMembers.Remove(propertyName); }
public CancelableClosure(ValidatorBase validator, bool validateAll, string propertyName, bool isAsync, AsyncValidationMessage message, CancellationTokenSource token) { _validator = validator; _validateAll = validateAll; _propertyName = propertyName; _isAsync = isAsync; _message = message; _token = token; }
/// <summary> /// Occurs when processing an asynchronous validation message. /// </summary> /// <param name="sender">The object that raised the event.</param> /// <param name="message">Information about event.</param> protected virtual void OnHandleAsyncValidationMessage(object sender, AsyncValidationMessage message) { if (message.IsEndOperation) { ((IHandler <object>) this).Handle(this, new EndBusyMessage(message.Id)); return; } ((IHandler <object>) this).Handle(this, new BeginBusyMessage(message.Id, Settings.ValidationBusyMessage)); }
protected override void OnHandleAsyncValidationMessage(object sender, AsyncValidationMessage message) { if (!string.IsNullOrEmpty(message.PropertyName) && ToolkitExtensions.GetMemberName(Entity, () => model => model.Login) != message.PropertyName) { return; } Interlocked.Increment(ref _validationLoginCount); message.Task.TryExecuteSynchronously(task => { Interlocked.Decrement(ref _validationLoginCount); this.OnPropertyChanged(() => m => m.IsLoginValidating); }); this.OnPropertyChanged(() => m => m.IsLoginValidating); }
/// <summary> /// Occurs when processing an asynchronous validation message. /// </summary> /// <param name="sender">The object that raised the event.</param> /// <param name="message">Information about event.</param> protected override void OnHandleAsyncValidationMessage(object sender, AsyncValidationMessage message) { if (ToolkitExtensions.GetMemberName(Entity, model => model.Login) != message.PropertyName) { return; } if (message.IsEndOperation) { Interlocked.Decrement(ref _validationLoginCount); } else { Interlocked.Increment(ref _validationLoginCount); } OnPropertyChanged(() => IsLoginValidating); }
protected virtual void OnHandleAsyncValidationMessage(object sender, AsyncValidationMessage message) { }
private void OnValidated(Task <IDictionary <string, IEnumerable> > task, bool validateAll, string propertyName, bool isAsync, AsyncValidationMessage message) { Exception exception = null; HashSet <string> properties = null; try { if (ReferenceEquals(task.Result, DoNothingResult.Result)) { return; } properties = new HashSet <string>(StringComparer.Ordinal); lock (_errors) { //Clearing old errors if (validateAll) { var keys = _errors.Keys.ToArrayEx(); for (int index = 0; index < keys.Length; index++) { properties.AddRange(UpdateErrorsInternal(keys[index], null)); } } else { properties.AddRange(UpdateErrorsInternal(propertyName, null)); } //Updating new errors var result = task.Result ?? EmptyValidationDictionary; foreach (var valuePair in result) { properties.AddRange(UpdateErrorsInternal(valuePair.Key, valuePair.Value)); } } lock (_validatingMembers) { _validatingMembers.Add(propertyName); _validatingMembers.AddRange(properties); } foreach (var property in properties) { RaiseErrorsChanged(property, isAsync); } } catch (Exception e) { exception = e; } finally { if (isAsync) { if (message != null) { message.SetCompleted(exception, false); } TraceAsync(false, propertyName); } lock (_validatingMembers) { _validatingMembers.Remove(propertyName); if (properties != null) { _validatingMembers.RemoveRange(properties); } } } }
private Task Validate(string propertyName) { if (IsDisposed) { return(Empty.Task); } var validateAll = string.IsNullOrWhiteSpace(propertyName); if (validateAll) { propertyName = string.Empty; } lock (_validatingMembers) { if (_validatingMembers.Contains(propertyName)) { return(Empty.Task); } } AsyncValidationMessage message = null; bool isAsync; Task <IDictionary <string, IEnumerable> > validationTask; var cancellationToken = new CancellationTokenSource(); try { validationTask = validateAll ? ValidateInternalAsync(cancellationToken.Token) : ValidateInternalAsync(propertyName, cancellationToken.Token); if (validationTask == null) { validationTask = EmptyResult; } if (ReferenceEquals(validationTask, DoNothingResult)) { return(Empty.Task); } isAsync = !validationTask.IsCompleted; if (isAsync) { lock (_validatingMembers) _validatingMembers.Add(propertyName); message = new AsyncValidationMessage(propertyName); Publish(message); TraceAsync(true, propertyName); } } finally { if (message != null) { lock (_validatingMembers) _validatingMembers.Remove(propertyName); } } if (validationTask.IsCompleted) { OnValidated(validationTask, validateAll, propertyName, isAsync, message); cancellationToken.Dispose(); return(Empty.Task); } InitializeRunningTaskDict(); var value = new CancelableClosure(this, validateAll, propertyName, isAsync, message, cancellationToken); CancelableClosure oldClosure; lock (_runningTask) { _runningTask.TryGetValue(propertyName, out oldClosure); _runningTask[propertyName] = value; } if (oldClosure != null) { oldClosure.Cancel(); } return(validationTask.TryExecuteSynchronously(value.Callback)); }
private Task Validate(string propertyName) { var validateAll = string.IsNullOrWhiteSpace(propertyName); if (validateAll) { propertyName = string.Empty; } lock (_validatingMembers) { if (!_validatingMembers.Add(propertyName)) { return(EmptyResult); } } AsyncValidationMessage message = null; bool isAsync; Task <IDictionary <string, IEnumerable> > validationTask = null; try { validationTask = validateAll ? ValidateInternalAsync() : ValidateInternalAsync(propertyName); if (validationTask == null) { validationTask = EmptyResult; } if (ReferenceEquals(validationTask, DoNothingResult)) { validationTask = null; return(EmptyResult); } isAsync = !validationTask.IsCompleted; if (isAsync) { message = new AsyncValidationMessage(Guid.NewGuid(), propertyName, false); Publish(message); Interlocked.Increment(ref _validationThreadCount); Tracer.Info("Start asynchronous validation, property name '{0}', validator '{1}'", propertyName, GetType()); } } catch { validationTask = null; throw; } finally { if (validationTask == null) { lock (_validatingMembers) _validatingMembers.Remove(propertyName); } } return(validationTask.TryExecuteSynchronously(task => { try { if (ReferenceEquals(task.Result, DoNothingResult.Result)) { return; } var properties = new HashSet <string>(StringComparer.Ordinal); lock (_internalErrors) { //Clearing old errors if (validateAll) { var keys = _internalErrors.Keys.ToArrayEx(); for (int index = 0; index < keys.Length; index++) { properties.AddRange(UpdateErrorsInternal(keys[index], null)); } } else { properties.AddRange(UpdateErrorsInternal(propertyName, null)); } //Updating new errors var result = task.Result ?? EmptyValidationDictionary; foreach (var valuePair in result) { properties.AddRange(UpdateErrorsInternal(valuePair.Key, valuePair.Value)); } } foreach (var property in properties) { RaiseErrorsChanged(property, isAsync); } } finally { lock (_validatingMembers) _validatingMembers.Remove(propertyName); if (isAsync) { Interlocked.Decrement(ref _validationThreadCount); if (message != null) { Publish(message.ToEndMessage()); } Tracer.Info("Finish asynchronous validation, property name '{0}', validator '{1}'", propertyName, GetType()); } } })); }