Base class does not implement INotifyPropertyChange; how do I implement it in derived class?

Question

---

Update: Sorry I wasn't clear about the question. I should've mentioned that:

1. Suppose I can't change the Base, and..

2. There are many properties in the Base. The sample code is simplified.

---

Here I have an object of this (base)class that is deserialized over the network.

public class Base
{
   public string Name { get; set; }
}

Now I wish to bind its properties on an WPF application so I implement INotifyPropertyChanged on a derived class.

public class Derived : Base, INotifyPropertyChanged
{
  private string _derivedName;

  public string DerivedName { 
    get { return _derivedName; }
    set
    { 
      _derivedName = value;
      RaisePropertyChanged("DerivedName");
    }
  }

  public event PropertyChangedEventHandler PropertyChanged;

  protected virtual void RaisePropertyChanged(string propertyName)
  {
    PropertyChangedEventHandler handler = PropertyChanged;
    if (handler != null)
    {
      handler(this, new PropertyChangedEventArgs(propertyName));
    }
  }
}

Now my question is : How do I raise the property changed event when Base.Name is changed?

I know I can remove the inheritance and re-implement every base property and raise the event, but is there any better way?

Answer 1

Change your code so Base implements the interface instead, and raise the event when Name is set:

public class Base : INotifyPropertyChanged
{
   private string _name;
   public string Name { get
   {
       return _name;
   }
   set{
       if(PropertyChanged != null)
           PropertyChanged(this, new PropertyChangedEventArgs("Some arg"));
       _name = value;
   }
}

   public event PropertyChangedEventHandler PropertyChanged;
}

"Derived" will inherit the interface implementation from Base, so just remove it from the class declaration:

public class Derived : Base
{
  private string _derivedName;

  public string DerivedName { 
    get { return _derivedName; }
    set
    { 
      _derivedName = value;
      RaisePropertyChanged("DerivedName");
    }
  }

  protected virtual void RaisePropertyChanged(string propertyName)
  {
    PropertyChangedEventHandler handler = PropertyChanged;
    if (handler != null)
    {
      handler(this, new PropertyChangedEventArgs(propertyName));
    }
  }
}

Answer 2

Create a new modifier to hide the base to the real world and report property change of Name such as:

public class Derived : Base, INotifyPropertyChanged
{ 
  public new string Name
  {
    get { return base.Name; }
    set { base.Name = value;
          RaisePropertyChanged("Name");
        }
  } 
}

See MSDN: new Modifier C# Reference as to why this works.

Update

I know I can remove the inheritance and re-implement every base property and raise the event, but is there any better way?

No...there is no way to implement a PropertyChange call on a setter in the base class after the fact without doing the modifier above.

Answer 3

I would choose a more pragmatic approach by wrapping the call to base class properties.

public class Derived : Base, INotifyPropertyChanged
{

  public string DerivedName { 
    get { return Name; }
    set
    { 
      Name = value;
      RaisePropertyChanged("DerivedName");
      RaisePropertyChanged("Name"); //probably you will not need this line
    }
  }
}