Anexar un archivo a otro archivo

En el ejemplo de código de este tema se muestra cómo abrir y cerrar archivos, leer y escribir en archivos, y bloquear y desbloquear archivos.

En el ejemplo, la aplicación anexa un archivo al final de otro archivo. En primer lugar, la aplicación abre el archivo que se anexa con permisos que permiten que solo la aplicación escriba en él. Sin embargo, durante el proceso de anexión, otros procesos pueden abrir el archivo con permiso de solo lectura, que proporciona una vista de instantánea del archivo que se está anexando. A continuación, el archivo se bloquea durante el proceso de anexión real para garantizar la integridad de los datos que se escriben en el archivo.

En este ejemplo no se usan transacciones. Si estuviera usando operaciones de transacción, solo podría tener acceso de solo lectura. En este caso, solo vería los datos anexados una vez completada la operación de confirmación de transacción.

En el ejemplo también se muestra que la aplicación abre dos archivos mediante CreateFile:

• One.txt se abre para leer.
• Two.txt se abre para escribir y compartir lecturas.

A continuación, la aplicación usa ReadFile y WriteFile para anexar el contenido de One.txt al final de Two.txt leyendo y escribiendo los bloques de 4 KB. Sin embargo, antes de escribir en el segundo archivo, la aplicación usa SetFilePointer para establecer el puntero del segundo archivo al final de ese archivo y usa LockFile para bloquear el área que se va a escribir. Esto impide que otro subproceso o proceso con un identificador duplicado acceda al área mientras la operación de escritura está en curso. Cuando se completa cada operación de escritura, UnlockFile se usa para desbloquear el área bloqueada.

#include <windows.h>
#include <stdio.h>

void main()
{
  HANDLE hFile;
  HANDLE hAppend;
  DWORD  dwBytesRead, dwBytesWritten, dwPos;
  BYTE   buff[4096];

  // Open the existing file.

  hFile = CreateFile(TEXT("one.txt"), // open One.txt
            GENERIC_READ,             // open for reading
            0,                        // do not share
            NULL,                     // no security
            OPEN_EXISTING,            // existing file only
            FILE_ATTRIBUTE_NORMAL,    // normal file
            NULL);                    // no attr. template

  if (hFile == INVALID_HANDLE_VALUE)
  {
     printf("Could not open one.txt."); 
     return;
  }

  // Open the existing file, or if the file does not exist,
  // create a new file.

  hAppend = CreateFile(TEXT("two.txt"), // open Two.txt
              FILE_APPEND_DATA | FILE_GENERIC_READ,    // open for appending and locking
              FILE_SHARE_READ,                         // allow multiple readers
              NULL,                                    // no security
              OPEN_ALWAYS,                             // open or create
              FILE_ATTRIBUTE_NORMAL,                   // normal file
              NULL);                                   // no attr. template

  if (hAppend == INVALID_HANDLE_VALUE)
  {
     printf("Could not open two.txt."); 
     return;
  }

  // Append the first file to the end of the second file.
  // Lock the second file to prevent another process from
  // accessing it while writing to it. Unlock the
  // file when writing is complete.

  while (ReadFile(hFile, buff, sizeof(buff), &dwBytesRead, NULL)
      && dwBytesRead > 0)
    {
    dwPos = SetFilePointer(hAppend, 0, NULL, FILE_END);
    if (!LockFile(hAppend, dwPos, 0, dwBytesRead, 0))
    {
       printf("Could not lock two.txt");
    }
    WriteFile(hAppend, buff, dwBytesRead, &dwBytesWritten, NULL);
    UnlockFile(hAppend, dwPos, 0, dwBytesRead, 0);
    }

  // Close both files.

  CloseHandle(hFile);
  CloseHandle(hAppend);
}