Vérifier si un fichier est en cours d'utilisation, attendez la fin de la

J'ai ce problème dans mon application:

Etape 1 - créer un fichier (xml) et mettre un peu de contenu en elle
Étape 2 - une application 3ème partie va ouvrir le fichier et obtenir les informations à partir du fichier de l'étape 1.
Étape 3 - supprimer le fichier à nouveau.

La première question que j'ai, c'est sur cette partie du code:

XmlDocument xmlDoc = new XmlDocument();
DataSet ds = //use a method to put in the data
xmlDoc.LoadXml(ds.GetXml());
xmlDoc.Save("Filename");
//...
Process.Start(startInfo);

Est mon hypothèse correcte que la dernière ligne sera exécuté lorsque le dessus est déjà fait?
Donc, je peux être sûr à 100% que les données sont dans le fichier xml avant qu'il essaye de le lancer droit?

La deuxième partie où j'obtiens une erreur est maintenant ici:

Process.Start(startInfo);
File.Delete("Filename");

Ce qui se passe maintenant, c'est que le fichier est supprimé avant la 3ème partie du programme avait lu dans sa mémoire.

Est-il un moyen que je puisse vérifier que le fichier n'est plus en cours d'utilisation, ou de faire quelques manière stable d'attente?

J'ai déjà trouvé un moyen d'utiliser Thread.Sleep(TimeInMiliSec); mais je suppose que ce n'est pas une façon correcte de le faire (en plus comme une solution de rechange)?

OriginalL'auteur Dante1986 | 2012-01-25

c#delete-file file load

3

Il semble que vous juste besoin d'ajouter quelque chose comme ce qui suit:
```
Process p = new Process();
p.StartInfo = startInfo;
p.WaitForExit();
```
Processus.Start() démarre un autre processus, mais il ne veut pas attendre que le processus se termine avant de continuer.

dans le cas d'un crash sur la 3ème partie du programme, il sera également considérée comme une sortie ? parce que je ne peut pas vraiment savoir ce que fait l'utilisateur dans la troisième 3ème partie du programme, ou comment il sort de là
Si l'autre le processus se bloque WaitForExit sera de retour, oui. Si il y a d'autres programmes touchant le fichier, puis vous serez peut-être obligé d'utiliser l'une des autres réponses, mais si vous êtes seulement de trébucher sur vous-même, alors vous devriez faire quelque chose comme ça.

OriginalL'auteur Servy
9

Description

Vous pouvez utiliser la méthode dans mon exemple et faire une boucle while.

Échantillon
```
while (IsFileLocked(new FileInfo("YourFilePath")))
{
    //do something, for example wait a second
    Thread.Sleep(TimeSpan.FromSeconds(1));
}
//file is not locked

public static bool IsFileLocked(FileInfo file)
{
    FileStream stream = null;

    try
    {
        stream = file.Open(FileMode.Open, FileAccess.ReadWrite, FileShare.None);
    }
    catch (IOException)
    {
        return true;
    }
    finally
    {
        if (stream != null)
            stream.Close();
    }
    return false;
}
```
C'est d'aborder l'objet à lui seul, pas le fait que le code affiché est d'accéder au même fichier à partir de deux processus plutôt que d'attendre que le processus à la fin.
Cela permettra d'attendre que le fichier peut être supprimé
Juste être prudent avec les attraper IOException avec ce code. Si le fichier n'existe pas, vous pourriez être coincé dans une boucle en raison du fait que FileNotFoundException s'étend IOException.
est mon hypothèse correcte que la dernière ligne sera exécuté lorsque le dessus est déjà fait ? donc, le départ ne se fera qu'une fois que la sauvegarde est faite ?
Oui, XmlDocument.Enregistrer un appel synchrone. Il permettra d'enregistrer le fichier avant de la retourner et de l'exécution de votre Processus.Commencer.

OriginalL'auteur dknaack

Process process = Process.Start(startInfo);
process.WaitForExit(); //alteratively, you can use WaitForExit(int milliseconds)
File.Delete("Filename");

OriginalL'auteur Phil Bolduc

1

C'est un problème commun. La solution est unfortunatley essayez de l'ouvrir et de voir si il y a une exception.

Utiliser le IsFileLocked(...) ici:

Est-il un moyen de vérifier si un fichier est en cours d'utilisation?

Et faire quelque chose comme:
```
while ( IsFileLocked(new FileInfo(FilePath)) ) 
{ 
    Thread.Sleep(TimeInMiliSec); 
}
```
OriginalL'auteur DanTheMan

Vous pouvez vérifier si le processus est toujours en cours d'exécution...

        if (System.Diagnostics.Process.GetProcessesByName("notepad").Length < 1)
        {
            Console.WriteLine("The process isnt running"); 
        }
        else
        {
            Console.WriteLine("The process is running..."); //Your code to delete the file
        }

Peut-être vous créer une minuterie et de vérifier ce que toutes les quelques secondes?

Espérons que cela aide, mon premier post ici 🙂

Il y a beaucoup de meilleures réponses que la mienne ici. Pas de soucis.

OriginalL'auteur MoatyMan

Vous devez vous connecter pour publier un commentaire.

Description

Échantillon