Show message box when exceptions occur due to wrong file encoding (the source files must be saved using utf-8 encoding).

Author: levitation

AsyncToSyncCodeRoundtripSynchroniserMonitorNet.csproj

@@ -112,6 +112,7 @@
     <Reference Include="System.Globalization.Calendars, Version=4.0.2.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
       <HintPath>packages\System.Globalization.Calendars.4.3.0\lib\net46\System.Globalization.Calendars.dll</HintPath>
     </Reference>
+    <Reference Include="System.Windows.Forms" />
     <Reference Include="System.IO.Compression" />
     <Reference Include="System.IO.Compression.FileSystem" />
     <Reference Include="System.IO.Compression.ZipFile, Version=4.0.2.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL">
@@ -181,6 +182,7 @@
   </ItemGroup>
   <ItemGroup>
     <Content Include="copyrights.txt" />
+    <Content Include="todo.txt" />
   </ItemGroup>
   <ItemGroup>
     <Folder Include="icon\" />

AsyncToSyncConverter.cs

@@ -22,6 +22,7 @@ static class AsyncToSyncConverter
         public static readonly List<KVP> Replacements = new List<KVP>()
         {
             //NB! VS may put the /*--await--*/ on a separate line therefore need handling for various space types after /*--await--*/
+            //TODO!: ensure that await starts at word boundary
             new KVP("await ", "/*--await--*/ "),
             new KVP("await\t", "/*--await--*/\t"),
             new KVP("await\r", "/*--await--*/\r"),
@@ -32,13 +33,22 @@ static class AsyncToSyncConverter
 
             new KVP(@" async Task ", @" /*--async Task--*/void "),
             //new KVP(@" async void ", @" /*--async void--*/void "),
+            new KVP(@" async IAsyncEnumerable", @" /*--async IAsyncEnumerable--*/IEnumerable"),
             new KVP(@" async ", @" /*--async--*/ "),
+
+            new KVP("(async ", "(/*--async--*/ "),
+            new KVP("(async\t", "(/*--async--*/\t"),
+            new KVP("(async\r", "(/*--async--*/\r"),
+            new KVP("(async\n", "(/*--async--*/\n"),
+
             new KVP(@" Task ", @" /*--Task--*/void "),  //method return type
             new KVP(@"Task ", @"/*--Task--*/Action "),  //method argument type
+            new KVP(@"Task<T> ", @"/*--Task<T>--*/Func<T> "),  //method argument type
 
             new KVP(@").Wait();", @")/*--.Wait()--*/;"),
             //new KVP("Task.Delay", "/*--Task.Delay--*/System.Threading.Thread.Sleep"),     //this needs special regex in sync to async direction
             new KVP(@"Task.FromResult", @"/*--Task.FromResult--*/"),
+            new KVP(@"Task.WhenAll", @"/*--Task.WhenAll--*/"),
             new KVP(@" AsyncLock", @" /*--AsyncLock--*/object"),    
 
             new KVP(@"#define ASYNC", @"#define NOASYNC"),
@@ -53,14 +63,18 @@ static class AsyncToSyncConverter
         private const string TaskDelayReplaceRegexReplacement = @"/*--Task.Delay--*/System.Threading.Thread.Sleep";
 
 
-        private static readonly Regex TaskReplaceRegex = new Regex(@"(\s+)(async\s+)?Task<([^ (]+)>(\s+)", RegexOptions.Singleline | RegexOptions.Compiled);
+        private static readonly Regex TaskReplaceRegex = new Regex(@"(\s+)(async\s+)?Task<([^(]+)>(\s+)", RegexOptions.Singleline | RegexOptions.Compiled);
         private const string TaskReplaceRegexReplacement = @"$1/*--$2Task<--*/$3/*-->--*/$4";
 
 
         private static readonly Regex AsyncLockReplaceRegex = new Regex(@"using([^(]*)[(]await(\s+[^(]+)[.]LockAsync[(][)][)]", RegexOptions.Singleline | RegexOptions.Compiled);
         private const string AsyncLockReplaceRegexReplacement = @"/*--using--*/lock$1(/*--await--*/ $2/*--.Lock A s y n c()--*/)";
 
 
+        private static readonly Regex FuncTaskReplaceRegex = new Regex(@"([\s,(]+)Func<Task<([^=)]+)>>", RegexOptions.Singleline | RegexOptions.Compiled);
+        private const string FuncTaskReplaceRegexReplacement = @"$1Func</*--Task<--*/$2/*-->--*/>";
+
+
         public static async Task AsyncFileUpdated(string fullName, Context context)
         {
             //using (await Global.FileOperationAsyncLock.LockAsync())
@@ -71,6 +85,7 @@ public static async Task AsyncFileUpdated(string fullName, Context context)
 
 
 
+                fileData = FuncTaskReplaceRegex.Replace(fileData, FuncTaskReplaceRegexReplacement);
                 fileData = AsyncLockReplaceRegex.Replace(fileData, AsyncLockReplaceRegexReplacement);
                 fileData = TaskReplaceRegex.Replace(fileData, TaskReplaceRegexReplacement);
                 fileData = TaskDelayReplaceRegex.Replace(fileData, TaskDelayReplaceRegexReplacement);

Program.cs

@@ -17,9 +17,11 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Windows.Forms;
 using Microsoft.Extensions.Configuration;
 using myoddweb.directorywatcher;
 using myoddweb.directorywatcher.interfaces;
+using Nito.AsyncEx;
 
 namespace AsyncToSyncCodeRoundtripSynchroniserMonitor
 {
@@ -45,7 +47,7 @@ internal static class Global
 
 
 
-        internal static readonly AsyncLockQueueDictionary FileOperationLocks = new AsyncLockQueueDictionary();
+        internal static readonly AsyncLockQueueDictionary<string> FileOperationLocks = new AsyncLockQueueDictionary<string>();
         //internal static readonly AsyncLock FileOperationAsyncLock = new AsyncLock();
     }
 #pragma warning restore S2223
@@ -227,7 +229,7 @@ await ConsoleWatch.OnAddedAsync
 
 
                     //listen for the Ctrl+C 
-                    WaitForCtrlC();
+                    await WaitForCtrlC();
 
                     Console.WriteLine("Stopping...");
 
@@ -241,7 +243,7 @@ await ConsoleWatch.OnAddedAsync
             }
             catch (Exception ex)
             {
-                WriteException(ex);
+                await WriteException(ex);
             }
         }
 
