using System;
using System.ComponentModel;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;

namespace WpfApp3
{
    /// <summary>
    /// Данный класс является промежуточным между модель и представлением
    /// Он позволяет открывать окна из модели представления на основе основе типа модели представления
    /// На основе типа модели окна находится соотвествующий стиль окна в ресурса приложения.
    /// То есть для окна должен быть предопределен стиль хранящийся в ресурсах приложения или главного окна
    /// </summary>
    public static class WindowManager
    {
        /// <summary>
        /// Открываем диалоговое окно
        /// </summary>
        /// <param name="model"></param>
        public static void ShowDialog(BaseWindowModel model)
        {
            var app = Application.Current;
            //Ищем стиль в ресурсах приложения
            var style = (Style)app.TryFindResource(model.GetType());
            //Если не нашли ищем в главном окне
            if (style == null)
            {
                style = (Style)app.MainWindow.TryFindResource(model.GetType());
            }
            
            //можно много где еще поискать, но если не нашли, то кидаем исключение
            if (style == null)
            {
                throw new Exception("Can't show window, style not found");
            }

            //создаем окно, задаем контекст, стиль
            var window = new Window
            {
                Style = style,
                DataContext = model
            };

            //Для нормальной реализации менеджера окна нужно больше чем примерчик, 
            //по этому пока оставляю вот так, безобразно, за то работает
            model.CloseWinow += (s,e) => window.Close();
            //открываем диалог
            window.ShowDialog();
        }
    }

    /// <summary>
    /// Класс реализующий ICommand, часто имеет название RelayCommand, это его упращенная версия
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ActionCommand<T> : ICommand
    {

        public event EventHandler CanExecuteChanged
        {
            add { CommandManager.RequerySuggested += value; }
            remove { CommandManager.RequerySuggested -= value; }
        }
        public bool LongRunning { set; get; }
        public ActionCommand(Action<T> action, Func<T, bool> condition)
        {
            Action = action;
            Condition = condition;
        }
        public ActionCommand(Action<T> action)
        {
            Action = action;
        }

        public Action<T> Action { set; get; }
        public Func<T, bool> Condition { set; get; }


        public bool CanExecute(object parameter)
        {
            return Condition == null || Condition((T)parameter);
        }

        public void Execute(object parameter)
        {
            Action?.Invoke((T)parameter);
        }
    }


    /// <summary>
    /// Базовая модель представления окна
    /// </summary>
    public abstract class BaseWindowModel : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
        public event EventHandler CloseWinow;

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

        /// <summary>
        /// Метод закрывет окно связанное с данной моделью
        /// </summary>
        protected void CloseWindow()
        {
            CloseWinow?.Invoke(this, null);
        }
    }

    /// <summary> Модель представления главного окна, в данном примере создается прямо из View </summary>
    public class MainModel : BaseWindowModel
    {
        private ActionCommand<object> _myCommand;
        public ActionCommand<object> MyCommand => _myCommand ?? (_myCommand = new ActionCommand<object>(OnMyCommand));

        private void OnMyCommand(object obj)
        {
            //Создаем объект который будет отвечать за обновления прогресса выполнеия в 
            //STA потоке
            var progress = new Progress<double>();
            //Создаем источник ключа для отмены операции
            var tokenSource = new CancellationTokenSource();
            var token = tokenSource.Token;
            //Создаем модель представления для отображения прогресса выполнения
            var progressModel = new ProgressModel(progress, tokenSource);
            //Запускаем асинхронную операцию в отдельном потоке через Task
            var task = Task.Run(() => LongOperation(progress, token), token);
            //Открываем окно
            WindowManager.ShowDialog(progressModel);
        }

        /// <summary>
        /// Метод реализующий длительную операцию с возможностью отмены и отчетом выполнения 
        /// </summary>
        /// <param name="progress"></param>
        /// <param name="token"></param>
        private void LongOperation(IProgress<double> progress, CancellationToken token)
        {
            for(var i = 0; i < 100; i++)
            {
                if (token.IsCancellationRequested) break;
                progress.Report((double)i);
                Task.Delay(200).Wait();
            }
        }
    }

    /// <summary> Модель окна с прогресс баром. </summary>
    public class ProgressModel : BaseWindowModel
    {


        private readonly IProgress<double> _progress;
        private readonly CancellationTokenSource _tokenSource;

        public ProgressModel(Progress<double> progress, CancellationTokenSource tokenSource)
        {
            _progress = progress;
            progress.ProgressChanged += OnProgressChanged;
            _tokenSource = tokenSource;
        }

        private double _progressValue;
        /// <summary>
        /// Значение прогресса выполнения от 0 до 100
        /// </summary>
        public double ProgressValue
        {
            set
            {
                _progressValue = value;
                OnPropertyChanged(nameof(ProgressValue));
            }
            get
            {
                return _progressValue;
            }
        }

        private ActionCommand<object> _cancel;
        /// <summary> Команда отмены операции </summary>
        public ActionCommand<object> Cancel => _cancel ?? (_cancel = new ActionCommand<object>(OnCancel));

        private void OnCancel(object obj)
        {
            _tokenSource.Cancel();
            CloseWindow();
        }

        /// <summary>
        /// Обрабочик события изменения прогресса выполнения
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnProgressChanged(object sender, double e)
        {
            ProgressValue = e;
        }

    }
}

<Window x:Class="WpfApp3.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WpfApp3"
        mc:Ignorable="d"
        Title="MainWindow" Height="350" Width="525">
    <Window.DataContext>
        <local:MainModel/>
    </Window.DataContext>
    <Window.Resources>
        <DataTemplate x:Key="ProgressModelTemplate" DataType="{x:Type local:ProgressModel}">
            <Grid>
                <Grid.RowDefinitions>
                    <RowDefinition/>
                    <RowDefinition/>
                </Grid.RowDefinitions>
                <ProgressBar Grid.Row="0" Margin="4" Width="300" Height="50" 
                             Value="{Binding ProgressValue}" 
                             Minimum="0" Maximum="100"/>
                <StackPanel Grid.Row="1"
                            Orientation="Horizontal">
                    <Button Command="{Binding Cancel}" Margin="4" Padding="10,5"
                            Content="Cancel"/>
                </StackPanel>
            </Grid>
        </DataTemplate>

        <Style x:Key="{x:Type local:ProgressModel}" TargetType="{x:Type Window}">
            <Setter Property="SizeToContent" Value="WidthAndHeight"/>
            <Setter Property="Content" Value="{Binding DataContext, RelativeSource={RelativeSource Self}}"/>
            <Setter Property="ContentTemplate" Value="{StaticResource ProgressModelTemplate}"/>
        </Style>

    </Window.Resources>
    <Grid>
        <Button HorizontalAlignment="Center" VerticalAlignment="Center"
                Width="200" Height="80"
                Content="Run"
                Command="{Binding MyCommand}"/>
    </Grid>
</Window>

<Window>
    <Grid/>
</Window>

var window = new Window() { Content = new Grid() }