dotnet: drop .NET Framework-specific code

mjcheetham · mjcheetham · commit 069df601580f · 2025-11-10T16:32:58.000Z
diff --git a/src/shared/Core/Authentication/AuthenticationBase.cs b/src/shared/Core/Authentication/AuthenticationBase.cs
@@ -60,11 +60,7 @@ protected internal virtual async Task<IDictionary<string, string>> InvokeHelperA
             // Write the standard input to the process if we have any to write
             if (standardInput is not null)
             {
-#if NETFRAMEWORK
-                await standardInput.BaseStream.CopyToAsync(process.StandardInput.BaseStream);
-#else
                 await standardInput.BaseStream.CopyToAsync(process.StandardInput.BaseStream, ct);
-#endif
                 process.StandardInput.Close();
             }
 
diff --git a/src/shared/Core/Authentication/MicrosoftAuthentication.cs b/src/shared/Core/Authentication/MicrosoftAuthentication.cs
@@ -15,10 +15,7 @@
 using GitCredentialManager.UI.ViewModels;
 using GitCredentialManager.UI.Views;
 using Microsoft.Identity.Client.AppConfig;
-
-#if NETFRAMEWORK
 using Microsoft.Identity.Client.Broker;
-#endif
 
 namespace GitCredentialManager.Authentication
 {
@@ -508,15 +505,13 @@ private async Task<IPublicClientApplication> CreatePublicClientApplicationAsync(
             // to save on the distribution size of the .NET builds (no need for MSALRuntime bits).
             if (enableBroker)
             {
-#if NETFRAMEWORK
                 appBuilder.WithBroker(
                     new BrokerOptions(BrokerOptions.OperatingSystems.Windows)
                     {
                         Title = "Git Credential Manager",
                         MsaPassthrough = msaPt,
                     }
                 );
-#endif
             }
 
             IPublicClientApplication app = appBuilder.Build();
@@ -808,7 +803,6 @@ public HttpClient GetHttpClient()
 
         public bool CanUseBroker()
         {
-#if NETFRAMEWORK
             // We only support the broker on Windows 10+ and in an interactive session
             if (!Context.SessionManager.IsDesktopSession || !PlatformUtils.IsWindowsBrokerSupported())
             {
@@ -827,34 +821,27 @@ public bool CanUseBroker()
             }
 
             return defaultValue;
-#else
-            // OS broker requires .NET Framework right now until we migrate to .NET 5.0 (net5.0-windows10.x.y.z)
-            return false;
-#endif
         }
 
         private bool CanUseEmbeddedWebView()
         {
-            // If we're in an interactive session and on .NET Framework then MSAL can show the WinForms-based embedded UI
-#if NETFRAMEWORK
-            return Context.SessionManager.IsDesktopSession;
-#else
-            return false;
-#endif
+            // If we're in an interactive session and on Windows then MSAL can show the WinForms-based embedded UI
+            return PlatformUtils.IsWindows() && Context.SessionManager.IsDesktopSession;
         }
 
         private void EnsureCanUseEmbeddedWebView()
         {
-#if NETFRAMEWORK
             if (!Context.SessionManager.IsDesktopSession)
             {
                 throw new Trace2InvalidOperationException(Context.Trace2,
                     "Embedded web view is not available without a desktop session.");
             }
-#else
-            throw new Trace2InvalidOperationException(Context.Trace2,
-                "Embedded web view is not available on .NET Core.");
-#endif
+
+            if (!PlatformUtils.IsWindows())
+            {
+                throw new Trace2InvalidOperationException(Context.Trace2,
+                    "Embedded web view is only available on Windows.");
+            }
         }
 
         private bool CanUseSystemWebView(IPublicClientApplication app, Uri redirectUri)
diff --git a/src/shared/Core/CurlCookie.cs b/src/shared/Core/CurlCookie.cs
@@ -66,18 +66,12 @@ public IList<Cookie> Parse(string content)
 
         private static DateTime ParseExpires(string expires)
         {
-#if NETFRAMEWORK
-            DateTime epoch = new DateTime(1970, 01, 01, 0, 0, 0, DateTimeKind.Utc);
-#else
-            DateTime epoch = DateTime.UnixEpoch;
-#endif
-
             if (long.TryParse(expires, out long i))
             {
-                return epoch.AddSeconds(i);
+                return DateTime.UnixEpoch.AddSeconds(i);
             }
 
-            return epoch;
+            return DateTime.UnixEpoch;
         }
     }
-}
+}
diff --git a/src/shared/Core/HttpClientFactory.cs b/src/shared/Core/HttpClientFactory.cs
@@ -99,11 +99,7 @@ public HttpClient CreateClient()
                 _streams.Error.WriteLine("warning: ---------------------------------------------------");
                 _streams.Error.WriteLine($"warning: HTTPS connections may not be secure. See {Constants.HelpUrls.GcmTlsVerification} for more information.");
 
