Implementing INotifyPropertyChanged - does a better way exist

Question

Microsoft should have implemented something snappy for INotifyPropertyChanged  like in the automatic properties  just specify  get  set  notify   I think it makes a lot of sense to do it  Or are there any complications to do it    Can we ourselves implement something like  notify  in our properties  Is there a graceful solution for implementing INotifyPropertyChanged in your class or the only way to do it is by raising the PropertyChanged event in each property   If not can we write something to auto-generate the piece of code to raise PropertyChanged  event

User · Answer

Another Idea      public class ViewModelBase   INotifyPropertyChanged       private Dictionary lt string  object gt   propertyStore   new Dictionary lt string  object gt         protected virtual void SetValue lt T gt  T value   CallerMemberName  string propertyName                propertyStore propertyName    value          OnPropertyChanged propertyName             protected virtual T GetValue lt T gt   CallerMemberName  string propertyName                     object ret          if   propertyStore TryGetValue propertyName  out ret                         return  T ret                    else                       return default T                          Usage       public string SomeProperty             get   return GetValue lt string gt                  set   SetValue value                  public event PropertyChangedEventHandler PropertyChanged      protected void OnPropertyChanged string propertyName                var temp   PropertyChanged          if  temp    null              temp Invoke this  new PropertyChangedEventArgs propertyName

User · Answer

I came up with this base class to implement the observable pattern  pretty much does what you need   automatically  implementing the set and get   I spent line an hour on this as prototype  so it doesn t have many unit tests  but proves the concept  Note it uses the Dictionary lt string  ObservablePropertyContext gt  to remove the need for private fields     public class ObservableByTracking lt T gt    IObservable lt T gt          private readonly Dictionary lt string  ObservablePropertyContext gt   expando      private bool  isDirty       public ObservableByTracking                expando   new Dictionary lt string  ObservablePropertyContext gt            var properties   this GetType   GetProperties BindingFlags Public   BindingFlags Instance  ToList          foreach  var property in properties                  var valueContext   new ObservablePropertyContext property Name  property PropertyType                      Value   GetDefault property PropertyType                       expando BuildKey valueContext     valueContext                     protected void SetValue lt T gt  Expression lt Func lt T gt  gt  expression  T value              var keyContext   GetKeyContext expression         var key   BuildKey keyContext PropertyName  keyContext PropertyType          if    expando ContainsKey key                   throw new Exception   Object doesn t contain  keyContext PropertyName  property                    var originalValue    T  expando key  Value        if  EqualityComparer lt T gt  Default Equals originalValue  value                   return                  expando key  Value   value         isDirty   true             protected T GetValue lt T gt  Expression lt Func lt T gt  gt  expression              var keyContext   GetKeyContext expression         var key   BuildKey keyContext PropertyName  keyContext PropertyType          if    expando ContainsKey key                   throw new Exception   Object doesn t contain  keyContext PropertyName  property                    var value    expando key  Value        return  T value             private KeyContext GetKeyContext lt T gt  Expression lt Func lt T gt  gt  expression              var castedExpression   expression Body as MemberExpression        if  castedExpression    null                  throw new Exception   Invalid expression                    var parameterName   castedExpression Member Name         var propertyInfo   castedExpression Member as PropertyInfo        if  propertyInfo    null                  throw new Exception   Invalid expression                    return new KeyContext  PropertyType   propertyInfo PropertyType  PropertyName   parameterName              private static string BuildKey ObservablePropertyContext observablePropertyContext              return    observablePropertyContext Type Name   observablePropertyContext Name               private static string BuildKey string parameterName  Type type              return    type Name   parameterName               private static object GetDefault Type type              if  type IsValueType                  return Activator CreateInstance type                 return null             public bool IsDirty               return  isDirty             public void SetPristine                isDirty   false             private class KeyContext             public string PropertyName   get  set          public Type PropertyType   get  set                 public interface IObservable lt T gt          bool IsDirty        void SetPristine          Here s the usage  public class ObservableByTrackingTestClass   ObservableByTracking lt ObservableByTrackingTestClass gt          public ObservableByTrackingTestClass               StringList   new List lt string gt           StringIList   new List lt string gt           NestedCollection   new List lt ObservableByTrackingTestClass gt                public IEnumerable lt string gt  StringList             get   return GetValue      gt  StringList           set   SetValue      gt  StringIList  value                public IList lt string gt  StringIList             get   return GetValue      gt  StringIList           set   SetValue      gt  StringIList  value                public int IntProperty             get   return GetValue      gt  IntProperty           set   SetValue      gt  IntProperty  value                public ObservableByTrackingTestClass NestedChild             get   return GetValue      gt  NestedChild           set   SetValue      gt  NestedChild  value                public IList lt ObservableByTrackingTestClass gt  NestedCollection             get   return GetValue      gt  NestedCollection           set   SetValue      gt  NestedCollection  value                public string StringProperty             get   return GetValue      gt  StringProperty           set   SetValue      gt  StringProperty  value

User · Answer

I keep this around as a snippet  C  6 adds some nice syntax for invoking the handler      INotifyPropertyChanged  public event PropertyChangedEventHandler PropertyChanged   private void Set lt T gt  ref T property  T value   CallerMemberName  string propertyName   null        if  EqualityComparer lt T gt  Default Equals property  value     false                property   value          PropertyChanged  Invoke this  new PropertyChangedEventArgs propertyName

User · Answer

