等待文件完全写入

当在一个目录中创建一个文件(FileSystemWatcher_Created)时，我将它复制到另一个目录。但是当我创建一个大的(> 10MB)文件时，它无法复制文件，因为它已经开始复制了，当文件还没有完成创建时..。
这将导致 无法复制该文件，因为它被另一个进程使用升高
有人帮忙吗？

class Program
{
static void Main(string[] args)
{
string path = @"D:\levan\FolderListenerTest\ListenedFolder";
FileSystemWatcher listener;
listener = new FileSystemWatcher(path);
listener.Created += new FileSystemEventHandler(listener_Created);
listener.EnableRaisingEvents = true;


while (Console.ReadLine() != "exit") ;
}


public static void listener_Created(object sender, FileSystemEventArgs e)
{
Console.WriteLine
(
"File Created:\n"
+ "ChangeType: " + e.ChangeType
+ "\nName: " + e.Name
+ "\nFullPath: " + e.FullPath
);
File.Copy(e.FullPath, @"D:\levan\FolderListenerTest\CopiedFilesFolder\" + e.Name);
Console.Read();
}
}
155648 次浏览
小开

实际上你很幸运——写入文件的程序会锁定它，所以你不能打开它。如果它没有锁定它，你可能已经拷贝了一个部分文件，完全不知道有什么问题。

当您无法访问一个文件时，您可以假定它仍在使用(更好的方法是尝试以独占模式打开它，并查看是否有其他人正在打开它，而不是从 File 的失败中猜测。收到)。如果文件是锁定的，那么您必须在其他时间复制它。如果它没有被锁定，您可以复制它(这里可能存在竞态条件)。

“其他时间”是什么时候？我不记得什么时候 FileSystemWatcher 每个文件发送多个事件-检查一下，它可能足以让你忽略这个事件并等待另一个事件。如果没有，您可以设置一个时间，并在5秒钟内重新检查文件。

小开

来自 FileSystemWatcher的文档:

创建文件后立即引发 OnCreated事件 正在被复制或传输到一个监视目录中, OnCreated事件将立即引发，随后是一个或多个事件 OnChanged事件。

因此，如果复制失败(捕获异常) ，将其添加到仍然需要移动的文件列表中，并在 OnChanged事件期间尝试复制。最终，应该会成功的。

类似(不完整的; 捕获特定的异常，初始化变量等) :

public static void listener_Created(object sender, FileSystemEventArgs e)
{
Console.WriteLine
(
"File Created:\n"
+ "ChangeType: " + e.ChangeType
+ "\nName: " + e.Name
+ "\nFullPath: " + e.FullPath
);
try {
File.Copy(e.FullPath, @"D:\levani\FolderListenerTest\CopiedFilesFolder\" + e.Name);
}
catch {
_waitingForClose.Add(e.FullPath);
}
Console.Read();
}


public static void listener_Changed(object sender, FileSystemEventArgs e)
{
if (_waitingForClose.Contains(e.FullPath))
{
try {
File.Copy(...);
_waitingForClose.Remove(e.FullPath);
}
catch {}
}

}

小开
最佳答案

对于你所面临的问题，只有一个解决办法。

在开始复制进程之前检查进程中的文件 ID。可以调用以下函数，直到得到 False 值为止。

第一种方法，直接复制自 这个答案:

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


try
{
stream = file.Open(FileMode.Open, FileAccess.ReadWrite, FileShare.None);
}
catch (IOException)
{
//the file is unavailable because it is:
//still being written to
//or being processed by another thread
//or does not exist (has already been processed)
return true;
}
finally
{
if (stream != null)
stream.Close();
}


//file is not locked
return false;
}

第二种方法:

const int ERROR_SHARING_VIOLATION = 32;
const int ERROR_LOCK_VIOLATION = 33;
private bool IsFileLocked(string file)
{
//check that problem is not in destination file
if (File.Exists(file) == true)
{
FileStream stream = null;
try
{
stream = File.Open(file, FileMode.Open, FileAccess.ReadWrite, FileShare.None);
}
catch (Exception ex2)
{
//_log.WriteLog(ex2, "Error in checking whether file is locked " + file);
int errorCode = Marshal.GetHRForException(ex2) & ((1 << 16) - 1);
if ((ex2 is IOException) && (errorCode == ERROR_SHARING_VIOLATION || errorCode == ERROR_LOCK_VIOLATION))
{
return true;
}
}
finally
{
if (stream != null)
stream.Close();
}
}
return false;
}
小开

您已经自己给出了答案; 您必须等待文件的创建完成。一种方法是通过检查文件是否仍在使用。这方面的一个例子可以在这里找到: 有没有检查文件是否正在使用的方法？

请注意，您必须修改此代码才能使其在您的情况下工作。您可能需要这样的代码(伪代码) :

public static void listener_Created()
{
while CheckFileInUse()
wait 1000 milliseconds


CopyFile()
}

显然，您应该保护自己不受无限 while的影响，以防所有者应用程序永远不释放锁。另外，也许值得检查一下 FileSystemWatcher中其他可以订阅的事件。可能有一个事件，你可以用来规避这整个问题。

小开

您可以使用下面的代码来检查文件是否可以通过独占访问打开(也就是说，它不是由另一个应用程序打开的)。如果文件没有关闭，您可以等待一段时间，并再次检查，直到文件关闭，您可以安全地复制它。

你仍然应该检查如果文件。复制失败，因为另一个应用程序可能在您检查文件和复制文件之间打开该文件。

public static bool IsFileClosed(string filename)
{
try
{
using (var inputStream = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.None))
{
return true;
}
}
catch (IOException)
{
return false;
}
}
小开

