Update dependencies (#21)

* Update dependencies
* Minor nit fixes
* Fix UTs

Daybreak.Tests/Services/ApplicationConfigurationOptionsManagerTests.cs

@@ -0,0 +1,63 @@
+using Daybreak.Configuration;
+using Daybreak.Services.Configuration;
+using Daybreak.Services.Options;
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using System;
+
+namespace Daybreak.Tests.Services
+{
+    [TestClass]
+    public class ApplicationConfigurationOptionsManagerTests
+    {
+        private ApplicationConfigurationOptionsManager applicationConfigurationOptionsManager;
+
+        [TestInitialize]
+        public void TestInitialize()
+        {
+            var configurationManagerMock = new Mock<IConfigurationManager>();
+            configurationManagerMock
+                .Setup(u => u.GetConfiguration())
+                .Returns(new ApplicationConfiguration());
+
+            this.applicationConfigurationOptionsManager = new ApplicationConfigurationOptionsManager(configurationManagerMock.Object);
+        }
+
+        [TestMethod]
+        public void GetApplicationConfiguration_ReturnsObject()
+        {
+            var config = this.applicationConfigurationOptionsManager.GetOptions<ApplicationConfiguration>();
+
+            config.Should().NotBeNull();
+        }
+
+        [TestMethod]
+        public void GetOtherOptions_ThrowsInvalidOperationException()
+        {
+            var action = new Action(() =>
+            {
+                this.applicationConfigurationOptionsManager.GetOptions<object>();
+            });
+
+            action.Should().Throw<InvalidOperationException>();
+        }
+
+        [TestMethod]
+        public void UpdateOptions_OnApplicationConfiguration_Succeeds()
+        {
+            this.applicationConfigurationOptionsManager.UpdateOptions(new ApplicationConfiguration());
+        }
+
+        [TestMethod]
+        public void UpdateOptions_OnOthers_ThrowsInvalidOperationException()
+        {
+            var action = new Action(() =>
+            {
+                this.applicationConfigurationOptionsManager.UpdateOptions(new object());
+            });
+
+            action.Should().Throw<InvalidOperationException>();
+        }
+    }
+}

Daybreak.Tests/Services/JsonLoggerProviderTests.cs

@@ -3,10 +3,9 @@ using FluentAssertions;
 using LiteDB;
 using Microsoft.Extensions.Logging;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
 using System.IO;
 using System.Linq;
-using WpfExtended.Logging;
+using System.Logging;
 
 namespace Daybreak.Tests.Services
 {

Daybreak/Configuration/ProjectConfiguration.cs

@@ -1,5 +1,4 @@
 using Daybreak.Services.ApplicationLauncher;
-using Daybreak.Services.ApplicationLifetime;
 using Daybreak.Services.Bloogum;
 using Daybreak.Services.BuildTemplates;
 using Daybreak.Services.Configuration;
@@ -8,7 +7,6 @@ using Daybreak.Services.IconRetrieve;
 using Daybreak.Services.Logging;
 using Daybreak.Services.Mutex;
 using Daybreak.Services.Privilege;
-using Daybreak.Services.Runtime;
 using Daybreak.Services.Screens;
 using Daybreak.Services.Screenshots;
 using Daybreak.Services.Shortcuts;
@@ -20,9 +18,9 @@ using Microsoft.Extensions.Logging;
 using Slim;
 using System.Extensions;
 using System.Net.Http;
-using System.Windows.Extensions.Http;
 using LiteDB;
-using System.Windows.Extensions;
+using Daybreak.Services.Options;
+using System.Http;
 
 namespace Daybreak.Configuration
 {
@@ -41,17 +39,16 @@ namespace Daybreak.Configuration
                     var handler = new LoggingHttpMessageHandler(logger) { InnerHandler = new HttpClientHandler() };
                     return handler;
                 }));
+            serviceManager.RegisterOptionsManager<ApplicationConfigurationOptionsManager>();
         }
 
         public static void RegisterServices(IServiceProducer serviceProducer)
         {
             serviceProducer.ThrowIfNull(nameof(serviceProducer));
 
-            serviceProducer.RegisterSingleton<ApplicationLifetimeManager>();
             serviceProducer.RegisterSingleton<ViewManager>();
             serviceProducer.RegisterSingleton<IConfigurationManager, ConfigurationManager>();
             serviceProducer.RegisterSingleton<ILiteDatabase, LiteDatabase>(sp => new LiteDatabase("Daybreak.db"));
-            serviceProducer.RegisterSingleton<IRuntimeStore, RuntimeStore>();
             serviceProducer.RegisterSingleton<IMutexHandler, MutexHandler>();
             serviceProducer.RegisterSingleton<IShortcutManager, ShortcutManager>();
             serviceProducer.RegisterScoped<ICredentialManager, CredentialManager>();
@@ -65,14 +62,7 @@ namespace Daybreak.Configuration
             serviceProducer.RegisterScoped<IScreenManager, ScreenManager>();
             serviceProducer.RegisterLogWriter<ILogsManager, JsonLogsManager>();
         }