An idea using reflection   class ViewModelBase   INotifyPropertyChanged        public event PropertyChangedEventHandler PropertyChanged       bool Notify lt T gt  MethodBase mb  ref T oldValue  T newValue                Get Name of Property         string name   mb Name Substring 4               Detect Change         bool changed   EqualityComparer lt T gt  Default Equals oldValue  newValue               Return if no change         if   changed  return false              Update value         oldValue   newValue              Raise Event         if  PropertyChanged    null                PropertyChanged this  new PropertyChangedEventArgs name               if             Notify caller of change         return true          method      string name       public string Name           get   return name            set               Notify MethodInfo GetCurrentMethod    ref this name  value                    method     class

User · Answer

I have written an article that helps with this  https   msdn microsoft com magazine mt736453    You can use the SolSoft DataBinding NuGet package   Then you can write code like this   public class TestViewModel   IRaisePropertyChanged     public TestViewModel           this m nameProperty   new NotifyProperty lt string gt  this  nameof Name   null          private readonly NotifyProperty lt string gt  m nameProperty    public string Name         get             return m nameProperty Value            set             m nameProperty SetValue value                   Plus implement IRaisePropertyChanged  or extend BaseViewModel      Benefits    base class is optional no reflection on every  set value  can have properties that depend on other properties  and they all automatically raise the appropriate events  article has an example of this

User · Answer

here my solution with the following features   public ResourceStatus Status         get   return  status         set                  status   value           Notify Npcea Status Npcea Comments                no refelction short notation no magic string in your business code Reusability of PropertyChangedEventArgs across application Possibility to notify multiple properties in one statement

User · Answer

Look here   http   dotnet-forum de blogs thearchitect archive 2012 11 01 die-optimale-implementierung-des-inotifypropertychanged-interfaces aspx  It s written in German  but you can download the ViewModelBase cs  All the comments in the cs-File are written in English   With this ViewModelBase-Class it is possible to implement bindable properties similar to the well known Dependency Properties    public string SomeProperty       get   return GetValue       gt  SomeProperty          set   SetValue       gt  SomeProperty  value

User · Answer

I resolved in This Way  it s a little bit laboriouse  but it s surely the faster in runtime    In VB  sorry  but I think it s not hard translate it in C    I make this substitution with RE      lt Attr gt  lt    ComponentModel   Bindable  True   gt      r n     lt Def gt  Public Private Friend Protected    Property     lt Name gt        As    lt Type gt         r n        r n  Get    with   Private    Name  As   Type  r n  Attr  r n  Def   Name  As   Type  r nGet r nReturn    Name  r nEnd Get r nSet  Value As   Type   r nIf    Name   lt  gt  Value Then  r n   Name    Value r nRaiseEvent PropertyChanged Me  New ComponentModel PropertyChangedEventArgs    Name     r nEnd If r nEnd Set r nEnd Property r n   This transofrm all code like this    lt Bindable True  gt  Protected Friend Property StartDate As DateTime    In  Private  StartDate As DateTime   lt Bindable True  gt  Protected Friend Property StartDate As DateTime      Get         Return  StartDate     End Get     Set Value As DateTime           If  StartDate  lt  gt  Value Then              StartDate   Value             RaiseEvent PropertyChange Me  New ComponentModel PropertyChangedEventArgs  StartDate            End If     End Set End Property   And If I want to have a more readable code  I can be the opposite just making the following substitution   Private     lt Name gt     As    lt Type gt      r n      lt Attr gt  lt    ComponentModel   Bindable  True   gt    r n      lt Def gt  Public Private Friend Protected    Property   k lt Name gt  As  k lt Type gt   r n   Get  r n   Return   k lt Name gt   r n   End Get  r n   Set  Value As  k lt Type gt     r n   If   k lt Name gt   lt  gt  Value Then  r n     k lt Name gt    Value  r n   RaiseEvent PropertyChanged  Me  New    ComponentModel   PropertyChangedEventArgs    k lt Name gt        r n   End If  r n   End Set  r n   End Property   With    Attr    Def    Name  As   Type    I throw to replace the IL code of the set method  but I can t write a lot of compiled code in IL    If a day I write it  I ll say you

User · Answer

I have just found ActiveSharp - Automatic INotifyPropertyChanged  I have yet to use it  but it looks good   To quote from it s web site          Send property change notifications   without specifying property name as a   string    Instead  write properties like this   public int Foo       get   return  foo        set   SetValue ref  foo  value          lt -- no property name here     Note that there is no need to include the name of the property as a string  ActiveSharp reliably and correctly figures that out for itself  It works based on the fact that your property implementation passes the backing field   foo  by ref   ActiveSharp uses that  by ref  call to identify which backing field was passed  and from the field it identifies the property

User · Answer

I think people should pay a little more attention to performance  it really does impact the UI when there are a lot of objects to be bound  think of a grid with 10 000  rows   or if the object s value changes frequently  real-time monitoring app    I took various implementation found here and elsewhere and did a comparison  check it out perfomance comparison of INotifyPropertyChanged implementations     Here is a peek at the result

User · Answer

If you are using dynamics in  NET 4 5 you don t need to worry about INotifyPropertyChanged    dynamic obj   new ExpandoObject    obj Name    John     if Name is bound to some control it just works fine

User · Answer

