dotnet: drop .NET Framework-specific code

mjcheetham · mjcheetham · commit 26735d17ec89 · 2023-10-25T11:45:42.000-07:00
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
 {
@@ -501,15 +498,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();
@@ -801,7 +796,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())
             {
@@ -820,34 +814,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
         }
 
         public static bool IsWindowsBrokerSupported()
@@ -99,11 +95,7 @@ public static bool IsWindowsBrokerSupported()
         /// <returns>True if running on macOS, false otherwise.</returns>
         public static bool IsMacOS()
         {
-#if NETFRAMEWORK
-            return Environment.OSVersion.Platform == PlatformID.MacOSX;
-#else
             return RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
-#endif
         }
 
         /// <summary>
@@ -112,11 +104,7 @@ public static bool IsMacOS()
         /// <returns>True if running on Windows, false otherwise.</returns>
         public static bool IsWindows()
         {
-#if NETFRAMEWORK
-            return Environment.OSVersion.Platform == PlatformID.Win32NT;
-#else
             return RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
-#endif
         }
 
         /// <summary>
@@ -125,11 +113,7 @@ public static bool IsWindows()
         /// <returns>True if running on a Linux distribution, false otherwise.</returns>
         public static bool IsLinux()
         {
-#if NETFRAMEWORK
-            return Environment.OSVersion.Platform == PlatformID.Unix;
-#else
             return RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
-#endif
         }
 
         /// <summary>
@@ -193,11 +177,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())
             {
@@ -283,9 +265,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
@@ -295,7 +274,6 @@ private static string GetLinuxEntryPath()
             //
             FileSystemInfo fsi = File.ResolveLinkTarget("/proc/self/exe", returnFinalTarget: false);
             return fsi?.FullName;
-#endif
         }
 
         private static string GetMacOSEntryPath()
@@ -364,12 +342,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();
@@ -459,9 +436,6 @@ string GetLinuxDistroVersion()
 
         private static string GetCpuArchitecture()
         {
-#if NETFRAMEWORK
-            return Environment.Is64BitOperatingSystem ? "x86-64" : "x86";
-#else
             switch (RuntimeInformation.OSArchitecture)
             {
                 case Architecture.Arm:
@@ -475,16 +449,11 @@ private static string GetCpuArchitecture()
                 default:
                     return RuntimeInformation.OSArchitecture.ToString();
             }
-#endif
         }
 
         private static string GetClrVersion()
         {
-#if NETFRAMEWORK
-            return $".NET Framework {Environment.Version}";
-#else
             return RuntimeInformation.FrameworkDescription;
-#endif
         }
 
         #endregion
