public void Invoke(NotifiableObject notifier, PropertyChangedEventArgsEx args, PropertyChangeEvent eventType)
{
if (notifier != null)
{
if (this.ContainsKey(notifier) && this[notifier] != null)
{
foreach (var handlers in this[notifier].Where(item => item.Item1 == args.PropertyName))
{
//changing handler[1]
if (eventType == PropertyChangeEvent.Changing)
{
if (handlers.Item2 != null)
{
handlers.Item2(notifier, args);
}
}
else
{
if (handlers.Item3 != null)
{
handlers.Item3(notifier, args);
}
}
}
}
}
}
private void InvokeEventAndRepositoryRegisterHandlers(PropertyChangedEventArgsEx args, PropertyChangeEvent period)
{
//var repository = period == PropertyChangeEvent.Changing ? _notifiedChangingRepository : _notifiedChangedRepository;
var commonEvent = period == PropertyChangeEvent.Changing ? PropertyChangingEx : PropertyChangedEx;
var eventName = period == PropertyChangeEvent.Changed ? "Changed" : "Changing";
var stackitem = new KeyValuePair <NotifiableObject, string>(this, args.PropertyName);
try
{
if (!_eventStack.Contains(stackitem))
{
_eventStack.Push(stackitem);
if (commonEvent != null)
{
commonEvent(this, args);
}
else
{
Logger.InfoFormat("{0} change property {1} again, {2} event don't be raised.", this.GetType().BaseType.FullName, args.PropertyName, eventName);
}
}
else
{
return;
}
}
catch (PropertyChangeException pce)
{
Errors = pce.Errors;
}
catch (Exception ex)
{
PropertyChangeError error = new PropertyChangeError()
{
Event = period,
Exceptions = new List <Exception>()
{
ex
},
PropertyName = args.PropertyName
};
Errors.Add(error);
}
finally
{
if (Errors != null && Errors.Count != 0)
{
Logger.ErrorFormat("Error occur when {0} property {1}", eventName, args.PropertyName);
}
}
_eventStack.Pop();
}
public object Invoke(IMethodInvocation invocation)
{
string propertyName = invocation.Method.Name.Substring(3);
if (ReadOnlyMode)
{
Logger.Debug("notifier is readonly");
return(invocation.Arguments[0]);
}
if (_readonly.Contains(propertyName))
{
Logger.DebugFormat("notifier is readonly, property {0} can't change", propertyName);
return(invocation.Arguments[0]);
}
if (invocation.Arguments.Length != 1)
{
Logger.Error("only listen the property changing event of an instance, other method not support.");
throw new Exception("only listen the property changing event of an instance, other method not support.");
}
var info = this.GetType().GetProperty(propertyName);
var val = invocation.Arguments[0];
var oldValue = info.GetValue(this);
if (val == oldValue)
{
Logger.InfoFormat("property {0} of type [{1}] not change, new value equle old value.", propertyName, this.GetType().BaseType.FullName);
return(val);
}
PropertyChangedEventArgsEx args = new PropertyChangedEventArgsEx(propertyName)
{
Source = this,
NewValue = invocation.Arguments[0],
OldValue = info.GetValue(this),
UserInited = _initialization == 0,
UIChanged = UIChanged
};
object rval;
UIChanged = false;
RaisePropertyChangingEvent(args);
rval = invocation.Proceed();
RaisePropertyChangedEvent(args);
return(rval);
}
private void RaisePropertyChangedEvent(PropertyChangedEventArgsEx args)
{
InvokeEventAndRepositoryRegisterHandlers(args, PropertyChangeEvent.Changed);
_notifyManager.RegisterToNotify(this, args.PropertyName);
HandleErrors();
}
private void RaisePropertyChangingEvent(PropertyChangedEventArgsEx args)
{
InvokeEventAndRepositoryRegisterHandlers(args, PropertyChangeEvent.Changing);
HandleErrors();
}
private void Invoke(object notifier, PropertyChangedEventArgsEx args, PropertyChangeEvent eventType)
{
var sender = notifier as NotifiableObject;
_registry.Invoke(sender, args, eventType);
}
public abstract void HandleError(NotifiableObject source, PropertyChangedEventArgsEx args);