Another combined solution is using StackFrame   public class BaseViewModel   INotifyPropertyChanged       public event PropertyChangedEventHandler PropertyChanged       protected void Set lt T gt  ref T field  T value                MethodBase method   new StackFrame 1  GetMethod            field   value          Raise method Name Substring 4               protected void Raise string propertyName                var temp   PropertyChanged          if  temp    null                        temp this  new PropertyChangedEventArgs propertyName                        Usage   public class TempVM   BaseViewModel       private int  intP      public int IntP               get   return  intP            set   Set lt int gt  ref  intP  value

User · Answer

Whilst there are obviously lots of ways to do this  with the exception of the AOP magic answers  none of the answers seem to look at setting a Model s property directly from the view model without having a local field to reference  The issue is you can t reference a property  However  you can use an Action to set that property  protected bool TrySetProperty lt T gt  Action lt T gt  property  T newValue  T oldValue   CallerMemberName  string propertyName   null        if  EqualityComparer lt T gt  Default Equals oldValue  newValue                 return false             property newValue       RaisePropertyChanged propertyName       return true     This can be used like the following code extract  public int Prop       get   gt  model Prop      set   gt  TrySetProperty x   gt  model Prop   x  value  model Prop      Check out this BitBucket repo for a full implementation of the method and a few different ways of achieving the same result  including a method that uses LINQ and a method that uses reflection  Do note that these methods are slower performance wise

User · Answer

I suggest to use ReactiveProperty  This is the shortest method except Fody   public class Data   INotifyPropertyChanged          boiler-plate                props     private string name      public string Name               get   return name            set   SetField ref name  value   Name                instead  public class Data          Don t need boiler-plate and INotifyPropertyChanged         props     public ReactiveProperty lt string gt  Name   get      new ReactiveProperty lt string gt          DOCS

User · Answer

Prism 5 implementation   public abstract class BindableBase   INotifyPropertyChanged       public event PropertyChangedEventHandler PropertyChanged       protected virtual bool SetProperty lt T gt  ref T storage                                            T value                                             CallerMemberName  string propertyName   null                if  object Equals storage  value   return false           storage   value          this OnPropertyChanged propertyName            return true             protected void OnPropertyChanged string propertyName                var eventHandler   this PropertyChanged          if  eventHandler    null                        eventHandler this  new PropertyChangedEventArgs propertyName                         protected void OnPropertyChanged lt T gt  Expression lt Func lt T gt  gt  propertyExpression                var propertyName   PropertySupport ExtractPropertyName propertyExpression           this OnPropertyChanged propertyName            public static class PropertySupport       public static string ExtractPropertyName lt T gt  Expression lt Func lt T gt  gt  propertyExpression                if  propertyExpression    null                        throw new ArgumentNullException  propertyExpression                       var memberExpression   propertyExpression Body as MemberExpression          if  memberExpression    null                        throw new ArgumentException  The expression is not a member access expression     propertyExpression                       var property   memberExpression Member as PropertyInfo          if  property    null                        throw new ArgumentException  The member access expression does not access a property     propertyExpression                       var getMethod   property GetMethod          if  getMethod IsStatic                        throw new ArgumentException  The referenced property is a static property     propertyExpression                       return memberExpression Member Name

User · Answer

Talk about massive overengineering  This is significantly more complex than just doing it the right way and gives little to no benefit  If your IDE supports code snippets  Visual Studio MonoDevelop do  then you can make implementing this ridiculously simple  All you d actually have to type is the type of the property and the property name  The extra three lines of code will be autogenerated

User · Answer

As of  Net 4 5 there is finally an easy way to do this    Net 4 5 introduces a new Caller Information Attributes   private void OnPropertyChanged lt T gt   CallerMemberName string caller   null            make sure only to call this if the value actually changes       var handler   PropertyChanged       if  handler    null            handler this  new PropertyChangedEventArgs caller               It s probably a good idea to add a comparer to the function as well   EqualityComparer lt T gt  Default Equals   More examples here and here  Also see Caller Information  C  and Visual Basic

User · Answer

Based on the answer by Thomas which was adapted from an answer by Marc I ve turned the reflecting property changed code into a base class   public abstract class PropertyChangedBase   INotifyPropertyChanged       public event PropertyChangedEventHandler PropertyChanged       protected void OnPropertyChanged string propertyName                PropertyChangedEventHandler handler   PropertyChanged          if  handler    null               handler this  new PropertyChangedEventArgs propertyName               protected void OnPropertyChanged lt T gt  Expression lt Func lt T gt  gt  selectorExpression                if  selectorExpression    null              throw new ArgumentNullException  selectorExpression            var me   selectorExpression Body as MemberExpression              Nullable properties can be nested inside of a convert function         if  me    null                        var ue   selectorExpression Body as UnaryExpression              if  ue    null                  me   ue Operand as MemberExpression                     if  me    null              throw new ArgumentException  The body must be a member expression             OnPropertyChanged me Member Name              protected void SetField lt T gt  ref T field  T value  Expression lt Func lt T gt  gt  selectorExpression  params Expression lt Func lt object gt  gt    additonal                if  EqualityComparer lt T gt  Default Equals field  value   return          field   value          OnPropertyChanged selectorExpression           foreach  var item in additonal              OnPropertyChanged item             Usage is the same as Thomas  answer except that you can pass additional properties to notify for   This was necessary to handle calculated columns which need to be refreshed in a grid   private int  quantity  private int  price   public int Quantity         get   return  quantity         set   SetField ref  quantity  value       gt  Quantity       gt  Total        public int Price         get   return  price         set   SetField ref  price  value       gt  Price       gt  Total        public int Total   get   return  price    quantity        I have this driving a collection of items stored in a BindingList exposed via a DataGridView   It has eliminated the need for me to do manual Refresh   calls to the grid

