''' <summary>
''' Compare le contenu de deux fichiers 
''' </summary>
''' <param name="FichierA">Chemin du premier fichier à comparer</param>
''' <param name="FichierB">Chemin du second fichier à comparer</param>
''' <returns>Vrai si identique, sinon faux</returns>
Public Function EstIdentique(ByVal FichierA As String, ByVal FichierB As String) As Boolean

 Const BufferSize As Integer = 8192 ' 8Ko

 Dim Retour As Boolean = True

 ' Verification existance fichiers
 If (Not File.Exists(FichierA)) Then
  Throw New IOException("Le fichier A n'existe pas !")
 End If

 If (Not File.Exists(FichierB)) Then
  Throw New IOException("Le fichier B n'existe pas !")
 End If

 ' Nos buffers de travail
 Dim bufferA(BufferSize) As Byte
 Dim bufferB(BufferSize) As Byte

 ' Ouverture du premier fichier A
 Dim fA As New FileStream(FichierA, FileMode.Open, FileAccess.Read, FileShare.Read, BufferSize)

 ' Ouverture du second fichier B
 Dim fB As New FileStream(FichierB, FileMode.Open, FileAccess.Read, FileShare.Read, BufferSize)

 Dim LuA As Integer = bufferA.Length
 Dim LuB As Integer = bufferB.Length

 Try

  Do
   ' Copie les 8 Ko suivant du flux dans les buffers
   LuA = fA.Read(bufferA, 0, bufferA.Length)
   LuB = fB.Read(bufferB, 0, bufferB.Length)

   ' On verifie que nous avons lu le meme nombre d'octet sur chaque flux
   If (LuA = LuB) Then

    ' Comparaison octet à octet
    For cpt As Integer = 0 To (bufferA.Length - 1)

     If (bufferA(cpt) <> bufferB(cpt)) Then
      Retour = False   ' Les fichiers ne sont pas identiques
      Exit Do          ' On sort, plus besoin de continuer
     End If

    Next

   Else
    Retour = False   ' Les fichiers ne sont pas identiques
    Exit Do          ' On sort, plus besoin de continuer
   End If

   ' On continu si on peut encore en lire
  Loop While (LuA > 0 And LuB > 0)

 Catch ex As Exception

  Throw New Exception("Erreur pendant l'execution de EstIdentique", ex)

 Finally

  ' Ferme fichier A
  If (Not fA Is Nothing) Then
   fA.Close()
   fA.Dispose()
  End If

  ' Ferme fichier B
  If (Not fB Is Nothing) Then
   fB.Close()
   fB.Dispose()
  End If

 End Try

 Return Retour

End Function

function CompareFile(const FilePathA, FilePathB: AnsiString): Boolean;
Var
 H1, H2, M1, M2, Size: Longword;
 P1, P2: Pointer;
begin
 P1 := nil;
 P2 := nil;
 M1 := 0;
 M2 := 0;
 H1 := INVALID_HANDLE_VALUE;
 H2 := INVALID_HANDLE_VALUE;
 Result := False;
 try
  H1 := CreateFile(PAnsiChar(FilePathA), GENERIC_READ, FILE_SHARE_READ, nil, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL or FILE_FLAG_SEQUENTIAL_SCAN, 0);
  if H1 <> INVALID_HANDLE_VALUE then
   begin
    H2 := CreateFile(PAnsiChar(FilePathB), GENERIC_READ, FILE_SHARE_READ, nil, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL or FILE_FLAG_SEQUENTIAL_SCAN, 0);
     if H2 <> INVALID_HANDLE_VALUE then
      begin
       Size := GetFileSize(H1, nil);
       if Size <> GetFileSize(H2, nil) then Exit;
       if Size = 0 then 
       begin 
         Result := True; 
         Exit; 
       end; 
        M1 := CreateFileMapping(H1, nil, PAGE_READONLY, 0, 0, nil);
       if M1 <> 0 then
        begin
         M2 := CreateFileMapping(H2, nil, PAGE_READONLY, 0, 0, nil);
         if M2 <> 0 then
          begin
           P1 := MapViewOfFile(M1, FILE_MAP_READ, 0, 0, 0);
           if P1 <> nil then
            begin
             P2 := MapViewOfFile(M2, FILE_MAP_READ, 0, 0, 0);
             if P2 <> nil then Result := CompareMem(P1, P2, Size);
            end;
          end;
        end;
      end;
   end;
 finally
  if P2 <> nil then UnmapViewOfFile(P2);
  if P1 <> nil then UnmapViewOfFile(P1);
  if M2 <> 0 then CloseHandle(M2);
  if M1 <> 0 then CloseHandle(M1);
  if H2 <> INVALID_HANDLE_VALUE then CloseHandle(H2);
  if H1 <> INVALID_HANDLE_VALUE then CloseHandle(H1);
 end;
