Fonction Delphi Comparaison du contenu de deux ttream?

Les iSidenticulestreams forts> La fonction postée par Daemon_x est excellente - mais a besoin d'un ajustement pour fonctionner correctement. (Uwe Raabe a déjà attrapé la question.) Il est critique que vous réinitialisez les positions du flux avant de démarrer la boucle em> - ou cette procédure renvoie probablement une erreur incorrecte si les deux flux ont déjà été accessibles en dehors de cette fonction.

C'est la solution finale qui fonctionne à chaque fois. Je viens de renommé la fonction pour convenir à mes conventions de nommage. Merci Daemon_x pour la solution élégante. P>

function StreamsAreIdentical(Stream1, Stream2: TStream): boolean;
const
  Block_Size = 4096;

var
  Buffer_1: array[0..Block_Size-1] of byte;
  Buffer_2: array[0..Block_Size-1] of byte;
  Buffer_Length: integer;

begin

  Result := False;

  if Stream1.Size <> Stream2.Size then exit;

  // These two added lines are critical for proper operation 
  Stream1.Position := 0;
  Stream2.Position := 0;

  while Stream1.Position < Stream1.Size do
  begin

    Buffer_Length := Stream1.Read(Buffer_1, Block_Size);
    Stream2.Read(Buffer_2, Block_Size);
    if not CompareMem(@Buffer_1, @Buffer_2, Buffer_Length) then exit;

  end;

  Result := True;

end;

réponses de user532231 strong> et Mike STRT> travaille dans 99% de cas, mais il existe des contrôles supplémentaires supplémentaires à faire forts>!

Descendants de Tstream peut être presque n'importe quoi, donc il n'est pas garanti que flux.Lead reviendra la même quantité de données forte>, même si des flux sont de la même longueur (le flux descendant peut également télécharger des données, donc peut-être revenir en lecture = 0 octets, en attendant le prochain chunk). Les flux peuvent également être également sur une erreur de support et de flux de flux complètes. P>

Pour 100% de code de travail, toutes ces vérifications doivent être effectuées. J'ai modifié la fonction de Mike. P>

Si cette fonction est utilisée par exemple pour réécrire le flux 2 s'il n'est pas identique à Stream1, toutes les erreurs doivent être vérifiées. Lorsque le résultat de la fonction est vrai, tout cela est correct, mais s'il est faux, il serait très intelligent de vérifier si des flux sont en réalité différentes ou simplement une erreur survenue. EM> P>

Edité: a ajouté des contrôles supplémentaires, FichiersAdentifier Fonction basé sur l'exemple StreamSareDidydyDidydyDidyDidydyDidydyDidyDidySical et d'utilisation. EM> PR>

// Usage example

var lError: Integer;
...
 if FilesAreIdentical(lError, 'file1.ext', 'file2.ext')
    then Memo1.Lines.Append('Files are identical.')
    else case lError of
           0: Memo1.Lines.Append('Files are NOT identical!');
           1: Memo1.Lines.Append('Files opened, stream read exception raised!');
           2: Memo1.Lines.Append('File does not exist!');
           3: Memo1.Lines.Append('File open exception raised!');
         end; // case
...

// StreamAreIdentical

function StreamsAreIdentical(var aError: Integer;
                             const aStream1, aStream2: TStream;
                             const aBlockSize: Integer = 4096): Boolean;

var
  lBuffer1: array of byte;
  lBuffer2: array of byte;
  lBuffer1Readed,
  lBuffer2Readed,
  lBlockSize: integer;

begin
  Result:=False;
  aError:=0;
  try
    if aStream1.Size <> aStream2.Size
       then Exit;

    aStream1.Position:=0;
    aStream2.Position:=0;

    if aBlockSize>0
       then lBlockSize:=aBlockSize
       else lBlockSize:=4096;

    SetLength(lBuffer1, lBlockSize);
    SetLength(lBuffer2, lBlockSize);

    lBuffer1Readed:=1; // just for entering while

    while (lBuffer1Readed > 0) and (aStream1.Position < aStream1.Size) do
    begin
      lBuffer1Readed := aStream1.Read(lBuffer1[0], lBlockSize);
      lBuffer2Readed := aStream2.Read(lBuffer2[0], lBlockSize);

      if (lBuffer1Readed <> lBuffer2Readed) or ((lBuffer1Readed <> lBlockSize) and (aStream1.Position < aStream1.Size))
         then Exit;

      if not CompareMem(@lBuffer1[0], @lBuffer2[0], lBuffer1Readed)
         then Exit;
    end; // while

    Result:=True;
  except
    aError:=1; // stream read exception
  end;
end;


// FilesAreIdentical using function StreamsAreIdentical

function FilesAreIdentical(var aError: Integer;
                           const aFileName1, aFileName2: String;
                           const aBlockSize: Integer = 4096): Boolean;

var lFileStream1,
    lFilestream2: TFileStream;

begin
 Result:=False;
 try
   if not (FileExists(aFileName1) and FileExists(aFileName2))
      then begin
        aError:=2; // file not found
        Exit;
      end;

   lFileStream1:=nil;
   lFileStream2:=nil;
   try
     lFileStream1:=TfileStream.Create(aFileName1, fmOpenRead or fmShareDenyNone);
     lFileStream2:=TFileStream.Create(aFileName2, fmOpenRead or fmShareDenyNone);
     result:=StreamsAreIdentical(aError, lFileStream1, lFileStream2, aBlockSize);
   finally
     if lFileStream2<>nil
        then lFileStream2.Free;

     if lFileStream1<>nil
        then lFileStream1.Free;
   end; // finally
 except
   aError:=3; // file open exception
 end; // except
end;