User · Answer

All these answer are very nice   My solution is using the code snippets to do the job   This uses the simplest call to PropertyChanged event   Save this snippet and use it as you use  fullprop  snippet      the location can be found at  Tools Code Snippet Manager     menu at Visual Studio     lt  xml version  1 0  encoding  utf-8    gt   lt CodeSnippets  xmlns  http   schemas microsoft com VisualStudio 2005 CodeSnippet  gt       lt CodeSnippet Format  1 0 0  gt           lt Header gt               lt Title gt inotifypropfull lt  Title gt               lt Shortcut gt inotifypropfull lt  Shortcut gt               lt HelpUrl gt http   ofirzeitoun wordpress com  lt  HelpUrl gt               lt Description gt Code snippet for property and backing field with notification lt  Description gt               lt Author gt Ofir Zeitoun lt  Author gt               lt SnippetTypes gt                   lt SnippetType gt Expansion lt  SnippetType gt               lt  SnippetTypes gt           lt  Header gt           lt Snippet gt               lt Declarations gt                   lt Literal gt                       lt ID gt type lt  ID gt                       lt ToolTip gt Property type lt  ToolTip gt                       lt Default gt int lt  Default gt                   lt  Literal gt                   lt Literal gt                       lt ID gt property lt  ID gt                       lt ToolTip gt Property name lt  ToolTip gt                       lt Default gt MyProperty lt  Default gt                   lt  Literal gt                   lt Literal gt                       lt ID gt field lt  ID gt                       lt ToolTip gt The variable backing this property lt  ToolTip gt                       lt Default gt myVar lt  Default gt                   lt  Literal gt               lt  Declarations gt               lt Code Language  csharp  gt                   lt   CDATA private  type   field        public  type   property                get   return  field            set                 field    value              var temp   PropertyChanged              if  temp    null                                temp this  new PropertyChangedEventArgs   property                                         end    gt               lt  Code gt           lt  Snippet gt       lt  CodeSnippet gt   lt  CodeSnippets gt    You can modify the call as you like  to use the above solutions

User · Answer

There s also Fody which has a PropertyChanged add-in  which lets you write this    ImplementPropertyChanged  public class Person                public string GivenNames   get  set        public string FamilyName   get  set           and at compile time injects property changed notifications

User · Answer

I m writing a library that deals with INotifyPropertyChanged  and the main idea is using a dynamic proxy to notify changes   the repo is here  CaulyKan NoMorePropertyChanged  with this library  you can write       public dynamic Test1Binding   get  set        public TestDTO Test1               get   return  TestDTO Test1Binding            set   SetBinding nameof Test1Binding   value             Then make all bindings and modifications go to Test1Binding  which will notify PropertyChange and CollectionChanged automatically no matter how complex TestDTO is   it can also handle dependencies        DependsOn  Test1Binding TestString        public string Test2               get   return Test1Binding TestString            Please give me some suggestions

User · Answer

A very AOP-like approach is to inject the INotifyPropertyChanged stuff onto an already instantiated object on the fly   You can do this with something like Castle DynamicProxy   Here is an article that explains the technique   Adding INotifyPropertyChanged to an existing object

User · Answer

