Refactor persistence

Author: ATrefzer

CSharpCodeAnalyst/App.xaml.cs

@@ -109,8 +109,8 @@ private void StartUi()
         var refactoringService = new RefactoringService(refactoringInteraction, messaging);
         mainWindow.SetViewer(explorationGraphViewer, messaging);
 
-        var projectStorage = new JsonProjectStorage(uiNotification);
-        var projectService = new ProjectService(projectStorage, userSettings);
+        var projectStorage = new JsonProjectStorage();
+        var projectService = new ProjectService(projectStorage, uiNotification, userSettings);
 
         var viewModel = new MainViewModel(messaging, applicationSettings, userSettings, analyzerManager, refactoringService, projectService);
         var graphViewModel = new GraphViewModel(explorationGraphViewer, explorer, messaging, applicationSettings, refactoringService);

CSharpCodeAnalyst/Persistence/Contracts/IProjectStorage.cs

@@ -1,44 +1,29 @@
-using CSharpCodeAnalyst.Features.Import;
 using CSharpCodeAnalyst.Persistence.Dto;
 using CSharpCodeAnalyst.Shared;
 
 namespace CSharpCodeAnalyst.Persistence.Contracts;
 
 /// <summary>
-///     Low-level persistence contract: serializes and deserializes project data to/from a storage medium.
-///     Implementations are storage-technology specific (e.g. JSON files, databases).
-///     Does not own application state, dirty tracking, or MRU management.
+///     Low-level persistence contract: serializes and deserializes project data to/from a
+///     storage medium. Implementations are storage-technology specific (e.g. JSON files).
+///     Has no UI dependency — no file dialogs, no notifications, no events.
+///     Callers are responsible for providing file paths and handling user feedback.
 /// </summary>
 public interface IProjectStorage
 {
     bool HasSnapshot { get; }
 
-    event EventHandler<ImportStateChangedArgs>? LoadingStateChanged;
+    /// <summary>Loads project data from the given file path.</summary>
+    Task<Result<ProjectData>> LoadFromFileAsync(string filePath);
 
-    /// <summary>
-    ///     Shows an open-file dialog and loads the selected project.
-    /// </summary>
-    Task<Result<(string fileName, ProjectData data)>> LoadAsync();
-
-    /// <summary>
-    ///     Loads a project directly from the given file path without showing a dialog.
-    /// </summary>
-    Task<Result<(string fileName, ProjectData data)>> LoadFromFileAsync(string filePath);
+    /// <summary>Saves project data to the given file path.</summary>
+    Result SaveToFile(ProjectData data, string filePath);
 
-    /// <summary>
-    ///     Saves the project. If <paramref name="currentFilePath" /> is provided the file is
-    ///     overwritten in place; otherwise a save-file dialog is shown.
-    /// </summary>
-    Result<string> Save(ProjectData data, string? currentFilePath = null);
-
-    /// <summary>
-    ///     Stores an in-memory snapshot of the given project data.
-    /// </summary>
+    /// <summary>Stores an in-memory snapshot of the given project data.</summary>
     void CreateSnapshot(ProjectData data);
 
     /// <summary>
-    ///     Restores the latest snapshot by invoking <paramref name="restoreAction" /> with the
-    ///     stored data. Shows a warning when no snapshot is available.
+    ///     Returns the latest snapshot, or a failure result when none exists.
     /// </summary>
-    void RestoreSnapshot(Action<ProjectData> restoreAction);
+    Result<ProjectData> RestoreSnapshot();
 }

CSharpCodeAnalyst/Persistence/Json/JsonProjectStorage.cs

@@ -1,126 +1,65 @@
 using System.IO;
 using System.Text.Json;
 using System.Text.Json.Serialization;
-using CSharpCodeAnalyst.Features.Import;
 using CSharpCodeAnalyst.Persistence.Contracts;
 using CSharpCodeAnalyst.Persistence.Dto;
-using CSharpCodeAnalyst.Resources;
 using CSharpCodeAnalyst.Shared;
-using CSharpCodeAnalyst.Shared.Notifications;
 
 namespace CSharpCodeAnalyst.Persistence.Json;
 
 /// <summary>
 ///     JSON-file based implementation of <see cref="IProjectStorage" />.