-#if NETFRAMEWORK
-                ServicePointManager.ServerCertificateValidationCallback = (req, cert, chain, errors) => true;
-#else
                 handler.ServerCertificateCustomValidationCallback = (req, cert, chain, errors) => true;
-#endif
             }
             // If schannel is the TLS backend, custom certificate usage must be explicitly enabled
             else if (!string.IsNullOrWhiteSpace(_settings.CustomCertificateBundlePath) &&
@@ -178,23 +174,7 @@ public HttpClient CreateClient()
 
                 // Set the custom server certificate validation callback.
                 // NOTE: this is executed after the default platform server certificate validation is performed
-#if NETFRAMEWORK
-                ServicePointManager.ServerCertificateValidationCallback = (_, cert, chain, errors) =>
-                {
-                    // Fail immediately if the cert or chain isn't present
-                    if (cert is null || chain is null)
-                    {
-                        return false;
-                    }
-
-                    using (X509Certificate2 cert2 = new X509Certificate2(cert))
-                    {
-                        return validationCallback(cert2, chain, errors);
-                    }
-                };
-#else
                 handler.ServerCertificateCustomValidationCallback = (_, cert, chain, errors) => validationCallback(cert, chain, errors);
-#endif
             }
 
             // If CustomCookieFilePath is set, set Cookie header from cookie file, which is written by libcurl
diff --git a/src/shared/Core/Interop/Posix/PosixFileSystem.cs b/src/shared/Core/Interop/Posix/PosixFileSystem.cs
@@ -13,13 +13,6 @@ public abstract class PosixFileSystem : FileSystem
         /// <exception cref="ArgumentException">Path is not absolute.</exception>
         protected internal static string ResolveSymbolicLinks(string path)
         {
-#if NETFRAMEWORK
-            // Support for symlinks only exists in .NET 6+.
-            // Since we're still targeting .NET Framework on Windows it
-            // doesn't matter if we don't resolve symlinks for POSIX here
-            // (unless we're running on Mono.. but why do that?)
-            return path;
-#else
             if (!Path.IsPathRooted(path))
             {
                 throw new ArgumentException("Path must be absolute", nameof(path));
@@ -54,10 +47,8 @@ protected internal static string ResolveSymbolicLinks(string path)
             }
 
             return Path.Combine("/", partialPath);
-#endif
         }
 
-#if !NETFRAMEWORK
         private static bool TryResolveFileLink(string path, out string target)
         {
             FileSystemInfo fsi = File.ResolveLinkTarget(path, true);
@@ -71,6 +62,5 @@ private static bool TryResolveDirectoryLink(string path, out string target)
             target = fsi?.FullName;
             return fsi != null;
         }
-#endif
     }
 }
diff --git a/src/shared/Core/Interop/Windows/WindowsSettings.cs b/src/shared/Core/Interop/Windows/WindowsSettings.cs
@@ -21,7 +21,6 @@ protected override bool TryGetExternalDefault(string section, string scope, stri
         {
             value = null;
 
-#if NETFRAMEWORK
             // Check for machine (HKLM) registry keys that match the Git configuration name.
             // These can be set by system administrators via Group Policy, so make useful defaults.
             using (Microsoft.Win32.RegistryKey configKey = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(Constants.WindowsRegistry.HKConfigurationPath))
@@ -48,9 +47,6 @@ protected override bool TryGetExternalDefault(string section, string scope, stri
 
                 return true;
             }
-#else
-            return base.TryGetExternalDefault(section, scope, property, out value);
-#endif
         }
     }
 }
