MSDN Community

WPF Data Binding

Data binding is a core concept in Windows Presentation Foundation (WPF) that allows you to bind UI elements to data sources. This mechanism simplifies the process of synchronizing data between your application's user interface and its underlying data, enabling richer and more dynamic user experiences.

What is Data Binding?

At its heart, data binding is a declarative way to establish a connection between a property of a UI element (the Target) and a property of a data object (the Source).

When this binding is established:

• Changes in the source property are automatically reflected in the target property.
• Optionally, changes in the target property can be automatically reflected back to the source property (two-way binding).

Core Components of Data Binding

WPF data binding involves several key components:

• Binding Source: The object or collection that provides the data. This can be a CLR object, a Dependency Object, an ADO.NET data object, or a collection.
• Binding Target: The Dependency Property of a UI element (e.g., Text property of a TextBlock, ItemsSource of a ListBox).
• Binding: The object that defines the connection between the source and target. It specifies which source property to bind to and any transformations or validation rules.
• Binding Path: A string that identifies the property of the binding source. It can traverse nested properties and collection items.

Types of Data Binding

WPF supports different binding modes:

• OneWay: Changes to the source property update the target property. The target property does not update the source. This is the default.
• TwoWay: Changes to the source property update the target property, and changes to the target property update the source property.
• OneTime: The target property is updated only once when the binding is initialized.
• OneWayToSource: Changes to the target property update the source property.

Example: Binding a TextBlock to a Property

Consider a simple scenario where we want to display a user's name in a TextBlock. We can use data binding to achieve this.

XAML:

<TextBlock Text="{Binding UserName}" />

C# (ViewModel or Data Context):

public class UserViewModel : INotifyPropertyChanged
{
    private string _userName;
    public string UserName
    {
        get { return _userName; }
        set
        {
            _userName = value;
            OnPropertyChanged("UserName");
        }
    }

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

// In your Window or UserControl:
var viewModel = new UserViewModel { UserName = "Alice Smith" };
this.DataContext = viewModel;

In this example, the TextBlock's Text property is bound to the UserName property of the DataContext. When UserName in the UserViewModel changes, the TextBlock will automatically update.

Binding to Collections

WPF also excels at binding to collections of data, often used to populate list controls like ListBox or DataGrid.

To ensure UI updates when the collection itself changes (items added, removed, or reordered), the source collection should implement INotifyCollectionChanged, or preferably use an observable collection such as ObservableCollection<T>.

XAML (Binding to a ListBox):

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

C# (ViewModel):

public class ProductViewModel : INotifyPropertyChanged
{
    private ObservableCollection<string> _products;
    public ObservableCollection<string> Products
    {
        get { return _products; }
        set
        {
            _products = value;
            OnPropertyChanged("Products");
        }
    }

    public ProductViewModel()
    {
        Products = new ObservableCollection<string>
        {
            "Laptop", "Mouse", "Keyboard"
        };
    }

    // ... INotifyPropertyChanged implementation ...
}

Further Concepts

• Value Converters: Used to transform data from one format to another (e.g., converting a boolean to a visible/hidden state).
• Data Templates: Define the visual representation of data items in collections.
• Validation Rules: Define rules for validating data before it's accepted by the source.