Simplified trace logging implementation.

dEajL3kA · dEajL3kA · commit bfe8d89eca9e · 2025-07-24T01:36:35.000+02:00
diff --git a/src/Dialogs/MainWindow.xaml.cs b/src/Dialogs/MainWindow.xaml.cs
@@ -2158,41 +2158,34 @@ private static async void CheckForUpdates()
             try
             {
                 Tuple<Version, Version, DateTime> versionLocal = GetVersionAndBuildDate();
-                TraceLogger logger = new TraceLogger("CheckForUpdate");
                 HashCode hashCode = HashCode.Compute($"{versionLocal.Item1}\\{versionLocal.Item2}\\{GetUnixTimeSeconds() / 3593}");
                 ulong? lastUpdateCheck = ReadRegValue(REGISTRY_VALUE_NAME);
                 if ((!lastUpdateCheck.HasValue) || (lastUpdateCheck.Value != hashCode.Value))
                 {
-                    logger.WriteLine($"Update check is starting...");
+                    TraceLog.WriteLine($"Update check is starting...");
                     Version versionRemote = await Task.Run(() => CheckForUpdatesTask(VERSION_URL, SIGNKEY_PUB));
-                    if (IsNotNull(versionRemote))
+                    if (versionRemote.CompareTo(versionLocal.Item1) > 0)
                     {
-                        try
+                        const string message = "A new program version is available!\n\nInstalled version: {0}\nLatest available version: {1}\n\nIt is recommended that you upgrade to the new version. Do you want to download the new version now?";
+                        TraceLog.WriteLine($"New program version is available: {versionLocal.Item1} -> {versionRemote}");
+                        if (MessageBox.Show(string.Format(message, versionLocal.Item1, versionRemote), "Update Notification", MessageBoxButton.YesNo, MessageBoxImage.Information) == MessageBoxResult.Yes)
                         {
-                            if (versionRemote.CompareTo(versionLocal.Item1) > 0)
-                            {
-                                const string message = "A new program version is available!\n\nInstalled version: {0}\nLatest available version: {1}\n\nIt is recommended that you upgrade to the new version. Do you want to download the new version now?";
-                                logger.WriteLine($"New program version is available: {versionLocal.Item1} -> {versionRemote}");
-                                if (MessageBox.Show(string.Format(message, versionLocal.Item1, versionRemote), "Update Notification", MessageBoxButton.YesNo, MessageBoxImage.Information) == MessageBoxResult.Yes)
-                                {
-                                    Process.Start(new ProcessStartInfo { FileName = WEBSITE_URL, UseShellExecute = true });
-                                    Application.Current.Shutdown();
-                                }
-                            }
-                            else
-                            {
-                                logger.WriteLine($"The installed program version is up to date -> nothing to do!");
-                            }
+                            Process.Start(new ProcessStartInfo { FileName = WEBSITE_URL, UseShellExecute = true });
+                            Application.Current.Shutdown();
                         }
-                        finally
+                    }
+                    else
+                    {
+                        TraceLog.WriteLine($"The installed program version is still up to date.");
+                        if (versionRemote.Major > 0)
                         {
                             WriteRegValue(REGISTRY_VALUE_NAME, hashCode.Value);
                         }
                     }
                 }
                 else
                 {
-                    logger.WriteLine($"Skipping update check this time.");
+                    TraceLog.WriteLine($"Skipping update check this time.");
                 }
             }
             catch