diff --git a/src/shared/Core/PlatformUtils.cs b/src/shared/Core/PlatformUtils.cs
@@ -31,7 +31,6 @@ public static bool IsDevBox()
                 return false;
             }
 
-#if NETFRAMEWORK
             // Check for machine (HKLM) registry keys for Cloud PC indicators
             // Note that the keys are only found in the 64-bit registry view
             using (Microsoft.Win32.RegistryKey hklm64 = Microsoft.Win32.RegistryKey.OpenBaseKey(Microsoft.Win32.RegistryHive.LocalMachine, Microsoft.Win32.RegistryView.Registry64))
@@ -48,9 +47,6 @@ public static bool IsDevBox()
 
                 return w365Value is not null && Guid.TryParse(partnerValue, out Guid partnerId) && partnerId == Constants.DevBoxPartnerId;
             }
-#else
-            return false;
-#endif
         }
 
         /// <summary>
@@ -197,11 +193,9 @@ public static bool IsElevatedUser()
         {
             if (IsWindows())
             {
-#if NETFRAMEWORK
                 var identity = System.Security.Principal.WindowsIdentity.GetCurrent();
                 var principal = new System.Security.Principal.WindowsPrincipal(identity);
                 return principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator);
-#endif
             }
             else if (IsPosix())
             {
@@ -287,9 +281,6 @@ private static string GetLinuxEntryPath()
                 }
             }
 
-#if NETFRAMEWORK
-            return null;
-#else
             //
             // We cannot determine the absolute file path from argv[0]
             // (how we were launched), so let's now try to extract the
@@ -299,7 +290,6 @@ private static string GetLinuxEntryPath()
             //
             FileSystemInfo fsi = File.ResolveLinkTarget("/proc/self/exe", returnFinalTarget: false);
             return fsi?.FullName;
-#endif
         }
 
         private static string GetMacOSEntryPath()
@@ -368,12 +358,11 @@ private static string GetOSVersion(ITrace2 trace2)
             // However, we still need to use the old method for Windows on .NET Framework
             // and call into the Win32 API to get the correct version (regardless of app
             // compatibility settings).
-#if NETFRAMEWORK
             if (IsWindows() && RtlGetVersionEx(out RTL_OSVERSIONINFOEX osvi) == 0)
             {
                 return $"{osvi.dwMajorVersion}.{osvi.dwMinorVersion} (build {osvi.dwBuildNumber})";
             }
