Using a Stopwatch and DataBinding on a WPF Window that is already being updated using IProgress

Question

In my Main() WPF program I run a time consuming method asynchronously. When this method is running, I fire up a secondary window that contains a ProgressBar, which I update using IProgress.

Following is an example of my setup.

MAIN Program:

public partial class MainWindow : Window
{
    private ProgressBarWindow pbwWindow = null;

    public MainWindow()
    {
        InitializeComponent();
    }

    private void RunMethodAsync(IProgress<int> progress)
    {
        Dispatcher.Invoke(() =>
        {
            pbwWindow = new ProgressBarWindow("Processing...");
            pbwWindow.Owner = this;
            pbwWindow.Show();
        });

        TimeConsumingMethod(progress);
    }

    private void TimeConsumingMethod(IProgress<int> progress)
    {
        for (int i = 1; i <= 100; i++)
        {
            // Thread.Sleep() represents actual time consuming work being done.
            Thread.Sleep(100);
            progress.Report(i);
        }
    }

    private async void btnRun_Click(object sender, RoutedEventArgs e)
    {
        IProgress<int> progress;

        progress = new Progress<int>(i => pbwWindow.SetProgressUpdate(i));
        await Task.Run(() => RunMethodAsync(progress));
    }
}

My ProgressBarWindow which contains the progress bar looks like this:

public partial class ProgressBarWindow : Window
{
    Stopwatch stopwatch = new Stopwatch();
    BackgroundWorker worker = new BackgroundWorker();
    public string ElapsedTimeString { get; set; }

    public ProgressBarWindow(string infoText)
    {
        InitializeComponent();
        SetTimer();
    }

    private void Window_Loaded(object sender, RoutedEventArgs e)
    {
        StartTimer();
    }

    private void SetTimer()
    {
        worker.WorkerReportsProgress = true;
        worker.WorkerSupportsCancellation = true;

        worker.DoWork += (s, e) =>
        {
            while (!worker.CancellationPending)
            {
                worker.ReportProgress(0, stopwatch.Elapsed);
                Thread.Sleep(1000);
            }
        };

        worker.ProgressChanged += (s, e) =>
        {
            TimeSpan elapsedTime = (TimeSpan)e.UserState;
            ElapsedTimeString = string.Format("{0}:{1}:{2}", elapsedTime.Minutes, elapsedTime.Seconds, elapsedTime.Milliseconds);
        };
    }

    private void StartTimer()
    {
        stopwatch.Start();
        worker.RunWorkerAsync();
    }

    private void StopTimer()
    {
        stopwatch.Stop();
        worker.CancelAsync();
    }

    public void SetProgressUpdate(int progress)
    {
        pbLoad.Value = progress;
        if (progress >= 100)
        {
            StopTimer();
            Close();
        }
    }
}

I borrowed the StopWatch logic from this SO answer. Then, on my ProgressBarWindow I have a TextBlock which I've used Binding as follows, just as the answer above says.

<TextBlock Name="tbElapsedTime" Text="{Binding ElapsedTimeString}"/>

Now when I run the program, the method executes, and the progress bar updates just fine. However, my TextBlock that's supposed to update with the elapsed time does not get updated.

To verify my timer's running fine, I updated TextBlock value directly as follows instead of Binding and it worked as expected and displayed Elapsed Time:

worker.ProgressChanged += (s, e) =>
        {
            TimeSpan elapsedTime = (TimeSpan)e.UserState;
            ElapsedTimeString = string.Format("{0}:{1}:{2}", elapsedTime.Minutes, elapsedTime.Seconds, elapsedTime.Milliseconds);
            tbElapsedTime.Text = ElapsedTimeString;
        };

So I'm guessing my problem is with the Binding and possibly using BackgroundWorker on a windows that's already being run asynchronously? How could I fix this so I could use DataBinding?

Answer 1

As mentioned by Ginger Ninja, you have to implement INotifyPropertyChanged and use RelativeSource={RelativeSource Self} (as additional setting to the binding):

public partial class MainWindow : Window, INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    private string _ElapsedTimeString;
    public string ElapsedTimeString
    {
        get { return _ElapsedTimeString; }
        set
        {
            if (_ElapsedTimeString != value)
            {
                _ElapsedTimeString = value;
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("ElapsedTimeString"));
            }
        }
    }

    // ....
}

and the XAML:

<TextBlock Name="tbElapsedTime" Text="{Binding ElapsedTimeString, RelativeSource={RelativeSource Self}}"/>

Data binding is often used in combination with MVVM. That is IMHO the prefered way to solve your problem... If you want to use MVVM, you have to implement a view model that contains all the logic and implements INotifyPropertyChanged. Than you can simply bind properties from the view model to the view. That ensures a nice separation between (GUI related) logic and view.