Obtenir la taille du fichier sans utiliser System.IO.FileInfo?

Est-il possible d'obtenir le taille d'un fichier en C# sans l'aide de System.IO.FileInfo?

Je sais que vous pouvez obtenir d'autres choses comme le Nom et l'Extension à l'aide de Path.GetFileName(yourFilePath) et Path.GetExtension(yourFilePath) respectivement, mais apparemment pas la taille du fichier? Est-il un autre moyen que je peux obtenir taille du fichier sans l'aide de System.IO.FileInfo?

La seule raison pour cela est que, si je suis correct, FileInfo attrape plus d'info que j'ai vraiment besoin, donc il faut plus de temps pour rassembler toutes les FileInfo si la seule chose dont j'ai besoin est la taille du fichier. Est-il un moyen plus rapide?

source d'informationauteur sergeidave | 2013-01-18

c#fileinfo filepath filesize

J'ai effectué un test à l'aide de ces deux méthodes:

    public static uint GetFileSizeA(string filename)
    {
        WIN32_FIND_DATA findData;
        FindFirstFile(filename, out findData);
        return findData.nFileSizeLow;
    }

    public static uint GetFileSizeB(string filename)
    {
        IntPtr handle = CreateFile(
            filename,
            FileAccess.Read,
            FileShare.Read,
            IntPtr.Zero,
            FileMode.Open,
            FileAttributes.ReadOnly,
            IntPtr.Zero);
        long fileSize;
        GetFileSizeEx(handle, out fileSize);
        CloseHandle(handle);
        return (uint) fileSize;
    }

En cours d'exécution contre un peu plus de 2300 fichiers, GetFileSizeA 62-63ms à exécuter. GetFileSizeB a pris plus de 18 secondes.

À moins que quelqu'un voit quelque chose que je fais mal, je pense que la réponse est claire quant à la méthode est plus rapide.

Est-il possible que je ne puisse s'abstenir d'ouvrir le fichier?

Mise à jour

Changer FileAttributes.ReadOnly FileAttributes.Normal réduit le calendrier de sorte que les deux méthodes étaient identiques dans les performances.

En outre, si vous passez le CloseHandle() de l'appel, le GetFileSizeEx méthode devient d'environ 20 à 30% plus rapide, bien que je ne sais pas ce que je recommande.

5

À partir d'un court test que j'ai fait, j'ai trouvé que l'utilisation d'un FileStream est à seulement 1 milliseconde plus lente en moyenne que l'aide de Pete GetFileSizeB (qui m'a pris environ 21 millisecondes sur un partage réseau...). Personnellement, je préfère rester à l'intérieur de la BCL limites dès que je peux.

Le code est simple:
```
using (var file = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
    return file.Length;
}
```
3

Comme par ce commentaire:

J'ai une petite application qui regroupe la taille de l'info et l'enregistre dans un tableau... mais j'ai souvent un demi-million de fichiers, donner ou prendre, et cela prend un certain temps pour parcourir tous ces fichiers (je suis en utilisant FileInfo). Je me demandais juste si il y avait un moyen plus rapide...

Depuis que vous êtes de trouver la longueur de autant de fichiers que vous êtes beaucoup plus susceptibles de bénéficier de la parallélisation que d'essayer d'obtenir la taille du fichier par une autre méthode. Le FileInfo classe devrait être assez bonet des améliorations sont susceptibles d'être petite.

De la parallélisation de la taille du fichier de demandes, d'autre part, a le potentiel pour significative améliorations dans la vitesse. (À noter que le degré d'amélioration sera largement basé sur votre disque dur, pas de votre processeur, de sorte que les résultats peuvent varier considérablement.)
3

Pas une réponse directe...parce que je ne suis pas sûr qu'il y est un moyen plus rapide en utilisant le .NET framework.

Voici le code, je suis en utilisant:
```
  List<long> list = new List<long>();
  DirectoryInfo di = new DirectoryInfo("C:\\Program Files");
  FileInfo[] fiArray = di.GetFiles("*", SearchOption.AllDirectories);
  foreach (FileInfo f in fiArray)
    list.Add(f.Length);
```
De course, il a fallu 2709ms de courir sur mon répertoire "Program Files", ce qui était autour de 22720 fichiers. C'est pas en reste par tous les moyens. De plus, quand je mets *.txt comme un filtre pour le premier paramètre de la GetFiles méthode, il réduit le temps de façon radicale à 461ms.

Beaucoup de cela dépend de la rapidité de votre disque dur, mais je ne pense vraiment pas que FileInfo est en train de tuer la performance.

NOTE: je thikn ce valable uniquement pour .NET 4+

Vous pouvez essayer ceci:

[DllImport("kernel32.dll")]
static extern bool GetFileSizeEx(IntPtr hFile, out long lpFileSize);

Mais ce n'est pas beaucoup d'une amélioration...

Voici l'exemple de code d'pinvoke.net:

IntPtr handle = CreateFile(
    PathString, 
    GENERIC_READ, 
    FILE_SHARE_READ, 
    0, 
    OPEN_EXISTING, 
    FILE_ATTRIBUTE_READONLY, 
    0); //PInvoked too

if (handle.ToInt32() == -1) 
{
    return; 
}

long fileSize;
bool result = GetFileSizeEx(handle, out fileSize);
if (!result) 
{
    return;
}

Vous devez vous connecter pour publier un commentaire.