Correct Methods to Retrieve New Values in WPF ComboBox SelectionChanged Event

Problem Background and Phenomenon Analysis

In WPF application development, ComboBox is a commonly used selection control, but many developers encounter a confusing phenomenon when handling its SelectionChanged event: when checking the ComboBox value in the event handler, they obtain the old value before the change rather than the newly selected value. This behavior initially seems contrary to the meaning of the event name "SelectionChanged" and more resembles a "SelectionChanging" event.

A typical incorrect usage example is as follows:

this.MyComboBox.SelectionChanged += new SelectionChangedEventHandler(OnMyComboBoxChanged);

private void OnMyComboBoxChanged(object sender, SelectionChangedEventArgs e)
{
    string text = this.MyComboBox.Text; // This gets the old value
}

Even attempting to use e.OriginalSource from the event parameters yields the same result. The fundamental reason for this phenomenon lies in the timing differences of updates between different internal parts of the ComboBox.

ComboBox Control Structure Analysis

ComboBox is a composite control consisting of two main parts:

• Text Part: Corresponds to the ComboBox's Text property, displaying the currently selected text content
• Selector Part: The drop-down list portion, corresponding to the SelectedItem property, managing the selection state of options

When a user selects a new item in the drop-down list, the selector part's SelectedItem updates immediately and triggers the SelectionChanged event. However, the text part's Text property update is delayed until after the event handler execution completes. This design ensures control state consistency during event processing but also causes the aforementioned "old value" phenomenon.

Correct Methods to Retrieve New Values

Using AddedItems Collection

According to MSDN documentation, the SelectionChangedEventArgs parameter provides an AddedItems property that returns a list containing newly selected items. This is the most direct method to obtain new values:

private void OnMyComboBoxChanged(object sender, SelectionChangedEventArgs e)
{
    if (e.AddedItems.Count > 0)
    {
        string text = (e.AddedItems[0] as ComboBoxItem).Content as string;
        // Process the new value
    }
}

This method directly obtains change information from the event parameters without relying on the control's current state, thus accurately reflecting selection changes.

Using SelectedItem Property

Another reliable approach is to access the SelectedItem property. Since the selector part has already been updated when the event triggers, this property returns the newly selected value:

private void OnMyComboBoxChanged(object sender, SelectionChangedEventArgs e)
{
    ComboBox comboBox = sender as ComboBox;
    if (comboBox != null)
    {
        string text = comboBox.SelectedItem as string;
        // Process the new value
    }
}

If the ComboBox items are ComboBoxItem objects rather than simple strings, further access to their Content property is required:

private void OnMyComboBoxChanged(object sender, SelectionChangedEventArgs e)
{
    ComboBox comboBox = sender as ComboBox;
    if (comboBox != null && comboBox.SelectedItem is ComboBoxItem)
    {
        string text = ((ComboBoxItem)comboBox.SelectedItem).Content as string;
        // Process the new value
    }
}

Type-Safe Handling Recommendations

Since both Content and SelectedItem are of type object, directly using as string for type conversion may return null when types don't match. A safer approach is to use the ToString() method:

private void OnMyComboBoxChanged(object sender, SelectionChangedEventArgs e)
{
    ComboBox comboBox = sender as ComboBox;
    if (comboBox != null && comboBox.SelectedItem != null)
    {
        string text = comboBox.SelectedItem.ToString();
        // Process the new value
    }
}

Or for the AddedItems method:

private void OnMyComboBoxChanged(object sender, SelectionChangedEventArgs e)
{
    if (e.AddedItems.Count > 0 && e.AddedItems[0] != null)
    {
        string text = e.AddedItems[0].ToString();
        // Process the new value
    }
}

Alternative Approach: DropDownClosed Event

Besides the SelectionChanged event, consider using the DropDownClosed event to obtain the ComboBox's current value:

private void comboBox_DropDownClosed(object sender, EventArgs e)
{
    string currentValue = comboBox.Text; // Text property is now updated
    // Process current value
}

The advantage of this method is ensuring all UI updates are complete, including text part refresh. However, note that the DropDownClosed event triggers every time the drop-down list closes, not just when selection changes.

Best Practices Summary

In practical development, the following best practices are recommended:

1. Prefer AddedItems: Use e.AddedItems and e.RemovedItems collections when precise knowledge of which items were added or removed is needed
2. Use SelectedItem for Current Value: Use the SelectedItem property when only the currently selected item is required
3. Implement Null Checks: Always check for null values for sender, SelectedItem, and collection elements
4. Consider Type Safety: Use ToString() or appropriate type conversions to ensure code robustness
5. Understand Update Timing: Recognize the update timing differences between ComboBox parts and avoid relying on unupdated properties

By correctly understanding ComboBox's event mechanism and property update timing, developers can avoid common pitfalls and write more reliable and maintainable WPF applications.