Erreur d'accès aux fichiers avec FileSystemWatcher lorsque plusieurs fichiers sont ajoutés à un répertoire

j'aurais laissé un commentaire ci-dessus, mais je n'ai pas assez de points encore.

la réponse la mieux cotée à cette question a un bloc de code qui ressemble à ceci:

using (Stream stream = System.IO.File.Open(fileName, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite))
{
    if (stream != null)
    {
        System.Diagnostics.Trace.WriteLine(string.Format("Output file {0} ready.", fileName));
        break;
    }
}

le problème avec l'utilisation de FileShare.ReadWrite paramètre est que c'est la demande d'accès au fichier qui revient à dire "je veux lire/écrire dans ce fichier, mais d'autres peuvent également lire/écrire."Cette approche a échoué dans notre situation. Le processus qui recevait le transfert à distance n'a pas mis un verrou sur le fichier, mais il lui écrivait activement. Notre code en aval (SharpZipLib) échouait avec l'exception "file in use" parce qu'il essayait d'ouvrir le fichier avec un FileShare.Read ("je veux que le fichier soit lu, et que les autres processus le soient aussi"). Parce que le processus qui avait le dossier ouvert était déjà écrit à lui, cette demande a échoué.

cependant, le code dans la réponse ci-dessus est trop détendu. À l'aide de FileShare.ReadWrite, il a réussi à obtenir l'accès au dossier (parce qu'il a été demandant une restriction de parts qui pourrait être respectée), mais l'appel en aval a continué d'échouer.

le paramètre de partage dans l'appel à File.Open doit être FileShare.Read ou FileShare.None et FileShare.ReadWrite.

lorsque vous ouvrez le fichier dans votre méthode OnChanged, vous spécifiez FileShare.None, qui, selon la documentation, fera échouer toute autre tentative d'ouvrir le fichier tant que vous l'aurez ouvert. Puisque tout ce que vous (et votre observateur) faites est de lire, essayez d'utiliser FileShare.Read à la place.

la solution Simple serait d'éliminer le filesystemwatcher une fois que vous recevez la notification. avant de copier le fichier, faites attendre le thread courant jusqu'à ce qu'il reçoive l'événement FileSystemWatcher dispose. ensuite, vous pouvez continuer à copier le fichier modifié sans les problèmes d'accès. J'ai eu la même exigence et j'ai fait exactement comme ce que j'ai mentionné. il a travaillé.

Exemple De Code:

public void TestWatcher()
{
    using (var fileWatcher = new FileSystemWatcher())
    {

        string path = @"C:\sv";
        string file = "pos.csv";

        fileWatcher.Path = path;
        fileWatcher.NotifyFilter = NotifyFilters.CreationTime | NotifyFilters.LastWrite;
        fileWatcher.Filter = file;

        System.EventHandler onDisposed = (sender,args) =>
        {
           eve.Set();
        };

        FileSystemEventHandler onFile = (sender, fileChange) =>
        {
           fileWatcher.EnableRaisingEvents = false;
           Thread t = new Thread(new ParameterizedThreadStart(CopyFile));
           t.Start(fileChange.FullPath);
           if (fileWatcher != null)
           {
               fileWatcher.Dispose();
           }
           proceed = false;
        };

        fileWatcher.Changed += onFile;
        fileWatcher.Created += onFile;
        fileWatcher.Disposed+= onDisposed;
        fileWatcher.EnableRaisingEvents = true;

        while (proceed)
        {
            if (!proceed)
            {
                break;
            }
        }
    }
}

public void CopyFile(object sourcePath)
{
    eve.WaitOne();
    var destinationFilePath = @"C:\sv\Co";
    if (!string.IsNullOrEmpty(destinationFilePath))
    {
        if (!Directory.Exists(destinationFilePath))
        {
            Directory.CreateDirectory(destinationFilePath);
        }
        destinationFilePath = Path.Combine(destinationFilePath, "pos.csv");
    }           

    File.Copy((string)sourcePath, destinationFilePath);
}

FileSystemWatcher guetteur de feu.Événement créé deux fois pour chaque création de fichier 1ce lorsque la copie de fichier est commencée et la 2e fois lorsque la copie de fichier est terminée. Tout ce que vous avez à faire est d'ignorer le 1er événement et de traiter l'événement la deuxième fois.

Un exemple simple de gestionnaire d'événement:

private bool _fileCreated = false;
private void FileSystemWatcher_FileCreated(object sender, FileSystemEventArgs e)
{
    if (_fileCreated)
    {
        ReadFromFile();//just an example method call to access the new file
    }

    _fileCreated = !_fileCreated;
}

je pense qu'un bon exemple de ce que vous voulez est la configuration Etwatchhandler dans log4net. Ils utilisent une minuterie pour lancer l'Événement du gestionnaire de fichiers. Je pense que cela finit par être une implémentation plus propre de la boucle while dans le post de 0xA3. Pour ceux d'entre vous qui ne veulent pas utiliser dotPeek pour examiner le fichier, je vais essayer de vous donner un extrait de code basé sur le code OP:

private System.Threading.Timer _timer;    

public void Run() {
  //setup filewatcher
  _timer = new System.Threading.Timer(new TimerCallback(OnFileChange), (object) null, -1, -1);
}

private void OnFileChange(object state)
{
    try 
    {
    //handle files
    }
    catch (Exception ex) 
    {
        //log exception
        _timer.Change(500, -1);
    }
}

j'ai eu le même problème. C'est juste à cause de FileSystemWatcher. J'ai juste utilisé

Fil.Dormir();

Et sa fonctionne bien maintenant. Quand le dossier vient dans l'annuaire il appelle onCreated deux fois. donc une fois quand le fichier est copié.et la deuxième fois quand la copie est terminée. Pour cela, j'ai utilisé du Fil.Sleep(); Donc, il faudra attendre avant que j'appelle ReadFile();

private static void OnCreated(object source, FileSystemEventArgs e)
    {
        try
        {
            Thread.Sleep(5000);
            var data = new FileData();
            data.ReadFile(e.FullPath);                
        }
        catch (Exception ex)
        {
            WriteLogforError(ex.Message, String.Empty, filepath);
        }
    }

j'ai eu le même problème au sein de la DSV. Ma résolution a été réalisée en ajoutant deux lignes vides à chaque fichier. Alors mon code attend deux lignes vides dans le fichier. Alors j'ai la certitude de lire des données entières à partir du fichier.

public static BitmapSource LoadImageNoLock(string path)
{
    while (true)
    {
        try
        {
            var memStream = new MemoryStream(File.ReadAllBytes(path));
            var img = new BitmapImage();
            img.BeginInit();
            img.StreamSource = memStream;
            img.EndInit();
            return img;
            break;
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}