MSDN Documentation

Data Binding in WPF

Data binding is a fundamental concept in Windows Presentation Foundation (WPF) that allows UI elements to be connected to data sources. This connection enables a dynamic synchronization between the UI and the data, meaning that changes in the data can automatically update the UI, and in some cases, changes in the UI can update the data.

Core Concepts of Data Binding

Data binding in WPF involves several key components:

• Target: The dependency property of a dependency object (typically a UI element) that you want to bind.
• Source: The object that provides the data. This can be any .NET object, including collections, data objects, or even other UI elements.
• Source Property: The property on the source object that holds the data.
• Binding Engine: The WPF data binding system that manages the connection between the target and source.
• Binding Object: An instance of the Binding class that defines the properties and behavior of the data binding.

The Binding Class

The Binding class is used in XAML or code to define a data binding. It exposes numerous properties to customize how the data is transferred and transformed.

Common Binding Properties:

• Path: Specifies the property on the data source to bind to.
• Mode: Defines the direction of data flow (OneWay, TwoWay, OneTime, OneWayToSource).
• Converter: A value converter that transforms data from source to target format or vice-versa.
• StringFormat: A format string to control the display of string data.
• UpdateSourceTrigger: Specifies when the binding updates the source property (e.g., PropertyChanged, LostFocus).

Binding Modes

The Mode property is crucial for defining the data flow:

• OneWay (Default): Updates the target property when the source property changes. The target property does not update the source.
• TwoWay: Updates the target property when the source property changes, and also updates the source property when the target property changes. Requires the source property to implement INotifyPropertyChanged and the target property to have a Set accessor.
• OneTime: Updates the target property once when the binding is initialized. The target property does not update the source, and subsequent changes to the source are ignored.
• OneWayToSource: Updates the source property when the target property changes. The target property does not update the source.

Example: Simple Two-Way Binding

Let's bind a TextBox's Text property to a property named Name on a data object.

<TextBox Text="{Binding Path=Name, UpdateSourceTrigger=PropertyChanged}" />

public class Person : INotifyPropertyChanged
{
    private string _name;
    public string Name
    {
        get { return _name; }
        set
        {
            if (_name != value)
            {
                _name = value;
                OnPropertyChanged(nameof(Name));
            }
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

// In your Window or UserControl constructor:
// this.DataContext = new Person { Name = "John Doe" };

INotifyPropertyChanged and ObservableCollection

For data binding to work effectively, especially with collections, two key interfaces are often used:

• INotifyPropertyChanged: As shown above, this interface allows an object to notify its listeners (including the WPF binding engine) when one of its properties has changed.
• INotifyCollectionChanged: This interface, implemented by ObservableCollection<T>, notifies listeners when items are added to, removed from, or the collection is otherwise changed. This is essential for data-bound ListBox, ListView, etc., to update when the underlying collection changes.

Value Converters

Sometimes, the data type or format of the source property doesn't directly match the target property. In such cases, you can use a IValueConverter to transform the data. A converter implements two methods: Convert (source to target) and ConvertBack (target to source for two-way bindings).

<Window.Resources>
    <local:BooleanToVisibilityConverter x:Key="BoolToVisConverter"/>
</Window.Resources>

<TextBlock Text="Status:" />
<TextBlock Text="{Binding IsActive, Converter={StaticResource BoolToVisConverter}}" />

public class BooleanToVisibilityConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value is bool boolValue)
        {
            return boolValue ? Visibility.Visible : Visibility.Collapsed;
        }
        return Visibility.Collapsed; // Default or error case
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value is Visibility visibility)
        {
            return visibility == Visibility.Visible;
        }
        return false; // Default or error case
    }
}

Binding to Collections

Binding to collections typically involves using an ItemsControl (like ListBox, ListView, DataGrid) and setting its ItemsSource property. Using an ObservableCollection<T> is highly recommended for automatic UI updates when the collection's contents change.

<ListBox ItemsSource="{Binding MyItems}" />

public ObservableCollection<string> MyItems { get; set; } = new ObservableCollection<string>();

// In constructor or initialization:
// MyItems.Add("Item 1");
// MyItems.Add("Item 2");

Key Takeaways

• Data binding decouples UI from data logic.
• Use Binding class to define connections.
• Understand the different Mode options.
• Implement INotifyPropertyChanged for observable data objects.
• Use ObservableCollection<T> for observable collections.
• Employ IValueConverter for data transformations.