Comprobando cuándo se modificó por última vez un archivo en C# en Windows OS

Question

Estoy buscando una forma de ver cuándo se modificó por última vez un archivo en C#. Tengo acceso completo al archivo.

Answer 1

System.IO.File.GetLastWriteTime es lo que necesita.

Answer 2

Simplemente use File.GetLastWriteTime. Hay una muestra en esa página que muestra cómo usarlo.

Answer 3

Simplemente desea el método estático File.GetLastWriteTime.

Ejemplo:

DateTime lastModified = System.IO.File.GetLastWriteTime("C:\foo.bar"); 

Console.WriteLine(lastModified.ToString("dd/MM/yy HH:mm:ss")); 

Answer 4

Tenga en cuenta que la función File.GetLastWriteTime no siempre funciona como se esperaba, los valores son a veces no se actualizan instantáneamente por el sistema operativo. Puede obtener una marca de tiempo anterior, incluso si el archivo se ha modificado justo antes.

El comportamiento puede variar entre las versiones del sistema operativo. Por ejemplo, esta prueba de unidad funcionó bien siempre en mi máquina de desarrollo, pero siempre falla en nuestro servidor de compilación.

[TestMethod] 
    public void TestLastModifiedTimeStamps() 
    { 
    var tempFile = Path.GetTempFileName(); 
    var lastModified = File.GetLastWriteTime(tempFile); 
    using (new FileStream(tempFile, FileMode.Create, FileAccess.Write, FileShare.None)) 
    { 

    } 
    Assert.AreNotEqual(lastModified, File.GetLastWriteTime(tempFile)); 
    } 

Ver File.GetLastWriteTime seems to be returning 'out of date' value

Sus opciones:

a) vivir con las omisiones ocasionales.

b) Cree un componente activo realizando el patrón del observador (por ejemplo, una estructura de cliente de servidor tcp), comunicando los cambios directamente en lugar de escribir/leer archivos. Rápido y flexible, pero otra dependencia y un posible punto de falla (y algo de trabajo, por supuesto).

c) Asegure el proceso de señalización reemplazando el contenido de un archivo de señal dedicado que otros procesos leen regularmente. No es tan inteligente ya que es un procedimiento de votación y tiene una sobrecarga mayor que llamar a File.GetLastWriteTime, pero si no se comprueba el contenido de demasiados lugares con demasiada frecuencia, hará el trabajo.

/// <summary> 
/// type to set signals or check for them using a central file 
/// </summary> 
public class FileSignal 
{ 
    /// <summary> 
    /// path to the central file for signal control 
    /// </summary> 
    public string FilePath { get; private set; } 

    /// <summary> 
    /// numbers of retries when not able to retrieve (exclusive) file access 
    /// </summary> 
    public int MaxCollisions { get; private set; } 

    /// <summary> 
    /// timespan to wait until next try 
    /// </summary> 
    public TimeSpan SleepOnCollisionInterval { get; private set; } 

    /// <summary> 
    /// Timestamp of the last signal 
    /// </summary> 
    public DateTime LastSignal { get; private set; } 

    /// <summary> 
    /// constructor 
    /// </summary> 
    /// <param name="filePath">path to the central file for signal control</param> 
    /// <param name="maxCollisions">numbers of retries when not able to retrieve (exclusive) file access</param> 
    /// <param name="sleepOnCollisionInterval">timespan to wait until next try </param> 
    public FileSignal(string filePath, int maxCollisions, TimeSpan sleepOnCollisionInterval) 
    { 
     FilePath = filePath; 
     MaxCollisions = maxCollisions; 
     SleepOnCollisionInterval = sleepOnCollisionInterval; 
     LastSignal = GetSignalTimeStamp(); 
    } 

    /// <summary> 
    /// constructor using a default value of 50 ms for sleepOnCollisionInterval 
    /// </summary> 
    /// <param name="filePath">path to the central file for signal control</param> 
    /// <param name="maxCollisions">numbers of retries when not able to retrieve (exclusive) file access</param>   
    public FileSignal(string filePath, int maxCollisions): this (filePath, maxCollisions, TimeSpan.FromMilliseconds(50)) 
    { 
    } 

    /// <summary> 
    /// constructor using a default value of 50 ms for sleepOnCollisionInterval and a default value of 10 for maxCollisions 
    /// </summary> 
    /// <param name="filePath">path to the central file for signal control</param>   
    public FileSignal(string filePath) : this(filePath, 10) 
    { 
    } 

    private Stream GetFileStream(FileAccess fileAccess) 
    { 
     var i = 0; 
     while (true) 
     { 
      try 
      { 
       return new FileStream(FilePath, FileMode.Create, fileAccess, FileShare.None); 
      } 
      catch (Exception e) 
      { 
       i++; 
       if (i >= MaxCollisions) 
       { 
        throw e; 
       } 
       Thread.Sleep(SleepOnCollisionInterval); 
      }; 
     }; 
    } 

    private DateTime GetSignalTimeStamp() 
    { 
     if (!File.Exists(FilePath)) 
     { 
      return DateTime.MinValue; 
     } 
     using (var stream = new FileStream(FilePath, FileMode.Open, FileAccess.Read, FileShare.None)) 
     { 
      if(stream.Length == 0) 
      { 
       return DateTime.MinValue; 
      } 
      using (var reader = new BinaryReader(stream)) 
      { 
       return DateTime.FromBinary(reader.ReadInt64()); 
      };     
     } 
    } 

    /// <summary> 
    /// overwrites the existing central file and writes the current time into it. 
    /// </summary> 
    public void Signal() 
    { 
     LastSignal = DateTime.Now; 
     using (var stream = new FileStream(FilePath, FileMode.Create, FileAccess.Write, FileShare.None)) 
     { 
      using (var writer = new BinaryWriter(stream)) 
      { 
       writer.Write(LastSignal.ToBinary()); 
      } 
     } 
    } 

    /// <summary> 
    /// returns true if the file signal has changed, otherwise false. 
    /// </summary>   
    public bool CheckIfSignalled() 
    { 
     var signal = GetSignalTimeStamp(); 
     var signalTimestampChanged = LastSignal != signal; 
     LastSignal = signal; 
     return signalTimestampChanged; 
    } 
} 

Algunas pruebas para ello:

[TestMethod] 
    public void TestSignal() 
    { 
     var fileSignal = new FileSignal(Path.GetTempFileName()); 
     var fileSignal2 = new FileSignal(fileSignal.FilePath); 
     Assert.IsFalse(fileSignal.CheckIfSignalled()); 
     Assert.IsFalse(fileSignal2.CheckIfSignalled()); 
     Assert.AreEqual(fileSignal.LastSignal, fileSignal2.LastSignal); 
     fileSignal.Signal(); 
     Assert.IsFalse(fileSignal.CheckIfSignalled()); 
     Assert.AreNotEqual(fileSignal.LastSignal, fileSignal2.LastSignal); 
     Assert.IsTrue(fileSignal2.CheckIfSignalled()); 
     Assert.AreEqual(fileSignal.LastSignal, fileSignal2.LastSignal); 
     Assert.IsFalse(fileSignal2.CheckIfSignalled()); 
    }