F := TFileStream.Create(Nom, fmOpenRead or fmShareDenyWrite);

F.Free;

F.Position := 0;

F.ReadBuffer(Mavariable, SizeOf(TMavariable));

type
    TEnumTest = (etPos1, etPos2, etPos3, etPos4);

    TMonRecord = record
       entier : integer;
       reel : double;
       enum : TEnumTest;
       chainelimit : string[100];
       chaine : string;
    end;
 
 
function OuvrirFichier(Nom : TFileName;var mrec : TMonRecord) : boolean;
var
   F : TFileStream;
   i : integer;
begin
    // Ouvre un fichier test
    F := nil;
    try
      // Ouverture d'un flux sur le fichier en lecture. Le fichier reste accessible en lecture seule pour d'autres appli.
      F := TFileStream.Create(Nom, fmOpenRead or fmShareDenyWrite);
      F.Position := 0; // Début du flux
      if (pos('.zio',ExtractFileName(Nom))>0) then // Vérification du type du Fichier
      begin
         // Lecture du fichier
         while (F.position < F.Size) do // Tant que la fin du fichier n'est pas atteinte faire :
         begin
            with mrec do // voir TMonRecord pour savoir quelle type de donnée nous avons.
            begin
               // Lit la valeur et déplace la position en cours
               // La première valeur lue est un entier (le fichier a été enregistré ainsi)
               F.ReadBuffer(entier, SizeOf(integer));
               // Ensuite nous avons un réel
               F.ReadBuffer(reel, SizeOf(Double));
               // De nouveau un entier mais sa valeur n'est pas directement exploitable dans mrec. 
               // On le convertit, ici il s'agit d'un type énuméré. 
               F.ReadBuffer(i, SizeOf(integer));
               enum := TEnumTest(i);
               // On lit ensuite une Chaine de caractère dont la taille est limitée (string[taille]).
               F.ReadBuffer(chainelimit, SizeOf(Chainelimit));
               // On lit un entier correspondant à la taille de la chaine qui suit
               F.ReadBuffer(i, SizeOf(i));
               // Allocation d'assez d'espace dans la chaine pour la lecture
               SetLength(chaine, i);
               // Lecture de la chaine, on transmet un pointeur sur la chaine soit Chaine[1].
               F.ReadBuffer(chaine[1], i);
            end;
         end;
         Result := true;
      end
      else
      begin
         MessageDlg('Erreur ce n''est pas un fichier test.', mtError, [mbOk], 0);
         Result := false;
      end;
      F.Free;
    except
      on EInOutError do
      begin
        Result := False;
        F.Free;
        MessageDlg('Erreur d''E-S fichier.', mtError, [mbOk], 0);
      end;
      on EReadError do
      begin
         Result := False;
         F.Free;
         MessageDlg('Erreur de lecture sur le fichier.', mtError, [mbOk], 0);
      end;
      else
      begin
         Result := False;
         F.Free;
         MessageDlg('Erreur sur le fichier.', mtError, [mbOk], 0);
      end;
    end; // try
end;

F := TFileStream.Create(Filetmp, fmCreate or fmShareExclusive);

.WriteBuffer(MaVariable, SizeOf(TMaVariable));

function EnregistreFichier(Nom : TFileName;mrec : TMonRecord):boolean;
var
   F: TFileStream;
   Filetmp : TFileName;
   Chem_tmp, Nom_tmp : string;
   i : integer;
begin
   // Enregistrement d'un fichier
   Chem_tmp := ExtractFilePath(Nom);
   Nom_tmp := '~temp.zio';
   Filetmp := TFileName(Chem_tmp+'\'+Nom_tmp);
   F := nil;
   try
      DeleteFile(Filetmp);
      // Ouverture d'un flux sur le fichier, en création et de façon exclusive
      F := TFileStream.Create(Filetmp, fmCreate or fmShareExclusive);
      F.Position := 0; // Début du flux
      // Ecriture du fichier
      with mrec do
      begin
        // On écrit le champ entier en premier
         F.WriteBuffer(entier, SizeOf(integer));
        // Puis le champ Réel
         F.WriteBuffer(reel, SizeOf( Double));
        // On convertit le champ de type énuméré en entier, on ne peut pas écrire directement une variable de type enuméré.
         i := Ord(enum);
        // On écrit l'entier correspondant au champ énuméré
         F.WriteBuffer(i, SizeOf(integer));
        // On écrit la chaîne à taille fixe, aucune difficulté.
         F.WriteBuffer(chainelimit, SizeOf(chainelimit));
        // Pour la chaîne de type string, il nous faut indiquer la taille de la chaîne sinon nous ne pourrions plus la relire
         i := Length(chaine);
        // On écrit donc la taille de la chaîne
         F.WriteBuffer(i, SizeOf(i));
        // Puis la chaîne en indiquant sa taille et en transmettant un pointeur.
         F.WriteBuffer(chaine[1], i);
      end;
      F.Free;
      // detruit Nom et renome temp.zio en Nom
      DeleteFile(Nom);
      if RenameFile(Filetmp, ExtractFileName(Nom)) then
          Result := true
      else
          Result := false;
  except
      on EInOutError do
      begin
        Result := False;
        F.Free;
        MessageDlg('Erreur d''E-S fichier : Fichier non enregistré.', mtError, [mbOk], 0);
      end;
      on EWriteError do
      begin
         Result := False;
         F.Free;
         MessageDlg('Erreur d''ecriture dans le fichier. Fichier non enregistré', mtError, [mbOk], 0);
      end;
      else
      begin
         Result := False;
         F.Free;
         MessageDlg('Erreur sur le fichier. Fichier non enregistré.', mtError, [mbOk], 0);
      end;
  end; // try
end;