Question

I’m attempting to create a CustomControl which will have various properties affected by an enum found in a ViewModel. The CustomControl created will be called within a View.

I would like the enum binding to change a couple of things within the Control, these include:

• Changing an Images source (images changed to are static within a folder created inside the CustomControl Library),
• Alter a TextBlocks Text property, again, the text options will be static between one of X amount of cases (X being the number of possible enum states(also doesn’t change)).

Keep in mind, these two DP’s will be linked e.g. if bound enum is case x, the image source will change and the displayed text.
Basically, the two exposed DP’s here will be bound to the same enum, but use it differently.

---

So, my question is, what would be the best way to carry what is described above?

I’ve already thought about two possible ways:

1. Expose useful DP types and bind these properties to the same enum (e.g Property1=”{Binding someEnum}” Property2=”{Binding someEnum}”) and also provide a ValueConvertor to convert these enums to useful types which the CustomControl can then use,
2. Or, expose a single DP which accepts an enum and then changes the properties somewhere else within the CustomControl code, depending on the value of the bound enum?

I am fairly comfortable with carrying out option 1 with a value convertor in the Views code-behind file. However, I would like to avoid doing it this way as it would make the control less independant.

Regarding option two, I’m not entirely sure how to do it this way so articles or a small explanation would help if you feel this is the way to go – Possibly implementing INoitifyPropertyChanged on the DP so the control knows it’s value has been changed when the Bound enum changes?

Also, I am not limited to doing it the two ways described, if you feel there is a better way, please suggest it!

I am using WPF (C#) in conjunction with MVVM architecture (MVVM Light Toolkit).

Quick Note: I would like to avoid altering the ViewModel – The exposed enum and all logic there should remain as it is unless absoloutely necessary!

Thanks in advance for your replies and I will attempt to update this question as much as possible with responses and updates regarding personal progress with the issue as well as possible extra information which has been requested!

Answer 1

Both of your solutions should work just fine.

For the second solution, all that you need is to register the dependecy property with a PropertyChangedCallback:

public static readonly DependencyProperty MyPropertyProperty =
        DependencyProperty.Register("MyProperty", typeof(EnumType), typeof(MyClass), new PropertyMetadata(new PropertyChangedCallback(MyPropertyChangedHandler)));

static void MyPropertyChangedHandler(DependencyObject obj, DependencyPropertyChangedEventArgs args)

Check this thread for usage of FrameworkPropertyMetadata, UIPropertyMetadata and PropertyMetadata When should I use FrameworkPropertyMetadata or UIPropertyMetadata over plain PropertyMetadata?

The advantage of your first solution is that it’s light, you only need 2 ValueConvertors, there is no need for a dependency property, so that another dev could understand there is a tight dependency between the enum and those properties just by looking at your xaml.
The disadvantage is that if you plan to use your custom control with the same logic in more than one place, copy pasting those convertors is not very neat.

The second solution, is a mirror to the first, you have the advantage of a greater level of reusability, but your logic gets embedded deep in your control.