Here is a Unity3D or non-CallerMemberName version of NotifyPropertyChanged  public abstract class Bindable   MonoBehaviour  INotifyPropertyChanged       private readonly Dictionary lt string  object gt   properties   new Dictionary lt string  object gt         private static readonly StackTrace stackTrace   new StackTrace        public event PropertyChangedEventHandler PropertyChanged            lt summary gt              Resolves a Property s name from a Lambda Expression passed in           lt  summary gt           lt typeparam name  T  gt  lt  typeparam gt           lt param name  property  gt  lt  param gt           lt returns gt  lt  returns gt      internal string GetPropertyName lt T gt  Expression lt Func lt T gt  gt  property                var expression    MemberExpression  property Body          var propertyName   expression Member Name           Debug AssertFormat propertyName    null   Bindable Property shouldn t be null             return propertyName              region Notification Handlers           lt summary gt              Notify s all other objects listening that a value has changed for nominated propertyName          lt  summary gt           lt param name  propertyName  gt  lt  param gt      internal void NotifyOfPropertyChange string propertyName                OnPropertyChanged new PropertyChangedEventArgs propertyName                    lt summary gt              Notifies subscribers of the property change           lt  summary gt           lt typeparam name  TProperty  gt The type of the property  lt  typeparam gt           lt param name  property  gt The property expression  lt  param gt      internal void NotifyOfPropertyChange lt TProperty gt  Expression lt Func lt TProperty gt  gt  property                var propertyName   GetPropertyName property           NotifyOfPropertyChange propertyName                   lt summary gt              Raises the  lt see cref  PropertyChanged    gt  event directly           lt  summary gt           lt param name  e  gt The  lt see cref  PropertyChangedEventArgs    gt  instance containing the event data  lt  param gt      internal void OnPropertyChanged PropertyChangedEventArgs e                var handler   PropertyChanged          if  handler    null                        handler this  e                         endregion       region Getters           lt summary gt              Gets the value of a property          lt  summary gt           lt typeparam name  T  gt  lt  typeparam gt           lt param name  name  gt  lt  param gt           lt returns gt  lt  returns gt      internal T Get lt T gt  Expression lt Func lt T gt  gt  property                var propertyName   GetPropertyName property           return Get lt T gt  GetPropertyName property                    lt summary gt              Gets the value of a property automatically based on its caller           lt  summary gt           lt typeparam name  T  gt  lt  typeparam gt           lt returns gt  lt  returns gt      internal T Get lt T gt                  var name   stackTrace GetFrame 1  GetMethod   Name Substring 4      strips the set  from name          return Get lt T gt  name                   lt summary gt              Gets the name of a property based on a string           lt  summary gt           lt typeparam name  T  gt  lt  typeparam gt           lt param name  name  gt  lt  param gt           lt returns gt  lt  returns gt      internal T Get lt T gt  string name                object value   null          if   properties TryGetValue name  out value               return value    null   default T     T  value          return default T               endregion       region Setters           lt summary gt              Sets the value of a property whilst automatically looking up its caller name           lt  summary gt           lt typeparam name  T  gt  lt  typeparam gt           lt param name  value  gt  lt  param gt      internal void Set lt T gt  T value                var propertyName   stackTrace GetFrame 1  GetMethod   Name Substring 4      strips the set  from name          Set value  propertyName                   lt summary gt              Sets the value of a property          lt  summary gt           lt typeparam name  T  gt  lt  typeparam gt           lt param name  value  gt  lt  param gt           lt param name  name  gt  lt  param gt      internal void Set lt T gt  T value  string propertyName                Debug Assert propertyName    null   name    null            if  Equals value  Get lt T gt  propertyName                return           properties propertyName    value          NotifyOfPropertyChange propertyName                   lt summary gt              Sets the value of a property based off an Expression      gt FieldName           lt  summary gt           lt typeparam name  T  gt  lt  typeparam gt           lt param name  value  gt  lt  param gt           lt param name  property  gt  lt  param gt      internal void Set lt T gt  T value  Expression lt Func lt T gt  gt  property                var propertyName   GetPropertyName property            Debug Assert propertyName    null   name    null             if  Equals value  Get lt T gt  propertyName                return           properties propertyName    value          NotifyOfPropertyChange propertyName               endregion     This code enables you to write property backing fields like this     public string Text               get   return Get lt string gt               set   Set value             Furthermore  in resharper if you create a pattern search snippet you can then also automate you re workflow by converting simple prop fields into the above backing   Search Pattern   public  type   fname    get  set      Replace Pattern   public  type   fname        get   return Get lt  type  gt           set   Set value

User · Answer

Without using something like postsharp  the minimal version I use uses something like  public class Data   INotifyPropertyChanged          boiler-plate     public event PropertyChangedEventHandler PropertyChanged      protected virtual void OnPropertyChanged string propertyName                PropertyChangedEventHandler handler   PropertyChanged          if  handler    null  handler this  new PropertyChangedEventArgs propertyName              protected bool SetField lt T gt  ref T field  T value  string propertyName                if  EqualityComparer lt T gt  Default Equals field  value   return false          field   value          OnPropertyChanged propertyName           return true                props     private string name      public string Name               get   return name            set   SetField ref name  value   quot Name quot               Each property is then just something like  private string name  public string Name       get   return name        set   SetField ref name  value   quot Name quot         which isn t huge  it can also be used as a base-class if you want  The bool return from SetField tells you if it was a no-op  in case you want to apply other logic   or even easier with C  5  protected bool SetField lt T gt  ref T field  T value       CallerMemberName  string propertyName   null         which can be called like this  set   SetField ref name  value      with which the compiler will add the  quot Name quot  automatically   C  6 0 makes the implementation easier  protected void OnPropertyChanged  CallerMemberName  string propertyName   null        PropertyChanged  Invoke this  new PropertyChangedEventArgs propertyName           and now with C 7  protected void OnPropertyChanged string propertyName       gt  PropertyChanged  Invoke this  new PropertyChangedEventArgs propertyName     protected bool SetField lt T gt  ref T field  T value  CallerMemberName  string propertyName    null        if  EqualityComparer lt T gt  Default Equals field  value   return false      field   value      OnPropertyChanged propertyName       return true     private string name  public string Name       get   gt  name      set   gt  SetField ref name  value       And  with C  8 and Nullable reference types  it would look like this  public event PropertyChangedEventHandler  PropertyChanged   protected void OnPropertyChanged string  propertyName    gt  PropertyChanged  Invoke this  new PropertyChangedEventArgs propertyName     protected bool SetField lt T gt  ref T field  T value   CallerMemberName  string  propertyName   null        if  EqualityComparer lt T gt  Default Equals field  value   return false      field   value      OnPropertyChanged propertyName       return true     private string name  public string Name       get   gt  name      set   gt  SetField ref name  value

User · Answer

