Sammenligne filer

Function GetCheckSum (const FileName : TFileName) : Integer;
var
  F : File of Integer;
  Fsize : Integer;
  Buffer : Array [0..500] of Integer;
begin
  FileMode := 0;
  AssignFile ( F , FileName);
  Reset ( F );
  Seek ( F , FileSize ( F ) div 2);
  Fsize := FileSize( F )-1-FilePos( F );
  if Fsize > 500 then Fsize := 500;
  BlockRead ( F, Buffer, Fsize);
  CloseFile ( F );
    asm
      xor eax, eax
      xor ecx, ecx
      lea edx , Buffer
    @again:
      add eax, [edx + 4*ecx]
      inc ecx
      cmp ecx, fsize
    jl @again
      mov @result, eax
    end;
end;

Det her kode kan give dig en entydig check sum på en fil .. Hvis tallene er en så ER det den samme fil. Ellers ikke.

Jens B

Jeg lavede en gang (lang tid siden) det her:

function IsSameFile(var F1, F2: File): Boolean; overload;
var
  OldSeek1, OldSeek2, Seeker, Size1, Size2, NumRead: Integer;
  Buf1, Buf2: array [1..2048] of Char;
begin
  OldSeek1 := FilePos(F1);
  OldSeek2 := FilePos(F2);
  Size1 := FileSize(F1);
  Size2 := FileSize(F2);
  Seeker := Min(Size1, Size2)-2048;
  if Seeker < 0 then
  begin
    FillChar(Buf1, 2048, 0);
    FillChar(Buf2, 2048, 0);
    Seeker := 0;
  end;
  Seek(F1, Seeker);
  Seek(F2, Seeker);
  if Seeker = 0 then
  begin
    BlockRead(F1, Buf1, Min(Size1, Size2), NumRead);
    BlockRead(F2, Buf2, NumRead);
  end
  else
  begin
    BlockRead(F1, Buf1, 2048);
    BlockRead(F2, Buf2, 2048);
  end;
  Seek(F1, OldSeek1);
  Seek(F1, OldSeek2);
  Result := Buf1 = Buf2;
end;

function IsSameFile(FileName1, FileName2: String): Boolean; overload;
var
  F1, F2: File;
  OldFileMode: Byte;
begin
  OldFileMode := FileMode;
  FileMode := 0;
  AssignFile(F1, FileName1);
  Reset(F1, 1);
  AssignFile(F2, FileName2);
  Reset(F2, 1);
  Result := IsSameFile(F1, F2);
  CloseFile(F1);
  CloseFile(F2);
  FileMode := OldFileMode;
end;

Dog tror jeg det er bedre at bruge Borrisholt's metode... Kunne godt se lidt hurtigere ud! ;)

Barsk ... jeg har ikke testet det, men jeg kan se at syntaxen er korrekt ..... NOT

jeg har en enkelt gang postet den før på eksperten . Der var det også kommentarer med :

Function GetCheckSum (const FileName : TFileName) : Integer;
var
  F : File of Integer;
  Fsize : Integer;
  Buffer : Array [0..500] of Integer;
begin
  FileMode := 0;
  AssignFile ( F , FileName);
  Reset ( F );
  Seek ( F , FileSize ( F ) div 2);
  Fsize := FileSize( F )-1-FilePos( F );
  if Fsize > 500 then
    Fsize := 500;
  BlockRead ( F, Buffer, Fsize);
  CloseFile ( F );
    asm
      xor eax, eax //NULSTILL  eax det skal bruges til at tælle sammen i
      xor ecx, ecx //NULSTILL  ecx det skal bruges til at holde vores tælle variabel
      lea edx , Buffer //Put adressen på Buffer over i edx registeret.
    @again: //En label vi kan hoppe til  PRÆCIS magen til en label i pascal (Ikke at forveksle med TLabel)
      add eax, [edx + 4*ecx]
//En integer fylder 4 BYTE (32 bit) så hvis vi skal have fat i Et eller andet element i vores
//Buffer array ligger det på adressen Starten af array + (4*Nummeret på elementet)
//Adressen på starten af arrayet ligger i edx registeret. Vores tæller variabel er ecx så
//regnestykket hedder edx + 4*ecx. Da vi ikke skal have adressen men der der ligger på adressen
//stopper vi det hele ind i []. Det hele bliver stoppet over i eax.
      inc ecx //tæl  ecx op med 1 (inc er en forkortelse af increase)
      cmp ecx, fsize  //sammenlign (cmp er en forkortelse af compare)
    jl @again //hvis ecx < fsize  så goto again lablen vi satte før (jl er en forkortelse af Jump less)
      mov @result, eax //kom resultater af vores tællen sammen over i result
    end;
