Cómo Copiar un Archivo Sin Usar la Caché de Archivos de Windows

Cuando se trata de gestión de archivos dentro de Windows, puedes encontrar situaciones en las que la caché de archivos del sistema operativo puede obstaculizar el rendimiento, especialmente al manejar archivos grandes. Por ejemplo, copiar un archivo grande de una unidad USB o un servidor a tu máquina local puede ser problemático ya que Windows almacena en caché el archivo, lo que podría llevar a intercambiar datos y aumentar el tiempo que toma completar la operación.

En esta publicación del blog, exploraremos cómo abordar este problema copiando archivos sin hacer uso de la caché del sistema de archivos de Windows, específicamente usando C#.

Entendiendo la Caché del Sistema de Archivos de Windows

Antes de sumergirnos en la solución de codificación, es importante entender qué es la caché del sistema de archivos. Windows utiliza una caché para acelerar las operaciones de archivos, lo que generalmente implica:

• Almacenar datos de archivos en memoria para un acceso más rápido.
• Buscar descargar datos de dispositivos más lentos, como unidades USB, a la memoria del sistema más rápida.

Sin embargo, con archivos más grandes (piensa en 2 GiB o más), este proceso de caché puede llevar a ineficiencias, ya que el sistema intenta gestionar su memoria disponible.

La Solución: Uso de Llamadas a la API de Win32

Para evitar este comportamiento de almacenamiento en caché, Windows proporciona banderas específicas que puedes usar al trabajar con operaciones de archivos. Estas banderas son:

• FILE_FLAG_WRITE_THROUGH: Esta bandera asegura que las escrituras en el archivo se escriben directamente en el dispositivo de almacenamiento y no se almacenan en caché en la memoria.
• FILE_FLAG_NO_BUFFERING: Esta bandera desactiva la caché del sistema para el archivo, lo que significa que todas las operaciones de lectura y escritura van directamente al disco sin ser almacenadas en caché.

Puedes utilizar estas banderas en tu código C# para lograr una copia directa de archivos sin usar la caché.

Implementación Paso a Paso en C#

Así es como implementar la solución en C#:

1. Agregar bibliotecas necesarias: Asegúrate de incluir los espacios de nombres requeridos para operaciones de archivos y servicios de interoperabilidad.

   using System;
   using System.IO;
   using System.Runtime.InteropServices;
   

2. Declarar métodos nativos: Necesitas declarar las funciones de la API de Win32 necesarias.

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

3. Usar las banderas: En tu función de copia de archivos, usa las banderas para crear los manejadores de archivos.

   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);
   
       // Implementa la lógica de lectura y escritura de archivos aquí...
   
       CloseHandle(sourceHandle);
       CloseHandle(destHandle);
   }
   

Conclusión

Con los pasos descritos anteriormente, puedes copiar archivos grandes de manera eficiente sin la interferencia de la caché del sistema de archivos de Windows. Este método es particularmente beneficioso al tratar con archivos de alta capacidad transferidos desde dispositivos lentos como unidades USB.

Para más detalles, consulta la documentación de Microsoft sobre FILE_FLAG_WRITE_THROUGH y FILE_FLAG_NO_BUFFERING.

Al comprender y aprovechar estas banderas, puedes mejorar significativamente el rendimiento de tus operaciones de archivos. ¡Feliz codificación!