Question

When .NET 4.5 was released i started using such great Attribute as CallerMemberName. It’s easier to understand code, developers can write it faster also. It’s like a snippet, not only a feature for debug/test purposes.

So I have a question. Is it normal to create and use something like this?

public class PropertyStore
{
    Dictionary<string, object> data = new Dictionary<string,object>();
    ViewModelBase modelBase;

    internal PropertyStore(ViewModelBase _base)
    {
        modelBase = _base;
    }

    public void SetValue<T>(T value = default(T), [CallerMemberName] string prop = "")
    {
        T prev = GetValue<T>(prop);
        if ((prev == null && value == null) || (prev != null && prev.Equals(value))) return;
        data[prop] = value;
        modelBase.OnPropertyChanged(prop);
    }

    public T GetValue<T>([CallerMemberName] string prop = "")
    {
        if (!data.ContainsKey(prop))
            data[prop] = default(T);
        return (T)data[prop];
    }
}

Class-helper, that makes other class more readable, and also we have list of our properties without need to use Reflection.
The usage is:

public class SampleClass : ViewModelBase
{
    PropertyStore PropertyStore;

    public SampleClass ()
    {
        PropertyStore = new PropertyStore(this);
    }

    public string Key
    {
        get { return PropertyStore.GetValue<string>(); }
        set { PropertyStore.SetValue(value); }
    }
    public DateTime Date
    {
        get { return PropertyStore.GetValue<DateTime>(); }
        set { PropertyStore.SetValue(value); }
    }
    public bool IsSelected
    {
        get { return PropertyStore.GetValue<bool>(); }
        set { PropertyStore.SetValue(value); }
    }
}

The class ViewModelBase here simply implements INotifyPropertyChanged interface.

As I understand, this approach is something like Microsoft Dependency Properties, but I don’t need all power of DependencyObject class, and I don’t want inherit it.
With something like this I can use Binding, because it’s enough to implement INotifyPropertyChanged, also we have no fields (as for me, i try to use properties smarter, than using fields directly (however, there is no problem to use Dictionary directly ^_^))

Sorry for my bad English… Not main language and not much practice.

Another Sample (after moving Methods to base class)

public class SampleClass : ViewModelBase
{
    public string Key
    {
        get { return GetValue<string>(); }
        set { SetValue(value); }
    }
    public DateTime Date
    {
        get { return GetValue<DateTime>(); }
        set { SetValue(value); }
    }
    public bool IsSelected
    {
        get { return GetValue<bool>(); }
        set { SetValue(value); }
    }
}

No diff with Microsoft’s WPF Property System.

Answer 1

Nice idea, property bag without reflection and it will even work with obfuscation.

I don’t see major problems with it but you may consider the following:

1. The prop parameter is optional so potentially a bug can be introduced by given a value in the call.
2. Value types will get boxed.
3. Access to the fields is relatively more expensive, can be a factor more expensive as you have much more code in a simple get (especially with boxing).
4. Dictionary takes more space than the number of properties you keep in (especially with boxing).
5. Each property also stores a string of the property name adding to the overhead.