end;


jens B

http://www.eksperten.dk/spm/98231

Ja, men det kom ikke frem ved at søge på "sammenligne"

Du kunne starte med at sammenligne filstørrelsen inden du laver checksum, det kunne spare en masse tid.

det er ikke særlig sikkert .. jeg har brug for noget der er meget præcist

Prøv at læse min kommentar igen ;)

Åååh ... ja. ... jeg pudser lige brillerne ;-)

Det der tager tiden er at finde filen på HD'en det andet tager ikke lang tid.

Jens B

Hmm .... Jens, har du prøvet dit eksempel? Jeg har lidt problemer med at få koden til at identificere forskelle. Jeg har lavet 2 sprit nye applilationer i Delphi. I den ene er der en knap med en caption := button1 og i det andet med button caption := button2. Programmet beregner identiske checksummer for programmerne, selvom de er forskellige :/

Funktionen GetCheckSum laver kun checksum på max. 500 bytes midt i filen. Det er en meget hurtig måde at gøre det på, men langt fra nøjagtig så vidt jeg kan se.

Du er nødt til at sammenligne hver eneste byte i de to filer for at være sikker, og så er det at starte med en sammenligning på filstørrelser kan spare en bunke tid, især hvis det er store filer.

prøv den her :
Function GetCheckSum ( FileName : String) : Integer;
var
  MemoryStream : TMemoryStream;
  FSize : Integer;
  P : PChar;
begin
  MemoryStream := TMemoryStream.Create;
  MemoryStream.LoadFromFile(FileName);
  p := MemoryStream.Memory;
  Result := 0;
  {$R-}
  for FSize := 0 to MemoryStream.Size do
    Result := Result + Integer(p[FSize]);
  {$R+}
  MemoryStream.Free;
end;

Kræver dog minst D5 ellers kan du risikere at få en range check error.

Jens B

Ok, jeg sammenligner størrelsen. De er ens. Og hvad så, lad os sige, at der kun er ændret en byte i enden af programmet, der fylder 1 mb. Så er det hverken størrelse eller 500 byte i midten der er ændret.

Tak Jens, den prøver jeg

skal det ikke være
for FSize := 0 to MemoryStream.Size-1 do

jo selvfølgelig ..

Er du kvik not til at fortælle mig hvrofor det andet går godt ? :-)

Jens B

den her er lidt hurtigere :
Function GetCheckSum ( FileName : String) : Integer;
var
  MemoryStream : TMemoryStream;
  i, FSize : Integer;
  P : PChar;
begin
  MemoryStream := TMemoryStream.Create;
  MemoryStream.LoadFromFile(FileName);
  p := MemoryStream.Memory;
  Result := 0;
  FSize := MemoryStream.Size div 4;
  {$R-}
  for i := 0 to FSize do
    inc(Result, Integer(p[FSize]));
  {$R+}
  MemoryStream.Free;
end;


Jens B

Ikke umiddelbart .. enlighten me please

fordi jeg har slåer Range Checking fra : {$R-}

Jens B

aha :)

BorrisHolt, i dit andet eksempel kan du misse 1-3 bytes, alt afhængig af hvor stor filen er ;)

Hvor store er dine filer justincase? Hvis de er meget store vil dit program få et enorm ram forbrug eftersom hele filen loades in på én gang.

Øøøh ja det er også en fejl ...  Det er sq da godt i er vårne .. DEet var fordi jeg var ved at ekpermentere med noget andet : Noget ASM.

Vi bringer lige en opdatering :

Function GetCheckSum (FileName : String) : Integer;
var
  MemoryStream : TMemoryStream;
  i, FSize : Integer;
  P : PChar;
begin
  MemoryStream := TMemoryStream.Create;
  MemoryStream.LoadFromFile(FileName);
  p := MemoryStream.Memory;
  Result := 0;
  FSize := MemoryStream.Size -1;
  {$R-}
  for i := 0 to FSize do
    inc(Result, Integer(p[FSize]));
  {$R+}
  MemoryStream.Free;
