make launching async (#9)

Author: SimonCropp

src/MsExcelDiff.Tests/ConcurrentLaunchTests.cs

@@ -68,7 +68,7 @@ public async Task WaitForProcess_FindsNewProcess()
     {
         var process = StartTestProcess();
 
-        using var found = SpreadsheetCompare.WaitForProcess(processName, []);
+        using var found = await SpreadsheetCompare.WaitForProcess(processName, []);
 
         await Assert.That(found).IsNotNull();
         await Assert.That(found!.Id).IsEqualTo(process.Id);
@@ -84,7 +84,7 @@ public async Task WaitForProcess_SkipsExistingPids()
             existing.Id
         };
 
-        using var found = SpreadsheetCompare.WaitForProcess(processName, existingPids);
+        using var found = await SpreadsheetCompare.WaitForProcess(processName, existingPids);
 
         await Assert.That(found).IsNotNull();
         await Assert.That(found!.Id).IsNotEqualTo(existing.Id);
@@ -100,7 +100,7 @@ public async Task WaitForProcess_ReturnsNull_WhenAllPidsExcluded()
         };
 
         // Use maxAttempts=1 to avoid 10s timeout
-        using var found = SpreadsheetCompare.WaitForProcess(processName, existingPids, maxAttempts: 1);
+        using var found = await SpreadsheetCompare.WaitForProcess(processName, existingPids, maxAttempts: 1);
 
         await Assert.That(found).IsNull();
     }
