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());
}
}
}));
}
