2 Textdateien vergleichen

[KodeZwerg]

Ich schließe mich lxo da voll und ganz an.
Dateigröße prüfen, wenn gleich dann einen Hash/Crc Wert beider Dateien vergleichen.
Dabei ist es völlig egal ob es Text oder Binär Inhalt ist.

Delphi-Quellcode:

uses
  WinApi.Windows, System.Hash;


// um Dateigrößen >4GB zu ermitteln
function GetFileSize(const aFilename: String): Int64;
var
  info: TWin32FileAttributeData;
begin
  Result := -1;
  if NOT GetFileAttributesEx(PWideChar(aFileName), GetFileExInfoStandard, @info) then
    Exit;
  Result := Int64(info.nFileSizeLow) or Int64(info.nFileSizeHigh shl 32);
end;

// von lxo aus Delphi-Praxis
function GetHashMD5(const Datei: String): String;
begin
  Result := THashMD5.GetHashStringFromFile(Datei);
end;

//beispiel, nur hier per editor... ungetestet
function IsEqualFile(const Datei1, Datei2: String): Boolean;
begin
  Result := ( (GetFileSize(Datei1) = GetFileSize(Datei2)) and (GetHashMD5(Datei1) = GetHashMD5(Datei2)) );
end;

//edit
code beispiel angefügt

[Uwe Raabe]

Zitat von TigerLilly:

CompareMemory ist aber nicht Teil der RTL - sondern?

Stimmt, aber CompareMem in SysUtils ist es.

Zitat von TigerLilly:

TBufferedFileStream optimiert bei wiederholtem Lesen, da für den Vergleich nur 1x gelesen werden muss, genügt doch TFileStream?

Da ich nach dem ersten Unterschied schon aufhören kann, ist es doch performanter, wenn ich die Dateien zeichenweise lese + vergleiche + nicht den ganzen Inhalt mit TFile.ReadAllBytes(FileA) einlese und dann erst vergleiche, oder?

Das ist so ein bisschen Statistik. Eenn sich die Dateien häufig erst am Ende unterscheiden, ist es meist performanter die Datei komplett oder blockweise einzulesen. Blockweise Einlesen ist in der Regel ein guter Kompromiss.

[einbeliebigername]

Hallo,

Zitat von Der schöne Günther:

Zitat von stahli:

StringList1.Text=StringList2.Text

Sicher nicht die beste Wahl wenn die Dateien groß oder keine Textdateien sind.

Sicherlich nicht die beste Lösung des Problems, welche aber unter schon genannten Bedingungen noch akzeptabel ist. Aber auf alle Fälle unendlich mal besser als dieser Blödsinn:

Zitat von lxo:

Hash ermitteln und vergleichen MD5 oder sonstiges evtl. ?
System.Hash

Und folgender Algorithmus ist fehlerhaft.

Zitat von KodeZwerg:

Delphi-Quellcode:

uses
  WinApi.Windows, System.Hash;


// um Dateigrößen >4GB zu ermitteln
function GetFileSize(const aFilename: String): Int64;
var
  info: TWin32FileAttributeData;
begin
  Result := -1;
  if NOT GetFileAttributesEx(PWideChar(aFileName), GetFileExInfoStandard, @info) then
    Exit;
  Result := Int64(info.nFileSizeLow) or Int64(info.nFileSizeHigh shl 32);
end;

// von lxo aus Delphi-Praxis
function GetHashMD5(const Datei: String): String;
begin
  Result := THashMD5.GetHashStringFromFile(Datei);
end;

//beispiel, nur hier per editor... ungetestet
function IsEqualFile(const Datei1, Datei2: String): Boolean;
begin
  Result := ( (GetFileSize(Datei1) = GetFileSize(Datei2)) and (GetHashMD5(Datei1) = GetHashMD5(Datei2)) );
end;

Genauer gesagt liefert dieser nur beim Rückgabewert False ein korrektes Ergebnis. Der Rückgabewert True ist unbrauchbar, denn es fehlt noch der Byteweise Vergleich.

[KodeZwerg]

Zitat von einbeliebigername:

Und folgender Algorithmus ist fehlerhaft.
...mein schnippsel von oben...
Genauer gesagt liefert dieser nur beim Rückgabewert False ein korrektes Ergebnis. Der Rückgabewert True ist unbrauchbar, denn es fehlt noch der Byteweise Vergleich.

Ein Hash wird über die Bytes generiert.
Hättest Du die Güte ein Beispiel zu posten damit das was Du sagst nachvollziehbar ist?
Das 2 unterschiedliche Dateien den gleichen MD5 Hash liefern... möglich ja aber eher die Ausnahme als die Regel.

Ich hatte halt Geschwindigkeit im Vordergrund.

so etwas hier wollte ich verhindern...
gefunden auf Stackoverflow, code von David

Delphi-Quellcode:

// 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;

[Gausi]

Warum bei zwei Dateien überhaupt die Hashwerte bilden, wenn man nur wissen will, ob die beiden Files gleich sind? Den Aufwand, den Hash zu berechnen (gut, der hält sich in aller Regel in Grenzen), kann man sich doch sparen, und einfach den Dateiinhalt vergleichen. Oder sind Dinge wie CompareMem so CPU-lastig?

Mit Hashwerten würde ich nur arbeiten, wenn ich mehr als nur eine Datei habe, und z.B. in einem Dokumenten-Verwaltungssystem checken möchte, ob eine Datei bereits im System vorhanden ist oder nicht (zumindest mit einer i.A. ausreichend hohen Wahrscheinlichkeit).

[einbeliebigername]

Hallo,

Zitat von KodeZwerg:

Ein Hash wird über die Bytes generiert.

Ja, richtig. Genauer gesagt über die gesamten Bytes. Sonst macht das garkeinen Sinn. Aber dazu später mehr.

Zitat von KodeZwerg:

Hättest Du die Güte ein Beispiel zu posten damit das was Du sagst nachvollziehbar ist?

Nein. Das ist mir zu aufwendig, bzw. der Strom ist mir zu teuer, zwei Dateien zu suchen wo dein Algorithmus falsche Ergebnisse liefert. Mir reicht es das es diese zwei Dateien theoretisch geben kann.

Zitat von KodeZwerg:

Das 2 unterschiedliche Dateien den gleichen MD5 Hash liefern... möglich ja aber eher die Ausnahme als die Regel.

Es reicht, dass es möglich ist. Denn wir wollen Programme scheiben die 100,0% richtig funktionieren.

Zitat von KodeZwerg:

so etwas hier wollte ich verhindern...

Beim überfliegen scheint das aber erst mal mit jedem Pärchen 100,0% richtig zu funktionieren.

Zitat von KodeZwerg:

Ich hatte halt Geschwindigkeit im Vordergrund.

Da verliert deinen Lösung mit Hash aber haushoch. Was ist denn langsam? Über den byteweisen vergleich gähnt die CPU heutzutage nur müde. Es ist doch das lesen der Dateien von der Festplatte, was langsam ist. Selbst bei einer sehr guten SSD hat die CPU neben bei noch genügend Zeit. Und das Problem an deiner Lösung mit Hash ist, neben dem Problem mit der mangelnden Aussagekraft bei gleichen Hashwerten, dass bei beiden Dateien immer der gesamte Inhalt gelesen werden muss, selbst wenn das erste Byte schon unterschiedlich ist. Und selbst wenn die heutigen CPU's die Berechnung eines Hash spielend erledigen, ist der Aufwand für die Hash-Berechnungen deutlich höher als für den byteweisen Vergleich.

Hash’s kann man einsetzten um den kreuzweisen Vergleich vieler Dateien zu optimieren. Dabei muss man dann aber auf die Eigenheiten der Hash-Algorithmen eingehen. Und läuft Gefahr, dass die Optimierung bei manchen Situationen nach hinten los geht.

[freimatz]

Zitat von TigerLilly:

TFile.Equals(<filename>) gibt es ja leider nicht. Was ist die eleganteste Möglichkeit, zu prüfen, ob zwei Dateien den gleichen Inhalt haben? Gibt es da in der Delphi RTL etwas?

Nein.
Definiere "elegant"
Mit unklaren Anforderungen bekommt man meist nicht das was man erwartet.