📑 Rewrite FileHelper in idiomatic C#

database64128 · database64128 · commit ec4ffe340129 · 2023-04-24T14:50:11.000+08:00
diff --git a/YoutubeDl.Wpf/Models/Settings.cs b/YoutubeDl.Wpf/Models/Settings.cs
@@ -78,48 +78,39 @@ public class Settings
     /// Loads settings from Settings.json.
     /// </summary>
     /// <param name="cancellationToken">A token that may be used to cancel the read operation.</param>
-    /// <returns>
-    /// A ValueTuple containing a <see cref="Settings"/> object and an optional error message.
-    /// </returns>
-    public static async Task<(Settings settings, string? errMsg)> LoadSettingsAsync(CancellationToken cancellationToken = default)
+    /// <returns>The <see cref="Settings"/> object.</returns>
+    public static async Task<Settings> LoadAsync(CancellationToken cancellationToken = default)
     {
-        var (settings, errMsg) = await FileHelper.LoadJsonAsync("Settings.json", SettingsJsonSerializerContext.Default.Settings, cancellationToken).ConfigureAwait(false);
-        errMsg ??= settings.UpdateSettings();
-        return (settings, errMsg);
+        var settings = await FileHelper.LoadFromJsonFileAsync("Settings.json", SettingsJsonSerializerContext.Default.Settings, cancellationToken).ConfigureAwait(false);
+        settings.UpdateSettings();
+        return settings;
     }
 
     /// <summary>
     /// Saves settings to Settings.json.
     /// </summary>
-    /// <param name="settings">The <see cref="Settings"/> object to save.</param>
     /// <param name="cancellationToken">A token that may be used to cancel the write operation.</param>
-    /// <returns>
-    /// An optional error message.
-    /// Null if no errors occurred.
-    /// </returns>
-    public static Task<string?> SaveSettingsAsync(Settings settings, CancellationToken cancellationToken = default)
-        => FileHelper.SaveJsonAsync("Settings.json", settings, SettingsJsonSerializerContext.Default.Settings, false, false, cancellationToken);
+    /// <returns>A task that represents the asynchronous write operation.</returns>
+    public Task SaveAsync(CancellationToken cancellationToken = default)
+        => FileHelper.SaveToJsonFileAsync("Settings.json", this, SettingsJsonSerializerContext.Default.Settings, cancellationToken);
 
     /// <summary>
     /// Updates the loaded settings to the latest version.
-    /// If the loaded settings have a higher version number,
-    /// an error message is returned.
     /// </summary>
-    /// <returns>
-    /// An optional error message.
-    /// Null if no errors occurred.
-    /// </returns>
-    public string? UpdateSettings()
+    /// <exception cref="Exception">
+    /// The loaded settings have a higher version number than supported.
+    /// </exception>
+    public void UpdateSettings()
     {
         switch (Version)
         {
             case 0: // nothing to do
                 Version++;
                 goto case 1; // go to the next update path
             case DefaultVersion: // current version
-                return null;
+                return;
             default:
-                return $"Settings version {Version} is newer than supported.";
+                throw new Exception($"Settings version {Version} is newer than supported.");
         }
     }
 }
