C-Sharp Windows Winapi Filesystems File Copying

Comment Copier un Fichier Sans Utiliser le Cache de Fichiers de Windows

Lorsqu’il s’agit de gestion de fichiers sous Windows, vous pourriez rencontrer des situations où le cache de fichiers du système peut nuire aux performances, en particulier lors du traitement de gros fichiers. Par exemple, copier un grand fichier d’un lecteur USB ou d’un serveur vers votre machine locale peut poser problème, car Windows met en cache le fichier, ce qui peut entraîner l’échange de données et augmenter le temps nécessaire à l’achèvement de l’opération.

Dans cet article de blog, nous allons explorer comment résoudre ce problème en copiant des fichiers sans utiliser le cache du système de fichiers de Windows, en utilisant spécifiquement C#.

Comprendre le Cache du Système de Fichiers de Windows

Avant de plonger dans la solution de codage, il est important de comprendre ce qu’est le cache du système de fichiers. Windows utilise un cache pour accélérer les opérations de fichiers, ce qui implique généralement:

Stocker les données des fichiers en mémoire pour un accès plus rapide.
Tenter de transférer des données depuis des appareils plus lents, comme des lecteurs USB, vers la mémoire système plus rapide.

Cependant, pour les fichiers plus volumineux (pensez à 2 Go ou plus), ce processus de mise en cache peut entraîner des inefficacités, car le système essaie de gérer la mémoire disponible.

La Solution: Utiliser les Appels API Win32

Pour contourner ce comportement de mise en cache, Windows fournit des indicateurs spécifiques que vous pouvez utiliser lors des opérations sur les fichiers. Ces indicateurs sont:

FILE_FLAG_WRITE_THROUGH : Cet indicateur garantit que les écritures dans le fichier sont directement écrites sur l’appareil de stockage et ne sont pas mises en cache en mémoire.
FILE_FLAG_NO_BUFFERING : Cet indicateur désactive le cache du système pour le fichier, ce qui signifie que toutes les opérations de lecture et d’écriture vont directement sur le disque sans être mises en cache.

Vous pouvez utiliser ces indicateurs dans votre code C# pour réaliser une copie directe de fichiers sans utiliser le cache.

Mise en œuvre étape par étape en C#

Voici comment mettre en œuvre la solution en C#:

Ajouter les bibliothèques nécessaires : Assurez-vous d’inclure les espaces de noms requis pour les opérations sur les fichiers et les services interop.
```
using System;
using System.IO;
using System.Runtime.InteropServices;
```

Déclarer les méthodes natives : Vous devez déclarer les fonctions API Win32 nécessaires.

[DllImport("kernel32.dll", SetLastError = true)]
public static extern IntPtr CreateFile(
    string lpFileName,
    uint dwDesiredAccess,
    uint dwShareMode,
    IntPtr lpSecurityAttributes,
    uint dwCreationDisposition,
    uint dwFlagsAndAttributes,
    IntPtr hTemplateFile);

[DllImport("kernel32.dll", SetLastError = true)]
public static extern bool ReadFile(
    IntPtr hFile,
    byte[] lpBuffer,
    uint nNumberOfBytesToRead,
    out uint lpNumberOfBytesRead,
    IntPtr lpOverlapped);

[DllImport("kernel32.dll", SetLastError = true)]
public static extern bool WriteFile(
    IntPtr hFile,
    byte[] lpBuffer,
    uint nNumberOfBytesToWrite,
    out uint lpNumberOfBytesWritten,
    IntPtr lpOverlapped);

[DllImport("kernel32.dll", SetLastError = true)]
public static extern bool CloseHandle(IntPtr hObject);

Utiliser les indicateurs : Dans votre fonction de copie de fichiers, utilisez les indicateurs pour créer les poignées de fichiers.

public void CopyFileWithoutCache(string sourceFilePath, string destFilePath)
{
    const uint GENERIC_READ = 0x80000000;
    const uint GENERIC_WRITE = 0x40000000;
    const uint OPEN_EXISTING = 3;
    const uint FILE_FLAG_WRITE_THROUGH = 0x80000000;
    const uint FILE_FLAG_NO_BUFFERING = 0x20000000;

    IntPtr sourceHandle = CreateFile(sourceFilePath, GENERIC_READ, 0, IntPtr.Zero, OPEN_EXISTING, FILE_FLAG_WRITE_THROUGH | FILE_FLAG_NO_BUFFERING, IntPtr.Zero);
    IntPtr destHandle = CreateFile(destFilePath, GENERIC_WRITE, 0, IntPtr.Zero, OPEN_EXISTING, FILE_FLAG_WRITE_THROUGH | FILE_FLAG_NO_BUFFERING, IntPtr.Zero);

    // Implémentez la logique de lecture et d'écriture de fichiers ici...

    CloseHandle(sourceHandle);
    CloseHandle(destHandle);
}

Conclusion

Avec les étapes décrites ci-dessus, vous pouvez copier efficacement de gros fichiers sans l’interférence du cache du système de fichiers de Windows. Cette méthode est particulièrement bénéfique lors du transfert de fichiers de grande capacité depuis des appareils lents comme des lecteurs USB.

Pour plus de détails, consultez la documentation de Microsoft sur FILE_FLAG_WRITE_THROUGH et FILE_FLAG_NO_BUFFERING.

En comprenant et en tirant parti de ces indicateurs, vous pouvez considérablement améliorer les performances de vos opérations sur les fichiers. Bon codage!