Attendez que le fichier soit libéré par le processus
Comment puis-je attendre que le fichier soit libre pour que ss.Save() puisse l'écraser avec un nouveau. Si je lance ceci deux fois de suite (ish), j'obtiens une erreur generic GDI+.
///<summary>
/// Grabs a screen shot of the App and saves it to the C drive in jpg
///</summary>
private static String GetDesktopImage(DevExpress.XtraEditors.XtraForm whichForm)
{
Rectangle bounds = whichForm.Bounds;
// This solves my problem but creates a clutter issue
//var timeStamp = DateTime.Now.ToString("ddd-MMM-dd-yyyy-hh-mm-ss");
//var fileName = "C:\\HelpMe" + timeStamp + ".jpg";
var fileName = "C:\\HelpMe.jpg";
File.Create(fileName);
using (Bitmap ss = new Bitmap(bounds.Width, bounds.Height))
using (Graphics g = Graphics.FromImage(ss))
{
g.CopyFromScreen(whichForm.Location, Point.Empty, bounds.Size);
ss.Save(fileName, ImageFormat.Jpeg);
}
return fileName;
}
Une fonction comme celle-ci le fera:
public static bool IsFileReady(string filename)
{
// If the file can be opened for exclusive access it means that the file
// is no longer locked by another process.
try
{
using (FileStream inputStream = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.None))
return inputStream.Length > 0;
}
catch (Exception)
{
return false;
}
}
Collez-le dans une boucle while et vous aurez quelque chose qui bloquera jusqu'à ce que le fichier soit accessible:
public static void WaitForFile(string filename)
{
//This will lock the execution until the file is ready
//TODO: Add some logic to make it async and cancelable
while (!IsFileReady(filename)) { }
}
Si vous vérifiez l'accès avant d'écrire dans le fichier, un autre processus pourrait l'arracher à nouveau avant que vous ne réussissiez à écrire. Par conséquent, je suggérerais l’un des deux suivants:
- Enveloppez ce que vous voulez faire dans une nouvelle tentative qui ne cache aucune autre erreur
- Créez une méthode de wrapper qui attend jusqu'à ce que vous puissiez obtenir un flux et l'utiliser
obtenir un flux
private FileStream GetWriteStream(string path, int timeoutMs)
{
var time = Stopwatch.StartNew();
while (time.ElapsedMilliseconds < timeoutMs)
{
try
{
return new FileStream(path, FileMode.Create, FileAccess.Write);
}
catch (IOException e)
{
// access error
if (e.HResult != -2147024864)
throw;
}
}
throw new TimeoutException($"Failed to get a write handle to {path} within {timeoutMs}ms.");
}
puis utilisez-le comme ceci:
using (var stream = GetWriteStream("path"))
{
using (var writer = new StreamWriter(stream))
writer.Write("test");
}
retry scope
private void WithRetry(Action action, int timeoutMs = 1000)
{
var time = Stopwatch.StartNew();
while(time.ElapsedMilliseconds < timeoutMs)
{
try
{
action();
return;
}
catch (IOException e)
{
// access error
if (e.HResult != -2147024864)
throw;
}
}
throw new Exception("Failed perform action within allotted time.");
}
et ensuite utilisez WithRetry (() => File.WriteAllText (Path.Combine (_directory, name), contents));
Il n’existe pas de fonction permettant d’attendre qu’un emplacement de système de traitement/fichier particulier soit disponible en écriture. Malheureusement, tout ce que vous pouvez faire est d’interroger la poignée pour l’écriture.
Voici une solution qui peut être exagérée pour certains utilisateurs. J'ai créé une nouvelle classe statique dont l'événement est déclenché uniquement à la fin de la copie du fichier.
L'utilisateur enregistre les fichiers qu'il souhaite regarder en appelant FileAccessWatcher.RegisterWaitForFileAccess(filePath). Si le fichier n'est pas encore en cours de visualisation, une nouvelle tâche est lancée. Elle vérifie à plusieurs reprises le fichier pour voir s'il peut être ouvert. Chaque fois qu'il le vérifie, il lit également la taille du fichier. Si la taille du fichier n'augmente pas dans un délai prédéfini (5 minutes dans mon exemple), la boucle est terminée.
Lorsque la boucle quitte le fichier accessible ou le délai d'attente, l'événement FileFinishedCopying est déclenché.
public class FileAccessWatcher
{
// this list keeps track of files being watched
private static ConcurrentDictionary<string, FileAccessWatcher> watchedFiles = new ConcurrentDictionary<string, FileAccessWatcher>();
public static void RegisterWaitForFileAccess(string filePath)
{
// if the file is already being watched, don't do anything
if (watchedFiles.ContainsKey(filePath))
{
return;
}
// otherwise, start watching it
FileAccessWatcher accessWatcher = new FileAccessWatcher(filePath);
watchedFiles[filePath] = accessWatcher;
accessWatcher.StartWatching();
}
/// <summary>
/// Event triggered when the file is finished copying or when the file size has not increased in the last 5 minutes.
/// </summary>
public static event FileSystemEventHandler FileFinishedCopying;
private static readonly TimeSpan MaximumIdleTime = TimeSpan.FromMinutes(5);
private readonly FileInfo file;
private long lastFileSize = 0;
private DateTime timeOfLastFileSizeIncrease = DateTime.Now;
private FileAccessWatcher(string filePath)
{
this.file = new FileInfo(filePath);
}
private Task StartWatching()
{
return Task.Factory.StartNew(this.RunLoop);
}
private void RunLoop()
{
while (this.IsFileLocked())
{
long currentFileSize = this.GetFileSize();
if (currentFileSize > this.lastFileSize)
{
this.lastFileSize = currentFileSize;
this.timeOfLastFileSizeIncrease = DateTime.Now;
}
// if the file size has not increased for a pre-defined time limit, cancel
if (DateTime.Now - this.timeOfLastFileSizeIncrease > MaximumIdleTime)
{
break;
}
}
this.RemoveFromWatchedFiles();
this.RaiseFileFinishedCopyingEvent();
}
private void RemoveFromWatchedFiles()
{
FileAccessWatcher accessWatcher;
watchedFiles.TryRemove(this.file.FullName, out accessWatcher);
}
private void RaiseFileFinishedCopyingEvent()
{
FileFinishedCopying?.Invoke(this,
new FileSystemEventArgs(WatcherChangeTypes.Changed, this.file.FullName, this.file.Name));
}
private long GetFileSize()
{
return this.file.Length;
}
private bool IsFileLocked()
{
try
{
using (this.file.Open(FileMode.Open)) { }
}
catch (IOException e)
{
var errorCode = Marshal.GetHRForException(e) & ((1 << 16) - 1);
return errorCode == 32 || errorCode == 33;
}
return false;
}
}
Exemple d'utilisation:
// register the event
FileAccessWatcher.FileFinishedCopying += FileAccessWatcher_FileFinishedCopying;
// start monitoring the file (put this inside the OnChanged event handler of the FileSystemWatcher
FileAccessWatcher.RegisterWaitForFileAccess(fileSystemEventArgs.FullPath);
Gérez le FileFinishedCopyingEvent:
private void FileAccessWatcher_FileFinishedCopying(object sender, FileSystemEventArgs e)
{
Console.WriteLine("File finished copying: " + e.FullPath);
}
bool isLocked = true;
while (isLocked)
try {
System.IO.File.Move(filename, filename2);
isLocked = false;
}
catch { }
System.IO.File.Move(filename2, filename);
Vous pouvez utiliser une instruction de verrouillage avec une variable factice et elle semble bien fonctionner.
Vérifiez ici .
En utilisant la réponse de @Gordon Thompson, vous devez créer une boucle telle que celle ci-dessous:
public static bool IsFileReady(string sFilename)
{
try
{
using (FileStream inputStream = File.Open(sFilename, FileMode.Open, FileAccess.Read, FileShare.None))
return inputStream.Length > 0;
}
catch (Exception)
{
return false;
}
}
while (!IsFileReady(yourFileName)) ;
J'ai trouvé un moyen optimisé qui ne provoque pas de fuites de mémoire:
public static bool IsFileReady(this string sFilename)
{
try
{
using (FileStream inputStream = File.Open(sFilename, FileMode.Open, FileAccess.Read, FileShare.None))
return inputStream.Length > 0;
}
catch (Exception)
{
return false;
}
}
SpinWait.SpinUntil(yourFileName.IsFileReady);
Prenant la première réponse, j'en ai écrit une similaire, mais elle est asynchrone, non bloquante, attendue, annulable (juste arrêter la tâche) et vérifie l'exception levée.
public static async Task IsFileReady(string filename)
{
await Task.Run(() =>
{
if (!File.Exists(path))
{
throw new IOException("File does not exist!");
}
var isReady = false;
while (!isReady)
{
// If the file can be opened for exclusive access it means that the file
// is no longer locked by another process.
try
{
using (FileStream inputStream =
File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.None))
isReady = inputStream.Length > 0;
}
catch (Exception e)
{
// Check if the exception is related to an IO error.
if (e.GetType() == typeof(IOException))
{
isReady = false;
}
else
{
// Rethrow the exception as it's not an exclusively-opened-exception.
throw;
}
}
}
});
}
Vous pouvez l'utiliser de cette façon:
Task ready = IsFileReady(path);
ready.Wait(1000);
if (!ready.IsCompleted)
{
throw new FileLoadException($"The file {path} is exclusively opened by another process!");
}
File.Delete(path);
Si vous devez vraiment attendre, ou d'une manière plus JS-promise-way:
IsFileReady(path).ContinueWith(t => File.Delete(path));