FileSystemWatcher: ignorer la première modification du fichier

C'est une situation délicate et vous ne pouvez pas faire grand-chose à part vérifier si le fichier est verrouillé (en supposant qu'il dispose d'un verrou en lecture ou en écriture):

public  bool IsFileLocked(string fileName)
{

   try
   {
      using (var stream = File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.None))
      {
         return false;
      }   
   }
   catch (IOException)
   {
      //the file is unavailable
      return true;
   }
}

La prémisse est quand vous obtenez une mise à jour, vous vérifiez si le fichier est verrouillé, si elle est pas alors vous pouvez supposer vaguement qu'il a été fermé.

Quelques points à considérer cependant:

1. Il peut y avoir une condition de concurrence lorsque vous vérifiez que le fichier est verrouillé, que tout est effacé, puis que vous découvrez qu'un autre processus a verrouillé le fichier.
2. J'ai utilisé FileAccess.Read , donc cela n'échoue pas sur les fichiers en lecture seule.
3. Les événements peuvent être supprimés de FileSystemWatcher pour diverses raisons et il n'est pas toujours possible de s'y fier dans certaines situations; Lisez la documentation pour connaître les raisons pour lesquelles les événements peuvent être supprimés et comment les corriger. Dans ces cas, vous pourriez vous en tirer avec un long sondage et une certaine logique pour ramasser les retardataires (en fonction de votre situation).

J'ai ajouté le code suivant dans le gestionnaire OnChanged , et il semble fonctionner comme prévu.

private void OnChanged(object source, FileSystemEventArgs file)
{
    if (file.ChangeType == WatcherChangeTypes.Created)
        return;

    FileInfo fileInfo = new FileInfo(file.FullPath);
    if (fileInfo.CreationTime == fileInfo.LastWriteTime)
        return; 

    // Handle the Changed event
    ...
}

Cependant, je ne suis pas sûr s'il me manque quelque chose qui provoquera une rupture. Des pensées?

Approche un:

1. Créez et enregistrez le fichier dans un répertoire qui n'est pas surveillé.
2. Déplacez le fichier dans le répertoire surveillé.

Approche deux:

Lorsqu'un fichier est créé, utilisez le gestionnaire d'événements OnCreated() pour ajouter le nom de fichier à une liste filesToIgnore .

Dans le gestionnaire d'événements OnChanged , vérifiez si la liste filesToIgnore contient le nom du fichier. Si c'est le cas, supprimez-le de la liste (pour le traiter la prochaine fois) et retournez-le depuis le gestionnaire.

private List<string> filesToIgnore = new List<string>();

private void OnCreated(object source, FileSystemEventArgs file)
{
   filesToIgnore.Add(file.Name);
}

private void OnChanged(object source, FileSystemEventArgs file)
{
    if(filesToIgnore.Contains(file.Name))
    {
         filesToIgnore.Remove(file.Name);
         return; 
    }

    // Code to execute when user saves the file
}

Cette approche suppose que OnCreated() sera toujours déclenché avant OnChanged().

La méthode d'extension ci-dessous permet de gérer les événements des actions de l'utilisateur uniquement:

var fsw = new FileSystemWatcher(DIR_NAME);
fsw.OnChangedByUser(File_ChangedByUser);
fsw.EnableRaisingEvents = true;

private static void File_ChangedByUser(object sender, FileSystemEventArgs e)
{
    // Handle the event
}

Exemple d'utilisation:

public static void OnChangedByUser(this FileSystemWatcher fsw,
    FileSystemEventHandler handler)
{
    const int TOLERANCE_MSEC = 100;
    object locker = new object();
    string fileName = null;
    Stopwatch stopwatch = new Stopwatch();
    fsw.Created += OnFileCreated;
    fsw.Changed += OnFileChanged;
    fsw.Disposed += OnDisposed;
    void OnFileCreated(object sender, FileSystemEventArgs e)
    {
        lock (locker)
        {
            fileName = e.Name;
            stopwatch.Restart();
        }
    }
    void OnFileChanged(object sender, FileSystemEventArgs e)
    {
        lock (locker)
        {
            if (e.Name == fileName && stopwatch.ElapsedMilliseconds < TOLERANCE_MSEC)
            {
                return; // Ignore this event
            }
        }
        handler.Invoke(sender, e);
    }
    void OnDisposed(object sender, EventArgs e)
    {
        fsw.Created -= OnFileCreated;
        fsw.Changed -= OnFileChanged;
        fsw.Disposed -= OnDisposed;
    }
}