@@ -2203,47 +2196,46 @@ private static async void CheckForUpdates()
 
         private static Version CheckForUpdatesTask(string versionUrl, string verificationKey)
         {
-            TraceLogger logger = new TraceLogger("ChckUpdateTask");
             const int MAX_TRIES = 5;
             Tuple<string, string> updateInfo;
             Version version;
             for (int retry = 0; retry < MAX_TRIES; ++retry)
             {
-                logger.WriteLine($"Downloading update information (attempt {retry+1}/{MAX_TRIES})");
+                TraceLog.WriteLine($"Downloading update information (attempt {retry+1}/{MAX_TRIES})");
                 try
                 {
-                    if (IsNotNull(updateInfo = DownloadFileContents(versionUrl)))
+                    if (IsNotNull(updateInfo = DownloadFile(versionUrl)))
                     {
-                        logger.WriteLine( $"Update information: info=\"{updateInfo.Item1}\", signature=\"{updateInfo.Item2}\"");
+                        TraceLog.WriteLine( $"Update information: info=\"{updateInfo.Item1}\", signature=\"{updateInfo.Item2}\"");
                         if (VerifySignature(updateInfo.Item1, updateInfo.Item2, verificationKey))
                         {
-                            logger.WriteLine($"Signature is valid.");
+                            TraceLog.WriteLine($"Signature is valid.");
                             if (Version.TryParse(updateInfo.Item1, out version))
                             {
-                                logger.WriteLine($"Latest available program version is: {version}");
+                                TraceLog.WriteLine($"Latest available program version is: {version}");
                                 return version;
                             }
                             else
                             {
-                                logger.WriteLine($"Failed to parse version string!");
+                                TraceLog.WriteLine($"Failed to parse version string!");
                             }
                         }
                         else
                         {
-                            logger.WriteLine($"Signature verification has failed -> discarding update information!");
+                            TraceLog.WriteLine($"Signature verification has failed -> discarding update information!");
                         }
                     }
                     else
                     {
-                        logger.WriteLine($"Failed to download update information!");
+                        TraceLog.WriteLine($"Failed to download update information!");
                     }
                 }
                 catch
                 {
                     if (IS_DEBUG) throw;
                 }
             }
-            return null;
+            return new Version();
         }
 
         private static void StartNewInstance()
diff --git a/src/Utilities/Utilities.cs b/src/Utilities/Utilities.cs
@@ -568,21 +568,15 @@ private static void DoEventsHelper() { }
     // Trace Log
     // ==================================================================
 
-    public class TraceLogger
+    public static class TraceLog
     {
-        private readonly string m_loggerName;
         private static readonly Lazy<BooleanSwitch> TRACING = new Lazy<BooleanSwitch>(() => new BooleanSwitch("Tracing", "Enable optional trace outputs", "False"));
 
-        public TraceLogger(string name)
-        {
-            m_loggerName = string.IsNullOrWhiteSpace(name) ? string.Empty : name;
-        }
-
-        public void WriteLine(FormattableString message)
+        public static void WriteLine(FormattableString message, [CallerMemberName] string callerName = "UnknownFunction")
         {
             try
             {
-                Trace.WriteLineIf(TRACING.Value.Enabled, (FormattableString)$"[{m_loggerName}] {message}");
+                Trace.WriteLineIf(TRACING.Value.Enabled, (FormattableString)$"[{callerName}] {message}");
             }
             catch { }
         }
@@ -599,7 +593,6 @@ public static class SecurityProtocolTypeExt
 
     public static class HttpNetClient
     {
-        private static readonly TraceLogger logger = new TraceLogger("HttpWebRequest");
         private const string USER_AGENT_STRING = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0";
 
         static HttpNetClient()
@@ -617,9 +610,9 @@ static HttpNetClient()
             }
         }
 
-        public static Tuple<string, string> DownloadFileContents(string url)
+        public static Tuple<string, string> DownloadFile(string url)
         {
-            logger.WriteLine($"Request URL: {url}");
+            TraceLog.WriteLine($"Request URL: {url}");
             try
             {
                 HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
@@ -630,7 +623,7 @@ public static Tuple<string, string> DownloadFileContents(string url)
                 request.ReadWriteTimeout = 8000;
                 using (HttpWebResponse response = GetResponseNoThrow(request))
                 {
-                    logger.WriteLine($"Response status: {response.StatusCode} ({(int)response.StatusCode})");
+                    TraceLog.WriteLine($"Response status: {response.StatusCode} ({(int)response.StatusCode})");
                     if (IsSuccess(response.StatusCode))
                     {
                         using (Stream responseStream = response.GetResponseStream())
@@ -646,20 +639,20 @@ public static Tuple<string, string> DownloadFileContents(string url)
                                         lines.Add(line);
                                         if (lines.Count >= 2)
                                         {
-                                            logger.WriteLine($"Response data received successfully.");
+                                            TraceLog.WriteLine($"Response data received successfully.");
                                             return Tuple.Create(lines[0], lines[1]);
                                         }
                                     }
                                 }
                             }
                         }