Let me introduce my own approach called Yappi  It belongs to Runtime proxy derived class generators  adding new functionality to an existing object or type  like Caste Project s Dynamic Proxy   It allows to implement INotifyPropertyChanged once in base class  and then declare derived classes in following style  still supporting INotifyPropertyChanged for new properties   public class Animal Concept       protected Animal         public virtual string Name   get  set        public virtual int Age   get  set        Complexity of derived class or proxy construction can be hidden behind the following line   var animal   Concept Create lt Animal gt  New      And all INotifyPropertyChanged implementation work can be done like this   public class Concept INotifyPropertyChanged         Hide constructor     protected Concept          public static class Create lt TConcept gt  where TConcept Concept                 Construct derived Type calling PropertyProxy ConstructType         public static readonly Type Type   PropertyProxy ConstructType lt TConcept  Implementation lt TConcept gt  gt  new Type 0   true             Create constructing delegate calling Constructor Compile         public static Func lt TConcept gt  New   Constructor Compile lt Func lt TConcept gt  gt  Type               public event PropertyChangedEventHandler PropertyChanged       protected void OnPropertyChanged PropertyChangedEventArgs eventArgs                var caller   PropertyChanged          if caller  null                        caller this  eventArgs                          define implementation     public class Implementation lt TConcept gt    DefaultImplementation lt TConcept gt  where TConcept Concept               public override Func lt TBaseType  TResult gt  OverrideGetter lt TBaseType  TDeclaringType  TConstructedType  TResult gt  PropertyInfo property                        return PropertyImplementation lt TBaseType  TDeclaringType gt  GetGetter lt TResult gt  property Name                          lt summary gt              Overriding property setter implementation               lt  summary gt               lt typeparam name  TBaseType  gt Base type for implementation  TBaseType must be TConcept  and inherits all its constraints  Also TBaseType is TDeclaringType  lt  typeparam gt               lt typeparam name  TDeclaringType  gt Type  declaring property  lt  typeparam gt               lt typeparam name  TConstructedType  gt Constructed type  TConstructedType is TDeclaringType and TBaseType  lt  typeparam gt               lt typeparam name  TResult  gt Type of property  lt  typeparam gt               lt param name  property  gt PropertyInfo of property  lt  param gt               lt returns gt Delegate  corresponding to property setter implementation  lt  returns gt          public override Action lt TBaseType  TResult gt  OverrideSetter lt TBaseType  TDeclaringType  TConstructedType  TResult gt  PropertyInfo property                          This code called once for each declared property on derived type s initialization                EventArgs instance is shared between all events for each concrete property              var eventArgs   new PropertyChangedEventArgs property Name                 get delegates for base calls              Action lt TBaseType  TResult gt  setter   PropertyImplementation lt TBaseType  TDeclaringType gt  GetSetter lt TResult gt  property Name               Func lt TBaseType  TResult gt  getter   PropertyImplementation lt TBaseType  TDeclaringType gt  GetGetter lt TResult gt  property Name                var comparer   EqualityComparer lt TResult gt  Default               return  pthis  value    gt                 This code executes each time property setter is called                  if  comparer Equals value  getter pthis    return                    base  call                 setter pthis  value                     Directly accessing Concept s protected method                  pthis OnPropertyChanged eventArgs                                      It is fully safe for refactoring  uses no reflection after type construction and fast enough

User · Answer

I created an Extension Method in my base Library for reuse   public static class INotifyPropertyChangedExtensions       public static bool SetPropertyAndNotify lt T gt  this INotifyPropertyChanged sender                 PropertyChangedEventHandler handler  ref T field  T value                   CallerMemberName  string propertyName                      EqualityComparer lt T gt  equalityComparer   null                bool rtn   false          var eqComp   equalityComparer    EqualityComparer lt T gt  Default          if   eqComp Equals field value                         field   value              rtn   true              if  handler    null                                var args   new PropertyChangedEventArgs propertyName                   handler sender  args                                   return rtn            This works with  Net 4 5 because of CallerMemberNameAttribute  If you want to use it with an earlier  Net version you have to change the method declaration from       CallerMemberName  string propertyName           to     string propertyName       Usage   public class Dog   INotifyPropertyChanged       public event PropertyChangedEventHandler PropertyChanged      string  name       public string Name               get   return  name            set                       this SetPropertyAndNotify PropertyChanged  ref  name  value

User · Answer

I haven t actually had a chance to try this myself yet  but next time I m setting up a project with a big requirement for INotifyPropertyChanged I m intending on writing a Postsharp attribute that will inject the code at compile time  Something like    NotifiesChange  public string FirstName   get  set      Will become   private string  firstName   public string FirstName      get   return  firstname       set            if   firstname    value                     firstname   value            OnPropertyChanged  FirstName                    I m not sure if this will work in practice and I need to sit down and try it out  but I don t see why not  I may need to make it accept some parameters for situations where more than one OnPropertyChanged needs to be triggered  if  for example  I had a FullName property in the class above   Currently I m using a custom template in Resharper  but even with that I m getting fed up of all my properties being so long     Ah  a quick Google search  which I should have done before I wrote this  shows that at least one person has done something like this before here  Not exactly what I had in mind  but close enough to show that the theory is good

User · Answer

