Binding list to textbox won't update if ObservableCollection

Question

I'm creating a custom control in WPF. I bind a List<IMyInterface> to a dependency property. This in turn binds again to a ListBox which shows all the items as expected.

I now want to bind 1 item from this list to a Textblock, so I bind the entire list to the textblock. I have a converter in this which extracts the single item I want.

It has worked fine but for a few reasons, I want to use ObservableCollection instead of List

Oddly, when I change a value in my ObservabaleCollection at run time, the value is shown in the ListBox (success) but not in my textblock. The converter is not even hit!

    public MainWindow()
    {
        InitializeComponent();
        this.DataContext = this;
        this.Errors = new ObservableCollection<IEventDetail>();
        this.Errors.CollectionChanged += Errors_CollectionChanged;
        var bw = new BackgroundWorker();
        bw.DoWork += ((o, e) =>
        {
            System.Threading.Thread.Sleep(1500);
            Dispatcher.Invoke(() =>
            {
                this.Errors.Add(new MyEvents("example of some detail", "Failed title"));
            });

            System.Threading.Thread.Sleep(2500);

            Dispatcher.Invoke(() =>
            {
                this.Errors.Add(new MyEvents("Another example", "Failed title 2"));
            });
        });
        bw.RunWorkerAsync();//background worker for testing/debugging only
    }

    private void Errors_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
    {
        OnPropertyChanged("Errors");
    }

    private ObservableCollection<IEventDetail> _errors;
    public ObservableCollection<IEventDetail> Errors
    {
        get
        {
            return this._errors;
        }
        set
        {
            this._errors = value;
            OnPropertyChanged("Errors");
        }
    }


    public event PropertyChangedEventHandler PropertyChanged;
    public void OnPropertyChanged(string propertyName)
    {
        if (PropertyChanged == null)
            return;

        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }

And the xaml is simply

 <local:Notify Events="{Binding Errors}" DockPanel.Dock="Right"/>

As you can see, I've tried to use the CollectionChanged event to then force fire the INotifyPropertyChanged, but it's firing in my Converter yet the ListBox is updating fine (so I know the binding is fine)

This is the UserControls xaml

 <TextBlock Text="{Binding Path=Events, RelativeSource={RelativeSource AncestorLevel=1, AncestorType=UserControl}, Mode=Default, Converter={StaticResource MostRecentConverter}}" Grid.Row="0" />

    <ListBox ItemsSource="{Binding Path=Events, RelativeSource={RelativeSource AncestorLevel=1,AncestorType=UserControl}, Mode=Default}" Grid.Row="1">
        <ListBox.ItemTemplate>
            <DataTemplate>
                <TextBlock Text="{Binding EventTitle}" Style="{StaticResource txtBckRed}"/>
            </DataTemplate>
        </ListBox.ItemTemplate>
    </ListBox>

Do I need to do something else?

Answer 1

As mentioned in the comments TextBlock it bound only to Events property change (not its items) so it won't trigger unless new instance of collection is created. Reacting to INotifyCollectionChanged is characteristic to ItemsSource property.

Solution 1

Leave everything as it is at the moment just give TextBlock some name

<TextBlock Text="{Binding ...}" x:Name="myTextBlock"/>

and subscribe to CollectionChanged event inside your UserControl where you manually force binding target to update

public partial class MyUserControl : UserControl
{
    public static readonly DependencyProperty EventsProperty =
                               DependencyProperty.Register("Events", 
                                   typeof(IEnumerable), 
                                   typeof(MyUserControl), 
                                   new PropertyMetadata(EventsPropertyChanged));

    private static void EventsPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        ((MyUserControl)d).EventsPropertyChanged(e);
    }

    private void EventsPropertyChanged(DependencyPropertyChangedEventArgs args)
    {
        var newCollection = args.NewValue as INotifyCollectionChanged;
        if (newCollection != null)
            newCollection.CollectionChanged += (s, e) => myTextBlock.GetBindingExpression(TextBlock.TextProperty).UpdateTarget();
    }

    public IEnumerable Events
    {
        get { return (IEnumerable)GetValue(EventsProperty); }
        set { SetValue(EventsProperty, value); }
    }

}

Solution 2

Create your own collection class inherited from ObservableCollection<T> with custom property that would do what your converter does

public class MyObservableCollection<T> : ObservableCollection<T>
{
    private string _convertedText;

    protected override void OnCollectionChanged(System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
    {
        base.OnCollectionChanged(e);
        this.ConvertedText = ...; // <- do here what your IValueConverter does
    }

    public string ConvertedText
    {
        get { return _convertedText; }
        private set
        {
            _convertedText = value;
            OnPropertyChanged(new PropertyChangedEventArgs("ConvertedText"));
        }
    }
}

and bind TextBlock.Text to Events.ConvertedText property instead, without need for converter