async locking around ide vs external disk file tree changes

Author: MattParkerDev

src/SharpIDE.Application/Features/FileWatching/IdeFileExternalChangeHandler.cs

@@ -1,6 +1,7 @@
 using System.Collections.Immutable;
 using Ardalis.GuardClauses;
 using Microsoft.Extensions.Logging;
+using NeoSmart.AsyncLock;
 using SharpIDE.Application.Features.Events;
 using SharpIDE.Application.Features.FileSystem;
 using SharpIDE.Application.Features.SolutionDiscovery;
@@ -16,6 +17,7 @@ public class IdeFileExternalChangeHandler
 	public SharpIdeSolutionModel SolutionModel { get; set; } = null!;
 
 	private SharpIdeRootFolder RootFolder => SolutionModel.RootFolder;
+	public AsyncLock IdeChangeLock { get; } = new AsyncLock();
 
 	public IdeFileExternalChangeHandler(FileChangedService fileChangedService, SharpIdeRootFolderModificationService rootFolderModificationService, ILogger<IdeFileExternalChangeHandler> logger)
 	{
@@ -34,13 +36,15 @@ public IdeFileExternalChangeHandler(FileChangedService fileChangedService, Sharp
 
 	private async Task OnFileRenamed(string oldFilePath, string newFilePath)
 	{
+		using var _ = await IdeChangeLock.LockAsync();
 		var sharpIdeFile = RootFolder.AllFiles.GetValueOrDefault(oldFilePath);
 		if (sharpIdeFile is null) return;
 		await _rootFolderModificationService.RenameFile(sharpIdeFile, Path.GetFileName(newFilePath));
 	}
 
 	private async Task OnFileDeleted(string filePath)
 	{
+		using var _ = await IdeChangeLock.LockAsync();
 		var sharpIdeFile = RootFolder.AllFiles.GetValueOrDefault(filePath);
 		if (sharpIdeFile is null) return;
 		await _rootFolderModificationService.RemoveFile(sharpIdeFile);
@@ -49,6 +53,7 @@ private async Task OnFileDeleted(string filePath)
 	// TODO: Test - this most likely only will ever be called on linux - windows and macos(?) does delete + create on rename of folders
 	private async Task OnFolderRenamed(string oldFolderPath, string newFolderPath)
 	{
+		using var _ = await IdeChangeLock.LockAsync();
 		var sharpIdeFolder = RootFolder.AllFolders.SingleOrDefault(f => f.Path == oldFolderPath);
 		if (sharpIdeFolder is null)
 		{
@@ -70,6 +75,7 @@ private async Task OnFolderRenamed(string oldFolderPath, string newFolderPath)
 
 	private async Task OnFolderDeleted(string folderPath)
 	{
+		using var _ = await IdeChangeLock.LockAsync();
 		var sharpIdeFolder = RootFolder.AllFolders.SingleOrDefault(f => f.Path == folderPath);
 		if (sharpIdeFolder is null)
 		{
@@ -80,6 +86,7 @@ private async Task OnFolderDeleted(string folderPath)
 
 	private async Task OnFolderCreated(string folderPath)
 	{
+		using var _ = await IdeChangeLock.LockAsync();
 		var sharpIdeFolder = RootFolder.AllFolders.SingleOrDefault(f => f.Path == folderPath);
 		if (sharpIdeFolder is not null)
 		{
@@ -99,6 +106,7 @@ private async Task OnFolderCreated(string folderPath)
 
 	private async Task OnFileCreated(string filePath)
 	{
+		using var _ = await IdeChangeLock.LockAsync();
 		var sharpIdeFile = RootFolder.AllFiles.GetValueOrDefault(filePath);
 		if (sharpIdeFile is not null)
 		{
@@ -118,6 +126,7 @@ private async Task OnFileCreated(string filePath)
 
 	private async Task OnFileChanged(string filePath)
 	{
+		using var _ = await IdeChangeLock.LockAsync();
 		var sharpIdeFile = RootFolder.AllFiles.GetValueOrDefault(filePath);
 		if (sharpIdeFile is null) return;
 		if (sharpIdeFile.SuppressDiskChangeEvents is true) return;
@@ -139,6 +148,7 @@ private async Task OnFileChanged(string filePath)
 
 	private async Task OnAnalyzerDllsChanged(ImmutableArray<string> analyzerDllPaths)
 	{
+		using var _ = await IdeChangeLock.LockAsync();
 		await _fileChangedService.AnalyzerDllFilesChanged(analyzerDllPaths);
 	}
 }

src/SharpIDE.Application/Features/FileWatching/IdeFileOperationsService.cs

@@ -4,34 +4,39 @@
 
 namespace SharpIDE.Application.Features.FileWatching;
 
-public class IdeFileOperationsService(SharpIdeRootFolderModificationService rootFolderModificationService)
+public class IdeFileOperationsService(SharpIdeRootFolderModificationService rootFolderModificationService, IdeFileExternalChangeHandler ideFileExternalChangeHandler)
 {
 	private readonly SharpIdeRootFolderModificationService _rootFolderModificationService = rootFolderModificationService;
+	private readonly IdeFileExternalChangeHandler _ideFileExternalChangeHandler = ideFileExternalChangeHandler;
 
 	public async Task RenameDirectory(SharpIdeFolder folder, string newDirectoryName)
 	{
 		var parentPath = Path.GetDirectoryName(folder.Path)!;
 		var newDirectoryPath = Path.Combine(parentPath, newDirectoryName);
+		using var _ = await _ideFileExternalChangeHandler.IdeChangeLock.LockAsync();
 		Directory.Move(folder.Path, newDirectoryPath);
 		await _rootFolderModificationService.RenameDirectory(folder, newDirectoryName);
 	}
 
 	public async Task CreateDirectory(SharpIdeFolder parentFolder, string newDirectoryName)
 	{
 		var newDirectoryPath = Path.Combine(parentFolder.ChildNodeBasePath, newDirectoryName);
+		using var _ = await _ideFileExternalChangeHandler.IdeChangeLock.LockAsync();
 		Directory.CreateDirectory(newDirectoryPath);
 		await _rootFolderModificationService.AddDirectory(parentFolder, newDirectoryName);
 	}
 
 	public async Task DeleteDirectory(SharpIdeFolder folder)
 	{
+		using var _ = await _ideFileExternalChangeHandler.IdeChangeLock.LockAsync();
 		Directory.Delete(folder.Path, true);
 		await _rootFolderModificationService.RemoveDirectory(folder);
 	}
 
 	public async Task CopyDirectory(SharpIdeFolder destinationParentFolder, string sourceDirectoryPath, string newDirectoryName)
 	{
 		var newDirectoryPath = Path.Combine(destinationParentFolder.ChildNodeBasePath, newDirectoryName);
+		using var _ = await _ideFileExternalChangeHandler.IdeChangeLock.LockAsync();
 		CopyAll(new DirectoryInfo(sourceDirectoryPath), new DirectoryInfo(newDirectoryPath));
 		await _rootFolderModificationService.AddDirectory(destinationParentFolder, newDirectoryName);
 		return;
@@ -55,12 +60,14 @@ static void CopyAll(DirectoryInfo source, DirectoryInfo target)
 	public async Task MoveDirectory(SharpIdeFolder destinationParentFolder, SharpIdeFolder folderToMove)
 	{
 		var newDirectoryPath = Path.Combine(destinationParentFolder.ChildNodeBasePath, folderToMove.Name.Value);
+		using var _ = await _ideFileExternalChangeHandler.IdeChangeLock.LockAsync();
 		Directory.Move(folderToMove.Path, newDirectoryPath);
 		await _rootFolderModificationService.MoveDirectory(destinationParentFolder, folderToMove);
 	}
 
 	public async Task DeleteFile(SharpIdeFile file)
 	{
+		using var _ = await _ideFileExternalChangeHandler.IdeChangeLock.LockAsync();
 		File.Delete(file.Path);
 		await _rootFolderModificationService.RemoveFile(file);
 	}
@@ -72,6 +79,7 @@ public async Task<SharpIdeFile> CreateCsFile(SharpIdeFolder parentFolder, string
 		var className = Path.GetFileNameWithoutExtension(newFileName);
 		var @namespace = NewFileTemplates.ComputeNamespace(parentFolder);
 		var fileText = NewFileTemplates.CsharpFile(className, @namespace, typeKeyword);
+		using var _ = await _ideFileExternalChangeHandler.IdeChangeLock.LockAsync();
 		await File.WriteAllTextAsync(newFilePath, fileText);
 		var sharpIdeFile = await _rootFolderModificationService.CreateFile(parentFolder, newFilePath, newFileName, fileText);
 		return sharpIdeFile;
@@ -82,6 +90,7 @@ public async Task<SharpIdeFile> CopyFile(SharpIdeFolder destinationParentFolder,
 		var newFilePath = Path.Combine(destinationParentFolder.Path, newFileName);
 		if (File.Exists(newFilePath)) throw new InvalidOperationException($"File {newFilePath} already exists.");
 		var fileContents = await File.ReadAllTextAsync(sourceFilePath);
+		using var _ = await _ideFileExternalChangeHandler.IdeChangeLock.LockAsync();
 		File.Copy(sourceFilePath, newFilePath);
 		var sharpIdeFile = await _rootFolderModificationService.CreateFile(destinationParentFolder, newFilePath, newFileName, fileContents);
 		return sharpIdeFile;
@@ -92,6 +101,7 @@ public async Task<SharpIdeFile> RenameFile(SharpIdeFile file, string newFileName
 		var parentPath = Path.GetDirectoryName(file.Path)!;
 		var newFilePath = Path.Combine(parentPath, newFileName);
 		if (File.Exists(newFilePath)) throw new InvalidOperationException($"File {newFilePath} already exists.");
+		using var _ = await _ideFileExternalChangeHandler.IdeChangeLock.LockAsync();
 		File.Move(file.Path, newFilePath);
 		var sharpIdeFile = await _rootFolderModificationService.RenameFile(file, newFileName);
 		return sharpIdeFile;
@@ -101,6 +111,7 @@ public async Task<SharpIdeFile> MoveFile(SharpIdeFolder destinationParentFolder,
 	{
 		var newFilePath = Path.Combine(destinationParentFolder.ChildNodeBasePath, fileToMove.Name.Value);
 		if (File.Exists(newFilePath)) throw new InvalidOperationException($"File {newFilePath} already exists.");
+		using var _ = await _ideFileExternalChangeHandler.IdeChangeLock.LockAsync();
 		File.Move(fileToMove.Path, newFilePath);
 		var sharpIdeFile = await _rootFolderModificationService.MoveFile(destinationParentFolder, fileToMove);
 		return sharpIdeFile;