我正在用 C# 编写一个需要重复访问 1 个图像文件的程序。大多数情况下它可以工作，但如果我的计算机运行速度很快，它会在文件保存回文件系统之前尝试访问文件并抛出错误：
“文件正在被另一个进程使用”
我想找到解决这个问题的方法，但我所有的谷歌搜索都只通过使用异常处理产生了创建检查。这违反了我的宗教信仰，所以我想知道是否有人有更好的方法？
问问题
631355 次
20 回答
612
更新了此解决方案的注意事项：检查FileAccess.ReadWrite只读文件将失败，因此已修改解决方案以检查FileAccess.Read。
ORIGINAL： 过去几年我一直在使用这个代码，我没有遇到任何问题。
了解您对使用异常的犹豫，但您不能一直避免它们：
protected virtual bool IsFileLocked(FileInfo file)
{
try
{
using(FileStream stream = file.Open(FileMode.Open, FileAccess.Read, FileShare.None))
{
stream.Close();
}
}
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;
}
//file is not locked
return false;
}
于 2009-06-02T01:20:19.047 回答
595
您可能会因此受到线程竞争条件的影响，有记录的示例将其用作安全漏洞。如果您检查该文件是否可用，然后尝试使用它，您可能会在此时抛出，恶意用户可以使用它来强制和利用您的代码。
您最好的选择是尝试获取文件句柄的 try catch / finally。
try
{
using (Stream stream = new FileStream("MyFilename.txt", FileMode.Open))
{
// File/Stream manipulating code here
}
} catch {
//check here why it failed and ask user to retry if the file is in use.
}
于 2009-05-18T06:57:05.370 回答
97
使用它来检查文件是否被锁定：
using System.IO;
using System.Runtime.InteropServices;
internal static class Helper
{
const int ERROR_SHARING_VIOLATION = 32;
const int ERROR_LOCK_VIOLATION = 33;
private static bool IsFileLocked(Exception exception)
{
int errorCode = Marshal.GetHRForException(exception) & ((1 << 16) - 1);
return errorCode == ERROR_SHARING_VIOLATION || errorCode == ERROR_LOCK_VIOLATION;
}
internal static bool CanReadFile(string filePath)
{
//Try-Catch so we dont crash the program and can check the exception
try {
//The "using" is important because FileStream implements IDisposable and
//"using" will avoid a heap exhaustion situation when too many handles
//are left undisposed.
using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None)) {
if (fileStream != null) fileStream.Close(); //This line is me being overly cautious, fileStream will never be null unless an exception occurs... and I know the "using" does it but its helpful to be explicit - especially when we encounter errors - at least for me anyway!
}
}
catch (IOException ex) {
//THE FUNKY MAGIC - TO SEE IF THIS FILE REALLY IS LOCKED!!!
if (IsFileLocked(ex)) {
// do something, eg File.Copy or present the user with a MsgBox - I do not recommend Killing the process that is locking the file
return false;
}
}
finally
{ }
return true;
}
}
出于性能原因，我建议您在同一操作中读取文件内容。这里有些例子：
public static byte[] ReadFileBytes(string filePath)
{
byte[] buffer = null;
try
{
using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
{
int length = (int)fileStream.Length; // get file length
buffer = new byte[length]; // create buffer
int count; // actual number of bytes read
int sum = 0; // total number of bytes read
// read until Read method returns 0 (end of the stream has been reached)
while ((count = fileStream.Read(buffer, sum, length - sum)) > 0)
sum += count; // sum is a buffer offset for next reading
fileStream.Close(); //This is not needed, just me being paranoid and explicitly releasing resources ASAP
}
}
catch (IOException ex)
{
//THE FUNKY MAGIC - TO SEE IF THIS FILE REALLY IS LOCKED!!!
if (IsFileLocked(ex))
{
// do something?
}
}
catch (Exception ex)
{
}
finally
{
}
return buffer;
}
public static string ReadFileTextWithEncoding(string filePath)
{
string fileContents = string.Empty;
byte[] buffer;
try
{
using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
{
int length = (int)fileStream.Length; // get file length
buffer = new byte[length]; // create buffer
int count; // actual number of bytes read
int sum = 0; // total number of bytes read
// read until Read method returns 0 (end of the stream has been reached)
while ((count = fileStream.Read(buffer, sum, length - sum)) > 0)
{
sum += count; // sum is a buffer offset for next reading
}
fileStream.Close(); //Again - this is not needed, just me being paranoid and explicitly releasing resources ASAP
//Depending on the encoding you wish to use - I'll leave that up to you
fileContents = System.Text.Encoding.Default.GetString(buffer);
}
}
catch (IOException ex)
{
//THE FUNKY MAGIC - TO SEE IF THIS FILE REALLY IS LOCKED!!!
if (IsFileLocked(ex))
{
// do something?
}
}
catch (Exception ex)
{
}
finally
{ }
return fileContents;
}
public static string ReadFileTextNoEncoding(string filePath)
{
string fileContents = string.Empty;
byte[] buffer;
try
{
using (FileStream fileStream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
{
int length = (int)fileStream.Length; // get file length
buffer = new byte[length]; // create buffer
int count; // actual number of bytes read
int sum = 0; // total number of bytes read
// read until Read method returns 0 (end of the stream has been reached)
while ((count = fileStream.Read(buffer, sum, length - sum)) > 0)
{
sum += count; // sum is a buffer offset for next reading
}
fileStream.Close(); //Again - this is not needed, just me being paranoid and explicitly releasing resources ASAP
char[] chars = new char[buffer.Length / sizeof(char) + 1];
System.Buffer.BlockCopy(buffer, 0, chars, 0, buffer.Length);
fileContents = new string(chars);
}
}
catch (IOException ex)
{
//THE FUNKY MAGIC - TO SEE IF THIS FILE REALLY IS LOCKED!!!
if (IsFileLocked(ex))
{
// do something?
}
}
catch (Exception ex)
{
}
finally
{
}
return fileContents;
}
自己尝试一下：
byte[] output1 = Helper.ReadFileBytes(@"c:\temp\test.txt");
string output2 = Helper.ReadFileTextWithEncoding(@"c:\temp\test.txt");
string output3 = Helper.ReadFileTextNoEncoding(@"c:\temp\test.txt");
于 2012-06-16T02:31:09.753 回答
8
只需按预期使用异常。接受该文件正在使用中，然后重试，重复直到您的操作完成。这也是最有效的，因为您不会浪费任何循环在执行之前检查状态。
使用下面的函数，例如
TimeoutFileAction(() => { System.IO.File.etc...; return null; } );
2秒后超时的可重用方法
private T TimeoutFileAction<T>(Func<T> func)
{
var started = DateTime.UtcNow;
while ((DateTime.UtcNow - started).TotalMilliseconds < 2000)
{
try
{
return func();
}
catch (System.IO.IOException exception)
{
//ignore, or log somewhere if you want to
}
}
return default(T);
}
于 2015-05-26T15:29:09.790 回答
7
也许您可以使用FileSystemWatcher并监视 Changed 事件。
我自己没有使用过这个，但它可能值得一试。如果在这种情况下文件系统观察器变得有点重，我会选择 try/catch/sleep 循环。
于 2009-05-18T06:52:09.807 回答
7
您可以返回一个任务，该任务会在它可用时立即为您提供流。这是一个简化的解决方案，但它是一个很好的起点。它是线程安全的。
private async Task<Stream> GetStreamAsync()
{
try
{
return new FileStream("sample.mp3", FileMode.Open, FileAccess.Write);
}
catch (IOException)
{
await Task.Delay(TimeSpan.FromSeconds(1));
return await GetStreamAsync();
}
}
您可以像往常一样使用此流：
using (var stream = await FileStreamGetter.GetStreamAsync())
{
Console.WriteLine(stream.Length);
}
于 2015-10-20T12:33:01.467 回答
6
上面接受的答案会遇到一个问题，如果文件已打开以使用 FileShare.Read 模式进行写入，或者文件具有只读属性，则代码将不起作用。这个修改后的解决方案最可靠，需要记住两点（对于公认的解决方案也是如此）：
- 它不适用于以写入共享模式打开的文件
- 这没有考虑线程问题，因此您需要将其锁定或单独处理线程问题。
牢记上述内容，这将检查文件是否被锁定以进行写入或锁定以防止读取：
public static bool FileLocked(string FileName)
{
FileStream fs = null;
try
{
// NOTE: This doesn't handle situations where file is opened for writing by another process but put into write shared mode, it will not throw an exception and won't show it as write locked
fs = File.Open(FileName, FileMode.Open, FileAccess.ReadWrite, FileShare.None); // If we can't open file for reading and writing then it's locked by another process for writing
}
catch (UnauthorizedAccessException) // https://msdn.microsoft.com/en-us/library/y973b725(v=vs.110).aspx
{
// This is because the file is Read-Only and we tried to open in ReadWrite mode, now try to open in Read only mode
try
{
fs = File.Open(FileName, FileMode.Open, FileAccess.Read, FileShare.None);
}
catch (Exception)
{
return true; // This file has been locked, we can't even open it to read
}
}
catch (Exception)
{
return true; // This file has been locked
}
finally
{
if (fs != null)
fs.Close();
}
return false;
}
于 2015-10-15T13:34:59.510 回答
6
我最近遇到了这个问题，发现了这个：https ://docs.microsoft.com/en-us/dotnet/standard/io/handling-io-errors 。
在这里，Microsoft 描述了以下方法来检查是否IOException是由于锁定文件引起的：
catch (IOException e) when ((e.HResult & 0x0000FFFF) == 32 ) {
Console.WriteLine("There is a sharing violation.");
}
于 2021-04-18T00:40:14.207 回答
5
static bool FileInUse(string path)
{
try
{
using (FileStream fs = new FileStream(path, FileMode.OpenOrCreate))
{
fs.CanWrite
}
return false;
}
catch (IOException ex)
{
return true;
}
}
string filePath = "C:\\Documents And Settings\\yourfilename";
bool isFileInUse;
isFileInUse = FileInUse(filePath);
// Then you can do some checking
if (isFileInUse)
Console.WriteLine("File is in use");
else
Console.WriteLine("File is not in use");
希望这可以帮助！
于 2011-08-22T16:01:58.190 回答
5
除了工作 3-liners 并且仅供参考：如果您想要完整的信息 - Microsoft 开发中心有一个小项目：
https://code.msdn.microsoft.com/windowsapps/How-to-know-the-process-704839f4
现在可以在以下位置找到： https ://github.com/TacticalHorse/LockFinder/blob/master/LockFinder.cs
从简介：
在 .NET Framework 4.0 中开发的 C# 示例代码将有助于找出锁定文件的进程。 rstrtmgr.dll中包含的 RmStartSession 函数已用于创建重启管理器会话，并根据返回结果创建 Win32Exception 对象的新实例。通过 RmRegisterRescources函数将资源注册到 Restart Manager 会话后，调用RmGetList函数通过枚举RM_PROCESS_INFO数组来检查哪些应用程序正在使用特定文件。
它通过连接到“重新启动管理器会话”来工作。
重新启动管理器使用在会话中注册的资源列表来确定必须关闭和重新启动哪些应用程序和服务。 资源可以通过文件名、服务短名称或描述正在运行的应用程序的 RM_UNIQUE_PROCESS 结构来标识。
对于您的特定需求，它可能有点过度设计......但如果这是您想要的，请继续抓住 vs-project。
于 2018-10-09T06:56:20.183 回答
4
我知道的唯一方法是使用速度不太快的 Win32 独占锁 API，但存在示例。
大多数人，对于一个简单的解决方案，只需尝试/捕获/睡眠循环。
于 2009-05-18T06:42:31.010 回答
4
这是一些代码，据我所知，它们与接受的答案相同，但代码更少：
public static bool IsFileLocked(string file)
{
try
{
using (var stream = File.OpenRead(file))
return false;
}
catch (IOException)
{
return true;
}
}
但是，我认为以以下方式执行此操作更为稳健：
public static void TryToDoWithFileStream(string file, Action<FileStream> action,
int count, int msecTimeOut)
{
FileStream stream = null;
for (var i = 0; i < count; ++i)
{
try
{
stream = File.OpenRead(file);
break;
}
catch (IOException)
{
Thread.Sleep(msecTimeOut);
}
}
action(stream);
}
于 2016-08-22T20:41:25.453 回答
3
以我的经验，您通常希望这样做，然后“保护”您的文件以做一些花哨的事情，然后使用“受保护”的文件。如果您只想像这样使用一个文件，则可以使用 Jeremy Thompson 的答案中解释的技巧。但是，如果您尝试对大量文件执行此操作（例如，当您编写安装程序时），您将受到相当大的伤害。
可以解决此问题的一种非常优雅的方法是使用这样一个事实，即如果您的文件系统正在使用其中一个文件，您将不允许您更改文件夹名称。将文件夹保存在同一个文件系统中，它会像一个魅力一样工作。
请注意，您应该了解可以利用它的明显方式。毕竟，文件不会被锁定。此外，请注意还有其他原因可能导致您的Move操作失败。显然，适当的错误处理 (MSDN) 可以在这里提供帮助。
var originalFolder = @"c:\myHugeCollectionOfFiles"; // your folder name here
var someFolder = Path.Combine(originalFolder, "..", Guid.NewGuid().ToString("N"));
try
{
Directory.Move(originalFolder, someFolder);
// Use files
}
catch // TODO: proper exception handling
{
// Inform user, take action
}
finally
{
Directory.Move(someFolder, originalFolder);
}
对于单个文件，我会坚持 Jeremy Thompson 发布的锁定建议。
于 2014-09-02T10:31:24.670 回答
3
我曾经需要将 PDF 上传到在线备份存档。但如果用户在另一个程序（如 PDF 阅读器）中打开文件，备份将失败。匆忙中，我尝试了该线程中的一些最佳答案，但无法使它们起作用。对我有用的是试图将 PDF 文件移动到它自己的目录。我发现如果文件在另一个程序中打开，这将失败，如果移动成功，则不需要恢复操作，就像将它移动到单独的目录一样。我想发布我的基本解决方案，以防它可能对其他人的特定用例有用。
string str_path_and_name = str_path + '\\' + str_filename;
FileInfo fInfo = new FileInfo(str_path_and_name);
bool open_elsewhere = false;
try
{
fInfo.MoveTo(str_path_and_name);
}
catch (Exception ex)
{
open_elsewhere = true;
}
if (open_elsewhere)
{
//handle case
}
于 2019-08-16T01:32:45.037 回答
2
您可以使用我的库从多个应用程序访问文件。
您可以从 nuget 安装它：Install-Package Xabe.FileLock
如果您想了解更多信息，请查看 https://github.com/tomaszzmuda/Xabe.FileLock
ILock fileLock = new FileLock(file);
if(fileLock.Acquire(TimeSpan.FromSeconds(15), true))
{
using(fileLock)
{
// file operations here
}
}
fileLock.Acquire 方法只有在可以为该对象锁定文件独占时才会返回 true。但是上传文件的应用程序也必须在文件锁定中进行。如果对象不可访问，则方法返回 false。
于 2017-09-07T10:44:08.407 回答
0
我有兴趣看看这是否会触发任何 WTF 反射。我有一个创建并随后从控制台应用程序启动 PDF 文档的过程。但是，我正在处理一个弱点，如果用户要多次运行该进程，生成相同的文件而不先关闭先前生成的文件，应用程序将抛出异常并死掉。这是一个相当频繁的事件，因为文件名基于销售报价编号。
我决定依靠自动递增的文件版本控制，而不是以这种不优雅的方式失败：
private static string WriteFileToDisk(byte[] data, string fileName, int version = 0)
{
try
{
var versionExtension = version > 0 ? $"_{version:000}" : string.Empty;
var filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"{fileName}{versionExtension}.pdf");
using (var writer = new FileStream(filePath, FileMode.Create))
{
writer.Write(data, 0, data.Length);
}
return filePath;
}
catch (IOException)
{
return WriteFileToDisk(data, fileName, ++version);
}
}
可能可以对catch块给予更多的关注，以确保我捕捉到正确的 IOException(s)。我可能还会在启动时清除应用程序存储，因为这些文件无论如何都是临时的。
我意识到这超出了 OP 简单检查文件是否正在使用的问题的范围，但这确实是我到达这里时想要解决的问题，所以也许它对其他人有用。
于 2018-04-05T12:07:23.587 回答
0
这样的事情会有帮助吗？
var fileWasWrittenSuccessfully = false;
while (fileWasWrittenSuccessfully == false)
{
try
{
lock (new Object())
{
using (StreamWriter streamWriter = new StreamWriter("filepath.txt"), true))
{
streamWriter.WriteLine("text");
}
}
fileWasWrittenSuccessfully = true;
}
catch (Exception)
{
}
}
于 2019-04-09T12:48:56.303 回答
0
retry_possibility:
//somecode here
try
{
using(FileStream stream = file.Open(FileMode.Open, FileAccess.Read, FileShare.None))
{
stream.Close();
}
//write or open your file here
}
catch (IOException)
{
DialogResult dialogResult = MessageBox.Show("This file is opened by you or another user. Please close it and press retry.\n"+ expFilePath, "File Locked", MessageBoxButtons.RetryCancel);
if (dialogResult == DialogResult.Retry)
{
goto retry_possibility;
}
else if (dialogResult == DialogResult.Cancel)
{
//do nothing
}
}
于 2020-07-30T17:11:38.503 回答
-1
尝试将文件移动/复制到临时目录。如果可以，它没有锁，您可以在临时目录中安全地工作而不会获得锁。否则，只需尝试在 x 秒内再次移动它。
于 2009-05-18T09:11:04.440 回答
-2
我使用这个解决方法，但是在我使用 IsFileLocked 函数检查文件锁定和打开文件之间有一个时间跨度。在这个时间跨度内，一些其他线程可以打开文件，所以我会得到 IOException。
所以，我为此添加了额外的代码。就我而言，我想加载 XDocument：
XDocument xDoc = null;
while (xDoc == null)
{
while (IsFileBeingUsed(_interactionXMLPath))
{
Logger.WriteMessage(Logger.LogPrioritet.Warning, "Deserialize can not open XML file. is being used by another process. wait...");
Thread.Sleep(100);
}
try
{
xDoc = XDocument.Load(_interactionXMLPath);
}
catch
{
Logger.WriteMessage(Logger.LogPrioritet.Error, "Load working!!!!!");
}
}
你怎么看？我可以改变一些东西吗？也许我根本不需要使用 IsFileBeingUsed 函数？
谢谢
于 2012-01-17T15:45:31.450 回答