ViewModel类应该实现INotifyPropertyChanged还是可以使用对象组合？

Question

I'm developing a MVVM WPF application with C# and .NET Framework 4.6.

I have this class:

public class ObservableObject : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected void RaisePropertyChangedEvent(string propertyName)
    {
        var handler = PropertyChanged;
        if (handler != null)
            handler(this, new PropertyChangedEventArgs(propertyName));
    }
}

I have implemented here INotifyPropertyChanged because I don't want to implement it in all of my ViewModel classes.

To use this class, I use inherit:

public class Presenter : ObservableObject
{
    private string _someText;

    public string SomeText
    {
        get { return _someText; }
        set
        {
            _someText = value;
            RaisePropertyChangedEvent("SomeText");
        }
    }
}

But, is there a way to use ObservableObject using object composition?

I understand object composition as instead of inherit, create a private object instance of ObservableObject in class Presenter .

I'm not sure if any ViewModel class should implement INotifyPropertyChanged .

UPDATE:
This is not a duplicate question . I'm asking if a ViewModel has always to implement INotifyPropertyChanged interface or instead, I can use Object composition. I have explained before. Please, read carefully my question.

Answer 1

Well, ... ViewModels are best to be viewed as Composition, but the notification part should be an implementation of the Interface (or in your case inheritance). You have your DTOs and your ViewModels would be a composition of the DTOs, depending on the scenario.

This implementation of the same stuff can be tedious, but for WPF is still necessary. What you can do to simplify the process is to use Veawrs like Fody . It changes your observation of the ViewModel. All of the properties of the VM are by default observable properties, but you exclude the ones you do not want to, or you can define for one property to let the UI know that it should also update others.

It keeps the code very clean and simple. You will not need to implement the Interface, but it will be inherited in build time if you give the class the needed attribute.

Answer 2

If you want to improve the robustness by avoiding code duplication and using strings in code. Then you could use the following base class.

I don't know an approach with composition, but this one is the best I know. Since it has some additional benefits (Cloning made easy aso)

public abstract class BindingBase : INotifyPropertyChanged
{
    private IDictionary<string, object> _backingFields;
    private IDictionary<string, object> BackingFields
    {
        get { return _backingFields ?? (_backingFields = new Dictionary<string, object>(); }
    }    

    protected T GetValue<T>(Expression<Func<T>gt; expr)
    {
        var name = GetName(expr);
        return BackingFields.Contains(name) ? (T)BackingFields[name].Value : default(T);
    } 

    protected void SetValue<T>(Expression<Func<T>gt; expr, T value)
    {
        var name = GetName(expr);
        if (BackingFields.Contains(name) && BackingFields[name].Value.Equals(value))
            return; // return without doing anything, since the value is not changing        

        BackingFields[name] = value;
        RaisePropertyChanged(name);
    }

    private void RaisePropertyChanged(string name)
    { // you know this part

    }

    private string GetName (Expression<Func<T> expr)
    { // implementation can be found via google 
    }
}

Usage is quite easy.

 public class BindingChild : BindingBase { public string SampleProperty { get { return GetValue(() => SampleProperty); } set { SetValue(() => SampleProperty, value); } } }