-                        logger.WriteLine($"Response is empty or incomplete.");
+                        TraceLog.WriteLine($"Response is empty or incomplete.");
                     }
                 }
             }
             catch (Exception exception)
             {
-                logger.WriteLine($"Exception: {exception}");
+                TraceLog.WriteLine($"Exception: {exception}");
             }
             return null;
         }

Original file line number	Diff line number	Diff line change
`@@ -2158,41 +2158,34 @@ private static async void CheckForUpdates()`
`2158`	`2158`	`try`
`2159`	`2159`	`{`
`2160`	`2160`	`Tuple<Version, Version, DateTime> versionLocal = GetVersionAndBuildDate();`
`2161`		`- TraceLogger logger = new TraceLogger("CheckForUpdate");`
`2162`	`2161`	`HashCode hashCode = HashCode.Compute($"{versionLocal.Item1}\\{versionLocal.Item2}\\{GetUnixTimeSeconds() / 3593}");`
`2163`	`2162`	`ulong? lastUpdateCheck = ReadRegValue(REGISTRY_VALUE_NAME);`
`2164`	`2163`	`if ((!lastUpdateCheck.HasValue) \|\| (lastUpdateCheck.Value != hashCode.Value))`
`2165`	`2164`	`{`
`2166`		`- logger.WriteLine($"Update check is starting...");`
	`2165`	`+ TraceLog.WriteLine($"Update check is starting...");`
`2167`	`2166`	`Version versionRemote = await Task.Run(() => CheckForUpdatesTask(VERSION_URL, SIGNKEY_PUB));`
`2168`		`- if (IsNotNull(versionRemote))`
	`2167`	`+ if (versionRemote.CompareTo(versionLocal.Item1) > 0)`
`2169`	`2168`	`{`
`2170`		`- try`
	`2169`	`+ const string message = "A new program version is available!\n\nInstalled version: {0}\nLatest available version: {1}\n\nIt is recommended that you upgrade to the new version. Do you want to download the new version now?";`
	`2170`	`+ TraceLog.WriteLine($"New program version is available: {versionLocal.Item1} -> {versionRemote}");`
	`2171`	`+ if (MessageBox.Show(string.Format(message, versionLocal.Item1, versionRemote), "Update Notification", MessageBoxButton.YesNo, MessageBoxImage.Information) == MessageBoxResult.Yes)`
`2171`	`2172`	`{`
`2172`		`- if (versionRemote.CompareTo(versionLocal.Item1) > 0)`
`2173`		`- {`
`2174`		`- const string message = "A new program version is available!\n\nInstalled version: {0}\nLatest available version: {1}\n\nIt is recommended that you upgrade to the new version. Do you want to download the new version now?";`
`2175`		`- logger.WriteLine($"New program version is available: {versionLocal.Item1} -> {versionRemote}");`
`2176`		`- if (MessageBox.Show(string.Format(message, versionLocal.Item1, versionRemote), "Update Notification", MessageBoxButton.YesNo, MessageBoxImage.Information) == MessageBoxResult.Yes)`
`2177`		`- {`
`2178`		`- Process.Start(new ProcessStartInfo { FileName = WEBSITE_URL, UseShellExecute = true });`
`2179`		`- Application.Current.Shutdown();`
`2180`		`- }`
`2181`		`- }`
`2182`		`- else`
`2183`		`- {`
`2184`		`- logger.WriteLine($"The installed program version is up to date -> nothing to do!");`
`2185`		`- }`
	`2173`	`+ Process.Start(new ProcessStartInfo { FileName = WEBSITE_URL, UseShellExecute = true });`
	`2174`	`+ Application.Current.Shutdown();`
`2186`	`2175`	`}`
`2187`		`- finally`
	`2176`	`+ }`
	`2177`	`+ else`
	`2178`	`+ {`
	`2179`	`+ TraceLog.WriteLine($"The installed program version is still up to date.");`
	`2180`	`+ if (versionRemote.Major > 0)`