end;

Jens B

Filerne varierer fra nogle få kb til op til 10 mb. Sammenligningen kommer nu til at køre på en server med adskillige GB ram og RAID, så det kommer ikk til at betyde noget .... så længe der ikke er leaks ;-)

Det er der ikke i min proc.

Jens B

Nej, glimrende

skal du så også vide hvornår der sker ændringer på din HD ?

Nej, ellers tak.
Sammenligningen af filerne skal jeg bruge i en natlig bygning af omkring 300 dller og exefiler og derudfra bestemme, om der skal incrementeres i en efterfølgende versionsstempling. Så denne sammenligning sker afhængig af en tidsevent

hvad med et træ til at stille den slags op i ?

Jens B

Her er mit bud på hvordan den funktion skal de ud :o) (jeg kunne ikke lade være)

type
  TFileCompareResult = (fcrEqual, fcrDiferentSizes, fcrDifferentContent, fcrFileNotFound, fcrUnknownError);

function IsSameFile(File1, File2: string): TFileCompareResult;
const BUFLEN = 65536;
var
  F1, F2      : file;
  Buf1, Buf2  : array[0..BUFLEN-1] of byte;
  Bytes      : integer;
begin
  try
    if (FileExists(File1) and FileExists(File2)) then begin
      AssignFile(F1, File1);
      AssignFile(F2, File2);
      Reset(F1, 1);
      Reset(F2, 1);
      if FileSize(F1) = FileSize(F2) then begin
        Result := fcrEqual;
        while not Eof(F1) do begin
          BlockRead(F1, Buf1[0], BUFLEN, Bytes);
          BlockRead(F2, Buf2[0], BUFLEN, Bytes);
          if not CompareMem(@Buf1[0], @Buf2[0], Bytes) then begin
            Result := fcrDifferentContent;
            break;
          end;
        end;
      end else begin
        Result := fcrDiferentSizes;
      end;
      CloseFile(F1);
      CloseFile(F2);
    end else begin
      Result := fcrFileNotFound;
    end;
  except
    on e: exception do begin
      MessageBox(0, pchar(E.Message), 'ok', mb_ok);
    Result := fcrUnknownError;
    end;
  end;
end;

Ooopsie, slet lige messageboxen! Den var bare til test, sorry

Exception delen skal bare se således ud:

  except
    Result := fcrUnknownError;
  end;

zimp : Tak

Jens B : Ellers tak .. hele scheduleringen af bygningen af filerne klares fra en database.

zimp ... Brug en stream i stedet. Det er hurtigere.

Jens B

noget alla det her :

type
  TFileCompareResult = (fcrEqual, fcrDiferentSizes, fcrDifferentContent, fcrUnknownError);

function IsSameFile(File1, File2: string): TFileCompareResult;
var
  Stream1, Stream2 : TMemoryStream;
begin
  try
    Stream1  := TMemoryStream.Create;
    Stream2  := TMemoryStream.Create;
  try
    Stream1.LoadFromFile(File1);
    Stream2.LoadFromFile(File2);

    if Stream1.Size = Stream2.Size then
        if CompareMem(Stream1.Memory, Stream2.Memory, Stream1.Size) then
          Result := fcrEqual
        else
          Result := fcrDifferentContent
    else
      Result := fcrDiferentSizes;

  finally
    Stream1.Free;
    Stream2.Free;
  end;
  except
    Result := fcrUnknownError;
  end;
end;


Jens B

Det der tager lang tid er at læse fra HD'en ar arbejde i ram er hurtigt !

Jens B

Det går nu ikke hurtigere fordi du bruger en stream, det skal loades alligevel, og ulempen ved det ovenstående er du loader hele filen på en gang, det giver et stort ram forbrug.

ja forskellen er at jeg tilgår HD' en gang pr fil. Du til går den flere gange. Det er det der er min pointer, og derfor jeg påstår at mine streams er hurtigere.

Jens B

fordelen ve en check sum frem for CompareMem er at Tallet sammen med filnavnet er meget tæt på et unik ID

Jens B

Jeg lavede lige en speedtest, på 1MB fil gik det ca. 2-3 gange så langsomt at bruge en stream, som selv at læse med BlockRead.