@@ -110,30 +110,29 @@ public async Task SerializedIdentification_YieldsUniqueProcesses()
     {
         const int count = 5;
         var identifiedPids = new ConcurrentBag<int>();
-        var mutexName = $@"Global\Test_{Guid.NewGuid():N}";
+        using var semaphore = new SemaphoreSlim(1, 1);
 
         // Simulate N concurrent diffexcel instances, each doing the
-        // mutex-protected snapshot-launch-identify sequence.
-        // The mutex ensures each snapshot sees previously identified processes.
+        // serialized snapshot-launch-identify sequence.
+        // The semaphore ensures each snapshot sees previously identified processes.
         var tasks = Enumerable
             .Range(0, count)
-            .Select(_ => Task.Run(() =>
+            .Select(_ => Task.Run(async () =>
             {
-                using var mutex = new Mutex(false, mutexName);
-                mutex.WaitOne();
+                await semaphore.WaitAsync();
                 try
                 {
                     var existing = SpreadsheetCompare.GetProcessPids(processName);
                     StartTestProcess();
-                    using var found = SpreadsheetCompare.WaitForProcess(processName, existing);
+                    using var found = await SpreadsheetCompare.WaitForProcess(processName, existing);
                     if (found != null)
                     {
                         identifiedPids.Add(found.Id);
                     }
                 }
                 finally
                 {
-                    mutex.ReleaseMutex();
+                    semaphore.Release();
                 }
             }))
             .ToArray();
@@ -161,7 +160,7 @@ public async Task UnsynchronizedIdentification_CanYieldDuplicates()
         var identifiedPids = new List<int>();
         for (var i = 0; i < count; i++)
         {
-            using var found = SpreadsheetCompare.WaitForProcess(processName, snapshot);
+            using var found = await SpreadsheetCompare.WaitForProcess(processName, snapshot);
             if (found != null)
             {
                 identifiedPids.Add(found.Id);

src/MsExcelDiff.Tests/LaunchTests.cs

@@ -2,7 +2,7 @@ public class LaunchTests
 {
     [Test]
     [Explicit]
-    public void Launch() =>
+    public Task Launch() =>
         SpreadsheetCompare.Launch(
             ProjectFiles.input_source_xlsx.FullPath,
             ProjectFiles.input_target_xlsx.FullPath);

src/MsExcelDiff.Tests/TempFilesTests.cs

@@ -3,8 +3,11 @@ public class TempFilesTests
     string tempDir = null!;
 
     [Before(Test)]
-    public void Setup() =>
+    public void Setup()
+    {
         tempDir = Path.Combine(Path.GetTempPath(), $"MsExcelDiff_Test_{Guid.NewGuid():N}");
+        Directory.CreateDirectory(tempDir);
+    }
 
     [After(Test)]
     public void Cleanup()
@@ -23,7 +26,7 @@ public async Task Create_WritesContent()
     {
         var path = TempFiles.Create(tempDir, "some content");
 
-        await Assert.That(File.ReadAllText(path)).IsEqualTo("some content");
+        await Assert.That(await File.ReadAllTextAsync(path)).IsEqualTo("some content");
     }
 
     [Test]

src/MsExcelDiff/CompareCommand.cs

@@ -23,7 +23,7 @@ public async ValueTask ExecuteAsync(IConsole console)
 
         try
         {
-            SpreadsheetCompare.Launch(Path1.FullName, Path2.FullName, settings.SpreadsheetComparePath);
+            await SpreadsheetCompare.Launch(Path1.FullName, Path2.FullName, settings.SpreadsheetComparePath);
         }
         catch (Exception exception)
         {

src/MsExcelDiff/SpreadsheetCompare.cs

@@ -1,4 +1,4 @@
-public static partial class SpreadsheetCompare
+public static class SpreadsheetCompare
 {
     static readonly string[] programFolders =
     [
@@ -56,7 +56,7 @@ public static partial class SpreadsheetCompare
         return null;
     }
 
-    public static void Launch(string path1, string path2, string? exePath = null)
+    public static async Task Launch(string path1, string path2, string? exePath = null)
     {
         var exe = FindExecutable(exePath);
         if (exe == null)
@@ -77,10 +77,10 @@ Spreadsheet Compare (SPREADSHEETCOMPARE.EXE) was not found.
 
         try
         {
-            using var process = LaunchProcess(exe, tempFile);
+            using var process = await LaunchProcess(exe, tempFile);
 
             JobObject.AssignProcess(job, process.Handle);
-            process.WaitForExit();
+            await process.WaitForExitAsync();
         }
         catch when (TempFiles.TryDelete(tempFile))
         {
@@ -93,7 +93,7 @@ Spreadsheet Compare (SPREADSHEETCOMPARE.EXE) was not found.
         }
     }
 
-    static Process LaunchProcess(string exe, string tempFile)
+    static async Task<Process> LaunchProcess(string exe, string tempFile)
     {
         // Click-to-Run Office installs require launching via AppVLP.exe (the App-V
         // virtualization layer). SPREADSHEETCOMPARE.EXE crashes if launched directly.
@@ -104,7 +104,7 @@ static Process LaunchProcess(string exe, string tempFile)
             return LaunchDirect(exe, tempFile);
         }
 
-        return LaunchViaAppVlp(appVlp, exe, tempFile);
+        return await LaunchViaAppVlp(appVlp, exe, tempFile);
     }
 
     static Process LaunchDirect(string exe, string tempFile) =>
@@ -115,16 +115,18 @@ static Process LaunchDirect(string exe, string tempFile) =>
             })
         ?? throw new("Failed to start Spreadsheet Compare process");
 
-    static Process LaunchViaAppVlp(string appVlp, string exe, string tempFile)
+    static readonly string lockFilePath = Path.Combine(TempFiles.TempDirectory, ".lock");
+
+    static async Task<Process> LaunchViaAppVlp(string appVlp, string exe, string tempFile)
     {
         // Serialize the snapshot-launch-identify sequence across concurrent
         // diffexcel instances. Without this, concurrent instances snapshot the
         // same PID set, race to claim the same SPREADSHEETCOMPARE process, and
         // leave others orphaned (not in any job object, so they survive when
         // diffexcel is killed).
-        using var mutex = new Mutex(false, @"Global\MsExcelDiff_Launch");
-        mutex.WaitOne();
-        try
+        // Uses a file lock instead of a Mutex because file locks are not
+        // thread-affine, allowing async code within the critical section.
+        using (await AcquireFileLock())
         {
             var existingPids = GetSpreadsheetComparePids();
 
@@ -137,15 +139,28 @@ static Process LaunchViaAppVlp(string appVlp, string exe, string tempFile)
 
             // AppVLP.exe is a launcher that exits after starting the real process.
             // Find the actual SPREADSHEETCOMPARE process and wait on it.
-            launcher.WaitForExit();
+            await launcher.WaitForExitAsync();
 
-            return WaitForProcess(existingPids)
+            return await WaitForProcess(existingPids)
                    ?? throw new("Spreadsheet Compare did not start. Ensure the application is installed correctly.");
         }
-        finally
+    }
+
+    static async Task<FileStream> AcquireFileLock()
+    {
+        for (var i = 0; i < 300; i++)
         {
-            mutex.ReleaseMutex();
+            try
+            {
+                return new(lockFilePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
+            }
+            catch (IOException)
+            {
+                await Task.Delay(100);
+            }
         }
+
+        throw new IOException($"Failed to acquire lock file: {lockFilePath}");
     }
 
     static HashSet<int> GetSpreadsheetComparePids() =>
@@ -163,10 +178,10 @@ internal static HashSet<int> GetProcessPids(string processName)
         return pids;
     }
 
-    static Process? WaitForProcess(HashSet<int> existingPids) =>
+    static Task<Process?> WaitForProcess(HashSet<int> existingPids) =>
         WaitForProcess("SPREADSHEETCOMPARE", existingPids);
 
-    internal static Process? WaitForProcess(string processName, HashSet<int> existingPids, int maxAttempts = 100)
+    internal static async Task<Process?> WaitForProcess(string processName, HashSet<int> existingPids, int maxAttempts = 100)
     {
         for (var i = 0; i < maxAttempts; i++)
         {
@@ -189,7 +204,7 @@ internal static HashSet<int> GetProcessPids(string processName)
                 return result;
             }
 
-            Thread.Sleep(100);
+            await Task.Delay(100);
         }
 
         return null;

src/MsExcelDiff/TempFiles.cs

@@ -1,14 +1,18 @@
 static class TempFiles
 {
-    static readonly string directory = Path.Combine(Path.GetTempPath(), "MsExcelDiff");
+    public static readonly string TempDirectory = Path.Combine(Path.GetTempPath(), "MsExcelDiff");
+
+    static TempFiles()
+    {
+        Directory.CreateDirectory(TempDirectory);
+        CleanOld(TempDirectory);
+    }
 
     public static string Create(string content) =>
-        Create(directory, content);
+        Create(TempDirectory, content);
 
     internal static string Create(string directory, string content)
     {
-        Directory.CreateDirectory(directory);
-        CleanOld(directory);
         var path = Path.Combine(directory, $"{Guid.NewGuid()}.txt");
         File.WriteAllText(path, content);
         return path;

src/MsWordDiff.Tests/Test.cs

@@ -2,14 +2,14 @@ public class Test
 {
     [Test]
     [Explicit]
-    public void Launch() =>
+    public Task Launch() =>
         Word.Launch(
             ProjectFiles.input_temp_docx.FullPath,
             ProjectFiles.input_target_docx.FullPath);
 
     [Test]
     [Explicit]
-    public void LaunchQuiet() =>
+    public Task LaunchQuiet() =>
         Word.Launch(
             ProjectFiles.input_temp_docx.FullPath,
             ProjectFiles.input_target_docx.FullPath,

src/MsWordDiff/CompareCommand.cs

@@ -28,7 +28,7 @@ public async ValueTask ExecuteAsync(IConsole console)
 
         try
         {
-            Word.Launch(Path1.FullName, Path2.FullName, quiet);
+            await Word.Launch(Path1.FullName, Path2.FullName, quiet);
         }
         catch (Exception exception)
         {

src/MsWordDiff/Word.cs

@@ -1,6 +1,6 @@
 public static partial class Word
 {
-    public static void Launch(string path1, string path2, bool quiet = false)
+    public static async Task Launch(string path1, string path2, bool quiet = false)
     {
         var wordType = Type.GetTypeFromProgID("Word.Application");
         if (wordType == null)
@@ -41,7 +41,7 @@ public static void Launch(string path1, string path2, bool quiet = false)
         // Bring Word to the foreground
         SetForegroundWindow(hwnd);
 
-        process.WaitForExit();
+        await process.WaitForExitAsync();
 
         Marshal.ReleaseComObject(compare);
         Marshal.ReleaseComObject(word);