`2188`	`2181`	`{`
`2189`	`2182`	`WriteRegValue(REGISTRY_VALUE_NAME, hashCode.Value);`
`2190`	`2183`	`}`
`2191`	`2184`	`}`
`2192`	`2185`	`}`
`2193`	`2186`	`else`
`2194`	`2187`	`{`
`2195`		`- logger.WriteLine($"Skipping update check this time.");`
	`2188`	`+ TraceLog.WriteLine($"Skipping update check this time.");`
`2196`	`2189`	`}`
`2197`	`2190`	`}`
`2198`	`2191`	`catch`
`@@ -2203,47 +2196,46 @@ private static async void CheckForUpdates()`
`2203`	`2196`
`2204`	`2197`	`private static Version CheckForUpdatesTask(string versionUrl, string verificationKey)`
`2205`	`2198`	`{`
`2206`		`- TraceLogger logger = new TraceLogger("ChckUpdateTask");`
`2207`	`2199`	`const int MAX_TRIES = 5;`
`2208`	`2200`	`Tuple<string, string> updateInfo;`
`2209`	`2201`	`Version version;`
`2210`	`2202`	`for (int retry = 0; retry < MAX_TRIES; ++retry)`
`2211`	`2203`	`{`
`2212`		`- logger.WriteLine($"Downloading update information (attempt {retry+1}/{MAX_TRIES})");`
	`2204`	`+ TraceLog.WriteLine($"Downloading update information (attempt {retry+1}/{MAX_TRIES})");`
`2213`	`2205`	`try`
`2214`	`2206`	`{`
`2215`		`- if (IsNotNull(updateInfo = DownloadFileContents(versionUrl)))`
	`2207`	`+ if (IsNotNull(updateInfo = DownloadFile(versionUrl)))`
`2216`	`2208`	`{`
`2217`		`- logger.WriteLine( $"Update information: info=\"{updateInfo.Item1}\", signature=\"{updateInfo.Item2}\"");`
	`2209`	`+ TraceLog.WriteLine( $"Update information: info=\"{updateInfo.Item1}\", signature=\"{updateInfo.Item2}\"");`
`2218`	`2210`	`if (VerifySignature(updateInfo.Item1, updateInfo.Item2, verificationKey))`
`2219`	`2211`	`{`
`2220`		`- logger.WriteLine($"Signature is valid.");`
	`2212`	`+ TraceLog.WriteLine($"Signature is valid.");`
`2221`	`2213`	`if (Version.TryParse(updateInfo.Item1, out version))`
`2222`	`2214`	`{`
`2223`		`- logger.WriteLine($"Latest available program version is: {version}");`
	`2215`	`+ TraceLog.WriteLine($"Latest available program version is: {version}");`
`2224`	`2216`	`return version;`
`2225`	`2217`	`}`
`2226`	`2218`	`else`
`2227`	`2219`	`{`
`2228`		`- logger.WriteLine($"Failed to parse version string!");`
	`2220`	`+ TraceLog.WriteLine($"Failed to parse version string!");`
`2229`	`2221`	`}`
`2230`	`2222`	`}`
`2231`	`2223`	`else`
`2232`	`2224`	`{`
`2233`		`- logger.WriteLine($"Signature verification has failed -> discarding update information!");`
	`2225`	`+ TraceLog.WriteLine($"Signature verification has failed -> discarding update information!");`
`2234`	`2226`	`}`
`2235`	`2227`	`}`
`2236`	`2228`	`else`
`2237`	`2229`	`{`
`2238`		`- logger.WriteLine($"Failed to download update information!");`
	`2230`	`+ TraceLog.WriteLine($"Failed to download update information!");`
`2239`	`2231`	`}`
`2240`	`2232`	`}`
`2241`	`2233`	`catch`
`2242`	`2234`	`{`
`2243`	`2235`	`if (IS_DEBUG) throw;`
`2244`	`2236`	`}`
`2245`	`2237`	`}`
`2246`		`- return null;`
	`2238`	`+ return new Version();`
`2247`	`2239`	`}`
`2248`	`2240`
`2249`	`2241`	`private static void StartNewInstance()`
Original file line number	Diff line number	Diff line change
`@@ -568,21 +568,15 @@ private static void DoEventsHelper() { }`
`568`	`568`	`// Trace Log`
`569`	`569`	`// ==================================================================`
`570`	`570`
`571`		`- public class TraceLogger`
	`571`	`+ public static class TraceLog`