Use this  using System  using System ComponentModel  using System Reflection  using System Reflection Emit  using System Runtime Remoting Messaging  using System Runtime Remoting Proxies    public static class ObservableFactory       public static T Create lt T gt  T target                if   typeof T  IsInterface              throw new ArgumentException  Target should be an interface    target             var proxy   new Observable lt T gt  target           return  T proxy GetTransparentProxy             internal class Observable lt T gt    RealProxy  INotifyPropertyChanged  INotifyPropertyChanging       private readonly T target       internal Observable T target            base ImplementINotify typeof T                  this target   target             public override IMessage Invoke IMessage msg                var methodCall   msg as IMethodCallMessage           if  methodCall    null                        return HandleMethodCall methodCall                      return null             public event PropertyChangingEventHandler PropertyChanging      public event PropertyChangedEventHandler PropertyChanged         IMessage HandleMethodCall IMethodCallMessage methodCall                var isPropertySetterCall   methodCall MethodName StartsWith  set             var propertyName   isPropertySetterCall   methodCall MethodName Substring 4    null           if  isPropertySetterCall                        OnPropertyChanging propertyName                      try                       object methodCalltarget   target               if  methodCall MethodName     add PropertyChanged     methodCall MethodName     remove PropertyChanged                    methodCall MethodName     add PropertyChanging     methodCall MethodName     remove PropertyChanging                                 methodCalltarget   this                             var result   methodCall MethodBase Invoke methodCalltarget  methodCall InArgs                if  isPropertySetterCall                                OnPropertyChanged methodCall MethodName Substring 4                               return new ReturnMessage result  null  0  methodCall LogicalCallContext  methodCall                     catch  TargetInvocationException invocationException                        var exception   invocationException InnerException              return new ReturnMessage exception  methodCall                        protected virtual void OnPropertyChanged string propertyName                var handler   PropertyChanged          if  handler    null  handler this  new PropertyChangedEventArgs propertyName               protected virtual void OnPropertyChanging string propertyName                var handler   PropertyChanging          if  handler    null  handler this  new PropertyChangingEventArgs propertyName               public static Type ImplementINotify Type objectType                var tempAssemblyName   new AssemblyName Guid NewGuid   ToString              var dynamicAssembly   AppDomain CurrentDomain DefineDynamicAssembly              tempAssemblyName  AssemblyBuilderAccess RunAndCollect            var moduleBuilder   dynamicAssembly DefineDynamicModule              tempAssemblyName Name              tempAssemblyName     dll             var typeBuilder   moduleBuilder DefineType              objectType FullName  TypeAttributes Public   TypeAttributes Interface   TypeAttributes Abstract            typeBuilder AddInterfaceImplementation objectType           typeBuilder AddInterfaceImplementation typeof INotifyPropertyChanged            typeBuilder AddInterfaceImplementation typeof INotifyPropertyChanging            var newType   typeBuilder CreateType            return newType

User · Answer

I realize this question already has a gazillion answers  but none of them felt quite right for me  My issue is I don t want any performance hits and am willing to put up with a little verbosity for that reason alone  I also don t care too much for auto properties either  which led me to the following solution   public abstract class AbstractObject   INotifyPropertyChanged       public event PropertyChangedEventHandler PropertyChanged       public void OnPropertyChanged string propertyName                PropertyChanged  Invoke this  new PropertyChangedEventArgs propertyName               protected virtual bool SetValue lt TKind gt  ref TKind Source  TKind NewValue  params string   Notify                  Set value if the new value is different from the old         if   Source Equals NewValue                         Source   NewValue                 Notify all applicable properties             foreach  var i in Notify                  OnPropertyChanged i                return true                     return false             public AbstractObject                   In other words  the above solution is convenient if you don t mind doing this   public class SomeObject   AbstractObject       public string AnotherProperty               get                       return someProperty    Car     Plane                        bool someProperty   false      public bool SomeProperty               get                       return someProperty                    set                       SetValue ref someProperty  value   SomeProperty    AnotherProperty                         public SomeObject     base                   Pros   No reflection Only notifies if old value    new value Notify multiple properties at once   Cons   No auto properties  you can add support for both  though   Some verbosity Boxing  small performance hit     Alas  it is still better than doing this   set       if   someProperty Equals value                 someProperty   value          OnPropertyChanged  SomeProperty            OnPropertyChanged  AnotherProperty              For every single property  which becomes a nightmare with the additional verbosity  -   Note  I do not claim this solution is better performance-wise compared to the others  just that it is a viable solution for those who don t like the other solutions presented

User · Answer

Yes  better way certainly exists  Here it is   Step by step tutorial shrank by me  based on this useful article    Create new project Install castle core package into the project       Install-Package Castle Core    Install mvvm light libraries only      Install-Package MvvmLightLibs    Add two classes in project    NotifierInterceptor  public class NotifierInterceptor   IInterceptor               private PropertyChangedEventHandler handler          public static Dictionary lt String  PropertyChangedEventArgs gt   cache             new Dictionary lt string  PropertyChangedEventArgs gt              public void Intercept IInvocation invocation                        switch  invocation Method Name                                case  add PropertyChanged                       handler    PropertyChangedEventHandler                                Delegate Combine handler   Delegate invocation Arguments 0                        invocation ReturnValue   handler                      break                  case  remove PropertyChanged                       handler    PropertyChangedEventHandler                                Delegate Remove handler   Delegate invocation Arguments 0                        invocation ReturnValue   handler                      break                  default                      if  invocation Method Name StartsWith  set                                                   invocation Proceed                            if  handler    null                                                        var arg   retrievePropertyChangedArg invocation Method Name                               handler invocation Proxy  arg                                                                       else invocation Proceed                        break                                   private static PropertyChangedEventArgs retrievePropertyChangedArg String methodName                        PropertyChangedEventArgs arg   null               cache TryGetValue methodName  out arg               if  arg    null                                arg   new PropertyChangedEventArgs methodName Substring 4                     cache Add methodName  arg                             return arg                    ProxyCreator  public class ProxyCreator       public static T MakeINotifyPropertyChanged lt T gt    where T   class  new                 var proxyGen   new ProxyGenerator            var proxy   proxyGen CreateClassProxy            typeof T             new     typeof INotifyPropertyChanged               ProxyGenerationOptions Default            new NotifierInterceptor                        return proxy as T             Create your view model  for example    -   public class MainViewModel               public virtual string MainTextBox   get  set             public RelayCommand TestActionCommand                       get   return new RelayCommand TestAction                        public void TestAction                         Trace WriteLine MainTextBox                      Put bindings into xaml    lt TextBox Text   Binding MainTextBox    gt  lt  TextBox gt   lt Button Command   Binding TestActionCommand    gt Test lt  Button gt   Put line of code in code-behind file MainWindow xaml cs like this    DataContext   ProxyCreator MakeINotifyPropertyChanged lt MainViewModel gt       Enjoy      Attention    All bounded properties should be decorated with keyword virtual because they used by castle proxy for overriding

