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