-        public static void RegisterLifetimeServices(IApplicationLifetimeProducer applicationLifetimeProducer)
-        {
-            applicationLifetimeProducer.ThrowIfNull(nameof(applicationLifetimeProducer));
 
-            applicationLifetimeProducer.RegisterService<IScreenshotProvider>();
-            applicationLifetimeProducer.RegisterService<IApplicationUpdater>();
-            applicationLifetimeProducer.RegisterService<IShortcutManager>();
-        }
         public static void RegisterViews(IViewProducer viewProducer)
         {
             viewProducer.ThrowIfNull(nameof(viewProducer));

Daybreak/Controls/ChromiumBrowserWrapper.xaml.cs

@@ -1,11 +1,12 @@
-using Daybreak.Models.Browser;
+using Daybreak.Configuration;
+using Daybreak.Models.Browser;
 using Daybreak.Models.Builds;
 using Daybreak.Services.BuildTemplates;
-using Daybreak.Services.Configuration;
 using Daybreak.Utils;
 using Microsoft.Extensions.Logging;
 using Microsoft.Web.WebView2.Core;
 using System;
+using System.Configuration;
 using System.Diagnostics;
 using System.Extensions;
 using System.Threading.Tasks;
@@ -31,7 +32,7 @@ namespace Daybreak.Controls
         public event EventHandler MaximizeClicked;
         public event EventHandler<Build> BuildDecoded;
 
-        private IConfigurationManager configurationManager;
+        private ILiveOptions<ApplicationConfiguration> liveOptions;
         private ILogger<ChromiumBrowserWrapper> logger;
         private IBuildTemplateManager buildTemplateManager;
         private CoreWebView2Environment coreWebView2Environment;
@@ -80,11 +81,11 @@ namespace Daybreak.Controls
         }
 
         public async void InitializeBrowser(
-            IConfigurationManager configurationManager,
+            ILiveOptions<ApplicationConfiguration> liveOptions,
             IBuildTemplateManager buildTemplateManager,
             ILogger<ChromiumBrowserWrapper> logger)
         {
-            this.configurationManager = configurationManager;
+            this.liveOptions = liveOptions;
             this.buildTemplateManager = buildTemplateManager;
             this.logger = logger;
             this.InitializeEnvironment();
@@ -98,7 +99,7 @@ namespace Daybreak.Controls
 
         private void InitializeEnvironment()
         {
-            if (this.configurationManager.GetConfiguration().BrowsersEnabled is false)
+            if (this.liveOptions.Value.BrowsersEnabled is false)
             {
                 this.BrowserSupported = false;
                 return;
@@ -122,8 +123,8 @@ namespace Daybreak.Controls
             {
                 this.WebBrowser.IsEnabled = true;
                 await this.WebBrowser.EnsureCoreWebView2Async(this.coreWebView2Environment);
-                this.AddressBarReadonly = this.configurationManager.GetConfiguration().AddressBarReadonly;
-                this.CanDownloadBuild = this.configurationManager.GetConfiguration().ExperimentalFeatures.DynamicBuildLoading;
+                this.AddressBarReadonly = this.liveOptions.Value.AddressBarReadonly;
+                this.CanDownloadBuild = this.liveOptions.Value.ExperimentalFeatures.DynamicBuildLoading;
                 this.WebBrowser.CoreWebView2.NewWindowRequested += (browser, args) => args.Handled = true;
                 this.WebBrowser.NavigationStarting += (browser, args) =>
                 {
@@ -196,6 +197,7 @@ namespace Daybreak.Controls
             {
                 this.logger.LogError(e, $"Exception encountered when deserializing {nameof(BrowserPayload)}");
             }
+
             if (payload?.Key == BrowserPayload.PayloadKeys.ContextMenu)
             {
                 var contextMenuPayload = args.WebMessageAsJson.Deserialize<BrowserPayload<OnContextMenuPayload>>();

Daybreak/Controls/Templates/BuildTemplate.xaml.cs

@@ -1,11 +1,12 @@
-using Daybreak.Models.Builds;
+using Daybreak.Configuration;
+using Daybreak.Models.Builds;
 using Daybreak.Services.BuildTemplates;
-using Daybreak.Services.Configuration;
 using Daybreak.Services.IconRetrieve;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Configuration;
 using System.Extensions;
 using System.Linq;
 using System.Windows;
@@ -59,16 +60,16 @@ namespace Daybreak.Controls
         {
             this.InitializeComponent();
             this.InitializeProperties();
-            this.DataContextChanged += BuildTemplate_DataContextChanged;
+            this.DataContextChanged += this.BuildTemplate_DataContextChanged;
         }
 
         public void InitializeTemplate(
             IIconRetriever iconRetriever,
-            IConfigurationManager configurationManager,
+            ILiveOptions<ApplicationConfiguration> liveOptions,
             IBuildTemplateManager buildTemplateManager,
             ILogger<ChromiumBrowserWrapper> logger)
         {
-            this.SkillBrowser.InitializeBrowser(configurationManager, buildTemplateManager, logger);
+            this.SkillBrowser.InitializeBrowser(liveOptions, buildTemplateManager, logger);
             this.SkillTemplate0.InitializeSkillTemplate(iconRetriever);
             this.SkillTemplate1.InitializeSkillTemplate(iconRetriever);
             this.SkillTemplate2.InitializeSkillTemplate(iconRetriever);
@@ -97,6 +98,7 @@ namespace Daybreak.Controls
                 {
                     this.loadedBuild.Build.Secondary = this.SecondaryProfession;
                 }
+
                 this.LoadSkills();
                 this.LoadAttributes();
                 if (this.suppressBuildChanged is false)
@@ -192,55 +194,62 @@ namespace Daybreak.Controls
         private void LoadSkills()
         {
             var possibleSkills = Skill.Skills
-                .Where(s => s.Profession == PrimaryProfession || s.Profession == SecondaryProfession || s.Profession == Profession.None)
+                .Where(s => s.Profession == this.PrimaryProfession || s.Profession == this.SecondaryProfession || s.Profession == Profession.None)
                 .Where(s => s != Skill.NoSkill)
                 .OrderBy(s => s.Name);
             this.AvailableSkills.ClearAnd().AddRange(possibleSkills);
 
-            if (this.Skill0.Profession != PrimaryProfession &&
-                this.Skill0.Profession != SecondaryProfession &&
+            if (this.Skill0.Profession != this.PrimaryProfession &&
+                this.Skill0.Profession != this.SecondaryProfession &&
                 this.Skill0.Profession != Profession.None)
             {
                 this.Skill0 = Skill.NoSkill;
             }
-            if (this.Skill1.Profession != PrimaryProfession &&
-                this.Skill1.Profession != SecondaryProfession &&
+
+            if (this.Skill1.Profession != this.PrimaryProfession &&
+                this.Skill1.Profession != this.SecondaryProfession &&
                 this.Skill1.Profession != Profession.None)
             {
                 this.Skill1 = Skill.NoSkill;
             }
-            if (this.Skill2.Profession != PrimaryProfession &&
-                this.Skill2.Profession != SecondaryProfession &&
+
+            if (this.Skill2.Profession != this.PrimaryProfession &&
+                this.Skill2.Profession != this.SecondaryProfession &&
                 this.Skill2.Profession != Profession.None)
             {
                 this.Skill2 = Skill.NoSkill;
             }
-            if (this.Skill3.Profession != PrimaryProfession &&
-                this.Skill3.Profession != SecondaryProfession &&
+
+            if (this.Skill3.Profession != this.PrimaryProfession &&
+                this.Skill3.Profession != this.SecondaryProfession &&
                 this.Skill3.Profession != Profession.None)
             {
                 this.Skill3 = Skill.NoSkill;
             }
-            if (this.Skill4.Profession != PrimaryProfession &&
-                this.Skill4.Profession != SecondaryProfession &&
+
+            if (this.Skill4.Profession != this.PrimaryProfession &&
+                this.Skill4.Profession != this.SecondaryProfession &&
                 this.Skill4.Profession != Profession.None)
             {
                 this.Skill4 = Skill.NoSkill;
             }
-            if (this.Skill5.Profession != PrimaryProfession &&
-                this.Skill5.Profession != SecondaryProfession &&
+
+            if (this.Skill5.Profession != this.PrimaryProfession &&
+                this.Skill5.Profession != this.SecondaryProfession &&
                 this.Skill5.Profession != Profession.None)
             {
                 this.Skill5 = Skill.NoSkill;
             }
-            if (this.Skill6.Profession != PrimaryProfession &&
-                this.Skill6.Profession != SecondaryProfession &&
+
+            if (this.Skill6.Profession != this.PrimaryProfession &&
+                this.Skill6.Profession != this.SecondaryProfession &&
                 this.Skill6.Profession != Profession.None)
             {
                 this.Skill6 = Skill.NoSkill;
             }
-            if (this.Skill7.Profession != PrimaryProfession &&
-                this.Skill7.Profession != SecondaryProfession &&
+
+            if (this.Skill7.Profession != this.PrimaryProfession &&
+                this.Skill7.Profession != this.SecondaryProfession &&
                 this.Skill7.Profession != Profession.None)
             {
                 this.Skill7 = Skill.NoSkill;
@@ -307,7 +316,7 @@ namespace Daybreak.Controls
                 return;
             }
 
-            this.BrowseToInfo(PrimaryProfession.Name);
+            this.BrowseToInfo(this.PrimaryProfession.Name);
             if (e is RoutedEventArgs routedEventArgs)
             {
                 routedEventArgs.Handled = true;
@@ -350,6 +359,7 @@ namespace Daybreak.Controls
             {
                 this.BrowseToInfo(skill.Name);
             }
+
             e.Handled = true;
         }
 
@@ -368,14 +378,14 @@ namespace Daybreak.Controls
 
             this.selectingSkillTemplate.DataContext = sender.As<ListView>().SelectedItem;
             this.HideSkillListView();
-            this.loadedBuild.Build.Skills[0] = Skill0;
-            this.loadedBuild.Build.Skills[1] = Skill1;
-            this.loadedBuild.Build.Skills[2] = Skill2;
-            this.loadedBuild.Build.Skills[3] = Skill3;
-            this.loadedBuild.Build.Skills[4] = Skill4;
-            this.loadedBuild.Build.Skills[5] = Skill5;
-            this.loadedBuild.Build.Skills[6] = Skill6;
-            this.loadedBuild.Build.Skills[7] = Skill7;
+            this.loadedBuild.Build.Skills[0] = this.Skill0;
+            this.loadedBuild.Build.Skills[1] = this.Skill1;
+            this.loadedBuild.Build.Skills[2] = this.Skill2;
+            this.loadedBuild.Build.Skills[3] = this.Skill3;
+            this.loadedBuild.Build.Skills[4] = this.Skill4;
+            this.loadedBuild.Build.Skills[5] = this.Skill5;
+            this.loadedBuild.Build.Skills[6] = this.Skill6;
+            this.loadedBuild.Build.Skills[7] = this.Skill7;
         }
 
         private void ListView_NavigateWithMouseWheel(object sender, System.Windows.Input.MouseWheelEventArgs e)

Daybreak/Daybreak.csproj

@@ -10,7 +10,7 @@
     <LangVersion>preview</LangVersion>
     <ApplicationIcon>Daybreak.ico</ApplicationIcon>
     <IncludePackageReferencesDuringMarkupCompilation>true</IncludePackageReferencesDuringMarkupCompilation>
-    <Version>0.9.2.2</Version>
+    <Version>0.9.2.5</Version>
   </PropertyGroup>
 
   <ItemGroup>
@@ -23,11 +23,12 @@
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     <PackageReference Include="NReco.Logging.File" Version="1.1.1" />
     <PackageReference Include="securifybv.ShellLink" Version="0.1.0" />
-    <PackageReference Include="Slim" Version="1.4.3" />
+    <PackageReference Include="Slim" Version="1.5.1" />
     <PackageReference Include="System.Windows.Interactivity.WPF" Version="2.0.20525" />
     <PackageReference Include="SystemExtensions.NetStandard" Version="1.3.0" />
+    <PackageReference Include="SystemExtensions.NetStandard.DependencyInjection" Version="1.1.0" />
     <PackageReference Include="WCL" Version="1.0.2" />
-    <PackageReference Include="WpfExtended" Version="0.4.2" />
+    <PackageReference Include="WpfExtended" Version="0.6.0" />
     <PackageReference Include="WpfExtended.SourceGeneration" Version="0.1.1" />
     <PackageReference Include="WpfScreenHelper" Version="1.0.0" />
   </ItemGroup>

Daybreak/Launch/Launcher.cs

@@ -1,6 +1,5 @@
 using Daybreak.Configuration;
 using Daybreak.Exceptions;
-using Daybreak.Services.ApplicationLifetime;
 using Daybreak.Services.ViewManagement;
 using Microsoft.Extensions.Logging;
 using Slim;
@@ -33,7 +32,6 @@ namespace Daybreak.Launch
         {
             ProjectConfiguration.RegisterServices(this.ServiceManager);
             ServiceManager.BuildSingletons();
-            ProjectConfiguration.RegisterLifetimeServices(this.ServiceManager.GetService<IApplicationLifetimeManager>());
             ProjectConfiguration.RegisterViews(this.ServiceManager.GetService<IViewManager>());
         }
         protected override bool HandleException(Exception e)
@@ -86,13 +84,11 @@ namespace Daybreak.Launch
         }
         protected override void ApplicationStarting()
         {
-            this.ServiceManager.GetService<IApplicationLifetimeManager>().OnStartup();
             this.logger = this.ServiceManager.GetService<ILogger<Launcher>>();
             this.RegisterViewContainer();
         }
         protected override void ApplicationClosing()
         {
-            this.ServiceManager.GetService<IApplicationLifetimeManager>().OnClosing();
         }
 
         private void RegisterViewContainer()

Daybreak/Launch/MainWindow.xaml.cs

@@ -1,13 +1,13 @@
-using Daybreak.Services.Bloogum;
-using Daybreak.Services.Configuration;
+using Daybreak.Configuration;
+using Daybreak.Services.Bloogum;
 using Daybreak.Services.Privilege;
-using Daybreak.Services.Runtime;
 using Daybreak.Services.Screenshots;
 using Daybreak.Services.Updater;
 using Daybreak.Services.ViewManagement;
 using Daybreak.Views;
 using Pepa.Wpf.Utilities;
 using System;
+using System.Configuration;
 using System.Diagnostics;
 using System.Extensions;
 using System.Threading;
@@ -32,11 +32,9 @@ namespace Daybreak.Launch
         private readonly IBloogumClient bloogumClient;
         private readonly IApplicationUpdater applicationUpdater;
         private readonly IPrivilegeManager privilegeManager;
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveOptions<ApplicationConfiguration> liveOptions;
         private readonly CancellationTokenSource cancellationToken = new();
 
-        private bool canCheckUpdate = false;
-
         [GenerateDependencyProperty]
         private string creditText;
         [GenerateDependencyProperty]
@@ -50,26 +48,19 @@ namespace Daybreak.Launch
             IBloogumClient bloogumClient,
             IApplicationUpdater applicationUpdater,
             IPrivilegeManager privilegeManager,
-            IConfigurationManager configurationManager)
+            ILiveOptions<ApplicationConfiguration> liveOptions)
         {
             this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
             this.screenshotProvider = screenshotProvider.ThrowIfNull(nameof(screenshotProvider));
             this.bloogumClient = bloogumClient.ThrowIfNull(nameof(bloogumClient));
             this.applicationUpdater = applicationUpdater.ThrowIfNull(nameof(applicationUpdater));
             this.privilegeManager = privilegeManager.ThrowIfNull(nameof(privilegeManager));
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
             this.InitializeComponent();
-            this.LoadConfiguration();
-            this.configurationManager.ConfigurationChanged += (s, e) => this.LoadConfiguration();
             this.CurrentVersionText = this.applicationUpdater.CurrentVersion.ToString();
             this.IsRunningAsAdmin = this.privilegeManager.AdminPrivileges;
         }
 
-        private void LoadConfiguration()
-        {
-            var configuration = this.configurationManager.GetConfiguration();
-            this.canCheckUpdate = configuration.AutoCheckUpdate;
-        }
 
         private void Window_Loaded(object sender, RoutedEventArgs e)
         {
@@ -178,7 +169,7 @@ namespace Daybreak.Launch
 
         private async void CheckForUpdates()
         {
-            var updateAvailable = this.canCheckUpdate is true && await this.applicationUpdater.UpdateAvailable().ConfigureAwait(true);
+            var updateAvailable = this.liveOptions.Value.AutoCheckUpdate is true && await this.applicationUpdater.UpdateAvailable().ConfigureAwait(true);
             if (updateAvailable)
             {
                 this.viewManager.ShowView<AskUpdateView>();

Daybreak/Services/ApplicationLauncher/ApplicationLauncher.cs

@@ -1,5 +1,5 @@
-using Daybreak.Exceptions;
-using Daybreak.Services.Configuration;
+using Daybreak.Configuration;
+using Daybreak.Exceptions;
 using Daybreak.Services.Credentials;
 using Daybreak.Services.Mutex;
 using Daybreak.Services.Privilege;
@@ -9,6 +9,7 @@ using Microsoft.Win32;
 using Pepa.Wpf.Utilities;
 using System;
 using System.Collections.Generic;
+using System.Configuration;
 using System.Diagnostics;
 using System.Extensions;
 using System.IO;
@@ -29,7 +30,7 @@ namespace Daybreak.Services.ApplicationLauncher
         private const string ProcessName = "gw";
         private const string ArenaNetMutex = "AN-Mute";
 
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveOptions<ApplicationConfiguration> liveOptions;
         private readonly ICredentialManager credentialManager;
         private readonly IMutexHandler mutexHandler;
         private readonly ILogger<ApplicationLauncher> logger;
@@ -40,7 +41,7 @@ namespace Daybreak.Services.ApplicationLauncher
         public bool IsToolboxRunning => GuildwarsToolboxProcessDetected();
 
         public ApplicationLauncher(
-            IConfigurationManager configurationManager,
+            ILiveOptions<ApplicationConfiguration> liveOptions,
             ICredentialManager credentialManager,
             IMutexHandler mutexHandler,
             ILogger<ApplicationLauncher> logger,
@@ -49,13 +50,13 @@ namespace Daybreak.Services.ApplicationLauncher
             this.logger = logger.ThrowIfNull(nameof(logger));
             this.mutexHandler = mutexHandler.ThrowIfNull(nameof(mutexHandler));
             this.credentialManager = credentialManager.ThrowIfNull(nameof(credentialManager));
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
             this.privilegeManager = privilegeManager.ThrowIfNull(nameof(privilegeManager));
         }
 
         public async Task<bool> LaunchGuildwars()
         {
-            var configuration = this.configurationManager.GetConfiguration();
+            var configuration = this.liveOptions.Value;
             var auth = await this.credentialManager.GetDefaultCredentials().ConfigureAwait(false);
             return await auth.Switch(
                 onSome: async (credentials) =>
@@ -68,10 +69,10 @@ namespace Daybreak.Services.ApplicationLauncher
                             return false;
                         }
 
-                        ClearGwLocks();
+                        this.ClearGwLocks();
                     }
 
-                    return await LaunchGuildwarsProcess(credentials.Username, credentials.Password, credentials.CharacterName);
+                    return await this.LaunchGuildwarsProcess(credentials.Username, credentials.Password, credentials.CharacterName);
                 },
                 onNone: () =>
                 {
@@ -84,7 +85,7 @@ namespace Daybreak.Services.ApplicationLauncher
         {
             return Task.Run(() =>
             {
-                var configuration = this.configurationManager.GetConfiguration();
+                var configuration = this.liveOptions.Value;
                 var executable = configuration.ToolboxPath;
                 if (File.Exists(executable) is false)
                 {
@@ -102,7 +103,7 @@ namespace Daybreak.Services.ApplicationLauncher
         {
             return Task.Run(() =>
             {
-                var configuration = this.configurationManager.GetConfiguration();
+                var configuration = this.liveOptions.Value;
                 var executable = configuration.TexmodPath;
                 if (File.Exists(executable) is false)
                 {
@@ -145,7 +146,7 @@ namespace Daybreak.Services.ApplicationLauncher
 
         private async Task<bool> LaunchGuildwarsProcess(string email, Models.SecureString password, string character)
         {
-            var executable = this.configurationManager.GetConfiguration().GuildwarsPaths.Where(path => path.Default).FirstOrDefault();
+            var executable = this.liveOptions.Value.GuildwarsPaths.Where(path => path.Default).FirstOrDefault();
             if (executable is null)
             {
                 throw new ExecutableNotFoundException($"No executable selected");
@@ -169,7 +170,7 @@ namespace Daybreak.Services.ApplicationLauncher
                 args.Add(character);
             }
 
-            var identity = this.configurationManager.GetConfiguration().ExperimentalFeatures.LaunchGuildwarsAsCurrentUser ?
+            var identity = this.liveOptions.Value.ExperimentalFeatures.LaunchGuildwarsAsCurrentUser ?
                 System.Security.Principal.WindowsIdentity.GetCurrent().Name :
                 System.Security.Principal.WindowsIdentity.GetAnonymous().Name;
             this.logger.LogInformation($"Launching guildwars as [{identity}] identity");
@@ -221,11 +222,11 @@ namespace Daybreak.Services.ApplicationLauncher
 
         private bool GuildwarsProcessDetected()
         {
-            if (this.configurationManager.GetConfiguration().ExperimentalFeatures.MultiLaunchSupport is true)
+            if (this.liveOptions.Value.ExperimentalFeatures.MultiLaunchSupport is true)
             {
                 try
                 {
-                    var path = this.configurationManager.GetConfiguration().GuildwarsPaths.Where(path => path.Default).FirstOrDefault();
+                    var path = this.liveOptions.Value.GuildwarsPaths.Where(path => path.Default).FirstOrDefault();
                     if (path is null)
                     {
                         return false;
@@ -253,7 +254,7 @@ namespace Daybreak.Services.ApplicationLauncher
 
         private void SetRegistryGuildwarsPath()
         {
-            var path = this.configurationManager.GetConfiguration().GuildwarsPaths.Where(path => path.Default).FirstOrDefault();
+            var path = this.liveOptions.Value.GuildwarsPaths.Where(path => path.Default).FirstOrDefault();
             if (path is null)
             {
                 throw new ExecutableNotFoundException("No executable currently selected");

Daybreak/Services/ApplicationLifetime/ApplicationLifetimeManager.cs

@@ -1,43 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Extensions;
-using IServiceProvider = Slim.IServiceProvider;
-
-namespace Daybreak.Services.ApplicationLifetime
-{
-    public sealed class ApplicationLifetimeManager : IApplicationLifetimeManager
-    {
-        private readonly IServiceProvider serviceProvider;
-        private List<Type> RegisteredTypes { get; } = new List<Type>();
-
-        public ApplicationLifetimeManager(IServiceProvider serviceProvider)
-        {
-            serviceProvider.ThrowIfNull(nameof(serviceProvider));
-
-            this.serviceProvider = serviceProvider;
-        }
-
-        public void RegisterService<T>() where T : IApplicationLifetimeService
-        {
-            this.RegisteredTypes.Add(typeof(T));
-        }
-
-        public void OnStartup()
-        {
-            foreach (var serviceType in this.RegisteredTypes)
-            {
-                var service = this.serviceProvider.GetService(serviceType);
-                service.As<IApplicationLifetimeService>().OnStartup();
-            }
-        }
-
-        public void OnClosing()
-        {
-            foreach (var serviceType in this.RegisteredTypes)
-            {
-                var service = this.serviceProvider.GetService(serviceType);
-                service.As<IApplicationLifetimeService>().OnClosing();
-            }
-        }
-    }
-}

Daybreak/Services/ApplicationLifetime/IApplicationLifetimeManager.cs

@@ -1,8 +0,0 @@
-namespace Daybreak.Services.ApplicationLifetime
-{
-    public interface IApplicationLifetimeManager : IApplicationLifetimeProducer
-    {
-        void OnStartup();
-        void OnClosing();
-    }
-}

Daybreak/Services/ApplicationLifetime/IApplicationLifetimeProducer.cs

@@ -1,7 +0,0 @@
-namespace Daybreak.Services.ApplicationLifetime
-{
-    public interface IApplicationLifetimeProducer
-    {
-        void RegisterService<T>() where T : IApplicationLifetimeService;
-    }
-}

Daybreak/Services/ApplicationLifetime/IApplicationLifetimeService.cs

@@ -1,8 +0,0 @@
-namespace Daybreak.Services.ApplicationLifetime
-{
-    public interface IApplicationLifetimeService
-    {
-        void OnStartup();
-        void OnClosing();
-    }
-}

Daybreak/Services/Credentials/CredentialManager.cs

@@ -1,8 +1,9 @@
-using Daybreak.Models;
-using Daybreak.Services.Configuration;
+using Daybreak.Configuration;
+using Daybreak.Models;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
+using System.Configuration;
 using System.Extensions;
 using System.Linq;
 using System.Security.Cryptography;
@@ -15,13 +16,13 @@ namespace Daybreak.Services.Credentials
     {
         private static readonly byte[] Entropy = Convert.FromBase64String("R3VpbGR3YXJz");
         private readonly ILogger<CredentialManager> logger;
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveUpdateableOptions<ApplicationConfiguration> liveOptions;
 
         public CredentialManager(
             ILogger<CredentialManager> logger,
-            IConfigurationManager configurationManager)
+            ILiveUpdateableOptions<ApplicationConfiguration> liveOptions)
         {
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
             this.logger = logger.ThrowIfNull(nameof(logger));
         }
 
@@ -53,7 +54,7 @@ namespace Daybreak.Services.Credentials
             return Task.Run(() =>
             {
                 this.logger.LogInformation("Retrieving credentials");
-                var config = this.configurationManager.GetConfiguration();
+                var config = this.liveOptions.Value;
                 if (config.ProtectedLoginCredentials is null || config.ProtectedLoginCredentials.Count == 0)
                 {
                     this.logger.LogInformation("No credentials found");
@@ -62,9 +63,9 @@ namespace Daybreak.Services.Credentials
 
                 return config
                     .ProtectedLoginCredentials
-                    .Select(UnprotectCredentials)
-                    .Where(CredentialsUnprotected)
-                    .Select(ExtractCredentials)
+                    .Select(this.UnprotectCredentials)
+                    .Where(this.CredentialsUnprotected)
+                    .Select(this.ExtractCredentials)
                     .ToList();
             });
         }
@@ -73,13 +74,12 @@ namespace Daybreak.Services.Credentials
             return Task.Run(() =>
             {
                 this.logger.LogInformation("Storing credentials");
-                var config = this.configurationManager.GetConfiguration();
-                config.ProtectedLoginCredentials = loginCredentials
-                    .Select(ProtectCredentials)
-                    .Where(CredentialsProtected)
-                    .Select(ExtractProtectedCredentials)
+                this.liveOptions.Value.ProtectedLoginCredentials = loginCredentials
+                    .Select(this.ProtectCredentials)
+                    .Where(this.CredentialsProtected)
+                    .Select(this.ExtractProtectedCredentials)
                     .ToList();
-                this.configurationManager.SaveConfiguration(config);
+                this.liveOptions.UpdateOption();
             });   
         }
 

Daybreak/Services/IconRetrieve/IconRetriever.cs

@@ -1,8 +1,9 @@
-using Daybreak.Models.Builds;
-using Daybreak.Services.Configuration;
+using Daybreak.Configuration;
+using Daybreak.Models.Builds;
 using HtmlAgilityPack;
 using Microsoft.Extensions.Logging;
 using System;
+using System.Configuration;
 using System.Extensions;
 using System.Http;
 using System.IO;
@@ -21,16 +22,16 @@ namespace Daybreak.Services.IconRetrieve
 
         private readonly IHttpClient<IconRetriever> httpClient;
         private readonly ILogger<IconRetriever> logger;
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveOptions<ApplicationConfiguration> liveOptions;
 
         public IconRetriever(
             ILogger<IconRetriever> logger,
             IHttpClient<IconRetriever> httpClient,
-            IConfigurationManager configurationManager)
+            ILiveOptions<ApplicationConfiguration> liveOptions)
         {
             this.logger = logger.ThrowIfNull(nameof(logger));
             this.httpClient = httpClient.ThrowIfNull(nameof(httpClient));
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
             this.httpClient.BaseAddress = new Uri(BaseUrl);
             if (Directory.Exists(IconsDirectoryName) is false)
             {
@@ -40,7 +41,7 @@ namespace Daybreak.Services.IconRetrieve
 
         public async Task<Optional<Stream>> GetIcon(Skill skill)
         {
-            if (this.configurationManager.GetConfiguration().KeepLocalIconCache)
+            if (this.liveOptions.Value.KeepLocalIconCache)
             {
                 this.logger.LogInformation($"{nameof(IconRetriever)} configured to look first in cache before downloading icons");
                 var maybeIcon = await this.GetLocalIcon(skill);
@@ -86,10 +87,11 @@ namespace Daybreak.Services.IconRetrieve
             {
                 this.logger.LogInformation("Retrieved latest icon stream");
                 var iconData = await iconResponse.Content.ReadAsByteArrayAsync();
-                if (this.configurationManager.GetConfiguration().KeepLocalIconCache)
+                if (this.liveOptions.Value.KeepLocalIconCache)
                 {
-                    await this.SaveIconLocally(skill, iconData);
+                    await SaveIconLocally(skill, iconData);
                 }
+
                 return new MemoryStream(iconData);
             }
 
@@ -113,7 +115,7 @@ namespace Daybreak.Services.IconRetrieve
             return Optional.None<Stream>();
         }
 
-        private async Task SaveIconLocally(Skill skill, byte[] data)
+        private static async Task SaveIconLocally(Skill skill, byte[] data)
         {
             var curedSkillName = skill.Name
                 .Replace(" ", "_")

Daybreak/Services/KeyboardHook/IKeyboardHookService.cs

@@ -1,6 +1,6 @@
 using Daybreak.Models;
-using Daybreak.Services.ApplicationLifetime;
 using System;
+using System.Windows.Extensions.Services;
 
 namespace Daybreak.Services.KeyboardHook
 {

Daybreak/Services/KeyboardMacros/IMacroService.cs

@@ -1,4 +1,4 @@
-using Daybreak.Services.ApplicationLifetime;
+using System.Windows.Extensions.Services;
 
 namespace Daybreak.Services.KeyboardMacros
 {

Daybreak/Services/KeyboardMacros/MacroService.cs

@@ -1,10 +1,10 @@
-using Daybreak.Models;
-using Daybreak.Services.Configuration;
+using Daybreak.Configuration;
+using Daybreak.Models;
 using Daybreak.Services.KeyboardHook;
-using Microsoft.Extensions.Logging;
 using Pepa.Wpf.Utilities;
 using System;
 using System.Collections.Generic;
+using System.Configuration;
 using System.Extensions;
 using System.Linq;
 using System.Text;
@@ -17,32 +17,23 @@ namespace Daybreak.Services.KeyboardMacros
     {
         private readonly CancellationTokenSource cancellationTokenSource = new();
         private readonly IKeyboardHookService keyboardHookService;
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveOptions<ApplicationConfiguration> liveOptions;
         private readonly HashSet<Keys> KeysDown = new();
 
-        private IEnumerable<KeyMacro> loadedMacros;
-        private bool gameActive, hookEnabled;
+        private bool gameActive;
         private IntPtr gwWindowHwnd;
 
         public MacroService(
             IKeyboardHookService keyboardHookService,
-            IConfigurationManager configurationManager)
+            ILiveOptions<ApplicationConfiguration> liveOptions)
         {
             this.keyboardHookService = keyboardHookService.ThrowIfNull(nameof(keyboardHookService));
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
 
-            this.configurationManager.ConfigurationChanged += (s, e) => this.LoadConfiguration();
-            this.LoadConfiguration();
             this.keyboardHookService.KeyboardPressed += this.KeyboardHookService_KeyboardPressed;
             this.SetupGameActiveChecker();
         }
 
-        private void LoadConfiguration()
-        {
-            this.hookEnabled = this.configurationManager.GetConfiguration().ExperimentalFeatures.CanInterceptKeys;
-            this.loadedMacros = this.configurationManager.GetConfiguration().ExperimentalFeatures.Macros ?? new List<KeyMacro>();
-        }
-
         private void SetupGameActiveChecker()
         {
             TaskExtensions.RunPeriodicAsync(() =>
@@ -62,12 +53,12 @@ namespace Daybreak.Services.KeyboardMacros
             },
             TimeSpan.Zero,
             TimeSpan.FromMilliseconds(33),
-            cancellationTokenSource.Token);
+            this.cancellationTokenSource.Token);
         }
 
         private void KeyboardHookService_KeyboardPressed(object sender, KeyboardHookEventArgs e)
         {
-            if (this.gameActive && this.hookEnabled)
+            if (this.gameActive && this.liveOptions.Value.ExperimentalFeatures.CanInterceptKeys)
             {
                 if (e.KeyboardState == KeyboardState.KeyDown)
                 {
@@ -79,7 +70,7 @@ namespace Daybreak.Services.KeyboardMacros
                     return;
                 }
 
-                e.Handled = this.loadedMacros
+                e.Handled = this.liveOptions.Value.ExperimentalFeatures.Macros
                     .Where(keyMacro => MacroContainsKey(keyMacro, e.KeyboardInput.Key))
                     .Where(this.MacroHit)
                     .Do(this.HandleMacro)

Daybreak/Services/Logging/ILogsManager.cs

@@ -2,14 +2,14 @@
 using System;
 using System.Collections.Generic;
 using System.Linq.Expressions;
-using WpfExtended.Logging;
+using System.Logging;
 
 namespace Daybreak.Services.Logging
 {
     public interface ILogsManager : ILogsWriter
     {
-        IEnumerable<Log> GetLogs(Expression<Func<Log, bool>> filter);
-        IEnumerable<Log> GetLogs();
+        IEnumerable<Models.Log> GetLogs(Expression<Func<Models.Log, bool>> filter);
+        IEnumerable<Models.Log> GetLogs();
         int DeleteLogs();
     }
 }

Daybreak/Services/Logging/JsonLogsManager.cs

@@ -3,7 +3,7 @@ using System;
 using System.Collections.Generic;
 using System.Extensions;
 using System.Linq.Expressions;
-using WpfExtended.Models;
+using System.Logging;
 
 namespace Daybreak.Services.Logging
 {

Daybreak/Services/Options/ApplicationConfigurationOptionsManager.cs

@@ -0,0 +1,39 @@
+using Daybreak.Configuration;
+using Daybreak.Services.Configuration;
+using System;
+using System.Configuration;
+using System.Extensions;
+
+namespace Daybreak.Services.Options
+{
+    public sealed class ApplicationConfigurationOptionsManager : IOptionsManager
+    {
+        private readonly IConfigurationManager configurationManager;
+
+        public ApplicationConfigurationOptionsManager(IConfigurationManager configurationManager)
+        {
+            this.configurationManager = configurationManager;
+        }
+
+        public T GetOptions<T>() where T : class
+        {
+            if (typeof(T) == typeof(ApplicationConfiguration))
+            {
+                return this.configurationManager.GetConfiguration().Cast<T>();
+            }
+
+            throw new InvalidOperationException($"{nameof(ApplicationConfigurationOptionsManager)} cannot return options of type {typeof(T).Name}");
+        }
+
+        public void UpdateOptions<T>(T value) where T : class
+        {
+            if (typeof(T) == typeof(ApplicationConfiguration))
+            {
+                this.configurationManager.SaveConfiguration(value.Cast<ApplicationConfiguration>());
+                return;
+            }
+
+            throw new InvalidOperationException($"{nameof(ApplicationConfigurationOptionsManager)} cannot save options of type {typeof(T).Name}");
+        }
+    }
+}

Daybreak/Services/Runtime/IRuntimeStore.cs

@@ -1,9 +0,0 @@
-namespace Daybreak.Services.Runtime
-{
-    public interface IRuntimeStore
-    {
-        void StoreValue<T>(string name, T value);
-        bool TryGetValue<T>(string name, out T value);
-        T GetValue<T>(string name);
-    }
-}

Daybreak/Services/Runtime/RuntimeStore.cs

@@ -1,36 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Extensions;
-
-namespace Daybreak.Services.Runtime
-{
-    public sealed class RuntimeStore : IRuntimeStore
-    {
-        private Dictionary<string, object> InnerStore { get; } = new Dictionary<string, object>();
-
-        public T GetValue<T>(string name)
-        {
-            if(this.InnerStore.TryGetValue(name, out var value))
-            {
-                return value.Cast<T>();
-            }
-
-            throw new InvalidOperationException($"Could not find any value stored with name {name}");
-        }
-        public void StoreValue<T>(string name, T value)
-        {
-            this.InnerStore[name] = value;
-        }
-        public bool TryGetValue<T>(string name, out T value)
-        {
-            if (this.InnerStore.TryGetValue(name, out var valueObj))
-            {
-                value = valueObj.Cast<T>();
-                return true;
-            }
-
-            value = default;
-            return false;
-        }
-    }
-}

Daybreak/Services/Screenshots/IScreenshotProvider.cs

@@ -1,5 +1,5 @@
-using Daybreak.Services.ApplicationLifetime;
-using System.Extensions;
+using System.Extensions;
+using System.Windows.Extensions.Services;
 using System.Windows.Media;
 
 namespace Daybreak.Services.Screenshots

Daybreak/Services/Shortcuts/IShortcutManager.cs

@@ -1,4 +1,4 @@
-using Daybreak.Services.ApplicationLifetime;
+using System.Windows.Extensions.Services;
 
 namespace Daybreak.Services.Shortcuts
 {

Daybreak/Services/Shortcuts/ShortcutManager.cs

@@ -1,16 +1,20 @@
-using Daybreak.Services.Configuration;
+using Daybreak.Configuration;
+using Daybreak.Services.Configuration;
 using ShellLink;
+using System.Configuration;
 using System.Diagnostics;
 using System.Extensions;
 using System.IO;
 
 namespace Daybreak.Services.Shortcuts
 {
+    //TODO: Fix dependency on IConfigurationManager
     public sealed class ShortcutManager : IShortcutManager
     {
         private const string ShortcutName = "Daybreak.lnk";
 
         private readonly IConfigurationManager configurationManager;
+        private readonly ILiveOptions<ApplicationConfiguration> liveOptions;
 
         public bool ShortcutEnabled {
             get => this.ShortcutExists();
@@ -27,16 +31,19 @@ namespace Daybreak.Services.Shortcuts
             }
         }
 
-        public ShortcutManager(IConfigurationManager configurationManager)
+        public ShortcutManager(
+            IConfigurationManager configurationManager,
+            ILiveOptions<ApplicationConfiguration> liveOptions)
         {
             this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
             this.configurationManager.ConfigurationChanged += (_, _) => this.LoadConfiguration();
             this.LoadConfiguration();
         }
 
         private void LoadConfiguration()
         {
-            var shortcutEnabled = this.configurationManager.GetConfiguration().PlaceShortcut;
+            var shortcutEnabled = this.liveOptions.Value.PlaceShortcut;
             if (shortcutEnabled && this.ShortcutEnabled is false)
             {
                 this.ShortcutEnabled = true;
@@ -49,7 +56,7 @@ namespace Daybreak.Services.Shortcuts
 
         private bool ShortcutExists()
         {
-            var shortcutFolder = this.configurationManager.GetConfiguration().ShortcutLocation;
+            var shortcutFolder = this.liveOptions.Value.ShortcutLocation;
             var shortcutPath = $"{shortcutFolder}\\{ShortcutName}";
             if (File.Exists(shortcutPath))
             {
@@ -73,7 +80,7 @@ namespace Daybreak.Services.Shortcuts
                 return;
             }
 
-            var shortcutFolder = this.configurationManager.GetConfiguration().ShortcutLocation;
+            var shortcutFolder = this.liveOptions.Value.ShortcutLocation;
             var shortcutPath = $"{shortcutFolder}\\{ShortcutName}";
             var currentExecutable = Process.GetCurrentProcess()?.MainModule?.FileName;
             var shortcut = Shortcut.CreateShortcut(currentExecutable);
@@ -92,7 +99,7 @@ namespace Daybreak.Services.Shortcuts
                 return;
             }
 
-            var shortcutFolder = this.configurationManager.GetConfiguration().ShortcutLocation;
+            var shortcutFolder = this.liveOptions.Value.ShortcutLocation;
             var shortcutPath = $"{shortcutFolder}\\{ShortcutName}";
             File.Delete(shortcutPath);
         }

Daybreak/Services/Updater/ApplicationUpdater.cs

@@ -1,7 +1,7 @@
-using Daybreak.Exceptions;
+using Daybreak.Configuration;
+using Daybreak.Exceptions;
 using Daybreak.Models;
 using Daybreak.Models.Github;
-using Daybreak.Services.Runtime;
 using Daybreak.Services.ViewManagement;
 using Daybreak.Utils;
 using Daybreak.Views;
@@ -9,6 +9,7 @@ using Microsoft.Extensions.Logging;
 using Microsoft.Win32;
 using System;
 using System.Collections.Generic;
+using System.Configuration;
 using System.Diagnostics;
 using System.Extensions;
 using System.Http;
@@ -26,7 +27,6 @@ namespace Daybreak.Services.Updater
     public sealed class ApplicationUpdater : IApplicationUpdater
     {
         private const string LaunchActionName = "Launch_Daybreak";
-        private const string UpdateDesiredKey = "UpdateDesired";
         private const string ExecutionPolicyKey = "ExecutionPolicy";
         private const string UpdatedKey = "Updating";
         private const string RegistryKey = "Daybreak";
@@ -59,19 +59,19 @@ namespace Daybreak.Services.Updater
         private readonly CancellationTokenSource updateCancellationTokenSource = new();
         private readonly ILogger<ApplicationUpdater> logger;
         private readonly IViewManager viewManager;
-        private readonly IRuntimeStore runtimeStore;
+        private readonly ILiveOptions<ApplicationConfiguration> liveOptions;
         private readonly IHttpClient<ApplicationUpdater> httpClient;
 
         public Version CurrentVersion { get; }
 
         public ApplicationUpdater(
             ILogger<ApplicationUpdater> logger,
-            IRuntimeStore runtimeStore,
+            ILiveOptions<ApplicationConfiguration> liveOptions,
             IViewManager viewManager,
             IHttpClient<ApplicationUpdater> httpClient)
         {
             this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
-            this.runtimeStore = runtimeStore.ThrowIfNull(nameof(runtimeStore));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
             this.logger = logger.ThrowIfNull(nameof(logger));
             this.httpClient = httpClient.ThrowIfNull(nameof(httpClient));
             this.httpClient.DefaultRequestHeaders.Add("user-agent", "Daybreak Client");
@@ -176,7 +176,7 @@ namespace Daybreak.Services.Updater
         {
             System.Extensions.TaskExtensions.RunPeriodicAsync(async () =>
             {
-                if (this.runtimeStore.TryGetValue<bool>(UpdateDesiredKey, out var desiringUpdate) && desiringUpdate is false)
+                if (this.liveOptions.Value.AutoCheckUpdate is false)
                 {
                     this.updateCancellationTokenSource.Cancel();
                     return;

Daybreak/Services/Updater/IApplicationUpdater.cs

@@ -1,8 +1,8 @@
 using Daybreak.Models;
 using Daybreak.Models.Versioning;
-using Daybreak.Services.ApplicationLifetime;
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using System.Windows.Extensions.Services;
 
 namespace Daybreak.Services.Updater
 {

Daybreak/Views/AskUpdateView.xaml.cs

@@ -1,8 +1,9 @@
-using Daybreak.Services.Privilege;
-using Daybreak.Services.Runtime;
+using Daybreak.Configuration;
+using Daybreak.Services.Privilege;
 using Daybreak.Services.Updater;
 using Daybreak.Services.ViewManagement;
 using Microsoft.Extensions.Logging;
+using System.Configuration;
 using System.Extensions;
 using System.Linq;
 using System.Windows.Controls;
@@ -14,24 +15,22 @@ namespace Daybreak.Views
     /// </summary>
     public partial class AskUpdateView : UserControl
     {
-        private const string UpdateDesiredKey = "UpdateDesired";
-
         private readonly ILogger<AskUpdateView> logger;
         private readonly IViewManager viewManager;
-        private readonly IRuntimeStore runtimeStore;
+        private readonly ILiveUpdateableOptions<ApplicationConfiguration> liveOptions;
         private readonly IPrivilegeManager privilegeManager;
         private readonly IApplicationUpdater applicationUpdater;
 
         public AskUpdateView(
             ILogger<AskUpdateView> logger,
             IViewManager viewManager,
-            IRuntimeStore runtimeStore,
+            ILiveUpdateableOptions<ApplicationConfiguration> liveOptions,
             IPrivilegeManager privilegeManager,
             IApplicationUpdater applicationUpdater)
         {
             this.logger = logger.ThrowIfNull(nameof(logger));
             this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
-            this.runtimeStore = runtimeStore.ThrowIfNull(nameof(runtimeStore));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
             this.privilegeManager = privilegeManager.ThrowIfNull(nameof(privilegeManager));
             this.applicationUpdater = applicationUpdater.ThrowIfNull(nameof(applicationUpdater));
             this.InitializeComponent();
@@ -51,14 +50,14 @@ namespace Daybreak.Views
         private void NoButton_Clicked(object sender, System.EventArgs e)
         {
             this.logger.LogInformation("User declined update");
-            this.runtimeStore.StoreValue(UpdateDesiredKey, false);
+            this.liveOptions.Value.AutoCheckUpdate = false;
+            this.liveOptions.UpdateOption();
             this.viewManager.ShowView<MainView>();
         }
 
         private async void YesButton_Clicked(object sender, System.EventArgs e)
         {
             this.logger.LogInformation("User accepted update");
-            this.runtimeStore.StoreValue(UpdateDesiredKey, true);
             if (this.CheckIfAdmin() is false)
             {
                 return;

Daybreak/Views/BuildTemplateView.xaml.cs

@@ -1,17 +1,17 @@
-using Daybreak.Controls;
+using Daybreak.Configuration;
+using Daybreak.Controls;
 using Daybreak.Models.Builds;
 using Daybreak.Services.BuildTemplates;
-using Daybreak.Services.Configuration;
 using Daybreak.Services.IconRetrieve;
 using Daybreak.Services.ViewManagement;
 using Microsoft.Extensions.Logging;
 using System;
+using System.Configuration;
 using System.Extensions;
 using System.Linq;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Extensions;
-using System.Windows.Input;
 
 namespace Daybreak.Views
 {
@@ -39,7 +39,7 @@ namespace Daybreak.Views
             IViewManager viewManager,
             IBuildTemplateManager buildTemplateManager,
             IIconRetriever iconRetriever,
-            IConfigurationManager configurationManager,
+            ILiveOptions<ApplicationConfiguration> liveOptions,
             ILogger<ChromiumBrowserWrapper> chromiumLogger,
             ILogger<BuildTemplateView> logger)
         {
@@ -47,7 +47,7 @@ namespace Daybreak.Views
             this.logger = logger.ThrowIfNull(nameof(logger));
             this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
             this.InitializeComponent();
-            this.BuildTemplate.InitializeTemplate(iconRetriever, configurationManager, buildTemplateManager, chromiumLogger);
+            this.BuildTemplate.InitializeTemplate(iconRetriever, liveOptions, buildTemplateManager, chromiumLogger);
             this.DataContextChanged += (sender, contextArgs) =>
             {
                 if (contextArgs.NewValue is BuildEntry)

Daybreak/Views/ExecutablesView.xaml.cs

@@ -1,10 +1,10 @@
-using Daybreak.Controls;
+using Daybreak.Configuration;
+using Daybreak.Controls;
 using Daybreak.Models;
-using Daybreak.Services.Configuration;
 using Daybreak.Services.ViewManagement;
-using Microsoft.Win32;
 using System;
 using System.Collections.ObjectModel;
+using System.Configuration;
 using System.Extensions;
 using System.Linq;
 using System.Windows.Controls;
@@ -17,15 +17,15 @@ namespace Daybreak.Views
     /// </summary>
     public partial class ExecutablesView : UserControl
     {
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveUpdateableOptions<ApplicationConfiguration> liveUpdateableOptions;
         private readonly IViewManager viewManager;
         public ObservableCollection<GuildwarsPath> Paths { get; } = new();
 
         public ExecutablesView(
-            IConfigurationManager configurationManager,
+            ILiveUpdateableOptions<ApplicationConfiguration> liveUpdateableOptions,
             IViewManager viewManager)
         {
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveUpdateableOptions = liveUpdateableOptions.ThrowIfNull(nameof(liveUpdateableOptions));
             this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
             this.InitializeComponent();
             this.GetPaths();
@@ -33,7 +33,7 @@ namespace Daybreak.Views
 
         private void GetPaths()
         {
-            this.Paths.AddRange(this.configurationManager.GetConfiguration().GuildwarsPaths);
+            this.Paths.AddRange(this.liveUpdateableOptions.Value.GuildwarsPaths);
         }
 
         private void BackButton_Clicked(object sender, EventArgs e)
@@ -53,9 +53,8 @@ namespace Daybreak.Views
 
         private void SaveButton_Clicked(object sender, EventArgs e)
         {
-            var config = this.configurationManager.GetConfiguration();
-            config.GuildwarsPaths = this.Paths.ToList();
-            this.configurationManager.SaveConfiguration(config);
+            this.liveUpdateableOptions.Value.GuildwarsPaths = this.Paths.ToList();
+            this.liveUpdateableOptions.UpdateOption();
             this.viewManager.ShowView<SettingsCategoryView>();
         }
 
@@ -81,6 +80,7 @@ namespace Daybreak.Views
             {
                 path.Default = false;
             }
+
             gwPath.Default = true;
             var view = CollectionViewSource.GetDefaultView(this.Paths);
             view.Refresh();

Daybreak/Views/ExperimentalSettingsView.xaml.cs

@@ -1,6 +1,7 @@
-using Daybreak.Services.Configuration;
+using Daybreak.Configuration;
 using Daybreak.Services.ViewManagement;
 using System;
+using System.Configuration;
 using System.Extensions;
 using System.Linq;
 using System.Windows;
@@ -27,7 +28,7 @@ namespace Daybreak.Views
             DependencyPropertyExtensions.Register<ExperimentalSettingsView, bool>(nameof(MacrosEnabled));
 
         private readonly IViewManager viewManager;
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveUpdateableOptions<ApplicationConfiguration> liveUpdateableOptions;
 
         public bool LaunchAsCurrentUser
         {
@@ -57,17 +58,17 @@ namespace Daybreak.Views
 
         public ExperimentalSettingsView(
             IViewManager viewManager,
-            IConfigurationManager configurationManager)
+            ILiveUpdateableOptions<ApplicationConfiguration> liveUpdateableOptions)
         {
             this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveUpdateableOptions = liveUpdateableOptions.ThrowIfNull(nameof(liveUpdateableOptions));
             this.InitializeComponent();
             this.LoadExperimentalSettings();
         }
 
         private void LoadExperimentalSettings()
         {
-            var config = this.configurationManager.GetConfiguration();
+            var config = this.liveUpdateableOptions.Value;
             this.MultiLaunch = config.ExperimentalFeatures.MultiLaunchSupport;
             this.GWToolboxLaunchDelay = config.ExperimentalFeatures.ToolboxAutoLaunchDelay.ToString();
             this.DynamicBuildLoading = config.ExperimentalFeatures.DynamicBuildLoading;
@@ -77,7 +78,7 @@ namespace Daybreak.Views
 
         private void SaveExperimentalSettings()
         {
-            var config = this.configurationManager.GetConfiguration();
+            var config = this.liveUpdateableOptions.Value;
             config.ExperimentalFeatures.MultiLaunchSupport = this.MultiLaunch;
             config.ExperimentalFeatures.DynamicBuildLoading = this.DynamicBuildLoading;
             config.ExperimentalFeatures.LaunchGuildwarsAsCurrentUser = this.LaunchAsCurrentUser;
@@ -87,7 +88,7 @@ namespace Daybreak.Views
                 config.ExperimentalFeatures.ToolboxAutoLaunchDelay = gwToolboxLaunchDelay;
             }
 
-            this.configurationManager.SaveConfiguration(config);
+            this.liveUpdateableOptions.UpdateOption();
         }
 
         private void SaveButton_Clicked(object sender, EventArgs e)

Daybreak/Views/MainView.xaml.cs

@@ -1,13 +1,14 @@
-using Daybreak.Controls;
+using Daybreak.Configuration;
+using Daybreak.Controls;
 using Daybreak.Exceptions;
 using Daybreak.Models.Builds;
 using Daybreak.Services.ApplicationLauncher;
 using Daybreak.Services.BuildTemplates;
-using Daybreak.Services.Configuration;
 using Daybreak.Services.Screens;
 using Daybreak.Services.ViewManagement;
 using Microsoft.Extensions.Logging;
 using System;
+using System.Configuration;
 using System.Extensions;
 using System.Linq;
 using System.Threading;
@@ -27,7 +28,7 @@ namespace Daybreak.Views
     {
         private readonly IApplicationLauncher applicationDetector;
         private readonly IViewManager viewManager;
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveUpdateableOptions<ApplicationConfiguration> liveOptions;
         private readonly IScreenManager screenManager;
         private readonly IBuildTemplateManager buildTemplateManager;
         private readonly ILogger<ChromiumBrowserWrapper> browserLogger;
@@ -58,7 +59,7 @@ namespace Daybreak.Views
         public MainView(
             IApplicationLauncher applicationDetector,
             IViewManager viewManager,
-            IConfigurationManager configurationManager,
+            ILiveUpdateableOptions<ApplicationConfiguration> liveOptions,
             IScreenManager screenManager,
             IBuildTemplateManager buildTemplateManager,
             ILogger<ChromiumBrowserWrapper> browserLogger)
@@ -66,7 +67,7 @@ namespace Daybreak.Views
             this.browserLogger = browserLogger;
             this.buildTemplateManager = buildTemplateManager.ThrowIfNull(nameof(buildTemplateManager));
             this.screenManager = screenManager.ThrowIfNull(nameof(screenManager));
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
             this.applicationDetector = applicationDetector.ThrowIfNull(nameof(applicationDetector));
             this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
             this.InitializeComponent();
@@ -77,13 +78,13 @@ namespace Daybreak.Views
 
         private void InitializeBrowsers()
         {
-            this.LeftWebBrowser.InitializeBrowser(this.configurationManager, this.buildTemplateManager, this.browserLogger);
-            this.RightWebBrowser.InitializeBrowser(this.configurationManager, this.buildTemplateManager, this.browserLogger);
+            this.LeftWebBrowser.InitializeBrowser(this.liveOptions, this.buildTemplateManager, this.browserLogger);
+            this.RightWebBrowser.InitializeBrowser(this.liveOptions, this.buildTemplateManager, this.browserLogger);
         }
 
         private void NavigateToDefaults()
         {
-            var applicationConfiguration = this.configurationManager.GetConfiguration();
+            var applicationConfiguration = this.liveOptions.Value;
             if (applicationConfiguration.BrowsersEnabled)
             {
                 this.LeftBrowserFavoriteAddress = applicationConfiguration.LeftBrowserDefault;
@@ -127,21 +128,22 @@ namespace Daybreak.Views
                     return;
                 }
 
-                if (this.configurationManager.GetConfiguration().SetGuildwarsWindowSizeOnLaunch)
+                if (this.liveOptions.Value.SetGuildwarsWindowSizeOnLaunch)
                 {
-                    var id = this.configurationManager.GetConfiguration().DesiredGuildwarsScreen;
+                    var id = this.liveOptions.Value.DesiredGuildwarsScreen;
                     var desiredScreen = this.screenManager.Screens.Skip(id).FirstOrDefault();
                     if (desiredScreen is null)
                     {
                         throw new InvalidOperationException($"Unable to set guildwars on desired screen. No screen with id {id}");
                     }
+
                     await Task.Delay(1000);
                     this.screenManager.MoveGuildwarsToScreen(desiredScreen);
                 }
 
-                if (this.configurationManager.GetConfiguration().ToolboxAutoLaunch is true)
+                if (this.liveOptions.Value.ToolboxAutoLaunch is true)
                 {
-                    var delay = this.configurationManager.GetConfiguration().ExperimentalFeatures.ToolboxAutoLaunchDelay;
+                    var delay = this.liveOptions.Value.ExperimentalFeatures.ToolboxAutoLaunchDelay;
                     await Task.Delay(delay);
                     await this.applicationDetector.LaunchGuildwarsToolbox();
                 }
@@ -180,23 +182,23 @@ namespace Daybreak.Views
             }
         }
 
-        private void ChromiumBrowserWrapper_BuildDecoded(object sender, Models.Builds.Build e)
+        private void ChromiumBrowserWrapper_BuildDecoded(object sender, Build e)
         {
             this.viewManager.ShowView<BuildTemplateView>(new BuildEntry { Build = e, Name = string.Empty });
         }
 
         private void LeftBrowser_FavoriteUriChanged(object sender, string e)
         {
-            var config = this.configurationManager.GetConfiguration();
+            var config = this.liveOptions.Value;
             config.LeftBrowserDefault = e;
-            this.configurationManager.SaveConfiguration(config);
+            this.liveOptions.UpdateOption();
         }
 
         private void RightBrowser_FavoriteUriChanged(object sender, string e)
         {
-            var config = this.configurationManager.GetConfiguration();
+            var config = this.liveOptions.Value;
             config.RightBrowserDefault = e;
-            this.configurationManager.SaveConfiguration(config);
+            this.liveOptions.UpdateOption();
         }
 
         private void LeftChromiumBrowserWrapper_MaximizeClicked(object sender, EventArgs e)

Daybreak/Views/ScreenChoiceView.xaml.cs

@@ -1,13 +1,13 @@
-using Daybreak.Controls.Templates;
+using Daybreak.Configuration;
+using Daybreak.Controls.Templates;
 using Daybreak.Models;
 using Daybreak.Services.ApplicationLauncher;
-using Daybreak.Services.Configuration;
 using Daybreak.Services.Screens;
 using Daybreak.Services.ViewManagement;
 using System;
+using System.Configuration;
 using System.Extensions;
 using System.Linq;
-using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Extensions;
 using System.Windows.Media;
@@ -23,7 +23,7 @@ namespace Daybreak.Views
     {        
         private readonly IScreenManager screenManager;
         private readonly IViewManager viewManager;
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveOptions<ApplicationConfiguration> liveOptions;
         private readonly IApplicationLauncher applicationLauncher;
         private int selectedId;
 
@@ -33,15 +33,15 @@ namespace Daybreak.Views
         public ScreenChoiceView(
             IViewManager viewManager,
             IScreenManager screenManager,
-            IConfigurationManager configurationManager,
+            ILiveOptions<ApplicationConfiguration> liveOptions,
             IApplicationLauncher applicationLauncher)
         {
             this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
             this.screenManager = screenManager.ThrowIfNull(nameof(screenManager));
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveOptions = liveOptions.ThrowIfNull(nameof(liveOptions));
             this.applicationLauncher = applicationLauncher.ThrowIfNull(nameof(applicationLauncher));
             this.InitializeComponent();
-            this.selectedId = configurationManager.GetConfiguration().DesiredGuildwarsScreen;
+            this.selectedId = this.liveOptions.Value.DesiredGuildwarsScreen;
             this.CanTest = applicationLauncher.IsGuildwarsRunning;
             this.SetupView();
         }
@@ -59,8 +59,8 @@ namespace Daybreak.Views
                     VerticalAlignment = System.Windows.VerticalAlignment.Top,
                     HorizontalAlignment = System.Windows.HorizontalAlignment.Left,
                     Foreground = screen.Id == this.selectedId ? Brushes.LightGreen : Brushes.White
-            };
-                screenTemplate.Clicked += ScreenTemplate_Clicked;
+                };
+                screenTemplate.Clicked += this.ScreenTemplate_Clicked;
                 this.ScreenContainer.Children.Add(screenTemplate);
             }
         }
@@ -86,7 +86,7 @@ namespace Daybreak.Views
 
         private void SaveButton_Clicked(object sender, EventArgs e)
         {
-            this.configurationManager.GetConfiguration().DesiredGuildwarsScreen = this.selectedId;
+            this.liveOptions.Value.DesiredGuildwarsScreen = this.selectedId;
             this.viewManager.ShowView<SettingsCategoryView>();
         }
 

Daybreak/Views/SettingsView.xaml.cs

@@ -1,11 +1,8 @@
-using Daybreak.Services.Configuration;
-using Daybreak.Services.Shortcuts;
+using Daybreak.Configuration;
 using Daybreak.Services.ViewManagement;
-using Microsoft.Win32;
 using System;
+using System.Configuration;
 using System.Extensions;
-using System.Windows;
-using System.Windows.Controls;
 using System.Windows.Extensions;
 using System.Windows.Forms;
 
@@ -18,7 +15,7 @@ namespace Daybreak.Views
     [System.Diagnostics.CodeAnalysis.SuppressMessage("CodeQuality", "IDE0052:Remove unread private members", Justification = "Used by source generators")]
     public partial class SettingsView : System.Windows.Controls.UserControl
     {
-        private readonly IConfigurationManager configurationManager;
+        private readonly ILiveUpdateableOptions<ApplicationConfiguration> liveUpdateableOptions;
         private readonly IViewManager viewManager;
 
         [GenerateDependencyProperty]
@@ -49,10 +46,10 @@ namespace Daybreak.Views
         private bool keepLocalIconCache;
 
         public SettingsView(
-            IConfigurationManager configurationManager,
+            ILiveUpdateableOptions<ApplicationConfiguration> liveUpdateableOptions,
             IViewManager viewManager)
         {
-            this.configurationManager = configurationManager.ThrowIfNull(nameof(configurationManager));
+            this.liveUpdateableOptions = liveUpdateableOptions.ThrowIfNull(nameof(liveUpdateableOptions));
             this.viewManager = viewManager.ThrowIfNull(nameof(viewManager));
             this.InitializeComponent();
             this.LoadSettings();
@@ -60,7 +57,7 @@ namespace Daybreak.Views
 
         private void LoadSettings()
         {
-            var config = this.configurationManager.GetConfiguration();
+            var config = this.liveUpdateableOptions.Value;
             this.AddressBarReadonly = config.AddressBarReadonly;
             this.ToolboxPath = config.ToolboxPath;
             this.LeftBrowserUrl = config.LeftBrowserDefault;
@@ -78,7 +75,7 @@ namespace Daybreak.Views
 
         private void SaveButton_Clicked(object sender, EventArgs e)
         {
-            var currentConfig = this.configurationManager.GetConfiguration();
+            var currentConfig = this.liveUpdateableOptions.Value;
             currentConfig.ToolboxPath = this.ToolboxPath;
             currentConfig.AddressBarReadonly = this.AddressBarReadonly;
             currentConfig.LeftBrowserDefault = this.LeftBrowserUrl;
@@ -92,7 +89,7 @@ namespace Daybreak.Views
             currentConfig.PlaceShortcut = this.ShortcutPlaced;
             currentConfig.AutoCheckUpdate = this.AutoCheckUpdate;
             currentConfig.KeepLocalIconCache = this.KeepLocalIconCache;
-            this.configurationManager.SaveConfiguration(currentConfig);
+            this.liveUpdateableOptions.UpdateOption();
             this.viewManager.ShowView<SettingsCategoryView>();
         }