User · Answer

Other things you may want to consider when implementing these sorts of properties is the fact that the INotifyPropertyChang  ed  ing both use event argument classes   If you have a large number of properties that are being set then the number of event argument class instances can be huge  you should consider caching them as they are one of the areas that a string explosion can occur   Take a look at this implementation and explanation of why it was conceived   Josh Smiths Blog

User · Answer

I really like Marc s solution  but I think it can be slightly improved to avoid using a  magic string   which doesn t support refactoring   Instead of using the property name as a string  it s easy to make it a lambda expression    private string name  public string Name       get   return name        set   SetField ref name  value       gt  Name         Just add the following methods to Marc s code  it will do the trick    protected virtual void OnPropertyChanged lt T gt  Expression lt Func lt T gt  gt  selectorExpression        if  selectorExpression    null          throw new ArgumentNullException  selectorExpression        MemberExpression body   selectorExpression Body as MemberExpression      if  body    null          throw new ArgumentException  The body must be a member expression        OnPropertyChanged body Member Name      protected bool SetField lt T gt  ref T field  T value  Expression lt Func lt T gt  gt  selectorExpression        if  EqualityComparer lt T gt  Default Equals field  value   return false      field   value      OnPropertyChanged selectorExpression       return true      BTW  this was inspired by this blog post updated URL

User · Answer

I use the following extension method  using C  6 0  to make the INPC implemenation as easy as possible   public static bool ChangeProperty lt T gt  this PropertyChangedEventHandler propertyChanged  ref T field  T value  object sender      IEqualityComparer lt T gt  comparer   null   CallerMemberName  string propertyName   null        if  comparer    null          comparer   EqualityComparer lt T gt  Default       if  comparer Equals field  value                 return false            else               field   value          propertyChanged  Invoke sender  new PropertyChangedEventArgs propertyName            return true            The INPC implementation boils down to  you can either implement this every time or create a base class    public class INPCBaseClass  INotifyPropertyChanged       public event PropertyChangedEventHandler PropertyChanged       protected bool changeProperty lt T gt  ref T field  T value          IEqualityComparer lt T gt  comparer   null   CallerMemberName  string propertyName   null                return PropertyChanged ChangeProperty ref field  value  this  comparer  propertyName             Then write your properties like this   private string testProperty  public string TestProperty       get   return testProperty        set   changeProperty ref testProperty  value         NOTE  You can omit the  CallerMemberName  declaration in the extension method  if you want  but I wanted to keep it flexible   If you have properties without a backing field you can overload changeProperty   protected bool changeProperty lt T gt  T property  Action lt T gt  set  T value      IEqualityComparer lt T gt  comparer   null   CallerMemberName  string propertyName   null        bool ret   changeProperty ref property  value  comparer  propertyName       if  ret          set property       return ret      An example use would be   public string MyTestProperty       get   return base TestProperty        set   changeProperty base TestProperty   x    gt    base TestProperty   x     value

User · Answer

I introduce a Bindable class in my blog at http   timoch com blog 2013 08 annoyed-with-inotifypropertychange  Bindable uses a dictionary as a property bag  It s easy enough to add the necessary overloads for a subclass to manage its own backing field using ref parameters    No magic string No reflection Can be improved to suppress the default dictionary lookup   The code    public class Bindable   INotifyPropertyChanged       private Dictionary lt string  object gt   properties   new Dictionary lt string  object gt               lt summary gt          Gets the value of a property          lt  summary gt           lt typeparam name  T  gt  lt  typeparam gt           lt param name  name  gt  lt  param gt           lt returns gt  lt  returns gt      protected T Get lt T gt   CallerMemberName  string name   null            Debug Assert name    null   name    null            object value   null          if   properties TryGetValue name  out value               return value    null   default T     T value          return default T                   lt summary gt          Sets the value of a property          lt  summary gt           lt typeparam name  T  gt  lt  typeparam gt           lt param name  value  gt  lt  param gt           lt param name  name  gt  lt  param gt           lt remarks gt Use this overload when implicitly naming the property lt  remarks gt      protected void Set lt T gt  T value   CallerMemberName  string name   null            Debug Assert name    null   name    null            if  Equals value  Get lt T gt  name                return           properties name    value          OnPropertyChanged name              public event PropertyChangedEventHandler PropertyChanged       protected virtual void OnPropertyChanged  CallerMemberName  string propertyName   null            PropertyChangedEventHandler handler   PropertyChanged          if  handler    null                handler this  new PropertyChangedEventArgs propertyName                        It can be used like this   public class Contact   Bindable       public string FirstName           get   return Get lt string gt               set   Set value

[c#] Implementing INotifyPropertyChanged - does a better way exist?

Examples related to c#

Examples related to .net

Examples related to winforms

Examples related to inotifypropertychanged