end;

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

char copyright[] = "\n"
                   "  Comparaison de fichier\n"
                   "  Ecrit par LEVEUGLE Damien\n"
                   "  Elguevel software (c) 2010\n\n";

char syntaxe[] = "\n  Usage : compare <fichierA> <fichierB>\n\n";

/*
 *  Compare deux fichiers octet à octet
 *
 *  Return : -1 -> Erreur programme
 *            0 -> Identique
 *            1 -> Non identique
 */
int compareFile( const char *fichierA, const char *fichierB )
{
    // handles fichier
    HANDLE hFileA = NULL;
    HANDLE hFileB = NULL;

    // mapping
    HANDLE hMapA  = NULL;
    HANDLE hMapB  = NULL;
    
    // buffers
    char *pFileBaseA;
    char *pFileBaseB;    
    
    // taille fichier
    DWORD dwFileSizeA, hwFileSizeA;
    DWORD dwFileSizeB, hwFileSizeB;

    // code retour
    int retour = 0;
    
    // pointeur caractere
    unsigned int cpt;

    /* Ouverture des fichiers */
    hFileA = CreateFile( fichierA, 
                        GENERIC_READ + GENERIC_WRITE,
                        FILE_SHARE_READ + FILE_SHARE_WRITE, 
                        NULL, 
                        OPEN_EXISTING, 
                        FILE_ATTRIBUTE_NORMAL, 
                        NULL );

    if( hFileA == INVALID_HANDLE_VALUE )
    {
        printf("\t* Impossible d'ouvrir le fichier A !\n");
        CloseHandle( hFileA );
        return -1;
    } 
    
    hFileB = CreateFile( fichierB, 
                        GENERIC_READ + GENERIC_WRITE, 
                        FILE_SHARE_READ + FILE_SHARE_WRITE, 
                        NULL, 
                        OPEN_EXISTING, 
                        FILE_ATTRIBUTE_NORMAL, 
                        NULL );    

    if( hFileB == INVALID_HANDLE_VALUE )
    {
        printf("\t* Impossible d'ouvrir le fichier B !\n");
        CloseHandle( hFileB );
        return -1;
    } 
    
    /* Mapping */ 
    hMapA = CreateFileMapping( hFileA, NULL, PAGE_WRITECOPY, 0, 0, NULL ); 
    hMapB = CreateFileMapping( hFileB, NULL, PAGE_WRITECOPY, 0, 0, NULL ); 

    if( hMapA == NULL || hMapB == NULL )
    {
        printf("\t* Erreur CreateFileMapping !\n");        
        CloseHandle( hFileA );
        CloseHandle( hFileB );        
        return -1;        
    }
    
    /* Buffers */     
    pFileBaseA = (char *)MapViewOfFile( hMapA, FILE_MAP_COPY,  0, 0, 0 );
    pFileBaseB = (char *)MapViewOfFile( hMapB, FILE_MAP_COPY,  0, 0, 0 );

    if( pFileBaseA == NULL || pFileBaseB == NULL )
    {
        printf("\t* Erreur MapViewOfFile !\n");
        CloseHandle( hMapA );
        CloseHandle( hMapB );
        CloseHandle( hFileA );
        CloseHandle( hFileB );        
        return -1;
    } 

    /* Tailles fichiers */     
    dwFileSizeA = GetFileSize( hFileA, &hwFileSizeA );
    dwFileSizeA += hwFileSizeA * MAXDWORD;

    dwFileSizeB = GetFileSize( hFileB, &hwFileSizeB );
    dwFileSizeB += hwFileSizeA * MAXDWORD;

    /* Comparaison */
    if ( ( dwFileSizeA && dwFileSizeB ) && ( dwFileSizeB == dwFileSizeA ) )
    {
        // boucle avec dwFileSizeA (= dwFileSizeB)
        for( cpt = 0; cpt < dwFileSizeA; cpt++ ) 
        {
            if ( pFileBaseA[cpt] != pFileBaseB[cpt] )
            {
                 // Si différence, stop
                 retour = 1;
                 break;
            }
        }
    }
    
    /* Release the kracken ... :-) */
    UnmapViewOfFile( pFileBaseA );    
    UnmapViewOfFile( pFileBaseB );    
    
    CloseHandle( hMapA  ); 
    CloseHandle( hMapB  ); 
        
    CloseHandle( hFileA );
    CloseHandle( hFileB );

    return retour;
}
/*
 *  Entry point (demo)
 */