diff --git a/YoutubeDl.Wpf/Utils/FileHelper.cs b/YoutubeDl.Wpf/Utils/FileHelper.cs
@@ -5,142 +5,83 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace YoutubeDl.Wpf.Utils
+namespace YoutubeDl.Wpf.Utils;
+
+public static class FileHelper
 {
-    public static class FileHelper
-    {
-        public static readonly string configDirectory;
+    private static readonly string s_configDirectory;
 
-        static FileHelper()
-        {
+    static FileHelper()
+    {
 #if PACKAGED
-            // ~/.config on Linux
-            // ~/AppData/Roaming on Windows
-            var appDataPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
-            configDirectory = $"{appDataPath}/youtube-dl-wpf";
+        // ~/.config on Linux
+        // ~/AppData/Roaming on Windows
+        var appDataPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
+        s_configDirectory = Path.Join(appDataPath, "youtube-dl-wpf");
 #else
-            // Use executable directory
-            // Executable directory for single-file deployments in .NET 5: https://docs.microsoft.com/en-us/dotnet/core/deploying/single-file
-            configDirectory = AppContext.BaseDirectory;
+        // Use executable directory
+        // Executable directory for single-file deployments in .NET 5+: https://docs.microsoft.com/en-us/dotnet/core/deploying/single-file
+        s_configDirectory = AppContext.BaseDirectory;
 #endif
-        }
+    }
 
-        /// <summary>
-        /// Gets the fully qualified absolute path
-        /// that the original path points to.
-        /// </summary>
-        /// <param name="path">A relative or absolute path.</param>
-        /// <returns>A fully qualified path.</returns>
-        public static string GetAbsolutePath(string path)
-            => Path.IsPathFullyQualified(path) ? path : $"{configDirectory}/{path}";
+    /// <summary>
+    /// Gets the absolute path pointed to by the specified path.
+    /// </summary>
+    /// <param name="path">A relative or absolute path.</param>
+    /// <returns>A fully qualified path.</returns>
+    public static string GetAbsolutePath(string path) => Path.Combine(s_configDirectory, path);
+
+    /// <summary>
+    /// Loads the specified JSON file and deserializes its content as a <typeparamref name="TValue"/>.
+    /// </summary>
+    /// <typeparam name="TValue">The type to deserialize the JSON value into.</typeparam>
+    /// <param name="path">JSON file path.</param>
+    /// <param name="jsonTypeInfo">Metadata about the type to convert.</param>
+    /// <param name="cancellationToken">A token that may be used to cancel the read operation.</param>
+    /// <returns>A <typeparamref name="TValue"/>.</returns>
+    public static async Task<TValue> LoadFromJsonFileAsync<TValue>(string path, JsonTypeInfo<TValue> jsonTypeInfo, CancellationToken cancellationToken = default) where TValue : class, new()
+    {
+        path = GetAbsolutePath(path);
+        if (!File.Exists(path))
+            return new();
 
-        /// <summary>
-        /// Loads data from a JSON file.
-        /// </summary>
-        /// <typeparam name="T">Data object type.</typeparam>
-        /// <param name="filename">JSON file name.</param>
-        /// <param name="jsonTypeInfo">Metadata about the type to convert.</param>
-        /// <param name="cancellationToken">A token that may be used to cancel the read operation.</param>
-        /// <returns>
-        /// A ValueTuple containing a data object loaded from the JSON file and an error message.
-        /// The error message is null if no errors occurred.
-        /// </returns>
-        public static async Task<(T, string? errMsg)> LoadJsonAsync<T>(string filename, JsonTypeInfo<T> jsonTypeInfo, CancellationToken cancellationToken = default) where T : class, new()
+        var fileStream = new FileStream(path, FileMode.Open);
+        await using (fileStream.ConfigureAwait(false))
         {
-            // extend relative path
-            filename = GetAbsolutePath(filename);
-
-            if (!File.Exists(filename))
-                return (new(), null);
-
-            if (cancellationToken.IsCancellationRequested)
-                return (new(), "The operation was canceled.");
-
-            T? jsonData = null;
-            string? errMsg = null;
-            FileStream? jsonFile = null;
-
-            try
-            {
-                jsonFile = new(filename, FileMode.Open);
-                jsonData = await JsonSerializer.DeserializeAsync<T>(jsonFile, jsonTypeInfo, cancellationToken).ConfigureAwait(false);
-            }
-            catch (Exception ex)
-            {
-                errMsg = $"Error: failed to load {filename}: {ex.Message}";
-            }
-            finally
-            {
-                if (jsonFile is not null)
-                    await jsonFile.DisposeAsync().ConfigureAwait(false);
-            }
-
-            jsonData ??= new();
-            return (jsonData, errMsg);
+            return await JsonSerializer.DeserializeAsync(fileStream, jsonTypeInfo, cancellationToken).ConfigureAwait(false) ?? new();
         }
+    }
 
-        /// <summary>
-        /// Saves data to a JSON file.
-        /// </summary>
-        /// <typeparam name="T">Data object type.</typeparam>
-        /// <param name="filename">JSON file name.</param>
-        /// <param name="jsonData">The data object to save.</param>
-        /// <param name="jsonTypeInfo">Metadata about the type to convert.</param>
-        /// <param name="alwaysOverwrite">Always overwrite the original file.</param>
-        /// <param name="noBackup">Do not create `filename.old` as backup.</param>
-        /// <param name="cancellationToken">A token that may be used to cancel the write operation.</param>
-        /// <returns>An error message. Null if no errors occurred.</returns>
-        public static async Task<string?> SaveJsonAsync<T>(
-            string filename,
-            T jsonData,
-            JsonTypeInfo<T> jsonTypeInfo,
-            bool alwaysOverwrite = false,
-            bool noBackup = false,
-            CancellationToken cancellationToken = default)
-        {
-            // extend relative path
-            filename = GetAbsolutePath(filename);
-
-            string? errMsg = null;
-            FileStream? jsonFile = null;
-
-            try
-            {
-                if (cancellationToken.IsCancellationRequested)
-                    return "The operation was canceled.";
-
-                // create directory
-                var directoryPath = Path.GetDirectoryName(filename);
-                if (directoryPath is null)
-                    return $"Error: invalid path: {filename}";
+    /// <summary>
+    /// Serializes the provided value as JSON and saves to the specified file.
+    /// </summary>
+    /// <typeparam name="TValue">The type of the value to serialize.</typeparam>
+    /// <param name="path">JSON file path.</param>
+    /// <param name="value">The value to save.</param>
+    /// <param name="jsonTypeInfo">Metadata about the type to convert.</param>
+    /// <param name="cancellationToken">A token that may be used to cancel the write operation.</param>
+    /// <returns>A task that represents the asynchronous write operation.</returns>
+    public static async Task SaveToJsonFileAsync<TValue>(
+        string path,
+        TValue value,
+        JsonTypeInfo<TValue> jsonTypeInfo,
+        CancellationToken cancellationToken = default)
+    {
+        path = GetAbsolutePath(path);
 
-                Directory.CreateDirectory(directoryPath);
+        var directoryPath = Path.GetDirectoryName(path);
+        if (string.IsNullOrEmpty(directoryPath))
+            throw new ArgumentException("Invalid path.", nameof(path));
 
-                // save JSON
-                if (alwaysOverwrite || !File.Exists(filename)) // alwaysOverwrite or file doesn't exist. Just write to it.
-                {
-                    jsonFile = new(filename, FileMode.Create);
-                    await JsonSerializer.SerializeAsync(jsonFile, jsonData, jsonTypeInfo, cancellationToken).ConfigureAwait(false);
-                }
-                else // File exists. Write to `filename.new` and then replace with the new file and creates backup `filename.old`.
-                {
-                    jsonFile = new($"{filename}.new", FileMode.Create);
-                    await JsonSerializer.SerializeAsync(jsonFile, jsonData, jsonTypeInfo, cancellationToken).ConfigureAwait(false);
-                    jsonFile.Close();
-                    File.Replace($"{filename}.new", filename, noBackup ? null : $"{filename}.old");
-                }
-            }
-            catch (Exception ex)
-            {
-                errMsg = $"Error: failed to save {filename}: {ex.Message}";
-            }
-            finally
-            {
-                if (jsonFile is not null)
-                    await jsonFile.DisposeAsync().ConfigureAwait(false);
-            }
+        _ = Directory.CreateDirectory(directoryPath);
 
-            return errMsg;
+        var newPath = $"{path}.new";
+        var fileStream = new FileStream(newPath, FileMode.Create);
+        await using (fileStream.ConfigureAwait(false))
+        {
+            await JsonSerializer.SerializeAsync(fileStream, value, jsonTypeInfo, cancellationToken);
         }
+        File.Replace(newPath, path, $"{path}.old");
     }
 }
diff --git a/YoutubeDl.Wpf/ViewModels/MainWindowViewModel.cs b/YoutubeDl.Wpf/ViewModels/MainWindowViewModel.cs
@@ -4,6 +4,7 @@
 using Serilog;
 using Splat;
 using Splat.Serilog;
+using System;
 using System.ComponentModel;
 using System.Threading;
 using System.Threading.Tasks;
@@ -30,14 +31,17 @@ public class MainWindowViewModel : ReactiveObject
 
         public MainWindowViewModel(ISnackbarMessageQueue snackbarMessageQueue)
         {
-            var (settings, loadSettingsErrMsg) = Settings.LoadSettingsAsync().GetAwaiter().GetResult();
-            if (loadSettingsErrMsg is not null)
+            try
             {
-                snackbarMessageQueue.Enqueue(loadSettingsErrMsg);
+                _settings = Settings.LoadAsync().GetAwaiter().GetResult();
+            }
+            catch (Exception ex)
+            {
+                snackbarMessageQueue.Enqueue(ex.Message);
+                _settings = new();
             }
 
-            _settings = settings;
-            _observableSettings = new(settings);
+            _observableSettings = new(_settings);
             _snackbarMessageQueue = snackbarMessageQueue;
 
             // Configure logging.
@@ -66,21 +70,22 @@ public async Task<bool> SaveSettingsAsync(CancelEventArgs? cancelEventArgs = nul
         {
             _observableSettings.UpdateSettings(_settings);
 
-            var errMsg = await Settings.SaveSettingsAsync(_settings, cancellationToken);
-            if (errMsg is not null)
+            try
+            {
+                await _settings.SaveAsync(cancellationToken);
+            }
+            catch (Exception ex)
             {
-                _snackbarMessageQueue.Enqueue(errMsg);
+                _snackbarMessageQueue.Enqueue(ex.Message);
 
                 // Cancel window closing
                 if (cancelEventArgs is not null)
                     cancelEventArgs.Cancel = true;
 
                 return false;
             }
-            else
-            {
-                return true;
-            }
+
+            return true;
         }
     }
 }
