public object AddPropertyChangedListener( object target, PropertyChangedEventHandler listener ) {
EventHandler changedHandler = ( sender, args ) => {
listener.Invoke( this, new PropertyChangedEventArgs( "S" ) );
};
( ( TargetClass ) target ).SChanged += changedHandler;
return changedHandler;
}
protected void RaisePropertyChanged([CallerMemberName] string propertyName = null !)
{
var e = new PropertyChangedEventArgs(propertyName);
OnPropertyChanged(e);
_propertyChanged?.Invoke(this, e);
}
protected void OnPropertyChanged([CallerMemberName] string propertyName = "")
{
PropertyChangedEventHandler changed = PropertyChanged;
if (changed == null)
{
return;
}
changed.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
protected void OnPropertyChanged(bool onUIThread = true, [CallerMemberName] string propertyName = "")
{
PropertyChangedEventHandler handler = PropertyChanged;
if (handler == null)
{
return;
}
if (onUIThread)
{
Application.Current?.Dispatcher.InvokeAsync(() =>
{
handler.Invoke(this, new PropertyChangedEventArgs(propertyName));
});
}
else
{
handler.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
}
protected virtual void OnPropertyChanged(string propertyName)
{
if (_nonSerializableHandlers != null)
{
_nonSerializableHandlers.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
if (_serializableHandlers != null)
{
_serializableHandlers.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
}
internal static void AttachPropertyChanged(
this System.ComponentModel.INotifyPropertyChanged observableObject,
PropertyChangedEventHandler eventHandler)
{
System.ComponentModel.PropertyChangedEventHandler eventHandlerAdapter;
eventHandlerAdapter = (object sender, System.ComponentModel.PropertyChangedEventArgs e) =>
{
eventHandler.Invoke(sender, (PropertyChangedEventArgs)e);
};
dictionaryAdapters[eventHandler] = eventHandlerAdapter;
observableObject.PropertyChanged += eventHandlerAdapter;
}
protected virtual void OnPropertyChanged(string propertyName)
{
Application.Current.Dispatcher.BeginInvoke((Action)(() =>
{
PropertyChangedEventHandler handler = PropertyChanged;
if (handler != null)
{
handler.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
}));
}
public void OnValueChangeRegister(Currency currencyName, PropertyChangedEventHandler changeEvent)
{
foreach (VirtualCurrency vc in virtualCurrencies)
{
if (vc.Name == currencyName)
{
vc.PropertyChanged += changeEvent;
changeEvent.Invoke(vc, null);
return;
}
}
}
public static void Raise(this PropertyChangedEventHandler handler, Expression <Func <object> > property)
{
if (handler == null)
{
return;
}
var memberExpr = (MemberExpression)property.Body;
var propertyName = memberExpr.Member.Name;
var sender = ((ConstantExpression)memberExpr.Expression).Value;
handler.Invoke(sender, new PropertyChangedEventArgs(propertyName));
}
protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
{
PropertyChangedEventHandler tempEvent = PropertyChanged;
if (tempEvent != null)
{
_context.Post(new SendOrPostCallback(o =>
{
tempEvent.Invoke(this, new PropertyChangedEventArgs(propertyName));
}), null);
}
}
/// <summary>
/// Raises this object's PropertyChanged event.
/// </summary>
/// <param name="propertyName">The property that has a new value.</param>
protected virtual void OnPropertyChanged(string propertyName)
{
VerifyPropertyName(propertyName);
PropertyChangedEventHandler handler = PropertyChanged;
if (handler != null)
{
Diag.UpdateLog("(19) ViewModelBase():\t" + propertyName + "\t" + handler.Method + "\t" + handler.Target);
PropertyChangedEventArgs e = new PropertyChangedEventArgs(propertyName);
handler.Invoke(this, e);
}
}
private void OnPropertyChanged(object sender, PropertyChangedEventArgs args)
{
PropertyChangedEventHandler target = (PropertyChangedEventHandler)this.Target;
if (target != null)
{
target.Invoke(sender, args);
}
else
{
_owner.PropertyChanged -= OnPropertyChanged;
}
}
// https://stackoverflow.com/a/60668668/111794
public static void NotifyChanged <T>(
this INotifyPropertyChanged inpc,
ref T current, T newValue,
PropertyChangedEventHandler?handler,
[CallerMemberName] string?name = null)
{
if (EqualityComparer <T> .Default.Equals(current, newValue))
{
return;
}
current = newValue;
handler?.Invoke(inpc, new PropertyChangedEventArgs(name));
}
/// <summary>
/// Called to notify that a property has changed.
/// </summary>
/// <param name="propertyName">
/// The property name.
/// </param>
public virtual void RaisePropertyChanged([CallerMemberName] string propertyName = null)
{
PropertyChangedEventHandler handler = this.PropertyChanged;
if (object.Equals(handler, null))
{
return;
}
PropertyChangedEventArgs args = new PropertyChangedEventArgs(propertyName);
handler.Invoke(this, args);
}
/// <summary>
/// Invokes the event for the target of the member expression.
/// </summary>
public static void InvokeFor <T, TProp>(
this PropertyChangedEventHandler handler,
Expression <Func <T, TProp> > expression)
{
if (handler != null)
{
var memExp = expression.Body as MemberExpression
?? (expression.Body as UnaryExpression)?.Operand as MemberExpression
?? throw new InvalidCastException("Cannot get property name");
handler.Invoke(null, new PropertyChangedEventArgs(memExp.Member.Name));
}
}
protected virtual void OnPropertyChanged(string propertyName)
{
PropertyChangedEventHandler propertyChanged = PropertyChanged;
if (propertyChanged == null)
{
return;
}
DispatcherHelper.BeginInvokeIfRequired(
() => propertyChanged.Invoke(this, new PropertyChangedEventArgs(propertyName)),
DispatcherPriority.DataBind
);
}
protected override void OnSuccessfullyCompleted(PropertyChangedEventHandler propertyChanged)
{
propertyChanged?.Invoke(this, PropertyChangedEventArgsCache.Instance.Get("Result"));
base.OnSuccessfullyCompleted(propertyChanged);
try
{
_whenSuccessfullyCompleted?.Invoke(this, Result);
}
catch (Exception exception)
{
_errorHandler?.Invoke("Error while calling when successfully completed callback", exception);
}
}
/// <summary>
/// Extension method that sets a new value in a variable and then executes the event handler if the new value
/// differs from the old one. Used to easily implement <see cref="INotifyPropertyChanged"/>.
/// </summary>
/// <typeparam name="T">The type of values being handled by the property.</typeparam>
/// <param name="handler">The event handler to execute in the event of actual value change.</param>
/// <param name="newValue">The new value to set.</param>
/// <param name="oldValue">The old value to replace (and the value holder).</param>
/// <param name="propertyName">The property's name as required by <see cref="PropertyChangedEventArgs"/>.</param>
/// <param name="sender">The object to be appointed as the executioner of the handler.</param>
/// <returns>A boolean value that indicates if the new value was truly different from the old value according to <see cref="Object.Equals(object, object)"/>.</returns>
public static bool RaiseHandler <T>(this PropertyChangedEventHandler handler, T newValue, ref T oldValue, string propertyName, object sender)
{
bool changed = !Object.Equals(oldValue, newValue);
if (changed)
{
//Save the new value.
oldValue = newValue;
//Raise the event
handler?.Invoke(sender, new PropertyChangedEventArgs(propertyName));
}
//Signal what happened.
return(changed);
}
public static bool SetProperty <T>(this PropertyChangedEventHandler handler, object sender, ref T currentValue, T newValue, [CallerMemberName] string propertyName = "")
{
if (EqualityComparer <T> .Default.Equals(currentValue, newValue))
{
return(false);
}
currentValue = newValue;
if (handler == null)
{
return(true);
}
handler.Invoke(sender, new PropertyChangedEventArgs(propertyName));
return(true);
}
protected virtual void RaisePropertyListChanged(params string[] propertyNames)
{
if (propertyNames == null || propertyNames.Length == 0)
{
return;
}
PropertyChangedEventHandler propertyChanged = PropertyChanged;
foreach (string propertyName in propertyNames.Where(i => i != null).ToArray())
{
propertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
}
private void CaptureEventHandlers()
{
if (WrappedList is IBindingList ibl)
{
ibl.ListChanged += (sender, e) => listChanged?.Invoke(this, e);
}
if (WrappedList is INotifyCollectionChanged ncc)
{
ncc.CollectionChanged += (sender, e) => collectionChanged?.Invoke(this, e);
}
if (WrappedList is INotifyPropertyChanged npc)
{
npc.PropertyChanged += (sender, e) => propertyChanged?.Invoke(this, e);
}
}
public void RaisePropertyChanged([CallerMemberName] string propertyName = null)
{
if (Windows.ApplicationModel.DesignMode.DesignModeEnabled)
{
return;
}
try
{
_handler?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
catch
{
// nothing
}
}
public static void Raise(this PropertyChangedEventHandler handler, INotifyPropertyChanged source, [CallerMemberName] string propertyName = null)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (propertyName == null)
{
throw new ArgumentNullException(nameof(propertyName));
}
var args = new PropertyChangedEventArgs(propertyName);
handler?.Invoke(source, args);
}
protected bool AssignField <T>(ref T field, T value, string propertyName)
{
if (EqualityComparer <T> .Default.Equals(field, value))
{
return(false);
}
PropertyChangedEventHandler handler = PropertyChanged;
field = value;
handler?.Invoke(this, new PropertyChangedEventArgs(propertyName.Substring(4)));
return(true);
}
/// <summary>
/// The Set.
/// </summary>
/// <param name="sender">The sender<see cref="INotifyPropertyChanged"/>.</param>
/// <param name="propertyChanged">The propertyChanged<see cref="PropertyChangedEventHandler"/>.</param>
/// <param name="field">The field<see cref="double"/>.</param>
/// <param name="value">The value<see cref="double"/>.</param>
/// <param name="range">The range<see cref="RangeDouble"/>.</param>
/// <param name="propertyName">The propertyName<see cref="string"/>.</param>
/// <param name="propertyNames">The propertyNames<see cref="string[]"/>.</param>
/// <returns>The <see cref="bool"/>.</returns>
public static bool Set(this INotifyPropertyChanged sender, PropertyChangedEventHandler propertyChanged, ref double field, double value, RangeDouble range, [CallerMemberName] string propertyName = null, params string[] propertyNames)
{
if (field.IsEqualTo(value))
{
return(false);
}
if (value.IsInRange(range.Start, range.End))
{
field = value;
}
propertyChanged?.Invoke(sender, new PropertyChangedEventArgs(propertyName));
return(true);
}
/// <summary>
/// Sets the property value and raises the PropertyChanged event
/// Automatically attached an event listener for nested PropertyChanged events
/// </summary>
/// <typeparam name="TProperty">Type of the value</typeparam>
/// <param name="value">Value to set</param>
/// <param name="onPropertyChanged">EventHandler to invoke when this property value has changed</param>
/// <param name="onPropertyChanging">EventHandler to invoke when this property value is changing</param>
/// <param name="propertyName">Name of the property</param>
/// <returns>Flag indicating wether the value has successfully been set</returns>
protected bool SetValue <TProperty>(
TProperty value,
PropertyChangedEventHandler onPropertyChanged = null,
PropertyChangingEventHandler onPropertyChanging = null,
[CallerMemberName] string propertyName = "")
{
if (EqualityComparer <TProperty> .Default.Equals(
value,
GetValue <TProperty>(propertyName)))
{
return(false);
}
var propertyChangingEventArgs = BuildPropertyChangingEventArgs(
propertyName,
value);
bool shouldContinue = RaisePropertyChanging(
propertyChangingEventArgs,
onPropertyChanging);
if (!shouldContinue)
{
return(false);
}
RemoveEventualNestedEventListeners(
value);
bool success = _propertyBag.SetValue(
value,
propertyName);
AppendNestedEventListeners(
value,
propertyName);
onPropertyChanged?.Invoke(
this,
new PropertyChangedEventArgs(propertyName));
RaisePropertyChanged(
propertyName);
return(success);
}
/// <summary>
/// Этот метод будет вызывать наши события
/// </summary>
/// <param name="propertyName"></param>
public virtual void OnPropertyChanged(string propertyName)
{
//это практически копия 19 строки,
//это нужно когда реализуем этот метод в многопоточных приложениях
//потому что в данном случае для каждого потока будет создаваться своя
//локальная переменная handler и он будет взаимодействовать с данными которые находятся
//в этой локальнйо переменной
//в противном же случаи потоки бы пользовались одним событием и если 1 поток его изменил
//то другой поток может получить некоректные данные
PropertyChangedEventHandler handler = this.PropertyChanged;
if (handler != null)
{
handler.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
}
/// <summary>
/// 속성 설정
/// </summary>
/// <typeparam name="TObject">속성을 포함한 객체 형식. INotifyPropertyChanged, INotifyPropertyChanging를 구현해야 함.</typeparam>
/// <typeparam name="TProperty">속성 형식</typeparam>
/// <param name="obj">속성을 포함한 객체</param>
/// <param name="target">속성 저장 멤버</param>
/// <param name="value">설정 값</param>
/// <param name="propertyChangingEvent">PropertyChanging 이벤트</param>
/// <param name="propertyChangedEvent">PropertyChanged 이벤트</param>
/// <param name="propertyName">속성 명</param>
/// <returns>값 변경 여부</returns>
public static bool Set <TObject, TProperty>(this TObject obj, ref TProperty target, TProperty value, PropertyChangingEventHandler propertyChangingEvent, PropertyChangedEventHandler propertyChangedEvent, [CallerMemberName] string propertyName = null)
where TObject : INotifyPropertyChanged, INotifyPropertyChanging
{
if (!EqualityComparer <TProperty> .Default.Equals(target, value))
{
var eventArgs = new QueryPropertyChangingEventArgs <TProperty>(propertyName, value);
propertyChangingEvent?.Invoke(obj, eventArgs);
if (!eventArgs.IsCanceled)
{
target = value;
propertyChangedEvent?.Invoke(obj, new PropertyChangedEventArgs(propertyName));
return(true);
}
}
return(false);
}
/// <summary>
/// 当成功完成时
/// </summary>
/// <param name="propertyChanged"></param>
protected override void OnSuccessfullyCompleted(PropertyChangedEventHandler propertyChanged)
{
//通知结果
propertyChanged?.Invoke(this, PropertyChangedEventArgsCache.Instance.Get("Result"));
base.OnSuccessfullyCompleted(propertyChanged);
try
{
//执行成功完成回调
_whenSuccessfullyCompleted?.Invoke(this, Result);
}
catch (Exception exception)
{
_errorHandler?.Invoke("执行成功完成回调出错", exception);
}
}
/// <summary>
/// Sets the given backing <c>field</c> in case that <c>value</c> changed (using the <c>equals</c> method to compare) the <c>propertyName</c> should be given using the nameof() expression
/// </summary>
public static void SetAndInvoke <TFieldType>(this object target, string propertyName, PropertyChangedEventHandler propertyChangedHandler, ref TFieldType field, TFieldType newValue, Action <string> changedDelegate = null)
{
if (object.Equals(field, newValue) == false)
{
field = newValue;
try
{
propertyChangedHandler?.Invoke(target, new PropertyChangedEventArgs(propertyName));
changedDelegate?.Invoke(propertyName);
}
catch (Exception Exception)
{
Debug.WriteLine("WARNING: a PropertyChanged event handler threw an exception!\nYou must make sure that exceptions are not thrown from an event handler.\nMessage: {0}\nStackTrace:{1}", Exception.Message, Exception.StackTrace);
}
}
}
/// <summary>
/// Raises the PropertyChanged event if needed, and broadcasts a
/// PropertyChangedMessage using the Messenger instance (or the
/// static default instance if no Messenger instance is available).
/// </summary>
/// <typeparam name="T">The type of the property that
/// changed.</typeparam>
/// <param name="propertyExpression">An expression identifying the property
/// that changed.</param>
/// <param name="oldValue">The property's value before the change
/// occurred.</param>
/// <param name="newValue">The property's value after the change
/// occurred.</param>
/// <param name="broadcast">If true, a PropertyChangedMessage will
/// be broadcasted. If false, only the event will be raised.</param>
protected virtual void RaisePropertyChanged <T>(Expression <Func <T> > propertyExpression, T oldValue, T newValue, bool broadcast)
{
PropertyChangedEventHandler propertyChangedHandler = base.PropertyChangedHandler;
if (propertyChangedHandler != null || broadcast)
{
string propertyName = base.GetPropertyName <T>(propertyExpression);
if (propertyChangedHandler != null)
{
propertyChangedHandler.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
if (broadcast)
{
this.Broadcast <T>(oldValue, newValue, propertyName);
}
}
}
