no ser capaz de convertir de FILETIME (ventanas de tiempo) a fechaHora (me da una fecha diferente)

Question

La mayoría de los archivos que leí llegar el momento adecuado cuando se utiliza el método siguiente para convertir:

// works great most of the time 
private static DateTime convertToDateTime(System.Runtime.InteropServices.ComTypes.FILETIME time) 
{ 
    long highBits = time.dwHighDateTime; 
    highBits = highBits << 32; 
    return DateTime.FromFileTimeUtc(highBits + time.dwLowDateTime); 
} 

Aquí tener un ejemplo en Visual Studio para mostrar cómo este método a veces no funciona, por ejemplo, mostraré el archivo real en mi computadora y la depuración. Por lo que el archivo que pasa a ser en mi depuración es:

"A: \ Users \ Tono \ Documents \ Visual Studio 2010 \ Projects \ WpfApplication4 \ WpfApplication4 \ obj \ x86 \ Debug \ App.g.cs"

y aquí es el FILETIME que estoy tratando de convertir a DateTime "necesito el LastWriteTime por cierto"

aquí se puede ver que dwHighDateTime = 30136437 y también que dwLowDateTime = -2138979250 de ese archivo.

Y cuando corro mi método más otras técnicas consigo las siguientes fechas:

Así que hasta ahora todo parece estar funcionando muy bien. Pero ¿por qué eso es que cuando navego y busco ese archivo específico en Windows obtengo una fecha diferente? Aquí está la fecha que recibo al ver las propiedades del archivo:

¿Por qué las fechas no coinciden? ¿Qué estoy haciendo mal?

Answer 1

Necesita combinar los valores LS y MS en modo bit, no aritméticamente.

Probar:

 ulong high = 30136437; 
     unchecked 
     { 
      int low = -2138979250; 
      uint uLow = (uint)low; 
      high = high << 32; 
      Date dt = DateTime.FromFileTime((long) (high | (ulong)uLow)); 
     } 

o cualquiera de lo siguiente debe funcionar también:

long highBits = time.dwHighDateTime;  
highBits = highBits << 32;  

return DateTime.FromFileTimeUtc(highBits + (long) (uint) time.dwLowDateTime); 

return DateTime.FromFileTimeUtc(highBits | (long) (uint) time.dwLowDateTime); 

return DateTime.FromFileTimeUtc(highBits + ((long)low & 0xFFFFFFFF)) 

return DateTime.FromFileTimeUtc(highBits | ((long)low & 0xFFFFFFFF)) 

Usted puede salirse con la adición en lugar de un bit a bit, o si está seguro de los valores son positivos (y no tienen bits en común). Pero a nivel de bit, o expresa mejor la intención.

Answer 2

dwLowDateTime y dwHighDateTime debe ser uint y parece que son int. Sin embargo, cambiar esto probablemente lo arregle, ya que @Joe señaló que aún debería usar | en lugar de +.

Answer 3

He intentado lo siguiente y no de ellos me llegar el momento adecuado:

Y tengo el método de here

Answer 4

Este es otro método que he visto para convertir una estructura FileTime a largo (usando un operador codificado en la estructura), que luego se puede convertir fácilmente a DateTime usando DateTime.FromFileTime funciones:

public struct FileTime 
{ 
    public uint dwLowDateTime; 
    public uint dwHighDateTime; 

    public static implicit operator long(FileTime fileTime) 
    { 
     long returnedLong; 
     // Convert 4 high-order bytes to a byte array 
     byte[] highBytes = BitConverter.GetBytes(fileTime.dwHighDateTime); 
     // Resize the array to 8 bytes (for a Long) 
     Array.Resize(ref highBytes, 8); 

     // Assign high-order bytes to first 4 bytes of Long 
     returnedLong = BitConverter.ToInt64(highBytes, 0); 
     // Shift high-order bytes into position 
     returnedLong = returnedLong << 32; 
     // Or with low-order bytes 
     returnedLong = returnedLong | fileTime.dwLowDateTime; 
     // Return long 
     return returnedLong; 
    } 
} 

Answer 5

estoy un poco tarde a la fiesta, pero esto ha funcionado de forma fiable para mí:

public static class FILETIMEExtensions 
{ 
    public static DateTime ToDateTime(this System.Runtime.InteropServices.ComTypes.FILETIME time) 
    { 
     ulong high = (ulong)time.dwHighDateTime; 
     uint low = (uint)time.dwLowDateTime; 
     long fileTime = (long)((high << 32) + low); 
     try 
     { 
      return DateTime.FromFileTimeUtc(fileTime); 
     } 
     catch 
     { 
      return DateTime.FromFileTimeUtc(0xFFFFFFFF); 
     } 
    } 
} 

Nota: No confiar en el Explorador de Windows. Use el método File.GetLastWriteTimeUtc, por ejemplo, para verificar lo que el sistema de archivos realmente tiene contra lo que devuelve este método de extensión. Explorer tiene algunos errores que no actualizan los tiempos de archivo en ciertas situaciones. ¡Aclamaciones! :)

Nota: Para probar esto, necesita utilizar valores máximos. Entonces, asumiendo dwHighDateTime = dwLowDateTime = UInt32.MaxValue = 4294967295 = 0xFFFFFFFF, se deduce que (long)(((ulong)UInt32.MaxValue << 32) + UInt32.MaxValue) = -1 = 0xFFFFFFFFFFFFFFFF. Desafortunadamente, la falacia en la API de Windows parece ser que eventualmente el tiempo necesita ser convertido a un valor long para trabajar con él para cualquier aplicación útil (ya que la mayoría de los métodos API de Windows toman el tiempo del archivo como un valor long), significa que una vez que el bit de entrada es alto (1) en dwHighDateTime, el valor se vuelve negativo. Probemos con el tiempo máximo no siendo alto. Suponiendo dwHighDateTime = Int32.MaxValue = 2147483647 = 0x7FFFFFFF y dwLowDateTime = UInt32.MaxValue = 4294967295 = 0xFFFFFFFF, se deduce que (long)(((ulong)Int32.MaxValue << 32) + UInt32.MaxValue) = 0x7FFFFFFFFFFFFFFF.

Nota: 0x7FFFFFFFFFFFFFFF ya es mucho más grande que DateTime.MaxValue.ToFileTimeUtc() = 2650467743999999999 = 0x24C85A5ED1C04000, números tan grandes que ya inútiles para cualquier aplicaciones prácticas en la prestación de .NET.