+///     Pure I/O — no UI dependency, no file dialogs, no notifications, no events.
 /// </summary>
 public class JsonProjectStorage : IProjectStorage
 {
-    private readonly IUserNotification _ui;
     private ProjectData? _snapshot;
 
-    public JsonProjectStorage(IUserNotification ui)
-    {
-        _ui = ui;
-    }
-
     public bool HasSnapshot => _snapshot != null;
 
-    public event EventHandler<ImportStateChangedArgs>? LoadingStateChanged;
-
-    /// <inheritdoc />
-    public async Task<Result<(string fileName, ProjectData data)>> LoadAsync()
-    {
-        var fileName = _ui.ShowOpenFileDialog("JSON files (*.json)|*.json", "Load Project");
-        if (string.IsNullOrEmpty(fileName))
-        {
-            return Result<(string, ProjectData)>.Canceled();
-        }
-
-        return await LoadFromFileAsync(fileName);
-    }
-
     /// <inheritdoc />
-    public async Task<Result<(string fileName, ProjectData data)>> LoadFromFileAsync(string filePath)
+    public async Task<Result<ProjectData>> LoadFromFileAsync(string filePath)
     {
         try
         {
-            OnLoadingStateChanged("Loading...", true);
-
             var projectData = await Task.Run(() => DeserializeProject(filePath));
-            return Result<(string, ProjectData)>.Success((filePath, projectData));
+            return Result<ProjectData>.Success(projectData);
         }
         catch (Exception ex)
         {
-            ShowError(ex);
-            return Result<(string, ProjectData)>.Failure(ex);
-        }
-        finally
-        {
-            OnLoadingStateChanged(string.Empty, false);
+            return Result<ProjectData>.Failure(ex);
         }
     }
 
     /// <inheritdoc />
-    public Result<string> Save(ProjectData data, string? currentFilePath = null)
+    public Result SaveToFile(ProjectData data, string filePath)
     {
-        if (!TryGetSaveFilePath(currentFilePath, out var filePath))
-        {
-            return Result<string>.Canceled();
-        }
-
         try
         {
             SerializeProject(data, filePath);
-            return Result<string>.Success(filePath);
+            return Result.Success();
         }
         catch (Exception ex)
         {
-            ShowError(ex);
-            return Result<string>.Failure(ex);
+            return Result.Failure(ex);
         }
     }
 
     /// <inheritdoc />
     public void CreateSnapshot(ProjectData data)
     {
         _snapshot = data;
-        _ui.ShowSuccess(Strings.Snapshot_Success);
     }
 
     /// <inheritdoc />
-    public void RestoreSnapshot(Action<ProjectData> restoreAction)
+    public Result<ProjectData> RestoreSnapshot()
     {
-        if (!HasSnapshot)
+        if (_snapshot is null)
         {
-            _ui.ShowWarning(Strings.Restore_NoSnapshot);
-            return;
+            return Result<ProjectData>.Failure(new InvalidOperationException("No snapshot available."));
         }
 
-        try
-        {
-            OnLoadingStateChanged(Strings.Restore_LoadMessage, true);
-            restoreAction(_snapshot!);
-            _ui.ShowSuccess(Strings.Restore_Success);
-        }
-        catch (Exception ex)
-        {
-            ShowError(ex);
-        }
-        finally
-        {
-            OnLoadingStateChanged(string.Empty, false);
-        }
-    }
-
-    private void OnLoadingStateChanged(string message, bool isLoading)
-    {
-        LoadingStateChanged?.Invoke(this, new ImportStateChangedArgs(message, isLoading));
-    }
-
-    private void ShowError(Exception ex)
-    {
-        var message = string.Format(Strings.OperationFailed_Message, ex.Message);
-        _ui.ShowError(message);
+        return Result<ProjectData>.Success(_snapshot);
     }
 
     private static ProjectData DeserializeProject(string filePath)
@@ -136,30 +75,8 @@ private static ProjectData DeserializeProject(string filePath)
 
     private static void SerializeProject(ProjectData projectData, string filePath)
     {
-        var options = new JsonSerializerOptions
-        {
-            WriteIndented = false
-        };
+        var options = new JsonSerializerOptions { WriteIndented = false };
         var json = JsonSerializer.Serialize(projectData, options);
         File.WriteAllText(filePath, json);
     }
-
-    private bool TryGetSaveFilePath(string? currentFilePath, out string outFileName)
-    {
-        if (!string.IsNullOrEmpty(currentFilePath))
-        {
-            outFileName = currentFilePath;
-            return true;
-        }
-
-        var fileName = _ui.ShowSaveFileDialog("JSON files (*.json)|*.json", "Save Project");
-        if (string.IsNullOrEmpty(fileName))
-        {
-            outFileName = string.Empty;
-            return false;
-        }
-
-        outFileName = fileName;
-        return true;
-    }
-}
+}