C# DateTime.ToFileTimeUtc方法代码示例

        public void Attach(byte[] streamId, byte[] streamIdToAttach, DateTime expiresAt)
        {
            if (ByteArrayHelper.Compare(streamId, streamIdToAttach))
                throw new ArgumentException("Attaching a stream to itself is now allowed.");

            var stream = repository.Load(streamId);
            var result = stream.Attach(streamIdToAttach, expiresAt.ToFileTimeUtc());
            if (result.IsSuccessful)
                repository.AttachStream(streamId, streamIdToAttach, expiresAt.ToFileTimeUtc());
        }

 public static string GetFileMd5(string fileName, DateTime modified)
 {
     fileName += modified.ToFileTimeUtc();
     char[] fileNameChars = fileName.ToCharArray();
     byte[] buffer = new byte[_stringEncoder.GetByteCount(fileNameChars, 0, fileName.Length, true)];
     _stringEncoder.GetBytes(fileNameChars, 0, fileName.Length, buffer, 0, true);
     return BitConverter.ToString(_md5CryptoProvider.ComputeHash(buffer)).Replace("-", string.Empty);
 }

 public sealed override byte[] EncodeUtcTime(DateTime utcTime)
 {
     long ft = utcTime.ToFileTimeUtc();
     unsafe
     {
         return Interop.Crypt32.CryptEncodeObjectToByteArray(CryptDecodeObjectStructType.PKCS_UTC_TIME, &ft);
     }
 }

 static FILETIME DateTimeToFILETIME(DateTime time)
 {
     FILETIME ft;
     var value = time.ToFileTimeUtc();
     ft.dwLowDateTime = (int)(value & 0xFFFFFFFF);
     ft.dwHighDateTime = (int)(value >> 32);
     return ft;
 }

 public static FILETIME DateTimeToFiletime(DateTime time)
 {
     FILETIME ft;
     long hFT1 = time.ToFileTimeUtc();
     ft.dwLowDateTime = (uint)(hFT1 & 0xFFFFFFFF);
     ft.dwHighDateTime = (uint)(hFT1 >> 32);
     return ft;
 }

 /// <summary>
 /// Converts DateTime to Win32 FileTime format
 /// </summary>
 public static Win32FileTime DateTimeToFiletime( DateTime time )
 {
     Win32FileTime ft;
     var fileTime = time.ToFileTimeUtc( );
     ft.DateTimeLow = ( uint ) ( fileTime & 0xFFFFFFFF );
     ft.DateTimeHigh = ( uint ) ( fileTime >> 32 );
     return ft;
 }

 public static FILETIME ToFileTimeStructureUtc(DateTime dateTime)
 {
     var value = dateTime.ToFileTimeUtc();
     return new FILETIME
     {
         dwHighDateTime = unchecked((int)((value >> 32) & 0xFFFFFFFF)),
         dwLowDateTime = unchecked((int)(value & 0xFFFFFFFF))
     };
 }

        public void Detach(byte[] streamId, byte[] streamIdToDetach, DateTime detachedSince)
        {
            if (ByteArrayHelper.Compare(streamId, streamIdToDetach))
                throw new ArgumentException("Detaching a stream from itself is now allowed.");

            var stream = repository.Load(streamId);
            var result = stream.Detach(streamIdToDetach, detachedSince);
            if (result.IsSuccessful)
                repository.DetachStream(streamId, streamIdToDetach, detachedSince.ToFileTimeUtc());
        }

        /// <summary>
        /// Create a path to queue for the given <paramref name="peer"/> and <paramref name="messageQueuedTime"/>.
        /// </summary>
        /// <param name="peer">The peer to build the path for.</param>
        /// <param name="messageQueuedTime">The message file time to build a path for.</param>
        /// <returns>A path to queue for the given <paramref name="peer"/> and <paramref name="messageQueuedTime"/>.</returns>
        public static string MessageLocation(IPeer peer, DateTime messageQueuedTime)
        {
            var messageLocation = string.Format(
                CultureInfo.InvariantCulture,
                "/{0}/queue/{1}",
                peer.EscapePeerAddress(),
                messageQueuedTime.ToFileTimeUtc());

            return messageLocation;
        }

        public static void WaitThenDoStuff(DateTime time, Action stuff)
        {
            Task.Run(() =>
            {
                IntPtr timer = NativeMethods.CreateWaitableTimer(IntPtr.Zero, 1, null);
                long abs_utc_time = time.ToFileTimeUtc();
                NativeMethods.SetWaitableTimer(timer, ref abs_utc_time, 0, IntPtr.Zero, IntPtr.Zero, 1);
                NativeMethods.WaitForSingleObject(timer, NativeMethods.INFINITE);

                stuff();
            });
        }

 public static bool IsValidValue(DateTime value)
 {
     var flag = true;
     try
     {
         value.ToFileTimeUtc();
     }
     catch
     {
         flag = false;
     }
     return flag;
 }

 private static byte[] Encode(DateTime signingTime)
 {
     long val = signingTime.ToFileTimeUtc();
     System.Security.Cryptography.SafeLocalAllocHandle handle = System.Security.Cryptography.CAPI.LocalAlloc(0x40, new IntPtr(Marshal.SizeOf(typeof(long))));
     Marshal.WriteInt64(handle.DangerousGetHandle(), val);
     byte[] encodedData = new byte[0];
     if (!System.Security.Cryptography.CAPI.EncodeObject("1.2.840.113549.1.9.5", handle.DangerousGetHandle(), out encodedData))
     {
         throw new CryptographicException(Marshal.GetLastWin32Error());
     }
     handle.Dispose();
     return encodedData;
 }

 public static bool IsValidValue(DateTime value)
 {
     bool result = true;
     try
     {
         value.ToFileTimeUtc();
     }
     catch
     {
         result = false;
     }
     return result;
 }

        /// <summary>
        /// Creates a new instance of the FILETIME struct.
        /// </summary>
        /// <param name="dateTime">A <see cref="DateTime"/> object to copy data from.</param>
        public FILETIME(DateTime dateTime)
        {
            // Get the file time as a long in Utc
            //
            long fileTime = dateTime.ToFileTimeUtc();

            // Copy the low bits
            //
            dwLowDateTime = (DWORD)(fileTime & 0xFFFFFFFF);

            // Copy the high bits
            //
            dwHighDateTime = (DWORD)(fileTime >> 32);
        }

        public void DataTimeTransfer(ref long dataTimeValue)
        {
            DateTime dtServerTime = new DateTime(2016, 2, 8);
            DateTime dtFromClient = DateTime.FromFileTimeUtc(dataTimeValue);
            if (dtServerTime == dtFromClient)
            {
                dataTimeValue = dtServerTime.ToFileTimeUtc();
            }
            else
            {
                dataTimeValue = -1;
            }

        }