При закрытии формы "не успевают" сохраниться настройки - C#

using System.Windows;
using Wpf_TimeRandomizer.ViewModel;
 
namespace Wpf_TimeRandomizer
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            Closing += (s, e) => ViewModelLocator.Cleanup();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Threading;
using Wpf_TimeRandomizer.Model;
 
namespace Wpf_TimeRandomizer.ViewModel
{
    public class MainViewModel : ViewModelBase
    {
        private RelayCommand _randomizeCommand;
        private TimeEngine _timeEngine;
        private TimeFormat _timeFormat;
        private DateTime _time;
        private bool _isLoaded;
        private bool _multipleOfFive;
 
        public MainViewModel()
        {
            Configuration = new GlobalConfig();
            Configuration.Loaded += (sender, args) => Dispatcher.CurrentDispatcher.Invoke(
                new Action(() =>
                {
                    _timeEngine = new TimeEngine();
                    Time = _timeEngine.GenerateRandomTime(Configuration.Settings.MinutesMultipleOfFive);
                    MultipleOfFive = Configuration.Settings.MinutesMultipleOfFive;
                    IsSettingsLoaded = true;
                    RaisePropertyChanged("TimeAsText");
                }));
            Configuration.LoadAsync();
        }
 
        //=================
        //== Свойства и т.д.
        //=================
 
        internal GlobalConfig Configuration { get; private set; }
 
        protected override void OnDispose()
        {
            Configuration.Save();
        }
    }
}

using System;
using System.IO;
using System.Threading;
 
namespace Wpf_TimeRandomizer
{
    public class GlobalConfig
    {
        public GlobalConfig()
        {
        }
 
        public AppFolders Folders { get; protected set; }
 
        public AppSettings Settings { get; protected set; }
 
        public event EventHandler Loaded;
 
        public virtual void Save()
        {
             AppSettings.Save(Settings, Path.Combine(Folders.MainData, Constants.SettingsFileName));
        }
 
        public virtual void LoadAsync()
        {
            ThreadPool.QueueUserWorkItem(unused =>
                {
                    Folders = new AppFolders(Constants.AppName);
                    Folders.CheckFolders();
                    Settings = AppSettings.Load(Path.Combine(Folders.MainData, Constants.SettingsFileName)) ?? new AppSettings();
                    OnLoaded();
                });
        }
 
        protected virtual void OnLoaded()
        {
            EventHandler handler = Loaded;
            if (handler != null)
            {
                handler(this, EventArgs.Empty);
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Wpf_TimeRandomizer.ViewModel
{
    public class ViewModelLocator
    {
        private static MainViewModel _main;
 
        /// <summary>
        /// Initializes a new instance of the ViewModelLocator class.
        /// </summary>
        public ViewModelLocator()
        {
            CreateMain();
        }
 
        /// <summary>
        /// Gets the Main property.
        /// </summary>
        public static MainViewModel MainStatic
        {
            get
            {
                if (_main == null)
                {
                    CreateMain();
                }
 
                return _main;
            }
        }
 
        /// <summary>
        /// Gets the Main property.
        /// </summary>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance",
            "CA1822:MarkMembersAsStatic",
            Justification = "This non-static member is needed for data binding purposes.")]
        public MainViewModel Main
        {
            get { return MainStatic; }
        }
 
        /// <summary>
        /// Provides a deterministic way to delete the Main property.
        /// </summary>
        public static void ClearMain()
        {
            _main.Dispose();
            _main = null;
        }
 
        /// <summary>
        /// Provides a deterministic way to create the Main property.
        /// </summary>
        public static void CreateMain()
        {
            if (_main == null)
            {
                _main = new MainViewModel();
            }
        }
 
        /// <summary>
        /// Cleans up all the resources.
        /// </summary>
        public static void Cleanup()
        {
            ClearMain();
        }
    }
}

        public static void Save(AppSettings settings, String fileName)
        {
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(AppSettings));
            using (FileStream fs = new FileStream(fileName, FileMode.OpenOrCreate))
            using (StreamWriter streamWriter = new StreamWriter(fs))
            {
                xmlSerializer.Serialize(streamWriter, settings);
            }
        }

        public static AppSettings Load(String fileName)
        {
            try
            {
                XmlSerializer xmlSerializer = new XmlSerializer(typeof(AppSettings));
                using (FileStream fs = new FileStream(fileName, FileMode.Open))
                using (StreamReader streamReader = new StreamReader(fs))
                {
                    return (AppSettings)xmlSerializer.Deserialize(streamReader);
                }
            }
            catch
            {
                if (File.Exists(fileName))
                    File.Delete(fileName);
            }
            return null;
        }

using (FileStream fs = new FileStream(fileName, FileMode.Create))