Refactor GetGetSystemTimeAsFileTimeFnPtr

* Don't check whether `GetSystemTimePreciseAsFileTime` exists, it is always available in `win8`.
* Move PInvokes to `Interop.Kernel32`.
* Don't use `Math.Abs` to avoid unecessary overflow check.

Author: xtqqczze

src/libraries/Common/src/Interop/Windows/Kernel32/Interop.GetSystemTimeAsFileTime.cs

@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Kernel32
+    {
+        // https://learn.microsoft.com/windows/win32/api/sysinfoapi/nf-sysinfoapi-getsystemtimeasfiletime
+        [LibraryImport(Libraries.Kernel32)]
+        [SuppressGCTransition]
+        internal static unsafe partial void GetSystemTimeAsFileTime(
+            // [NativeTypeName("LPFILETIME")]
+            ulong* lpSystemTimeAsFileTime);
+    }
+}

src/libraries/Common/src/Interop/Windows/Kernel32/Interop.GetSystemTimePreciseAsFileTime.cs

@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class Kernel32
+    {
+        // https://learn.microsoft.com/windows/win32/api/sysinfoapi/nf-sysinfoapi-getsystemtimepreciseasfiletime
+        [LibraryImport(Libraries.Kernel32)]
+        [SuppressGCTransition]
+        internal static unsafe partial void GetSystemTimePreciseAsFileTime(
+            // [NativeTypeName("LPFILETIME")]
+            ulong* lpSystemTimeAsFileTime);
+    }
+}

src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems

@@ -1748,6 +1748,12 @@
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.GetSystemTime.cs">
       <Link>Common\Interop\Windows\Kernel32\Interop.GetSystemTime.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.GetSystemTimeAsFileTime.cs">
+      <Link>Common\Interop\Windows\Kernel32\Interop.GetSystemTimeAsFileTime.cs</Link>
+    </Compile>
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.GetSystemTimePreciseAsFileTime.cs">
+      <Link>Common\Interop\Windows\Kernel32\Interop.GetSystemTimePreciseAsFileTime.cs</Link>
+    </Compile>
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.GetSystemTimes.cs">
       <Link>Common\Interop\Windows\Kernel32\Interop.GetSystemTimes.cs</Link>
     </Compile>
@@ -2602,4 +2608,4 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Numerics\IUnaryPlusOperators.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Numerics\IUnsignedNumber.cs" />
   </ItemGroup>
-</Project>
+</Project>

src/libraries/System.Private.CoreLib/src/System/DateTime.Windows.cs

@@ -142,39 +142,35 @@ private static unsafe bool GetSystemSupportsLeapSeconds()
 
         private static unsafe delegate* unmanaged[SuppressGCTransition]<ulong*, void> GetGetSystemTimeAsFileTimeFnPtr()
         {
-            IntPtr kernel32Lib = Interop.Kernel32.LoadLibraryEx(Interop.Libraries.Kernel32, IntPtr.Zero, Interop.Kernel32.LOAD_LIBRARY_SEARCH_SYSTEM32);
-            Debug.Assert(kernel32Lib != IntPtr.Zero);
-
-            IntPtr pfnGetSystemTime = NativeLibrary.GetExport(kernel32Lib, "GetSystemTimeAsFileTime");
-
-            if (NativeLibrary.TryGetExport(kernel32Lib, "GetSystemTimePreciseAsFileTime", out IntPtr pfnGetSystemTimePrecise))
+            const long TargetAccuracy = 100 * TicksPerMillisecond;
+
+            delegate* unmanaged[SuppressGCTransition]<ulong*, void> pfnGetSystemTime, pfnGetSystemTimePrecise;
+            pfnGetSystemTime = &Interop.Kernel32.GetSystemTimeAsFileTime;
+            pfnGetSystemTimePrecise = &Interop.Kernel32.GetSystemTimePreciseAsFileTime;
+
+            // We would like to use GetSystemTimePreciseAsFileTime.
+            // However, on misconfigured systems, it's possible for the "precise" time to be inaccurate:
+            //     https://github.com/dotnet/runtime/issues/9014
+            // If it's inaccurate, though, we expect it to be wildly inaccurate, so as a workaround/heuristic,
+            // we get both the "normal" and "precise" times, and as long as they're close, we use the precise one.
+            // This workaround can be removed when we better understand what's causing the drift
+            // and the issue is no longer a problem or can be better worked around on all targeted OSes.
+
+            // Retry this check several times to reduce chance of false negatives due to thread being rescheduled
+            // at wrong time.
+            for (int i = 10; --i >= 0;)
             {
-                // GetSystemTimePreciseAsFileTime exists and we'd like to use it.  However, on
-                // misconfigured systems, it's possible for the "precise" time to be inaccurate:
-                //     https://github.com/dotnet/runtime/issues/9014
-                // If it's inaccurate, though, we expect it to be wildly inaccurate, so as a
-                // workaround/heuristic, we get both the "normal" and "precise" times, and as
-                // long as they're close, we use the precise one. This workaround can be removed
-                // when we better understand what's causing the drift and the issue is no longer
-                // a problem or can be better worked around on all targeted OSes.
-
-                // Retry this check several times to reduce chance of false negatives due to thread being rescheduled
-                // at wrong time.
-                for (int i = 0; i < 10; i++)
-                {
-                    long systemTimeResult, preciseSystemTimeResult;
-                    ((delegate* unmanaged[SuppressGCTransition]<long*, void>)pfnGetSystemTime)(&systemTimeResult);
-                    ((delegate* unmanaged[SuppressGCTransition]<long*, void>)pfnGetSystemTimePrecise)(&preciseSystemTimeResult);
+                ulong systemTimeResult, preciseSystemTimeResult;
+                pfnGetSystemTime(&systemTimeResult);
+                pfnGetSystemTimePrecise(&preciseSystemTimeResult);
 
-                    if (Math.Abs(preciseSystemTimeResult - systemTimeResult) <= 100 * TicksPerMillisecond)
-                    {
-                        pfnGetSystemTime = pfnGetSystemTimePrecise; // use the precise version
-                        break;
-                    }
+                if (preciseSystemTimeResult - systemTimeResult + TargetAccuracy <= 2 * TargetAccuracy)
+                {
+                    return pfnGetSystemTimePrecise;
                 }
             }
 
-            return (delegate* unmanaged[SuppressGCTransition]<ulong*, void>)pfnGetSystemTime;
+            return pfnGetSystemTime;
         }
 
         private static unsafe DateTime UpdateLeapSecondCacheAndReturnUtcNow()