@@ -306,36 +308,75 @@ private static IEnumerable<FileInfo> ProcessSubDirs(DirectoryInfo srcDirInfo, st
             }   //foreach (var dirInfo in dirInfos)
 #endif
         }   //private static IEnumerable<FileInfo> ProcessSubDirs(DirectoryInfo srcDirInfo, string searchPattern, bool forHistory, int recursionLevel = 0)
-        private static void WriteException(Exception ex)
+        private static async Task WriteException(Exception ex)
         {
             if (ex is AggregateException aggex)
             {
-                WriteException(aggex.InnerException);
+                await WriteException(aggex.InnerException);
                 foreach (var aggexInner in aggex.InnerExceptions)
                 {
-                    WriteException(aggexInner);
+                    await WriteException(aggexInner);
                 }
                 return;
             }
 
-            Console.WriteLine(ex.Message);
+            //Console.WriteLine(ex.Message);
+            StringBuilder message = new StringBuilder(ex.Message);
             while (ex.InnerException != null)
             {
                 ex = ex.InnerException;
-                Console.WriteLine(ex.Message);
+                //Console.WriteLine(ex.Message);
+                message.Append(Environment.NewLine + ex.Message);
             }
+
+
+            var time = DateTime.Now;
+            var msg = $"[{time:yyyy.MM.dd HH:mm:ss.ffff}]:{message}";
+            await AddMessage(ConsoleColor.Red, msg, time, showAlert: true);
+        }
+
+        private static async Task AddMessage(ConsoleColor color, string message, DateTime time, bool showAlert = false)
+        {
+            await Task.Run(() =>
+            {
+                lock (ConsoleWatch.Lock)
+                {
+                    try
+                    {
+                        Console.ForegroundColor = color;
+                        Console.WriteLine(message);
+
+                        if (
+                            showAlert
+                            && (ConsoleWatch.PrevAlertTime != time || ConsoleWatch.PrevAlertMessage != message)
+                        )
+                        {
+                            MessageBox.Show(message, "AsyncToSyncCodeRoundtripSynchroniserMonitor");
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        Console.ForegroundColor = ConsoleColor.Red;
+                        Console.WriteLine(e.Message);
+                    }
+                    finally
+                    {
+                        Console.ForegroundColor = ConsoleWatch._consoleColor;
+                    }
+                }
+            });
         }
 
-        private static void WaitForCtrlC()
+        private static Task WaitForCtrlC()
         {
-            var exitEvent = new ManualResetEvent(false);
+            var exitEvent = new AsyncManualResetEvent(false);
             Console.CancelKeyPress += delegate (object sender, ConsoleCancelEventArgs e)
             {
                 e.Cancel = true;
                 Console.WriteLine("Stop detected.");
                 exitEvent.Set();
             };
-            exitEvent.WaitOne();
+            return exitEvent.WaitAsync();
         }
     }
 