这是个旧帖子，不过我会给其他人加点信息。

I experienced a similar issue with a program that writes PDF files, sometimes they take 30 seconds to render.. which is the same period that my watcher_FileCreated class waits before copying the file.

文件没有被锁定。

在这种情况下，我检查了 PDF 的大小，然后等待2秒钟才比较新的大小，如果它们不相等，线程将睡眠30秒，然后再试一次。

小开

我想在这里补充一个答案，因为这对我很有效。我用了时间延迟，循环，所有我能想到的。

我打开了输出文件夹的文件资源管理器窗口，然后关上它，一切都很顺利。

我希望这能帮到别人。

小开

当文件写入二进制文件(一个字节一个字节) ，创建 FileStream 及以上解决方案不工作，因为文件已经准备好并写入每个字节，所以在这种情况下，你需要其他的变通方法，像下面这样: 在创建文件或希望开始处理文件时执行此操作

long fileSize = 0;
currentFile = new FileInfo(path);


while (fileSize < currentFile.Length)//check size is stable or increased
{
fileSize = currentFile.Length;//get current size
System.Threading.Thread.Sleep(500);//wait a moment for processing copy
currentFile.Refresh();//refresh length value
}


//Now file is ready for any process!
小开

因此，在快速浏览了这些问题和其他类似问题之后，我今天下午进行了一次愉快的徒劳尝试，试图用两个单独的程序解决一个问题，它们使用一个文件作为同步(以及文件保存)方法。这是一个不寻常的情况，但是对于我来说，它明确地强调了“检查文件是否被锁定，如果没有就打开它”的方法的问题。

问题是: 文件可以 成为锁定之间的时间，您检查它和时间，您实际打开文件。如果你不去寻找它，那么很难找到零星的 无法复制该文件，因为它被另一个进程使用错误。

基本的解决方案是尝试打开 catch 块中的文件，这样如果文件被锁定，就可以再试一次。这样在检查和打开之间就没有经过的时间，操作系统可以同时执行这两个操作。

这里的代码使用 File。复制，但是它同样适用于 File 类: File 的任何静态方法。打开，文件。读取所有文本，文件。WriteAllText 等等。

/// <param name="timeout">how long to keep trying in milliseconds</param>
static void safeCopy(string src, string dst, int timeout)
{
while (timeout > 0)
{
try
{
File.Copy(src, dst);


//don't forget to either return from the function or break out fo the while loop
break;
}
catch (IOException)
{
//you could do the sleep in here, but its probably a good idea to exit the error handler as soon as possible
}
Thread.Sleep(100);


//if its a very long wait this will acumulate very small errors.
//For most things it's probably fine, but if you need precision over a long time span, consider
//   using some sort of timer or DateTime.Now as a better alternative
timeout -= 100;
}
}

关于并行性的另一个小注释: 这是一个同步方法，它将在等待和处理线程时阻塞其线程。这是最简单的方法，但是如果文件长时间保持锁定，程序可能会变得无响应。并行是一个很大的话题，无法在这里深入探讨(设置异步读/写的方法有很多种，这有点荒谬) ，但这里有一种方法可以实现并行化。

public class FileEx
{
public static async void CopyWaitAsync(string src, string dst, int timeout, Action doWhenDone)
{
while (timeout > 0)
{
try
{
File.Copy(src, dst);
doWhenDone();
break;
}
catch (IOException) { }


await Task.Delay(100);
timeout -= 100;
}
}


public static async Task<string> ReadAllTextWaitAsync(string filePath, int timeout)
{
while (timeout > 0)
{
try {
return File.ReadAllText(filePath);
}
catch (IOException) { }


await Task.Delay(100);
timeout -= 100;
}
return "";
}


public static async void WriteAllTextWaitAsync(string filePath, string contents, int timeout)
{
while (timeout > 0)
{
try
{
File.WriteAllText(filePath, contents);
return;
}
catch (IOException) { }


await Task.Delay(100);
timeout -= 100;
}
}
}

以下是它的使用方法:

public static void Main()
{
test_FileEx();
Console.WriteLine("Me First!");
}


public static async void test_FileEx()
{
await Task.Delay(1);


//you can do this, but it gives a compiler warning because it can potentially return immediately without finishing the copy
//As a side note, if the file is not locked this will not return until the copy operation completes. Async functions run synchronously
//until the first 'await'. See the documentation for async: https://msdn.microsoft.com/en-us/library/hh156513.aspx
CopyWaitAsync("file1.txt", "file1.bat", 1000);


//this is the normal way of using this kind of async function. Execution of the following lines will always occur AFTER the copy finishes
await CopyWaitAsync("file1.txt", "file1.readme", 1000);
Console.WriteLine("file1.txt copied to file1.readme");


//The following line doesn't cause a compiler error, but it doesn't make any sense either.
ReadAllTextWaitAsync("file1.readme", 1000);


//To get the return value of the function, you have to use this function with the await keyword
string text = await ReadAllTextWaitAsync("file1.readme", 1000);
Console.WriteLine("file1.readme says: " + text);
}


//Output:
//Me First!
//file1.txt copied to file1.readme
//file1.readme says: Text to be duplicated!

提交答案