ne pas être en mesure de convertir de FILETIME (windows temps) de type dateTime ( j'ai une date différente )

La plupart des fichiers que j'ai lu d'obtenir le droit de temps lorsque vous utilisez la méthode suivante pour 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);
}

Ici, j'ai un exemple dans visual studio pour montrer comment cette méthode ne fonctionne pas pour l'exemple, je vais vous montrer la taille réelle du fichier dans mon ordinateur et le débogage. Ainsi, le fichier qui se trouve être dans mon debug:

"A:\Users\Tono\Documents\Visual Studio 2010\Projects\WpfApplication4\WpfApplication4\obj\x86\Debug\App.g.cs"
ne pas être en mesure de convertir de FILETIME (windows temps) de type dateTime ( j'ai une date différente )

Et voici le FILETIME que je suis en train de convertir DateTime "j'ai besoin de la LastWriteTime par la voie"

ne pas être en mesure de convertir de FILETIME (windows temps) de type dateTime ( j'ai une date différente )

Ici, vous pouvez voir que dwHighDateTime = 30136437 et aussi que dwLowDateTime = -2138979250 à partir de ce fichier.

Et quand je lance ma méthode, en plus d'autres techniques je obtenir les dates suivantes:
ne pas être en mesure de convertir de FILETIME (windows temps) de type dateTime ( j'ai une date différente )

Donc, jusqu'à présent, tout semble fonctionner parfaitement. Mais pourquoi est-ce que quand je de parcourir et de rechercher ce fichier spécifique dans windows je reçois une autre date !? Ici est la date que je reçois quand voir les propriétés du fichier:
ne pas être en mesure de convertir de FILETIME (windows temps) de type dateTime ( j'ai une date différente )

Pourquoi les dates ne correspondent pas? Ce que je fais mal?

Pourquoi vous faites ça à la dure? Semble que vous êtes assez bien la réécriture de la classe FileInfo... msdn.microsoft.com/en-us/library/system.io.fileinfo.aspx
Je ne sais pas pourquoi l'OP c'est ce que fait à la dure. Lorsque vous travaillez avec de longs noms de chemin d'accès, c'est à des chemins de plus de [MAX_LENGTH] = 260 octets, vous devez pour réécrire la plupart de Système.IO utiliser du code non managé. Il n'y a plus d'infos à être trouvé ici: blogs.msdn.com/b/bclteam/archive/2007/02/13/...
Il est légitime de scénarios d'utilisation FILETIME / GetFileTime au lieu de FileInfo: Par exemple, si vous souhaitez obtenir des statistiques sur un fichier dont la poignée que vous avez déjà ouvertes (et ne peut pas ré-ouvrir via FileInfo pour une certaine raison)

OriginalL'auteur Tono Nam | 2011-05-21

  1. 16

    Vous avez besoin de combiner les LS et les valeurs de MS au niveau du bit, pas de manière arithmétique.

    Essayer:

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

    Ou l'une des suivantes doivent travailler trop:

    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))

    Vous pouvez vous en sortir avec l'ajout plutôt que d'un bit à bit ou si vous êtes sûr que les valeurs sont positives (et n'ont pas de bits en commun). Mais au niveau du bit-ou exprime l'intention de mieux.

    temps.dwLowDateTime s'affiche comme une valeur négative (il ne devrait pas être) donc un moulage de long va donner un résultat incorrect. au lieu de cela SI vous avez besoin de faire (long)((uint)(time.dwLowDateTime)) ou de corriger le interop si il commence comme un uint.
    fatigué, mais ne fonctionne pas. Je pense que ma méthode est celle qui est la lecture de la mauvaise date. Je vais continuer à essayer de le comprendre.

    OriginalL'auteur Joe

  2. 7

    Je suis un peu en retard à la fête, mais cela a fonctionné de manière fiable pour moi:

    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);
        }
    }
}

    Note: Ne faites pas confiance à l'Explorateur Windows. Utilisation Fichier.GetLastWriteTimeUtc méthode, par exemple, pour vérifier que le système de fichiers en fait a l'encontre de ce que cette extension de la méthode retourne. Explorer a quelques bugs qui ne sont pas de fichier de mise à jour des temps dans certaines situations. Cheers! 🙂

    Note: Pour tester cela, vous devez utiliser les valeurs maximales. Donc, en supposant dwHighDateTime = dwLowDateTime = UInt32.MaxValue = 4294967295 = 0xFFFFFFFF, il s'ensuit que (long)(((ulong)UInt32.MaxValue << 32) + UInt32.MaxValue) = -1 = 0xFFFFFFFFFFFFFFFF. Malheureusement, l'erreur de l'API Windows semble être que, finalement, le temps a besoin d'être castée pour un long valeur afin de travailler avec elle pour toutes les applications utiles (puisque la plupart des Windows méthodes de l'API de prendre le temps de fichier comme un long valeur), ce qui signifie que, une fois le premier bit est élevé (1) sur dwHighDateTime, la valeur devient négative. Permet d'essayer avec le maximum de temps de ne pas être élevé. En supposant que dwHighDateTime = Int32.MaxValue = 2147483647 = 0x7FFFFFFF et dwLowDateTime = UInt32.MaxValue = 4294967295 = 0xFFFFFFFF, il s'ensuit que (long)(((ulong)Int32.MaxValue << 32) + UInt32.MaxValue) = 0x7FFFFFFFFFFFFFFF.

    Note: 0x7FFFFFFFFFFFFFFF est déjà beaucoup plus grande que DateTime.MaxValue.ToFileTimeUtc() = 2650467743999999999 = 0x24C85A5ED1C04000, le rendu des numéros de grande déjà inutile pour des applications pratiques .NET.

    Cette solution fonctionne pour moi, alors que les autres réponses retourner des résultats incorrects
    C'est parce que les autres réponses ne sont pas comptabilisés dans les hautes date composant comme un entier non signé de 64 bits de la valeur...à la place je vois qu'ils incorrectement jeté à l'un signé de 64 bits de valeur, qui peut retourner un résultat négatif, ce qui est incorrect.
    En effet, ce qui semble être la plus précise de la solution.

    OriginalL'auteur Alexandru

  3. 5

    C'est une autre méthode que j'ai vu à la convertir en une structure FileTime à une longue (à l'aide d'un code de l'opérateur dans la structure), qui peut ensuite être facilement convertis en DateTime à l'aide de l'DateTime.FromFileTime fonctions:

    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;
    }
}

    OriginalL'auteur mkisaacs

  4. 0

    J'ai essayé ce qui suit, et non de m'avoir le droit de temps:

    ne pas être en mesure de convertir de FILETIME (windows temps) de type dateTime ( j'ai une date différente )

    Et j'ai eu la méthode de ici

    Avez-vous tous les trouver le correctif pour cela?

    OriginalL'auteur Tono Nam

  5. 0

    dwLowDateTime et dwHighDateTime devrait être uint et on dirait qu'ils sont int. Changer ce sera probablement bien fixer comme @Joe a souligné, vous devriez toujours utiliser | au lieu de +.

    OriginalL'auteur Yaur