@@ -368,20 +409,23 @@ internal class ConsoleWatch
         /// <summary>
         /// The original console color
         /// </summary>
-        private static readonly ConsoleColor _consoleColor = Console.ForegroundColor;
+        internal static readonly ConsoleColor _consoleColor = Console.ForegroundColor;
 
         /// <summary>
         /// We need a static lock so it is shared by all.
         /// </summary>
-        private static readonly object Lock = new object();
+        internal static readonly object Lock = new object();
         //private static readonly AsyncLock AsyncLock = new AsyncLock();  //TODO: use this
 
+        internal static DateTime PrevAlertTime;
+        internal static string PrevAlertMessage;
+
 #pragma warning disable S2223   //Warning	S2223	Change the visibility of 'DoingInitialSync' or make it 'const' or 'readonly'.
         public static bool DoingInitialSync = false;
 #pragma warning restore S2223
 
         private static ConcurrentDictionary<string, DateTime> BidirectionalConverterSavedFileDates = new ConcurrentDictionary<string, DateTime>();
-        private static readonly AsyncLockQueueDictionary FileEventLocks = new AsyncLockQueueDictionary();
+        private static readonly AsyncLockQueueDictionary<string> FileEventLocks = new AsyncLockQueueDictionary<string>();
 
 
 #pragma warning disable S1118   //Warning	S1118	Hide this public constructor by making it 'protected'.
@@ -422,7 +466,9 @@ public static async Task WriteException(Exception ex, Context context)
                 message.Append(Environment.NewLine + ex.Message);
             }
 
-            await AddMessage(ConsoleColor.Red, message.ToString(), context);
+
+            var msg = $"[{context.Time.ToLocalTime():yyyy.MM.dd HH:mm:ss.ffff}] : {context.Event?.FullName} : {message}";
+            await AddMessage(ConsoleColor.Red, msg, context, showAlert: true);
         }
 
         public static bool IsSyncPath(string fullNameInvariant)
@@ -836,7 +882,7 @@ private static async Task OnTouchedAsync(IFileSystemEvent fse, CancellationToken
         //    }
         //}
 
-        public static async Task AddMessage(ConsoleColor color, string message, Context context)
+        public static async Task AddMessage(ConsoleColor color, string message, Context context, bool showAlert = false)
         {
             await Task.Run(() =>
             {
@@ -846,7 +892,18 @@ await Task.Run(() =>
                     try
                     {
                         Console.ForegroundColor = color;
-                        Console.WriteLine($"[{context.Time.ToLocalTime():yyyy.MM.dd HH:mm:ss.ffff}]:{message}");
+                        Console.WriteLine(message);
+
+                        if (
+                            showAlert
+                            && (PrevAlertTime != context.Time || PrevAlertMessage != message)
+                        )
+                        {
+                            PrevAlertTime = context.Time;
+                            PrevAlertMessage = message;
+
+                            MessageBox.Show(message, "AsyncToSyncCodeRoundtripSynchroniserMonitor");
+                        }
                     }
                     catch (Exception e)
                     {

SyncToAsyncConverter.cs

@@ -38,6 +38,11 @@ static class SyncToAsyncConverter
         private static readonly Regex AsyncLockReplaceRegex = new Regex(@"/[*]--using--[*]/\s*lock(\s*)[(]/[*]--await--[*]/\s+([^/*()-]+)/[*]--[.]Lock\sA\ss\sy\sn\sc[(][)]--[*]/\s*[)]", RegexOptions.Singleline | RegexOptions.Compiled);
         private const string AsyncLockReplaceRegexReplacement = @"using$1(await $2.LockAsync())";
 
+
+        private static readonly Regex FuncTaskReplaceRegex = new Regex(@"([\s,(]+)Func</[*]--Task<--[*]/([^=)]+)/[*]-->--[*]/>", RegexOptions.Singleline | RegexOptions.Compiled);
+        private const string FuncTaskReplaceRegexReplacement = @"$1Func<Task<$2>>";
+
+
         static SyncToAsyncConverter()
         {
             var asyncToSyncReplacements = AsyncToSyncConverter.Replacements.GetReverse();   //NB! use reverse order
@@ -72,6 +77,7 @@ public static async Task SyncFileUpdated(string fullName, Context context)
                 fileData = TaskDelayReplaceRegex.Replace(fileData, TaskDelayReplaceRegexReplacement);
                 fileData = TaskReplaceRegex.Replace(fileData, TaskReplaceRegexReplacement);
                 fileData = AsyncLockReplaceRegex.Replace(fileData, AsyncLockReplaceRegexReplacement);
+                fileData = FuncTaskReplaceRegex.Replace(fileData, FuncTaskReplaceRegexReplacement);
 
 
                 foreach (var replacement in Replacements)