`572`	`572`	`{`
`573`		`- private readonly string m_loggerName;`
`574`	`573`	`private static readonly Lazy<BooleanSwitch> TRACING = new Lazy<BooleanSwitch>(() => new BooleanSwitch("Tracing", "Enable optional trace outputs", "False"));`
`575`	`574`
`576`		`- public TraceLogger(string name)`
`577`		`- {`
`578`		`- m_loggerName = string.IsNullOrWhiteSpace(name) ? string.Empty : name;`
`579`		`- }`
`580`		`-`
`581`		`- public void WriteLine(FormattableString message)`
	`575`	`+ public static void WriteLine(FormattableString message, [CallerMemberName] string callerName = "UnknownFunction")`
`582`	`576`	`{`
`583`	`577`	`try`
`584`	`578`	`{`
`585`		`- Trace.WriteLineIf(TRACING.Value.Enabled, (FormattableString)$"[{m_loggerName}] {message}");`
	`579`	`+ Trace.WriteLineIf(TRACING.Value.Enabled, (FormattableString)$"[{callerName}] {message}");`
`586`	`580`	`}`
`587`	`581`	`catch { }`
`588`	`582`	`}`
`@@ -599,7 +593,6 @@ public static class SecurityProtocolTypeExt`
`599`	`593`
`600`	`594`	`public static class HttpNetClient`
`601`	`595`	`{`
`602`		`- private static readonly TraceLogger logger = new TraceLogger("HttpWebRequest");`
`603`	`596`	`private const string USER_AGENT_STRING = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0";`
`604`	`597`
`605`	`598`	`static HttpNetClient()`
`@@ -617,9 +610,9 @@ static HttpNetClient()`
`617`	`610`	`}`
`618`	`611`	`}`
`619`	`612`
`620`		`- public static Tuple<string, string> DownloadFileContents(string url)`
	`613`	`+ public static Tuple<string, string> DownloadFile(string url)`
`621`	`614`	`{`
`622`		`- logger.WriteLine($"Request URL: {url}");`
	`615`	`+ TraceLog.WriteLine($"Request URL: {url}");`
`623`	`616`	`try`
`624`	`617`	`{`
`625`	`618`	`HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);`
`@@ -630,7 +623,7 @@ public static Tuple<string, string> DownloadFileContents(string url)`
`630`	`623`	`request.ReadWriteTimeout = 8000;`
`631`	`624`	`using (HttpWebResponse response = GetResponseNoThrow(request))`
`632`	`625`	`{`
`633`		`- logger.WriteLine($"Response status: {response.StatusCode} ({(int)response.StatusCode})");`
	`626`	`+ TraceLog.WriteLine($"Response status: {response.StatusCode} ({(int)response.StatusCode})");`
`634`	`627`	`if (IsSuccess(response.StatusCode))`
`635`	`628`	`{`
`636`	`629`	`using (Stream responseStream = response.GetResponseStream())`
`@@ -646,20 +639,20 @@ public static Tuple<string, string> DownloadFileContents(string url)`
`646`	`639`	`lines.Add(line);`
`647`	`640`	`if (lines.Count >= 2)`
`648`	`641`	`{`
`649`		`- logger.WriteLine($"Response data received successfully.");`
	`642`	`+ TraceLog.WriteLine($"Response data received successfully.");`
`650`	`643`	`return Tuple.Create(lines[0], lines[1]);`
`651`	`644`	`}`
`652`	`645`	`}`
`653`	`646`	`}`
`654`	`647`	`}`
`655`	`648`	`}`
`656`		`- logger.WriteLine($"Response is empty or incomplete.");`
	`649`	`+ TraceLog.WriteLine($"Response is empty or incomplete.");`
`657`	`650`	`}`
`658`	`651`	`}`
`659`	`652`	`}`
`660`	`653`	`catch (Exception exception)`
`661`	`654`	`{`
`662`		`- logger.WriteLine($"Exception: {exception}");`
	`655`	`+ TraceLog.WriteLine($"Exception: {exception}");`
`663`	`656`	`}`
`664`	`657`	`return null;`
`665`	`658`	`}`