public static void PropertyChanged(PropertyChangedEventHandler del, object sender, PropertyChangedEventArgs args)
{
if (del == null)
{
return;
}
Delegate[] delegates = del.GetInvocationList();
if (AsynchronousPropertyChanged)
{
AsyncCallback cleanUp = delegate(IAsyncResult asyncResult)
{
asyncResult.AsyncWaitHandle.Close();
};
foreach (PropertyChangedEventHandler sink in delegates)
{
sink.BeginInvoke(sender, args, cleanUp, null);
}
}
else
{
foreach (PropertyChangedEventHandler sink in delegates)
{
sink.Invoke(sender, args);
}
}
}
/// <summary>
/// Extends the specified event handler using a LINQ expression instead of plain string literals for property names.
/// </summary>
/// <param name="eventHandler">The event handler.</param>
/// <param name="expression">The expression.</param>
/// <exception cref="ArgumentNullException">If <paramref name="expression"/> is null</exception>
public static void Notify(this PropertyChangedEventHandler eventHandler, [NotNull] Expression <Func <Object> > expression)
{
expression.ExceptionIfNull("expression");
if (null == eventHandler)
{
return;
}
LambdaExpression lambda = expression;
MemberExpression memberExpression;
if (lambda.Body is UnaryExpression)
{
UnaryExpression unaryExpression = lambda.Body as UnaryExpression;
memberExpression = unaryExpression.Operand as MemberExpression;
}
else
{
memberExpression = lambda.Body as MemberExpression;
}
ConstantExpression constantExpression = memberExpression.Expression as ConstantExpression;
PropertyInfo propertyInfo = memberExpression.Member as PropertyInfo;
foreach (var del in eventHandler.GetInvocationList())
{
del.DynamicInvoke(new [] { constantExpression.Value, new PropertyChangedEventArgs(propertyInfo.Name) });
}
}
public static void Notify(this PropertyChangedEventHandler eventHandler, Expression <Func <object> > expression)
{
if (null == eventHandler)
{
return;
}
var lambda = expression as LambdaExpression;
MemberExpression memberExpression;
if (lambda.Body is UnaryExpression)
{
var unaryExpression = lambda.Body as UnaryExpression;
memberExpression = unaryExpression.Operand as MemberExpression;
}
else
{
memberExpression = lambda.Body as MemberExpression;
}
var constantExpression = memberExpression.Expression as ConstantExpression;
var propertyInfo = memberExpression.Member as PropertyInfo;
foreach (var del in eventHandler.GetInvocationList())
{
del.DynamicInvoke(new object[] { constantExpression.Value, new PropertyChangedEventArgs(propertyInfo.Name) });
}
}
/// <summary>
/// Raises the specified event handler ensuring the event is received by each subscriber.
/// </summary>
/// <param name="handler">The event handler to raise.</param>
/// <param name="sender">The source of the event.</param>
/// <param name="e">An <see cref="PropertyChangedEventArgs"/> that contains the event data.</param>
/// <exception cref="AggregateException">The exception is thrown by at least one of the subscribers.</exception>
public static void RaiseSafe(PropertyChangedEventHandler handler, object sender, PropertyChangedEventArgs e)
{
if (handler != null)
{
List <Exception> errors = null;
Delegate[] list = handler.GetInvocationList();
for (int i = 0; i < list.Length; i++)
{
try
{
(list[i] as PropertyChangedEventHandler)(sender, e);
}
catch (Exception exception)
{
if (errors == null)
{
errors = new List <Exception>(1);
}
errors.Add(exception);
}
}
if (errors != null)
{
throw Error.Aggregate(errors.ToArray());
}
}
}
/// <summary>
/// Notifies listeners about a change.
/// </summary>
/// <param name="EventHandler">The event to raise.</param>
/// <param name="Property">The property that changed.</param>
public static void Notify(this PropertyChangedEventHandler EventHandler, Expression <Func <object> > Property)
{
// Check for null
if (EventHandler == null)
{
return;
}
// Get property name
var lambda = Property as LambdaExpression;
MemberExpression memberExpression;
if (lambda.Body is UnaryExpression)
{
var unaryExpression = lambda.Body as UnaryExpression;
memberExpression = unaryExpression.Operand as MemberExpression;
}
else
{
memberExpression = lambda.Body as MemberExpression;
}
var constantExpression = memberExpression.Expression as ConstantExpression;
var propertyInfo = memberExpression.Member as PropertyInfo;
// Invoke event
foreach (Delegate del in EventHandler.GetInvocationList())
{
del.DynamicInvoke(new[]
{
constantExpression.Value, new PropertyChangedEventArgs(propertyInfo.Name)
});
}
}
public IEnumerable <Delegate> GetInvocationList()
{
if (_propertyChanged == null)
{
return(Enumerable.Empty <Delegate>());
}
return(_propertyChanged?.GetInvocationList());
}
public static bool IsRegistered(PropertyChangedEventHandler handler, Delegate prospectiveHandler)
{
if (handler == null)
{
return(false);
}
return(handler.GetInvocationList().Any(
existingHandler => existingHandler == prospectiveHandler) || handler.IsEventHandlerRegistered(prospectiveHandler));
}
/// <summary>
/// Invokes the specified <paramref name="handler"/> in a thread-safe manner. Where normally one
/// has to write the following code:
/// <para />
/// <code>
/// <![CDATA[
/// var handler = PropertyChanged;
/// if (handler != null)
/// {
/// handler(this, e, new PropertyChangedEventArgs("propertyName"));
/// }
/// ]]>
/// </code>
/// <para />
/// One can now write:
/// <para />
/// <code>
/// PropertyChanged.SafeInvoke(this, e, new PropertyChangedEventArgs("propertyName"));
/// </code>
/// </summary>
/// <param name="handler">The handler.</param>
/// <param name="sender">The sender.</param>
/// <param name="e">The event args.</param>
/// <returns><c>true</c> if the event handler was not <c>null</c>; otherwise <c>false</c>.</returns>
public static bool SafeInvoke(this PropertyChangedEventHandler handler, object sender, PropertyChangedEventArgs e)
{
if (handler != null)
{
SplitInvoke <PropertyChangedEventHandler>(handler.GetInvocationList(), x => x(sender, e), sender, e);
return(true);
}
return(false);
}
// Copy - Constructor
public Node(Node _orginal, bool _deep_copy = false)
{
this.was_created_by_ctor = Node.CTOR_CODE;
// general info
this.ID = (++Node.NR_NODES);
this.NodeName = _orginal.NodeName;
this.sync_by_name = _orginal.SyncByName;
this.NodeDescr = _orginal.NodeDescr;
this.NodeUnit = _orginal.NodeUnit;
this.NodeDefaultVal = _orginal.NodeDefaultVal;
this.NodeSource = _orginal.NodeSource;
// specific SIMULTAN info (connections are not copied)
this.NodeManager = _orginal.NodeManager;
this.HasGeometry = _orginal.HasGeometry;
this.ConnectionTo = new List <Node>();
if (!_deep_copy)
{
this.ContainedNodes = new List <Node>();
}
else
{
this.ContainedNodes = WinUtils.GeneralUtils.DeepCopyNodeList(_orginal.ContainedNodes);
}
this.LastEdit = DateTime.Now;
this.IsMarked = false;
this.NodeParamType = _orginal.NodeParamType;
// GUI
this.isSelected = false;
this.IsParentOfSelected = false;
this.IsExpanded = false;
this.NodeColor = Node.COLOR_DEFAULT;
this.NodeBackgr = Node.BACKGR_DEFAULT;
this.NodeWeight = Node.FONT_WEIGHT_DEFAULT;
// event handlers for the Node Manager
PropertyChangedEventHandler pceh_new = this.PropertyChanged;
PropertyChangedEventHandler pceh_orig = _orginal.PropertyChanged;
if (pceh_new == null && pceh_orig != null)
{
Delegate[] handlers = pceh_orig.GetInvocationList();
foreach (Delegate h in handlers)
{
PropertyChangedEventHandler pceh = h as PropertyChangedEventHandler;
NodeManager target = h.Target as NodeManager;
if (h != null && target != null)
{
this.PropertyChanged += pceh;
}
}
}
}
public void Subscribe(PropertyChangedEventHandler handler)
{
var weakHandlers = handler
.GetInvocationList()
.Select(d => new WeakDelegate(d))
.ToList();
lock (_handlers)
{
_handlers.AddRange(weakHandlers);
}
}
public static void InvokeEventHandlerAsync(PropertyChangedEventHandler eventHandler, object sender, PropertyChangedEventArgs e)
{
if ((object)eventHandler == null)
{
throw new ArgumentNullException("eventHandler");
}
System.Delegate[] invocationList = eventHandler.GetInvocationList();
for (int i = 0; i < invocationList.Length; i++)
{
PropertyChangedEventHandler currentEventHandler = (PropertyChangedEventHandler)invocationList[i];
currentEventHandler.BeginInvoke(sender, e, new AsyncCallback(currentEventHandler.EndInvoke), null);
}
}
public static IEnumerable <INotifyListPropertyChanged> GetContainers(PropertyChangedEventHandler handler)
{
if (handler == null)
{
yield break;
}
foreach (var invocator in handler.GetInvocationList())
{
if (invocator.Target is INotifyListPropertyChanged container)
{
yield return(container);
}
}
}
public static void NotifyAll(this PropertyChangedEventHandler eventHandler, INotifyPropertyChanged obj)
{
if (null == eventHandler || obj == null)
{
return;
}
foreach (PropertyDescriptor desc in TypeDescriptor.GetProperties(obj))
{
foreach (var del in eventHandler.GetInvocationList())
{
del.DynamicInvoke(new object[] { obj, new PropertyChangedEventArgs(desc.Name) });
}
}
}
public static void Raise(this PropertyChangedEventHandler eventHandler, Expression <Func <object> > expression)
{
if (null == eventHandler)
{
return;
}
PropertyInfo propertyInfo;
var constantExpression = expression.GetPropertyInfo(out propertyInfo);
foreach (var del in eventHandler.GetInvocationList())
{
del.DynamicInvoke(new[] { constantExpression.Value, new PropertyChangedEventArgs(propertyInfo.Name) });
}
}
public bool AddNode(Node _n, bool _pass_on_own_event_handler = false)
{
// cannot assign self as SubEntity
if (Object.ReferenceEquals(this, _n))
{
return(false);
}
// cannot create a NULL SubEntity
if (Object.ReferenceEquals(_n, null))
{
return(false);
}
// cannot take same Subentity twice
if (this.ContainedNodes.Contains(_n))
{
return(false);
}
// add event handlers for the NodeManager
// (for generating new nodes lower than the ROOT of the tree)
if (_pass_on_own_event_handler)
{
PropertyChangedEventHandler pceh_n = _n.PropertyChanged;
PropertyChangedEventHandler pceh_this = this.PropertyChanged;
if (pceh_n == null && pceh_this != null)
{
Delegate[] handlers = pceh_this.GetInvocationList();
foreach (Delegate h in handlers)
{
PropertyChangedEventHandler pceh = h as PropertyChangedEventHandler;
NodeManager target = h.Target as NodeManager;
if (h != null && target != null)
{
_n.PropertyChanged += pceh;
}
}
}
}
// add node to SELF
this.ContainedNodes.Add(_n);
this.LastEdit = DateTime.Now;
return(true);
}
public static void ThreadSafeInvoke(
[CanBeNull] this PropertyChangedEventHandler Event,
[CanBeNull] object sender,
[NotNull, ItemCanBeNull] params string[] PropertyName)
{
if (PropertyName is null)
{
throw new ArgumentNullException(nameof(PropertyName));
}
if (Event is null || PropertyName.Length == 0)
{
return;
}
var args = PropertyName.ToArray(name => new PropertyChangedEventArgs(name));
foreach (var d in Event.GetInvocationList())
{
switch (d.Target)
{
case ISynchronizeInvoke synchronize_invoke when synchronize_invoke.InvokeRequired:
foreach (var arg in args)
{
synchronize_invoke.Invoke(d, new[] { sender, arg });
}
break;
case DispatcherObject dispatcher_obj when !dispatcher_obj.CheckAccess():
foreach (var arg in args)
{
dispatcher_obj.Dispatcher.Invoke(d, arg);
}
break;
default:
foreach (var arg in args)
{
d.DynamicInvoke(sender, arg);
}
break;
}
}
}
internal void OnPropertyChanged(string name)
{
PropertyChangedEventHandler handler = PropertyChangedInternal;
if (handler != null)
{
foreach (PropertyChangedEventHandler propertyChangedEventHandler in handler.GetInvocationList())
{
try
{
propertyChangedEventHandler((MarshalByRefObject)this, new PropertyChangedEventArgs(name));
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
ChoTrace.Error(ex);
}
foreach (string depends in ChoPropertyDependsOnCache.Instance.GetDependsOn(GetType(), name))
{
try
{
propertyChangedEventHandler((MarshalByRefObject)this, new PropertyChangedEventArgs(depends));
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
ChoTrace.Error(ex);
}
}
}
}
}
/// <summary>
/// Fires the set of events in the handler and passes the name of the changed
/// property along as the changed property.
/// </summary>
/// <param name="eventHandler"></param>
/// <param name="changedProperty"></param>
public static void Notify(
this PropertyChangedEventHandler eventHandler,
Expression <Func <object> > changedProperty)
{
if (null == eventHandler)
{
return;
}
ConstantExpression constantExpression;
var memberExpression = _GetMemberExpression(changedProperty, out constantExpression);
var propertyInfo = (PropertyInfo)memberExpression.Member;
foreach (var del in eventHandler.GetInvocationList())
{
del.DynamicInvoke(new[]
{
constantExpression.Value,
new PropertyChangedEventArgs(propertyInfo.Name)
});
}
}
/// <summary>
/// makes sure the event is not null when invoking it
/// </summary>
/// <remarks>for use in classes that implement INotifyPropertyChanged</remarks>
public static void SafeInvoke(this PropertyChangedEventHandler @event, object sender, string propertyName)
{
PropertyChangedEventHandler e = Interlocked.CompareExchange(ref @event, null, null);
if (e != null)
{
var args = new PropertyChangedEventArgs(propertyName);
var invocationList = e.GetInvocationList();
foreach (PropertyChangedEventHandler handler in invocationList)
{
try
{
handler(sender, args);
}
catch (Exception ex)
{
HandleExceptions(handler, ex);
}
}
}
}
protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
{
PropertyChangedEventHandler eventHandler = PropertyChanged;
if (eventHandler != null)
{
Delegate[] delegates = eventHandler.GetInvocationList();
foreach (PropertyChangedEventHandler handler in delegates)
{
var dispatcherObject = handler.Target as System.Windows.Threading.DispatcherObject;
if (dispatcherObject != null && dispatcherObject.CheckAccess() == false)
{
dispatcherObject.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.DataBind,
handler, this, e);
}
else
{
handler(this, e);
}
}
}
}
internal void OnPropertyChanged(string name)
{
PropertyChangedEventHandler handler = PropertyChangedInternal;
if (handler != null)
{
foreach (PropertyChangedEventHandler propertyChangedEventHandler in handler.GetInvocationList())
{
try
{
propertyChangedEventHandler((MarshalByRefObject)this, new PropertyChangedEventArgs(name));
}
catch (ChoFatalApplicationException)
{
}
catch (Exception ex)
{
ChoTrace.Error(ex);
}
}
}
}
public static void Notify(this PropertyChangedEventHandler eventHandler, Expression <Func <object> > expression)
{
if (null == eventHandler)
{
return;
}
var memberExpression = expression.GetMemberExpression();
var constantExpression = memberExpression.Expression as ConstantExpression;
var propertyInfo = memberExpression.Member as PropertyInfo;
foreach (var del in eventHandler.GetInvocationList())
{
try
{
del.DynamicInvoke(new object[] { constantExpression.Value, new PropertyChangedEventArgs(propertyInfo.Name) });
}
catch
{
}
}
}
public static void ThreadSafeBeginInvoke(
[CanBeNull] this PropertyChangedEventHandler Handler,
[CanBeNull] object Sender,
[NotNull] string PropertyName)
{
if (PropertyName is null)
{
throw new ArgumentNullException(nameof(PropertyName));
}
if (Handler is null || PropertyName.Length == 0)
{
return;
}
var e = new PropertyChangedEventArgs(PropertyName);
var invocation_list = Handler.GetInvocationList();
var args = new[] { Sender, e };
foreach (var d in invocation_list)
{
switch (d.Target)
{
case ISynchronizeInvoke synchronize_invoke when synchronize_invoke.InvokeRequired:
synchronize_invoke.BeginInvoke(d, args);
break;
case DispatcherObject dispatcher_obj when !dispatcher_obj.CheckAccess() && dispatcher_obj.Dispatcher != null:
dispatcher_obj.Dispatcher.BeginInvoke(d, DispatcherPriority.DataBind, args);
break;
default:
{
var @delegate = d;
((Action <object[]>)(a => @delegate.DynamicInvoke(a))).BeginInvoke(args, null, null);
break;
}
}
}
}
/// <summary>
/// Raise the PropertyChangedEvent if value is changed
/// </summary>
/// <param name="changedEventHandler"></param>
/// <param name="expression"></param>
public static void ChangeAndNotify <T>(this PropertyChangedEventHandler changedEventHandler, ref T field, T value, Expression <Func <T> > expression)
{
if (!EqualityComparer <T> .Default.Equals(field, value))
{
field = value;
if (changedEventHandler == null)
{
return;
}
var lambda = expression as LambdaExpression;
MemberExpression memberExp;
if (lambda.Body is UnaryExpression)
{
var unaryExp = lambda.Body as UnaryExpression;
memberExp = unaryExp.Operand as MemberExpression;
}
else
{
memberExp = lambda.Body as MemberExpression;
}
var constantExp = memberExp.Expression as ConstantExpression;
var propertyName = memberExp.Member.Name;// as PropertyInfo;
foreach (var dele in changedEventHandler.GetInvocationList())
{
dele.DynamicInvoke(new object[] {
constantExp.Value,
new PropertyChangedEventArgs(propertyName)
}
);
}
}
}
/// <summary>
/// Raises an event safely, ensuring that all handlers are called on the proper thread, and any exceptions do not prevent other handlers being called.
/// </summary>
/// <param name="handler">The event to raise.</param>
/// <param name="sender">The sender of the event.</param>
/// <param name="propertyName">The name of the property relating to this event.</param>
/// <exception cref="ArgumentNullException">Thrown if propertyName is null or an empty string.</exception>
/// <exception cref="ArgumentException">Thrown if sender is not null, and the type of object in the sender does not have the named property.</exception>
/// <exception cref="AggregateException">Thrown if any handlers raise exceptions, with the exceptions raised captured in the <see cref="AggregateException.InnerExceptions"/> property.</exception>
/// <remarks>For static events, the type raising the event is not passed in to this function, so no check can be performed on whether or not the class raising the event has the static property.</remarks>
public static void SafeRaise(this PropertyChangedEventHandler handler, INotifyPropertyChanged sender, string propertyName)
{
propertyName.ThrowIfNullOrEmpty(nameof(propertyName));
sender?.GetType().ValidatePropertyName(propertyName, nameof(propertyName));
if (handler is null)
{
return;
}
PropertyChangedEventArgs e = new (propertyName);
List <Exception> raisedExceptions = null;
foreach (Delegate del in handler.GetInvocationList())
{
try
{
del.DynamicInvoke(sender, e);
}
catch (TargetInvocationException ex) when(ex.InnerException is Exception)
{
if (raisedExceptions is null)
{
raisedExceptions = new List <Exception>();
}
raisedExceptions.Add(ex.InnerException);
}
}
// Check list of exceptions is either still null, or not empty.
Debug.Assert(raisedExceptions is null || raisedExceptions.Any(), "Empty list of exceptions after handling event.");
if (raisedExceptions is List <Exception> )
{
throw new AggregateException(Properties.Resources.SafeRaiseExceptionMessage, raisedExceptions);
}
}
public void Invoke(PropertyChangedEventHandler eventHandler, object source, PropertyChangedEventArgs args)
{
if (eventHandler == null)
{
return;
}
var delegates = eventHandler.GetInvocationList();
async void BeginInvoke(Delegate d)
{
//Debug.Print(args.ToString());
switch (d.Target)
{
case DispatcherObject dispatcherObject:
await dispatcherObject.Dispatcher.BeginInvoke(DispatcherPriority.DataBind, d, source, args);
break;
case ISynchronizeInvoke s:
s.BeginInvoke(d, new[] { source, args });
break;
default:
Application.Current?.Dispatcher.BeginInvoke(DispatcherPriority.DataBind, d, source, args);
//d.Method.Invoke(d.Target, new object[] { source, args });
//d.DynamicInvoke(source, args); // note : this does not execute handler in target thread's context
break;
}
}
foreach (var d in delegates)
{
BeginInvoke(d);
}
}
public static void Notify(this PropertyChangedEventHandler eventHandler, Expression <Func <object> > expression)
{
if (eventHandler == null || !DispatcherManager.HasBeenSet)
{
return;
}
var lambda = expression as LambdaExpression;
MemberExpression memberExpression;
if (lambda.Body is UnaryExpression)
{
var unaryExpression = lambda.Body as UnaryExpression;
memberExpression = unaryExpression.Operand as MemberExpression;
}
else
{
memberExpression = lambda.Body as MemberExpression;
}
var constantExpression = memberExpression.Expression as ConstantExpression;
var propertyInfo = memberExpression.Member as PropertyInfo;
Bifrost.Execution.DispatcherManager.Current.BeginInvoke(
() =>
{
foreach (var del in eventHandler.GetInvocationList())
{
try
{
del.DynamicInvoke(new object[] { constantExpression.Value, new PropertyChangedEventArgs(propertyInfo.Name) });
}
catch
{
}
}
});
}