-#endif
+
             if (IsWindows() || IsMacOS())
             {
                 return Environment.OSVersion.Version.ToString();
diff --git a/src/shared/Core/UI/AvaloniaUi.cs b/src/shared/Core/UI/AvaloniaUi.cs
@@ -65,22 +65,15 @@ public static Task ShowWindowAsync(Func<Window> windowFunc, object dataContext,
                 {
                     var appBuilder = AppBuilder.Configure<AvaloniaApp>();
 
-#if NETFRAMEWORK
                     // Set custom rendering options and modes if required
                     if (PlatformUtils.IsWindows() && _win32SoftwareRendering)
                     {
                         appBuilder.With(new Win32PlatformOptions
                             { RenderingMode = new[] { Win32RenderingMode.Software } });
                     }
-#endif
 
                     appBuilder
-#if NETFRAMEWORK
-                        .UseWin32()
-                        .UseSkia()
-#else
                         .UsePlatformDetect()
-#endif
                         .LogToTrace()
                         .SetupWithoutStarting();
 
diff --git a/src/shared/Git-Credential-Manager/Program.cs b/src/shared/Git-Credential-Manager/Program.cs
@@ -76,12 +76,7 @@ private static void AppMain(object o)
         // Required for Avalonia designer
         static AppBuilder BuildAvaloniaApp() =>
             AppBuilder.Configure<AvaloniaApp>()
-#if NETFRAMEWORK
-                .UseWin32()
-                .UseSkia()
-#else
                 .UsePlatformDetect()
-#endif
                 .LogToTrace();
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -60,11 +60,7 @@ protected internal virtual async Task<IDictionary<string, string>> InvokeHelperA`
`60`	`60`	`// Write the standard input to the process if we have any to write`
`61`	`61`	`if (standardInput is not null)`
`62`	`62`	`{`
`63`		`-#if NETFRAMEWORK`
`64`		`- await standardInput.BaseStream.CopyToAsync(process.StandardInput.BaseStream);`
`65`		`-#else`
`66`	`63`	`await standardInput.BaseStream.CopyToAsync(process.StandardInput.BaseStream, ct);`
`67`		`-#endif`
`68`	`64`	`process.StandardInput.Close();`
`69`	`65`	`}`
`70`	`66`
Original file line number	Diff line number	Diff line change
`@@ -15,10 +15,7 @@`
`15`	`15`	`using GitCredentialManager.UI.ViewModels;`
`16`	`16`	`using GitCredentialManager.UI.Views;`
`17`	`17`	`using Microsoft.Identity.Client.AppConfig;`
`18`		`-`
`19`		`-#if NETFRAMEWORK`
`20`	`18`	`using Microsoft.Identity.Client.Broker;`
`21`		`-#endif`
`22`	`19`
`23`	`20`	`namespace GitCredentialManager.Authentication`
`24`	`21`	`{`
`@@ -508,15 +505,13 @@ private async Task<IPublicClientApplication> CreatePublicClientApplicationAsync(`
`508`	`505`	`// to save on the distribution size of the .NET builds (no need for MSALRuntime bits).`
`509`	`506`	`if (enableBroker)`
`510`	`507`	`{`
`511`		`-#if NETFRAMEWORK`
`512`	`508`	`appBuilder.WithBroker(`
`513`	`509`	`new BrokerOptions(BrokerOptions.OperatingSystems.Windows)`
`514`	`510`	`{`
`515`	`511`	`Title = "Git Credential Manager",`
`516`	`512`	`MsaPassthrough = msaPt,`
`517`	`513`	`}`
`518`	`514`	`);`
`519`		`-#endif`
`520`	`515`	`}`
`521`	`516`
`522`	`517`	`IPublicClientApplication app = appBuilder.Build();`
`@@ -808,7 +803,6 @@ public HttpClient GetHttpClient()`
`808`	`803`
`809`	`804`	`public bool CanUseBroker()`
`810`	`805`	`{`
`811`		`-#if NETFRAMEWORK`
`812`	`806`	`// We only support the broker on Windows 10+ and in an interactive session`
`813`	`807`	`if (!Context.SessionManager.IsDesktopSession \|\| !PlatformUtils.IsWindowsBrokerSupported())`
`814`	`808`	`{`
`@@ -827,34 +821,27 @@ public bool CanUseBroker()`
`827`	`821`	`}`
`828`	`822`
`829`	`823`	`return defaultValue;`
`830`		`-#else`
`831`		`- // OS broker requires .NET Framework right now until we migrate to .NET 5.0 (net5.0-windows10.x.y.z)`
`832`		`- return false;`
`833`		`-#endif`
`834`	`824`	`}`
`835`	`825`
`836`	`826`	`private bool CanUseEmbeddedWebView()`
`837`	`827`	`{`
`838`		`- // If we're in an interactive session and on .NET Framework then MSAL can show the WinForms-based embedded UI`
`839`		`-#if NETFRAMEWORK`
`840`		`- return Context.SessionManager.IsDesktopSession;`
`841`		`-#else`
`842`		`- return false;`
`843`		`-#endif`
	`828`	`+ // If we're in an interactive session and on Windows then MSAL can show the WinForms-based embedded UI`
	`829`	`+ return PlatformUtils.IsWindows() && Context.SessionManager.IsDesktopSession;`
`844`	`830`	`}`
`845`	`831`
`846`	`832`	`private void EnsureCanUseEmbeddedWebView()`
`847`	`833`	`{`
`848`		`-#if NETFRAMEWORK`
`849`	`834`	`if (!Context.SessionManager.IsDesktopSession)`
`850`	`835`	`{`
`851`	`836`	`throw new Trace2InvalidOperationException(Context.Trace2,`
`852`	`837`	`"Embedded web view is not available without a desktop session.");`
`853`	`838`	`}`
`854`		`-#else`
`855`		`- throw new Trace2InvalidOperationException(Context.Trace2,`
`856`		`- "Embedded web view is not available on .NET Core.");`
`857`		`-#endif`
	`839`	`+`
	`840`	`+ if (!PlatformUtils.IsWindows())`
	`841`	`+ {`
	`842`	`+ throw new Trace2InvalidOperationException(Context.Trace2,`
	`843`	`+ "Embedded web view is only available on Windows.");`
	`844`	`+ }`
`858`	`845`	`}`
`859`	`846`
`860`	`847`	`private bool CanUseSystemWebView(IPublicClientApplication app, Uri redirectUri)`
Original file line number	Diff line number	Diff line change
`@@ -66,18 +66,12 @@ public IList<Cookie> Parse(string content)`
`66`	`66`
`67`	`67`	`private static DateTime ParseExpires(string expires)`
`68`	`68`	`{`
`69`		`-#if NETFRAMEWORK`
`70`		`- DateTime epoch = new DateTime(1970, 01, 01, 0, 0, 0, DateTimeKind.Utc);`
`71`		`-#else`
`72`		`- DateTime epoch = DateTime.UnixEpoch;`
`73`		`-#endif`
`74`		`-`
`75`	`69`	`if (long.TryParse(expires, out long i))`
`76`	`70`	`{`
`77`		`- return epoch.AddSeconds(i);`
	`71`	`+ return DateTime.UnixEpoch.AddSeconds(i);`
`78`	`72`	`}`
`79`	`73`
`80`		`- return epoch;`
	`74`	`+ return DateTime.UnixEpoch;`
`81`	`75`	`}`
`82`	`76`	`}`
`83`		`-}`
	`77`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -13,13 +13,6 @@ public abstract class PosixFileSystem : FileSystem`
`13`	`13`	`/// <exception cref="ArgumentException">Path is not absolute.</exception>`
`14`	`14`	`protected internal static string ResolveSymbolicLinks(string path)`
`15`	`15`	`{`
`16`		`-#if NETFRAMEWORK`
`17`		`- // Support for symlinks only exists in .NET 6+.`
`18`		`- // Since we're still targeting .NET Framework on Windows it`
`19`		`- // doesn't matter if we don't resolve symlinks for POSIX here`
`20`		`- // (unless we're running on Mono.. but why do that?)`
`21`		`- return path;`
`22`		`-#else`
`23`	`16`	`if (!Path.IsPathRooted(path))`
`24`	`17`	`{`
`25`	`18`	`throw new ArgumentException("Path must be absolute", nameof(path));`
`@@ -54,10 +47,8 @@ protected internal static string ResolveSymbolicLinks(string path)`
`54`	`47`	`}`
`55`	`48`
`56`	`49`	`return Path.Combine("/", partialPath);`
`57`		`-#endif`
`58`	`50`	`}`
`59`	`51`
`60`		`-#if !NETFRAMEWORK`
`61`	`52`	`private static bool TryResolveFileLink(string path, out string target)`
`62`	`53`	`{`
`63`	`54`	`FileSystemInfo fsi = File.ResolveLinkTarget(path, true);`
`@@ -71,6 +62,5 @@ private static bool TryResolveDirectoryLink(string path, out string target)`
`71`	`62`	`target = fsi?.FullName;`
`72`	`63`	`return fsi != null;`
`73`	`64`	`}`
`74`		`-#endif`
`75`	`65`	`}`
`76`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,6 @@ protected override bool TryGetExternalDefault(string section, string scope, stri`
`21`	`21`	`{`
`22`	`22`	`value = null;`
`23`	`23`
`24`		`-#if NETFRAMEWORK`
`25`	`24`	`// Check for machine (HKLM) registry keys that match the Git configuration name.`
`26`	`25`	`// These can be set by system administrators via Group Policy, so make useful defaults.`
`27`	`26`	`using (Microsoft.Win32.RegistryKey configKey = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(Constants.WindowsRegistry.HKConfigurationPath))`
`@@ -48,9 +47,6 @@ protected override bool TryGetExternalDefault(string section, string scope, stri`
`48`	`47`
`49`	`48`	`return true;`
`50`	`49`	`}`
`51`		`-#else`
`52`		`- return base.TryGetExternalDefault(section, scope, property, out value);`
`53`		`-#endif`
`54`	`50`	`}`
`55`	`51`	`}`
`56`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,6 @@ public static bool IsDevBox()`
`31`	`31`	`return false;`
`32`	`32`	`}`
`33`	`33`
`34`		`-#if NETFRAMEWORK`
`35`	`34`	`// Check for machine (HKLM) registry keys for Cloud PC indicators`
`36`	`35`	`// Note that the keys are only found in the 64-bit registry view`
`37`	`36`	`using (Microsoft.Win32.RegistryKey hklm64 = Microsoft.Win32.RegistryKey.OpenBaseKey(Microsoft.Win32.RegistryHive.LocalMachine, Microsoft.Win32.RegistryView.Registry64))`
`@@ -48,9 +47,6 @@ public static bool IsDevBox()`
`48`	`47`
`49`	`48`	`return w365Value is not null && Guid.TryParse(partnerValue, out Guid partnerId) && partnerId == Constants.DevBoxPartnerId;`
`50`	`49`	`}`
`51`		`-#else`
`52`		`- return false;`
`53`		`-#endif`
`54`	`50`	`}`
`55`	`51`
`56`	`52`	`/// <summary>`
`@@ -197,11 +193,9 @@ public static bool IsElevatedUser()`
`197`	`193`	`{`
`198`	`194`	`if (IsWindows())`
`199`	`195`	`{`
`200`		`-#if NETFRAMEWORK`
`201`	`196`	`var identity = System.Security.Principal.WindowsIdentity.GetCurrent();`
`202`	`197`	`var principal = new System.Security.Principal.WindowsPrincipal(identity);`
`203`	`198`	`return principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator);`
`204`		`-#endif`
`205`	`199`	`}`
`206`	`200`	`else if (IsPosix())`
`207`	`201`	`{`
`@@ -287,9 +281,6 @@ private static string GetLinuxEntryPath()`
`287`	`281`	`}`
`288`	`282`	`}`
`289`	`283`
`290`		`-#if NETFRAMEWORK`
`291`		`- return null;`
`292`		`-#else`
`293`	`284`	`//`
`294`	`285`	`// We cannot determine the absolute file path from argv[0]`
`295`	`286`	`// (how we were launched), so let's now try to extract the`
`@@ -299,7 +290,6 @@ private static string GetLinuxEntryPath()`
`299`	`290`	`//`
`300`	`291`	`FileSystemInfo fsi = File.ResolveLinkTarget("/proc/self/exe", returnFinalTarget: false);`
`301`	`292`	`return fsi?.FullName;`
`302`		`-#endif`
`303`	`293`	`}`
`304`	`294`
`305`	`295`	`private static string GetMacOSEntryPath()`
`@@ -368,12 +358,11 @@ private static string GetOSVersion(ITrace2 trace2)`
`368`	`358`	`// However, we still need to use the old method for Windows on .NET Framework`
`369`	`359`	`// and call into the Win32 API to get the correct version (regardless of app`
`370`	`360`	`// compatibility settings).`
`371`		`-#if NETFRAMEWORK`
`372`	`361`	`if (IsWindows() && RtlGetVersionEx(out RTL_OSVERSIONINFOEX osvi) == 0)`
`373`	`362`	`{`
`374`	`363`	`return $"{osvi.dwMajorVersion}.{osvi.dwMinorVersion} (build {osvi.dwBuildNumber})";`
`375`	`364`	`}`
`376`		`-#endif`
	`365`	`+`
`377`	`366`	`if (IsWindows() \|\| IsMacOS())`
`378`	`367`	`{`
`379`	`368`	`return Environment.OSVersion.Version.ToString();`
Original file line number	Diff line number	Diff line change
`@@ -76,12 +76,7 @@ private static void AppMain(object o)`
`76`	`76`	`// Required for Avalonia designer`
`77`	`77`	`static AppBuilder BuildAvaloniaApp() =>`
`78`	`78`	`AppBuilder.Configure<AvaloniaApp>()`
`79`		`-#if NETFRAMEWORK`
`80`		`- .UseWin32()`
`81`		`- .UseSkia()`
`82`		`-#else`
`83`	`79`	`.UsePlatformDetect()`
`84`		`-#endif`
`85`	`80`	`.LogToTrace();`
`86`	`81`	`}`
`87`	`82`	`}`