Многопоточное программирование

using System;
using System.Windows;
using Microsoft.Phone.Controls;
using Microsoft.Phone.Shell;
using System.ComponentModel;
using System.Threading;

namespace CSWP8ProgressIndicator
{
    public partial class MainPage : PhoneApplicationPage
    {
        static string strMsg = string.Empty;   // Сообщение о результате.

        // Конструктор
        public MainPage()
        {
            InitializeComponent();
        }

        private void btnWork_Click(object sender, RoutedEventArgs e)
        {
            //Добавлено, воспроизведение анимации
            Storyboard1.Begin();
            // Создание и настройка нового индикатора выполнения
            ProgressIndicator prog = new ProgressIndicator();
            prog.IsVisible = true;
            prog.IsIndeterminate = true;
            prog.Text = "Выполнение задачи...";
            //Установка нового индикатора 
            SystemTray.SetProgressIndicator(this, prog);

            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                btnWork.Visibility = Visibility.Collapsed;
                tbMessage.Text = "Рабочий процесс запущен, 
пожалуйста, подождите 5 секунд.";
            });

            RunProcessAsync(DateTime.Now);
        }

        /// <summary>
        /// Запуск процесса
        /// </summary>
        /// <param name="dumpDate"></param>
        public void RunProcessAsync(DateTime dumpDate)
        {
            //Новый фоновый рабочий процесс
            BackgroundWorker worker = new BackgroundWorker();
            //Подписка на событие завершения работы
            worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted);
            worker.DoWork += new DoWorkEventHandler(worker_DoWork);
            worker.RunWorkerAsync(dumpDate);
        }

        /// <summary>
        /// Обработчик события DoWork
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        async void worker_DoWork(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker worker = new BackgroundWorker();

            // Здесь следует разместить код, выполняющий ресурсоёмкую задачу 
            Thread.Sleep(5 * 1000);  // 5 секунд;

            await worker.RunWorkerTaskAsync();
        }
        //Обработчик события завершения работы фонового процесса
        void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            BackgroundWorker worker = sender as BackgroundWorker;
            worker.RunWorkerCompleted -= new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted);
            worker.DoWork -= new DoWorkEventHandler(worker_DoWork);

            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                tbMessage.Text = "Выполнение задачи завершено.";
                btnWork.Visibility = Visibility.Visible;
            });

            SystemTray.ProgressIndicator.IsVisible = false;
        }

        //Добавлено, иллюстрация синхронного кода
        private void btnSyncWork_Click(object sender, RoutedEventArgs e)
        {
            Storyboard1.Begin();
            tbMessage.Text = "Выполнение задачи начато, пожалуйста, подождите 5 секунд.";
            Thread.Sleep(5 * 1000);
            tbMessage.Text = "Выполнение задачи завершено.";
        }
    }
}

using System.ComponentModel;
using System.Threading.Tasks;

namespace CSWP8ProgressIndicator
{
    //Задача для фонового процесса
    public static class BackgroundWorkerExtensions
    {
        public static Task<object> RunWorkerTaskAsync(this BackgroundWorker backgroundWorker)
        {
            var tcs = new TaskCompletionSource<object>();
            RunWorkerCompletedEventHandler handler = null;
            handler = (sender, args) =>
            {
                if (args.Cancelled)
                    tcs.TrySetCanceled();
                else if (args.Error != null)
                    tcs.TrySetException(args.Error);
                else
                    tcs.TrySetResult(args.Result);
            };
            backgroundWorker.RunWorkerCompleted += handler;
            try
            {
                backgroundWorker.RunWorkerAsync();
            }
            catch
            {
                backgroundWorker.RunWorkerCompleted -= handler;
                throw;
            }
            return tcs.Task;
        }
    }
}