public void SetView(Type view)
        {
            foreach (ViewBase openView in OpenViews)
            {
                if (openView.GetType().Equals(view))
                {
                    CurrentView = openView;
                    CurrentView.Reset();
                    return;
                }
            }

            CurrentView = Activator.CreateInstance(view) as ViewBase;
            if (CurrentView.TargetDataContext == null)
            {
                CurrentView.DataContext = this;
            }
            else
            {
                var context = Activator.CreateInstance(CurrentView.TargetDataContext, new object[] { mediator });
                var type    = CurrentView.TargetDataContext;
                CurrentView.DataContext = Convert.ChangeType(context, type);
            }
            OpenViews.Add(CurrentView);
        }
        /// <summary>
        /// Handler for Closed event, triggered when window is about to close.
        /// </summary>
        /// <param name="sender">Window object</param>
        private void WindowClosed(object sender, EventArgs e)
        {
            Window window = (Window)sender;

            window.Closed -= WindowClosed;

            OpenViews.Remove(window);
        }
        /// <summary>
        /// Creates instance of Window of type T and shows it.
        /// </summary>
        /// <typeparam name="T">Window type</typeparam>
        public void OpenWindow <T>() where T : Window
        {
            if (!CheckIfAlreadyOpened(typeof(T)))
            {
                Window window = (T)Activator.CreateInstance(typeof(T));

                window.Closed += WindowClosed;
                window.Show();

                OpenViews.Add(window, window.DataContext);
            }
        }
        /// <summary>
        /// Finds Window in ActiveViews dictionary basing on VM value, closes this window, removes from dictionary.
        /// </summary>
        /// <param name="viewModel">View model object</param>
        public void CloseWindow(object viewModel)
        {
            if (viewModel != null)
            {
                Type   type   = viewModel.GetType();
                Window window = OpenViews.FirstOrDefault(view => view.Value.GetType() == type).Key as Window;

                if (window != null)
                {
                    window.Close();
                }
            }
        }
        private void DialogWindowClosed(object sender, EventArgs e)
        {
            Window window = (Window)sender;

            window.Closed -= DialogWindowClosed;

            OpenViews.Remove(window);

            var vm = window.DataContext as IDialogViewModel;

            DialogResult = vm.DialogResult;

            Returned = true;
        }
        public async Task <bool?> OpenDialogWindow <T>() where T : Window
        {
            Returned = false;

            if (!CheckIfAlreadyOpened(typeof(T)))
            {
                Window window = (T)Activator.CreateInstance(typeof(T));

                window.Closed += DialogWindowClosed;
                window.Show();

                OpenViews.Add(window, window.DataContext);

                while (!Returned)
                {
                    await Task.Delay(100);
                }

                return(DialogResult);
            }

            return(null);
        }
 /// <summary>
 /// Verify if window can be found in ActiveViews.
 /// </summary>
 /// <param name="type">Window type</param>
 /// <returns>is opened or not</returns>
 private bool CheckIfAlreadyOpened(Type type)
 {
     return(OpenViews.Select(view => view.Key.GetType() == type).FirstOrDefault());
 }