Files
Stephen Toub e2c7b4200a Fix (mostly) IDE0055 (formatting)
Lots of various spacing issues.  I say "mostly" because I explicitly undid some changes that added to rather than reduced inconsistency, e.g. region indents.  We can revisit that later.

Signed-off-by: dotnet-bot <[email protected]>
2019-08-22 20:21:18 +02:00

216 lines
8.8 KiB
C#

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace System
{
public readonly partial struct DateTime
{
internal static readonly bool s_systemSupportsLeapSeconds = SystemSupportsLeapSeconds();
public static unsafe DateTime UtcNow
{
get
{
if (s_systemSupportsLeapSeconds)
{
FullSystemTime time;
GetSystemTimeWithLeapSecondsHandling(&time);
return CreateDateTimeFromSystemTime(in time);
}
return new DateTime(((ulong)(GetSystemTimeAsFileTime() + FileTimeOffset)) | KindUtc);
}
}
internal static unsafe bool IsValidTimeWithLeapSeconds(int year, int month, int day, int hour, int minute, int second, DateTimeKind kind)
{
DateTime dt = new DateTime(year, month, day);
FullSystemTime time = new FullSystemTime(year, month, dt.DayOfWeek, day, hour, minute, second);
return kind switch
{
DateTimeKind.Local => ValidateSystemTime(&time.systemTime, localTime: true),
DateTimeKind.Utc => ValidateSystemTime(&time.systemTime, localTime: false),
_ => ValidateSystemTime(&time.systemTime, localTime: true) || ValidateSystemTime(&time.systemTime, localTime: false),
};
}
private static unsafe DateTime FromFileTimeLeapSecondsAware(long fileTime)
{
FullSystemTime time;
if (FileTimeToSystemTime(fileTime, &time))
{
return CreateDateTimeFromSystemTime(in time);
}
throw new ArgumentOutOfRangeException(nameof(fileTime), SR.ArgumentOutOfRange_DateTimeBadTicks);
}
private static unsafe long ToFileTimeLeapSecondsAware(long ticks)
{
FullSystemTime time = new FullSystemTime(ticks);
long fileTime;
if (SystemTimeToFileTime(&time.systemTime, &fileTime))
{
return fileTime + ticks % TicksPerMillisecond;
}
throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_FileTimeInvalid);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private static DateTime CreateDateTimeFromSystemTime(in FullSystemTime time)
{
long ticks = DateToTicks(time.systemTime.Year, time.systemTime.Month, time.systemTime.Day);
ticks += TimeToTicks(time.systemTime.Hour, time.systemTime.Minute, time.systemTime.Second);
ticks += time.systemTime.Milliseconds * TicksPerMillisecond;
ticks += time.hundredNanoSecond;
return new DateTime(((ulong)(ticks)) | KindUtc);
}
// FullSystemTime struct is the SYSTEMTIME struct with extra hundredNanoSecond field to store more precise time.
[StructLayout(LayoutKind.Sequential)]
private struct FullSystemTime
{
internal Interop.Kernel32.SYSTEMTIME systemTime;
internal long hundredNanoSecond;
internal FullSystemTime(int year, int month, DayOfWeek dayOfWeek, int day, int hour, int minute, int second)
{
systemTime.Year = (ushort)year;
systemTime.Month = (ushort)month;
systemTime.DayOfWeek = (ushort)dayOfWeek;
systemTime.Day = (ushort)day;
systemTime.Hour = (ushort)hour;
systemTime.Minute = (ushort)minute;
systemTime.Second = (ushort)second;
systemTime.Milliseconds = 0;
hundredNanoSecond = 0;
}
internal FullSystemTime(long ticks)
{
DateTime dt = new DateTime(ticks);
int year, month, day;
dt.GetDatePart(out year, out month, out day);
systemTime.Year = (ushort)year;
systemTime.Month = (ushort)month;
systemTime.DayOfWeek = (ushort)dt.DayOfWeek;
systemTime.Day = (ushort)day;
systemTime.Hour = (ushort)dt.Hour;
systemTime.Minute = (ushort)dt.Minute;
systemTime.Second = (ushort)dt.Second;
systemTime.Milliseconds = (ushort)dt.Millisecond;
hundredNanoSecond = 0;
}
}
#if !CORECLR
internal static readonly bool s_systemSupportsPreciseSystemTime = SystemSupportsPreciseSystemTime();
private static unsafe bool SystemSupportsPreciseSystemTime()
{
if (Environment.IsWindows8OrAbove)
{
// 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/coreclr/issues/14187
// 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.
long systemTimeResult;
Interop.Kernel32.GetSystemTimeAsFileTime(&systemTimeResult);
long preciseSystemTimeResult;
Interop.Kernel32.GetSystemTimePreciseAsFileTime(&preciseSystemTimeResult);
return Math.Abs(preciseSystemTimeResult - systemTimeResult) <= 100 * TicksPerMillisecond;
}
return false;
}
private static unsafe bool ValidateSystemTime(Interop.Kernel32.SYSTEMTIME* time, bool localTime)
{
if (localTime)
{
Interop.Kernel32.SYSTEMTIME st;
return Interop.Kernel32.TzSpecificLocalTimeToSystemTime(IntPtr.Zero, time, &st) != Interop.BOOL.FALSE;
}
else
{
long timestamp;
return Interop.Kernel32.SystemTimeToFileTime(time, &timestamp) != Interop.BOOL.FALSE;
}
}
private static unsafe bool FileTimeToSystemTime(long fileTime, FullSystemTime* time)
{
if (Interop.Kernel32.FileTimeToSystemTime(&fileTime, &time->systemTime) != Interop.BOOL.FALSE)
{
// to keep the time precision
time->hundredNanoSecond = fileTime % TicksPerMillisecond;
if (time->systemTime.Second > 59)
{
// we have a leap second, force it to last second in the minute as DateTime doesn't account for leap seconds in its calculation.
// we use the maxvalue from the milliseconds and the 100-nano seconds to avoid reporting two out of order 59 seconds
time->systemTime.Second = 59;
time->systemTime.Milliseconds = 999;
time->hundredNanoSecond = 9999;
}
return true;
}
return false;
}
private static unsafe void GetSystemTimeWithLeapSecondsHandling(FullSystemTime* time)
{
if (!FileTimeToSystemTime(GetSystemTimeAsFileTime(), time))
{
Interop.Kernel32.GetSystemTime(&time->systemTime);
time->hundredNanoSecond = 0;
if (time->systemTime.Second > 59)
{
// we have a leap second, force it to last second in the minute as DateTime doesn't account for leap seconds in its calculation.
// we use the maxvalue from the milliseconds and the 100-nano seconds to avoid reporting two out of order 59 seconds
time->systemTime.Second = 59;
time->systemTime.Milliseconds = 999;
time->hundredNanoSecond = 9999;
}
}
}
private static unsafe bool SystemTimeToFileTime(Interop.Kernel32.SYSTEMTIME* time, long* fileTime)
{
return Interop.Kernel32.SystemTimeToFileTime(time, fileTime) != Interop.BOOL.FALSE;
}
private static unsafe long GetSystemTimeAsFileTime()
{
long timestamp;
if (s_systemSupportsPreciseSystemTime)
{
Interop.Kernel32.GetSystemTimePreciseAsFileTime(&timestamp);
}
else
{
Interop.Kernel32.GetSystemTimeAsFileTime(&timestamp);
}
return timestamp;
}
#endif
}
}