diff --git a/src/shared/Core/UI/AvaloniaUi.cs b/src/shared/Core/UI/AvaloniaUi.cs
@@ -47,12 +47,7 @@ public static Task ShowWindowAsync(Func<Window> windowFunc, object dataContext,
                 Dispatcher.MainThread.Post(appCancelToken =>
                 {
                     AppBuilder.Configure<AvaloniaApp>()
-#if NETFRAMEWORK
-                        .UseWin32()
-                        .UseSkia()
-#else
                         .UsePlatformDetect()
-#endif
                         .LogToTrace()
                         // Workaround https://github.com/AvaloniaUI/Avalonia/issues/10296
                         // by always setting a application lifetime.
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`	`{`
`@@ -501,15 +498,13 @@ private async Task<IPublicClientApplication> CreatePublicClientApplicationAsync(`
`501`	`498`	`// to save on the distribution size of the .NET builds (no need for MSALRuntime bits).`
`502`	`499`	`if (enableBroker)`
`503`	`500`	`{`
`504`		`-#if NETFRAMEWORK`
`505`	`501`	`appBuilder.WithBroker(`
`506`	`502`	`new BrokerOptions(BrokerOptions.OperatingSystems.Windows)`
`507`	`503`	`{`
`508`	`504`	`Title = "Git Credential Manager",`
`509`	`505`	`MsaPassthrough = msaPt,`
`510`	`506`	`}`
`511`	`507`	`);`
`512`		`-#endif`
`513`	`508`	`}`
`514`	`509`
`515`	`510`	`IPublicClientApplication app = appBuilder.Build();`
`@@ -801,7 +796,6 @@ public HttpClient GetHttpClient()`
`801`	`796`
`802`	`797`	`public bool CanUseBroker()`
`803`	`798`	`{`
`804`		`-#if NETFRAMEWORK`
`805`	`799`	`// We only support the broker on Windows 10+ and in an interactive session`
`806`	`800`	`if (!Context.SessionManager.IsDesktopSession \|\| !PlatformUtils.IsWindowsBrokerSupported())`
`807`	`801`	`{`
`@@ -820,34 +814,27 @@ public bool CanUseBroker()`
`820`	`814`	`}`
`821`	`815`
`822`	`816`	`return defaultValue;`
`823`		`-#else`
`824`		`- // OS broker requires .NET Framework right now until we migrate to .NET 5.0 (net5.0-windows10.x.y.z)`
`825`		`- return false;`
`826`		`-#endif`
`827`	`817`	`}`
`828`	`818`
`829`	`819`	`private bool CanUseEmbeddedWebView()`
`830`	`820`	`{`
`831`		`- // If we're in an interactive session and on .NET Framework then MSAL can show the WinForms-based embedded UI`
`832`		`-#if NETFRAMEWORK`
`833`		`- return Context.SessionManager.IsDesktopSession;`
`834`		`-#else`
`835`		`- return false;`
`836`		`-#endif`
	`821`	`+ // If we're in an interactive session and on Windows then MSAL can show the WinForms-based embedded UI`
	`822`	`+ return PlatformUtils.IsWindows() && Context.SessionManager.IsDesktopSession;`
`837`	`823`	`}`
`838`	`824`
`839`	`825`	`private void EnsureCanUseEmbeddedWebView()`
`840`	`826`	`{`
`841`		`-#if NETFRAMEWORK`
`842`	`827`	`if (!Context.SessionManager.IsDesktopSession)`
`843`	`828`	`{`
`844`	`829`	`throw new Trace2InvalidOperationException(Context.Trace2,`
`845`	`830`	`"Embedded web view is not available without a desktop session.");`
`846`	`831`	`}`
`847`		`-#else`
`848`		`- throw new Trace2InvalidOperationException(Context.Trace2,`
`849`		`- "Embedded web view is not available on .NET Core.");`
`850`		`-#endif`
	`832`	`+`
	`833`	`+ if (!PlatformUtils.IsWindows())`
	`834`	`+ {`
	`835`	`+ throw new Trace2InvalidOperationException(Context.Trace2,`
	`836`	`+ "Embedded web view is only available on Windows.");`
	`837`	`+ }`
`851`	`838`	`}`
`852`	`839`
`853`	`840`	`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`	`public static bool IsWindowsBrokerSupported()`
`@@ -99,11 +95,7 @@ public static bool IsWindowsBrokerSupported()`
`99`	`95`	`/// <returns>True if running on macOS, false otherwise.</returns>`
`100`	`96`	`public static bool IsMacOS()`
`101`	`97`	`{`
`102`		`-#if NETFRAMEWORK`
`103`		`- return Environment.OSVersion.Platform == PlatformID.MacOSX;`
`104`		`-#else`
`105`	`98`	`return RuntimeInformation.IsOSPlatform(OSPlatform.OSX);`
`106`		`-#endif`
`107`	`99`	`}`
`108`	`100`
`109`	`101`	`/// <summary>`
`@@ -112,11 +104,7 @@ public static bool IsMacOS()`
`112`	`104`	`/// <returns>True if running on Windows, false otherwise.</returns>`
`113`	`105`	`public static bool IsWindows()`
`114`	`106`	`{`
`115`		`-#if NETFRAMEWORK`
`116`		`- return Environment.OSVersion.Platform == PlatformID.Win32NT;`
`117`		`-#else`
`118`	`107`	`return RuntimeInformation.IsOSPlatform(OSPlatform.Windows);`
`119`		`-#endif`
`120`	`108`	`}`
`121`	`109`
`122`	`110`	`/// <summary>`
`@@ -125,11 +113,7 @@ public static bool IsWindows()`
`125`	`113`	`/// <returns>True if running on a Linux distribution, false otherwise.</returns>`
`126`	`114`	`public static bool IsLinux()`
`127`	`115`	`{`
`128`		`-#if NETFRAMEWORK`
`129`		`- return Environment.OSVersion.Platform == PlatformID.Unix;`
`130`		`-#else`
`131`	`116`	`return RuntimeInformation.IsOSPlatform(OSPlatform.Linux);`
`132`		`-#endif`
`133`	`117`	`}`
`134`	`118`
`135`	`119`	`/// <summary>`
`@@ -193,11 +177,9 @@ public static bool IsElevatedUser()`
`193`	`177`	`{`
`194`	`178`	`if (IsWindows())`
`195`	`179`	`{`
`196`		`-#if NETFRAMEWORK`
`197`	`180`	`var identity = System.Security.Principal.WindowsIdentity.GetCurrent();`
`198`	`181`	`var principal = new System.Security.Principal.WindowsPrincipal(identity);`
`199`	`182`	`return principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator);`
`200`		`-#endif`
`201`	`183`	`}`
`202`	`184`	`else if (IsPosix())`
`203`	`185`	`{`
`@@ -283,9 +265,6 @@ private static string GetLinuxEntryPath()`
`283`	`265`	`}`
`284`	`266`	`}`
`285`	`267`
`286`		`-#if NETFRAMEWORK`
`287`		`- return null;`
`288`		`-#else`
`289`	`268`	`//`
`290`	`269`	`// We cannot determine the absolute file path from argv[0]`
`291`	`270`	`// (how we were launched), so let's now try to extract the`
`@@ -295,7 +274,6 @@ private static string GetLinuxEntryPath()`
`295`	`274`	`//`
`296`	`275`	`FileSystemInfo fsi = File.ResolveLinkTarget("/proc/self/exe", returnFinalTarget: false);`
`297`	`276`	`return fsi?.FullName;`
`298`		`-#endif`
`299`	`277`	`}`
`300`	`278`
`301`	`279`	`private static string GetMacOSEntryPath()`
`@@ -364,12 +342,11 @@ private static string GetOSVersion(ITrace2 trace2)`
`364`	`342`	`// However, we still need to use the old method for Windows on .NET Framework`
`365`	`343`	`// and call into the Win32 API to get the correct version (regardless of app`
`366`	`344`	`// compatibility settings).`
`367`		`-#if NETFRAMEWORK`
`368`	`345`	`if (IsWindows() && RtlGetVersionEx(out RTL_OSVERSIONINFOEX osvi) == 0)`
`369`	`346`	`{`
`370`	`347`	`return $"{osvi.dwMajorVersion}.{osvi.dwMinorVersion} (build {osvi.dwBuildNumber})";`
`371`	`348`	`}`
`372`		`-#endif`
	`349`	`+`
`373`	`350`	`if (IsWindows() \|\| IsMacOS())`
`374`	`351`	`{`
`375`	`352`	`return Environment.OSVersion.Version.ToString();`
`@@ -459,9 +436,6 @@ string GetLinuxDistroVersion()`
`459`	`436`
`460`	`437`	`private static string GetCpuArchitecture()`
`461`	`438`	`{`
`462`		`-#if NETFRAMEWORK`
`463`		`- return Environment.Is64BitOperatingSystem ? "x86-64" : "x86";`
`464`		`-#else`
`465`	`439`	`switch (RuntimeInformation.OSArchitecture)`
`466`	`440`	`{`
`467`	`441`	`case Architecture.Arm:`
`@@ -475,16 +449,11 @@ private static string GetCpuArchitecture()`
`475`	`449`	`default:`
`476`	`450`	`return RuntimeInformation.OSArchitecture.ToString();`
`477`	`451`	`}`
`478`		`-#endif`
`479`	`452`	`}`
`480`	`453`
`481`	`454`	`private static string GetClrVersion()`
`482`	`455`	`{`
`483`		`-#if NETFRAMEWORK`
`484`		`- return $".NET Framework {Environment.Version}";`
`485`		`-#else`
`486`	`456`	`return RuntimeInformation.FrameworkDescription;`
`487`		`-#endif`
`488`	`457`	`}`
`489`	`458`
`490`	`459`	`#endregion`
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`	`}`