Come vedere se un sottofile di una directory è cambiato

Question

In Windows, esiste un modo semplice per sapere se una cartella ha un file secondario che è cambiato?

Ho verificato e la data dell'ultima modifica sulla cartella non viene aggiornata quando cambia un file secondario.

Esiste una voce di registro che posso impostare che modificherà questo comportamento?

Se è importante, sto utilizzando un volume NTFS.

Alla fine mi piacerebbe avere questa capacità da un programma C++.

La scansione ricorsiva di un'intera directory non funzionerà per me perché la cartella è troppo grande.

Aggiornamento:Ho davvero bisogno di un modo per farlo senza che un processo sia in esecuzione mentre si verifica la modifica.Quindi installare un osservatore del file system non è ottimale per me.

Aggiornamento2:Anche il bit di archivio non funzionerà perché presenta lo stesso problema dell'ultima data di modifica.Il bit di archivio del file verrà impostato, ma le cartelle no.

Answer 1

Questo articolo dovrebbe aiutare.Fondamentalmente, crei uno o più oggetti di notifica come:

HANDLE dwChangeHandles[2]; 
dwChangeHandles[0] = FindFirstChangeNotification( 
      lpDir,                          // directory to watch 
      FALSE,                          // do not watch subtree 
      FILE_NOTIFY_CHANGE_FILE_NAME);  // watch file name changes 

   if (dwChangeHandles[0] == INVALID_HANDLE_VALUE) 
   {
     printf("\n ERROR: FindFirstChangeNotification function failed.\n");
     ExitProcess(GetLastError()); 
   }

// Watch the subtree for directory creation and deletion.  
   dwChangeHandles[1] = FindFirstChangeNotification( 
      lpDrive,                       // directory to watch 
      TRUE,                          // watch the subtree 
      FILE_NOTIFY_CHANGE_DIR_NAME);  // watch dir name changes 

   if (dwChangeHandles[1] == INVALID_HANDLE_VALUE) 
   {
     printf("\n ERROR: FindFirstChangeNotification function failed.\n");
     ExitProcess(GetLastError()); 
   }

e poi aspetti una notifica:

 while (TRUE) 
   { 
   // Wait for notification. 
      printf("\nWaiting for notification...\n");

      DWORD dwWaitStatus = WaitForMultipleObjects(2, dwChangeHandles, 
         FALSE, INFINITE); 

      switch (dwWaitStatus) 
      { 
         case WAIT_OBJECT_0: 

         // A file was created, renamed, or deleted in the directory.
         // Restart the notification. 
             if ( FindNextChangeNotification(dwChangeHandles[0]) == FALSE )
             {
               printf("\n ERROR: FindNextChangeNotification function failed.\n");
               ExitProcess(GetLastError()); 
             }
             break; 

         case WAIT_OBJECT_0 + 1: 

         // Restart the notification. 
             if (FindNextChangeNotification(dwChangeHandles[1]) == FALSE )
             {
               printf("\n ERROR: FindNextChangeNotification function failed.\n");
               ExitProcess(GetLastError()); 
             }
             break; 

         case WAIT_TIMEOUT:

         // A time-out occurred. This would happen if some value other 
         // than INFINITE is used in the Wait call and no changes occur.
         // In a single-threaded environment, you might not want an
         // INFINITE wait.

            printf("\nNo changes in the time-out period.\n");
            break;

         default: 
            printf("\n ERROR: Unhandled dwWaitStatus.\n");
            ExitProcess(GetLastError());
            break;
      }
   }
}

Answer 2

Questo è forse eccessivo, ma il Kit IFS dalla SM o dal FDDK da OSR potrebbe essere un'alternativa.Crea il tuo driver di filtro del filesystem con un semplice monitoraggio di tutte le modifiche al filesystem.

Answer 3

Leggi le modifiche alla directory W

Un eccellente codice di esempio in questo articolo di CodeProject

Answer 4

Se non puoi eseguire un processo quando si verifica la modifica, non c'è molto che puoi fare se non scansionare il filesystem e controllare la data/ora della modifica.Ciò richiede tuttavia di memorizzare l'ultima data/ora di ciascun file e di confrontarla.

Puoi velocizzare l'operazione utilizzando il file bit di archivio (anche se potrebbe rovinare il software di backup, quindi procedi con attenzione).

Un bit di archivio è un attributo file presente in molti file system di computer, in particolare FAT, FAT32 e NTFS.Lo scopo di un bit di archivio è tracciare le modifiche incrementali ai file ai fini del backup, anche chiamato archiviazione.

Poiché il bit di archivio è un bit binario, è 1 o 0 o in questo caso più frequentemente chiamato set (1) e chiaro (0).Il sistema operativo imposta il bit di archivio ogni volta che un file viene creato, spostato, rinominato o altrimenti modificato in alcun modo.Il bit di archivio rappresenta quindi uno dei due stati:"Cambiato" e "non cambiato" dall'ultimo backup.

I bit di archivio non sono influenzati semplicemente leggendo un file.Quando viene copiato un file, il bit di archivio del file originale non è influenzato, tuttavia il bit di archivio della copia verrà impostato al momento della copia.

Quindi il processo sarebbe:

1. Cancella il bit di archivio su tutti i file
2. Lascia che il file system cambi nel tempo
3. Esegui la scansione di tutti i file: quelli con il bit di archivio impostato sono cambiati

Ciò eliminerà la necessità che il tuo programma mantenga lo stato e poiché stai esaminando solo le voci della directory (dove è archiviato il bit) e sono raggruppate, dovrebbe essere molto, molto veloce.

Se puoi eseguire un processo durante le modifiche, tuttavia, ti consigliamo di guardare il file FileSystemWatcher classe.Ecco un esempio di come potresti usarlo.

Esiste anche nel .NETTO (per futuri ricercatori di questo tipo di problema)

Forse puoi lasciare un processo in esecuzione sulla macchina controllando le modifiche e creando un file da leggere in seguito.

-Adamo

Answer 5

Forse puoi utilizzare NTFS 5 Change Journal con DeviceIoControl come spiegato Qui

Answer 6

Se non sei contrario all'utilizzo di .NET, il file FileSystemWatcher class lo gestirà per te abbastanza facilmente.

Answer 7

Dal doppio post qualcuno ha menzionato:Sink di eventi WMI

Sto ancora cercando una risposta migliore, però.

Answer 8

Niente di facile: se hai un'app in esecuzione puoi utilizzare le API di notifica di modifica del file Win32 (FindFirstChangeNotification) come suggerito con le altre risposte.avvertimento:lo scanner antivirus in tempo reale Trend Micro del 2000 circa raggruppava le modifiche rendendo necessario l'utilizzo di buffer molto grandi quando si richiedevano gli elenchi delle modifiche del file system.

Se non disponi di un'app in esecuzione, puoi attivare il journaling NTFS e scansionare il journal per eventuali modifiche http://msdn.microsoft.com/en-us/library/aa363798(VS.85).aspx ma questo può essere più lento della scansione dell'intera directory quando il numero di modifiche è maggiore del numero di file.