Ajout d’un fichier à un autre fichier

L’exemple de code de cette rubrique vous montre comment ouvrir et fermer des fichiers, lire et écrire dans des fichiers, et verrouiller et déverrouiller des fichiers.

Dans l’exemple, l’application ajoute un fichier à la fin d’un autre fichier. Tout d’abord, l’application ouvre le fichier en cours d’ajout avec des autorisations qui permettent uniquement à l’application d’y écrire. Toutefois, pendant le processus d’ajout, d’autres processus peuvent ouvrir le fichier avec l’autorisation en lecture seule, ce qui fournit une vue instantané du fichier ajouté. Ensuite, le fichier est verrouillé pendant le processus d’ajout réel pour garantir l’intégrité des données écrites dans le fichier.

Cet exemple n’utilise pas de transactions. Si vous utilisiez des opérations traitées, vous ne pourrez disposer que d’un accès en lecture seule. Dans ce cas, vous ne verrez les données ajoutées qu’une fois l’opération de validation de transaction terminée.

L’exemple montre également que l’application ouvre deux fichiers à l’aide de CreateFile :

• One.txt est ouvert pour lecture.
• Two.txt est ouvert pour l’écriture et la lecture partagée.

Ensuite, l’application utilise ReadFile et WriteFile pour ajouter le contenu de One.txt à la fin de Two.txt en lisant et en écrivant les blocs de 4 Ko. Toutefois, avant d’écrire dans le deuxième fichier, l’application utilise SetFilePointer pour définir le pointeur du deuxième fichier vers la fin de ce fichier, et utilise LockFile pour verrouiller la zone à écrire. Cela empêche un autre thread ou processus avec un handle en double d’accéder à la zone pendant que l’opération d’écriture est en cours. Une fois chaque opération d’écriture terminée, UnlockFile est utilisé pour déverrouiller la zone verrouillée.

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