/// <summary>
/// This is used to change the backing field for a given property. If it has a new value then the
/// property change notification is raised.
/// </summary>
/// <typeparam name="T">Property type</typeparam>
/// <param name="self">Owner</param>
/// <param name="propertyExpression">Expression tree</param>
/// <param name="value">New value</param>
/// <param name="useExtendedNotify">True to use extended PropertyChangedEventArgs</param>
public static void SetBackingValue <T>(this INotifyPropertyChanged self, Expression <Func <T> > propertyExpression, T value, bool useExtendedNotify = false)
{
var values = DataStore.GetValue(self, o => new Dictionary <PropertyInfo, object>());
var propertyInfo = (PropertyInfo)((MemberExpression)propertyExpression.Body).Member;
object oldValue;
if (!values.TryGetValue(propertyInfo, out oldValue))
{
{
oldValue = default(T);
}
}
if (!Equals(value, oldValue))
{
{
values[propertyInfo] = value;
PropertyChangedEventArgs e = (useExtendedNotify)
? new PropertyChangedEventArgsEx(propertyInfo.Name, oldValue, value)
: new PropertyChangedEventArgs(propertyInfo.Name);
self.OnPropertyChanged(e);
}
}
}
/// <summary>
/// Set a property value on an object and notify that it changed only if it changed
/// </summary>
/// <typeparam name="T">The type the field and the value are</typeparam>
/// <param name="sender">The object that the field is being set on</param>
/// <param name="field">The field that will be changing</param>
/// <param name="value">The new value for the field</param>
/// <param name="before">The action that should be performed before the value is set</param>
/// <param name="after">The action that should be performed after the value is set</param>
/// <param name="properties">The property names of the properties that have changed</param>
public static void SetAndNotify <T>(this INotifyPropertyChanged sender, ref T field, T value, Action before, Action after, params string[] properties)
{
if (sender != null && sender.Set(ref field, value, before, after))
{
sender.OnPropertyChanged(properties);
}
}
public static bool SetField <T>(this INotifyPropertyChanged entity, ref T field, T value, PropertyChangedEventHandler handler, params string[] propertyNames)
{
if (EqualityComparer <T> .Default.Equals(field, value))
{
return(false);
}
field = value;
foreach (var name in propertyNames)
{
entity.OnPropertyChanged(handler, name);
}
return(true);
}
/// <summary>
/// invoke action list when propertyName raised
/// </summary>
public static void OnPropertyChanged(this INotifyPropertyChanged notifyPropertyChanged, string propertyName, params Action[] actions)
{
if (propertyName == null)
{
throw new ArgumentNullException("propertyName");
}
notifyPropertyChanged.OnPropertyChanged(propertyName, () =>
{
foreach (var action in actions)
{
action();
}
});
}
public static void Set <S>(this INotifyPropertyChanged vm, ref S property, S value, PropertyChangedEventHandler propertyChanged, [CallerMemberName] string propertyName = "")
{
property = value;
vm.OnPropertyChanged(propertyChanged, propertyName);
}
/// <summary>
/// This is used to raise the property changed event using an expression.
/// </summary>
/// <typeparam name="T">Property type</typeparam>
/// <param name="self">Owner</param>
/// <param name="propertyExpression">Expression tree</param>
public static void OnPropertyChanged <T>(this INotifyPropertyChanged self, Expression <Func <T> > propertyExpression)
{
var propertyInfo = (PropertyInfo)((MemberExpression)propertyExpression.Body).Member;
self.OnPropertyChanged(new PropertyChangedEventArgs(propertyInfo.Name));
}
/// <summary>
/// This is used to raise the property changed event. It attempts to use the cached handler, if it cannot
/// then it resorts to a runtime lookup of the property changed event field.
/// </summary>
/// <param name="self">Owner</param>
/// <param name="propertyName">Property name</param>
public static void OnPropertyChanged(this INotifyPropertyChanged self, string propertyName)
{
Debug.Assert(string.IsNullOrEmpty(propertyName) || self.GetType().GetProperty(propertyName) != null);
self.OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
}
/// <summary>
/// This is used to raise the property changed event for all properties
/// </summary>
/// <typeparam name="T">Property type</typeparam>
/// <param name="self">Owner</param>
public static void OnPropertyChanged <T>(this INotifyPropertyChanged self)
{
self.OnPropertyChanged(new PropertyChangedEventArgs(null));
}
public static void OnPropertyChanged <T>(this INotifyPropertyChanged notifyPropertyChanged,
Expression <Func <T> > memberExpression)
{
notifyPropertyChanged.OnPropertyChanged(memberExpression.GetMemberInfo().Name);
}
