Question

New to WPF. I am creating UserControls that need read access to the ViewModel state to do their thing. I currently use the following technique:

public partial class ControlBar : UserControl
{

    private static readonly DependencyProperty URLProperty =
        DependencyProperty.Register("URL", typeof(string), typeof(ControlBar),
        new UIPropertyMetadata(null));

    public ControlBar()
    {
        InitializeComponent();

        SetBinding(URLProperty, "CurrentPage.URL");

        Pin.Click += Pin_Click;       
    }

    private void Pin_Click(object sender, RoutedEventArgs e)
    {
        var URL = (string)GetValue(URLProperty);

    }
}

Is this the correct way and is it not overkill to set up a long-term binding for each variable I need access to? Or can you do something like:

GetValue(new Path("CurrentPage.URL..... 

I made up the above obviously.

Thanks!

Answer 1

In general data-binding is the way to go. However sometimes when you are creating controls that have view-specific concerns for which data-binding will not be appropriate.

In those cases you will want to be able to interact with the DependencyProperty to set it and know when it changes. I have been following a pattern that I picked up from a Charles Petzold article in MSDN magazine.

My answer to another question shows the pattern for creating a DependencyProperty for a UserControl Stack Overflow: Dependency Property In WPF/SilverLight

Again, data-binding to a view model will likely solve your problem, but a DependencyProperty may come in useful depending on the situation.

Update in response to comment:

In many situations you can data bind your in a UserControl without using a DependencyProperty. For example if you have a TextBlock that displays a name you would put a TextBlock in the XAML of the UserControl

<TextBlock Text="{Binding Path=NameString}" />

In the view model which is present in the DataContext you would have a property NameString and if the TextBlock is to update the display when the NameString property changes the view model should implement INotifyPropertyChanged and the property should fire the PropertyChanged event with the name of the property sent along with the event.

protected string _NameString;
public string NameString
{
    get { return _NameString; }
    set { _NameString = value: Notify("NameString"); }
}

Where Notify is a method that checks the PropertyChanged event for null and sends the event if not null.

This works well if everywhere that you want to use the UserControl has a view model with a Name property. The great thing is that the UserControl can pick up on the DataContext of wherever it is hosted and bind to an external view model.

When you want to start binding the same UserControl to different properties is one place that you may want to use a DependencyProperty. In that case you could make a UserControl with a DependencyProperty and bind it to different properties

<my:SampleControl NameString="{Binding Path=GivenName}" />
<my:SampleControl NameString="{Binding Path=FamilyName}" />

And then have an internal view model that the DependencyProperty change handler updates when the bound property changes.

Update: No DependencyProperty or binding

You can always add an ordinary C# property to the UserControl and pass the data in that way.

public MyClass Data { get; set; }

Then in the code-behind of the UserControl you can simply use the property:

if (this.Data != null)
{
    this.textBox1.Text = Data.NameString;
}

Update in response to comment:

Another way to access the view model in code is to cast the DataContext to your view model type:

MyClass data = this.DataContext as MyClass;
if (data != null)
{
    // do something
    this.textBox1.Text = data.NameString;
}