Handle race conditions during stream read. Refactor multiple-file lock code.

Author: levitation

AsyncToSyncCodeRoundtripSynchroniserMonitorNet.csproj

@@ -179,5 +179,8 @@
   <ItemGroup>
     <Content Include="copyrights.txt" />
   </ItemGroup>
+  <ItemGroup>
+    <Folder Include="icon\" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
 </Project>

BinaryFileExtensions.cs

@@ -16,9 +16,9 @@ namespace AsyncToSyncCodeRoundtripSynchroniserMonitor
     public static partial class FileExtensions
     {
         //https://stackoverflow.com/questions/18472867/checking-equality-for-two-byte-arrays/
-        public static bool BinaryEqual(Binary a1, Binary b1)
+        public static bool BinaryEqual(Binary a, Binary b)
         {
-            return a1.Equals(b1);
+            return a.Equals(b);
         }
 
         public static async Task<byte[]> ReadAllBytesAsync(string path, CancellationToken cancellationToken = default(CancellationToken))
@@ -32,8 +32,9 @@ public static bool BinaryEqual(Binary a1, Binary b1)
                 useAsync: true
             ))
             {
-                byte[] result = new byte[stream.Length];
-                await stream.ReadAsync(result, 0, (int)stream.Length, cancellationToken);
+                var len = (int)stream.Length;    //NB! the lenght might change during the code execution, so need to save it into separate variable
+                byte[] result = new byte[len];
+                await stream.ReadAsync(result, 0, len, cancellationToken);
                 return result;
             }
         }

Program.cs

@@ -444,17 +444,7 @@ public static async Task FileUpdated(string fullName, Context context)
             )
             {
                 var otherFullName = GetOtherFullName(fullName);
-                var filenames = new List<string>()
-                            {
-                                fullName,
-                                otherFullName
-                            };
-
-                //NB! in order to avoid deadlocks, always take the locks in deterministic order
-                filenames.Sort(StringComparer.InvariantCultureIgnoreCase);
-
-                using (await Global.FileOperationLocks.LockAsync(filenames[0], context.Token))
-                using (await Global.FileOperationLocks.LockAsync(filenames[1], context.Token))
+                using (await Global.FileOperationLocks.LockAsync(fullName, otherFullName, context.Token))
                 {
                     if (
                         fullName.EndsWith("." + Global.WatchedCodeExtension)
@@ -577,17 +567,7 @@ private static async Task OnRenamedAsync(IRenamedFileSystemEvent rfse, Cancellat
                         //NB! if file is renamed to cs~ or resx~ then that means there will be yet another write to same file, so lets skip this event here
                         if (!rfse.FileSystemInfo.FullName.EndsWith("~"))
                         {
-                            var filenames = new List<string>()
-                            {
-                                rfse.FileSystemInfo.FullName,
-                                rfse.PreviousFileSystemInfo.FullName
-                            };
-
-                            //NB! in order to avoid deadlocks in case of file swaps, always take the locks in deterministic order
-                            filenames.Sort(StringComparer.InvariantCultureIgnoreCase);
-
-                            using (await FileEventLocks.LockAsync(filenames[0], token))
-                            using (await FileEventLocks.LockAsync(filenames[1], token))
+                            using (await Global.FileOperationLocks.LockAsync(rfse.FileSystemInfo.FullName, rfse.PreviousFileSystemInfo.FullName, context.Token))
                             {
                                 await FileUpdated(rfse.FileSystemInfo.FullName, context);
                                 await FileDeleted(rfse.PreviousFileSystemInfo.FullName, context);

Synchronisation.cs

@@ -25,10 +25,10 @@ public AsyncLockWithCount()
 
         public sealed class LockDictReleaser : IDisposable
         {
-            public readonly string Name;
-            public readonly AsyncLockWithCount LockEntry;
-            public readonly IDisposable LockHandle;
-            public readonly AsyncLockQueueDictionary AsyncLockQueueDictionary;
+            private readonly string Name;
+            private readonly AsyncLockWithCount LockEntry;
+            private readonly IDisposable LockHandle;
+            private readonly AsyncLockQueueDictionary AsyncLockQueueDictionary;
 
             internal LockDictReleaser(string name, AsyncLockWithCount lockEntry, IDisposable lockHandle, AsyncLockQueueDictionary asyncLockQueueDictionary)
             {
@@ -76,5 +76,41 @@ private void ReleaseLock(string name, AsyncLockWithCount lockEntry, IDisposable
             var lockHandle = await lockEntry.LockEntry.LockAsync(cancellationToken);
             return new LockDictReleaser(name, lockEntry, lockHandle, this);
         }
+
+        public sealed class MultiLockDictReleaser : IDisposable
+        {
+            private readonly LockDictReleaser[] Releasers;
+
+            public MultiLockDictReleaser(params LockDictReleaser[] releasers)
+            {
+                this.Releasers = releasers;
+            }
+
+            public void Dispose()
+            {
+                foreach (var releaser in Releasers)
+                {
+                    if (releaser != null)   //NB!
+                        releaser.Dispose();
+                }
+            }
+        }
+
+        public async Task<MultiLockDictReleaser> LockAsync(string name1, string name2, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var names = new List<string>()
+                            {
+                                name1,
+                                name2
+                            };
+
+            //NB! in order to avoid deadlocks, always take the locks in deterministic order
+            names.Sort(StringComparer.InvariantCultureIgnoreCase);
+        
+            var releaser1 = await Global.FileOperationLocks.LockAsync(names[0], cancellationToken);
+            var releaser2 = name1 != name2 ? await Global.FileOperationLocks.LockAsync(names[1], cancellationToken) : null;
+
+            return new MultiLockDictReleaser(releaser1, releaser2);
+        }
     }
 }