int main(int argc, char *argv[])
{
    printf("%s", copyright);

    if ( argc != 3 )
    {
        printf("%s\n\t* Nombre d'arguments incorrect !\n", syntaxe);
        return -1;
    }
    else
    {
        int iresult = compareFile( argv[1], argv[2] );

        switch ( iresult )
        {
            case 0 :
            {
               printf("\t* Les fichiers sont identiques\n");
               break;
            }
            
            case 1 :
            {
               printf("\t* Les fichiers sont differents !\n");
               break;                       
            }
            default :             
              printf("\t* Erreur de la fonction compareFile()\n");                        
        }
    }
    return 0;
}

 

class CompareFiles
{
    /** @var array $fileA : fichier 1 */
    private $fileA;
    
    /** @var array $fileB : fichier 2 */
    private $fileB;
    
    /** @var array $result : résultat de la comparaison */
    private $result;
    
    
    /**
     * Méthode magique, définition des fichiers à comparer
     */
    public function __construct($fileA, $fileB)
    {
        if(!file_exists($fileA))
            throw new Exception('Le fichier '.$fileA.' est inexistant');
        if(!file_exists($fileB))
            throw new Exception('Le fichier '.$fileB.' est inexistant');
        $this->fileA = $fileA;
        $this->fileB = $fileB;
        $this->compare();
    }
    
    /**
     * Méthode magique, retourne le résultat
     */
    public function __toString()
    {
        if(!$this->result) 
            return 'Les deux fichiers ne sont pas identiques';
        else
            return 'Les deux fichiers sont identiques';
    }
    
    /**
     * Comparaison des fichiers
     */
    private function compare()
    {
        $oFileA = new SplFileObject($this->fileA, 'rb');
        $oFileB = new SplFileObject($this->fileB, 'rb');    
        
        if($oFileA->getSize()!==$oFileB->getSize())
            return $this->result = FALSE;
        /* A partir de PHP 5.3.6    
        if($oFileA->getExtension()!==$oFileB->getExtension())
            return $this->result = FALSE;    
        */
        
        while(!$oFileA->eof()) {
            if($oFileA->ftell()===$oFileB->ftell()) {
                if($oFileA->fgets()!==$oFileB->fgets()) {
                    unset($oFileA, $oFileB);
                    return $this->result = FALSE;
                }
            }
            else {
                unset($oFileA, $oFileB);
                return $this->result = FALSE;
            }
        }
        unset($oFileA, $oFileB);
        return $this->result = TRUE;
    }
    
        
}