有没有办法检查文件是否正在使用?


845

我正在用C#编写一个程序,该程序需要重复访问1个图像文件。在大多数情况下,它都可以工作,但是如果我的计算机运行速度很快,它将在尝试将文件保存回文件系统之前尝试访问该文件,并抛出错误:“文件正在被另一个进程使用”

我想找到一种解决方法,但是我所有的Google搜索都只能通过使用异常处理来创建检查。这与我的宗教信仰背道而驰,所以我想知道是否有人能做得更好?


30
好了,您可以通过检查系统上所有打开的手柄来对其进行测试。但是,由于Windows是多任务操作系统,因此有可能在您运行代码以确定文件是否打开并且您认为未打开文件之后,进程代码便开始使用该文件,然后尝试进行操作。使用它,您会收到一个错误。但是,先检查没有错;只是不要以为您在实际需要时不使用它。
BobbyShaftoe,2009年

3
但是仅针对此特定问题;我建议不要检查文件句柄,而要尝试一些预设次数,例如3-5次,然后再失败。
BobbyShaftoe,2009年

如何生成此图像文件?您可以在生成完成之前停止/睡眠/暂停程序吗?到目前为止,这是处理情况的一种上乘方式。如果没有,那么我认为您不能避免使用异常处理。
卡察瓦(Catchwa)2009年

难道不是所有人都在例外情况下通过做一些潜在的危险而故意不排除失败的可能性来检查某些假设吗?
jwg 2013年

26
您的哲学对例外有不好的理解。大多数人认为例外意味着将错误的骰子骰子模样丢掉。当异常意味着...。这意味着您需要“处理”(或说明)异常情况。也许您想继续尝试进行数据访问,也许用户需要知道您无法获得连接。你是做什么?您可以处理ConnectionFailedException并通知用户,因此,一个小时后他们可能会停止尝试,并注意到电缆已拔出。
Lee Louviere 2013年

Answers:


543

关于此解决方案的更新的注释FileAccess.ReadWrite只读文件的“ 检查” 将失败,因此该解决方案已被修改为“”进行检查FileAccess.Read。尽管此解决方案有效,因为尝试检查是否FileAccess.Read会失败(如果文件上具有写入或读取锁定),但是,如果文件没有写入或读取锁定(即已打开),则此解决方案将不起作用(用于读取或写入)具有FileShare.Read或FileShare.Write访问权限。

原文: 我在过去的几年中一直使用此代码,但至今没有任何问题。

了解您对使用异常的犹豫,但是您无法始终避免使用它们:

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;
}

60
这是一个很好的解决方案,但是我有一条评论-您可能无法使用访问模式FileAccess.Read打开文件,因为如果文件碰巧是只读的,则ReadWrite总是会失败。
adeel825

219
-1。这是一个很差的答案,因为在IsFileLocked中关闭文件之后,在线程没有机会打开该文件之前,该文件可能会被另一个线程/进程锁定。
Polyfun

16
我认为这是一个很好的答案。我将其用作扩展方法 ála public static bool IsLocked(this FileInfo file) {/*...*/}
Manuzor 2012年

53
@ChrisW:您可能想知道发生了什么。不要惊慌。你只是受制于每日跆拳道界的愤怒:thedailywtf.com/Comments/...
皮埃尔Lebeaupin

16
@ChrisW为什么这是一件坏事。这个社区在这里指出好与坏的答案。如果一堆专业人士注意到这是一件坏事,并加入downvote,那么该网站就是WAI。在您否定之前,如果您阅读该文章,他们会说“支持正确的答案”而不是错误的答案。您是否也希望他们在评论中解释他们的投票。感谢您向我介绍另一个好网站!
Lee Louviere 2013年

569

您可能因此而遭受线程争用的情况,有记录在此的示例被用作安全漏洞。如果您检查文件是否可用,然后尝试使用它,则可能会丢掉该文件,恶意用户可能会使用该文件来强制和利用您的代码。

最好的选择是try catch /最终尝试获取文件句柄。

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.
}

124
+1。没有100%安全的方法来“了解文件是否正在使用中”,因为执行检查后的毫秒数可能不再使用该文件,反之亦然。相反,您只需打开文件并在没有例外的情况下使用它。
Sedat Kapanoglu 2011年

8
太糟糕了。NET不支持CAS。诸如TryOpenFile(Ref FileHandle)之类的返回成功/失败的东西。应始终有一种解决方法,而不是仅依靠异常处理。我不知道Microsoft Office是如何做到的。
TamusJRoyce,2011年

2
这里要了解的关键是该API只是使用Windows API来获取文件句柄。因此,他们需要转换从C API接收到的错误代码,并将其包装为引发异常。.Net中有异常处理,所以为什么不使用它。这样,您可以在代码中编写干净的转发路径,并将错误处理留在单独的代码路径中。
Spence

36
using语句是确保完成后关闭流。我认为您会发现using(){}的字符数少于最后尝试{}的字符数(obj.Dispose())。您还会发现,现在需要在using语句之外声明对象引用,这是更多类型的输入。如果您有一个明确的接口,则还必须强制转换。最后,您要尽快处置,并且最后的逻辑可能具有UI或任何其他长时间运行的动作,这些动作与调用IDispose无关。</ rant>
Spence 2012年

2
但这并不否认您必须在try之外声明对象并必须显式调用dispose,而using对您而言意味着相同的意思。
Spence

92

使用此命令检查文件是否被锁定:

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");

8
如果那里没有那么多“魔术数字”,我会表示赞成。en.wikipedia.org/wiki/Magic_number_( programming)
克里斯,

3
我指的是errorCode比较,而不是移位。尽管现在您提到了它
克里斯(Kris)

1
您的Catch应该在上IOException,而不是一般的Exception,然后是对类型的测试。
Askolein

3
@JeremyThompson可悲的是您将特定内容放在IOException一般内容之后。一般的人会抓住路过的一切,而具体的IOException人总是孤独的。只需将两者交换即可。
Askolein

我喜欢这个解决方案。另一个建议是:在catch中插入if(IsFileLocked(ex)),否则我将抛出ex。然后,这将通过引发异常来处理文件不存在(或任何其他IOException)的情况。
shindigo 2014年

7

只需按预期使用异常即可。接受该文件正在使用中,然后重试,直到操作完成。这也是最有效的方法,因为您在执行操作之前不会浪费任何时间检查状态。

例如,使用以下功能

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);
}

6

也许您可以使用FileSystemWatcher来监视Changed事件。

我自己没有用过,但是可能值得一试。如果在这种情况下filesystemwatcher有点沉重,我将尝试使用try / catch / sleep循环。


1
使用FileSystemWatcher没有帮助,因为Created和Changed事件在文件创建/更改开始时出现。与.NET应用程序通过FileSystemEventHandler回调运行所需的时间相比,甚至小文件也需要更多的时间来由操作系统写入和关闭。这是这么伤心,但没有其他的选项不是访问文件或运行到异常循环之前估计等待时间...

但是,FileSystemWatcher不能很好地同时处理很多更改,因此请务必谨慎。
Ben F

1
顺便说一句,你们在调试和观看线程时是否注意到MS将其自己的FSW称为“ FileSystemWather”?反正是个老婆?
devlord

恰好我遇到了这个问题,因为带有FileSystemWatcher的Windows服务尝试在进程关闭文件之前读取文件。
freedeveloper

6

您可以返回一个任务,该任务将在流可用时立即为您提供流。这是一个简化的解决方案,但这是一个很好的起点。这是线程安全的。

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);
}

3
从递归中堆栈溢出之前需要多少秒GetStreamAsync()
CAD bloke

@CADbloke,您提出了一个非常好的观点。的确,如果文件长时间不可用,我的示例可能会有堆栈溢出异常。与此答案stackoverflow.com/questions/4513438/…相关,它可能会在5小时内引发异常。
伊万·布雷内茨

与您的用例相关,如果假设10次读取文件的尝试失败,则最好抛出I / O异常。一旦10次尝试失败,另一种策略可能是增加等待时间。您也可以将两者混合使用。
伊万·布雷内茨

我会(并确实)只是警告用户文件已锁定。他们通常会自己锁定它,因此他们可能会对此做一些事情。或不。
CAD bloke'July

在某些情况下,您可能需要使用重试策略,因为文件可能尚未准备好。想象一下桌面应用程序将图像下载到某个临时文件夹中。该应用程序开始下载,同时您在文件浏览器中打开此文件夹。Windows希望立即创建缩略图并锁定文件。同时,您的应用尝试将锁定的图像替换到其他位置。如果您不使用重试策略,您将收到一个例外。
伊万·布雷内茨

4

我知道的唯一方法是使用Win32独占锁定API,该API不太快,但是存在示例。

为了解决这个问题,大多数人只是尝试尝试/捕获/睡眠循环。


1
您必须先打开文件才能使用此API,此时不再需要该文件。
哈里·约翰斯顿

1
薛定inger的档案。
TheLastGIS

4
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");

希望这可以帮助!


10
您执行的实际检查很好。将其放在函数中会产生误导。您不希望在打开文件之前使用类似这样的功能。在函数内部,将打开,检查和关闭文件。然后程序员假定该文件仍然可以使用,并尝试打开该文件以供使用。这很不好,因为它可能被排队打开该文件的另一个进程使用和锁定。在第一次打开(用于检查)和第二次打开(用于使用)之间,操作系统可能已经调度了您的进程,并且可能正在运行另一个进程。
Lakey 2013年

3

上面接受的答案会遇到以下问题:如果已打开文件以使用FileShare.Read模式进行写入,或者如果文件具有“只读”属性,则代码将不起作用。修改后的解决方案最可靠地工作,需要牢记两点(对于公认的解决方案也是如此):

  1. 它不适用于以写共享模式打开的文件
  2. 这没有考虑线程问题,因此您需要将其锁定或单独处理线程问题。

牢记以上几点,这将检查文件是被锁定以进行写入还是被锁定以防止读取

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;
}

与接受的答案仍然存在相同的问题-它仅告诉您文件是否在某个特定时间被另一个进程锁定,这不是有用的信息。到函数返回时,结果可能已经过时了!
哈里·约翰斯顿

1
的确如此,一个人只能在任何给定的时间进行检查(或订阅事件),这种方法相对于公认的解决方案的优势在于它可以检查只读属性和写锁定,而不会返回假肯定。
rboy

3

除了可以使用的3层衬纸,仅供参考:如果您需要完整的信息-Microsoft Dev Center上有一个小项目:

https://code.msdn.microsoft.com/windowsapps/How-to-know-the-process-704839f4

从简介:

在.NET Framework 4.0中开发的C#示例代码将有助于找出哪个进程锁定了文件。 rstrtmgr.dll中包含的RmStartSession函数已用于创建重新启动管理器会话,并根据返回结果创建Win32Exception对象的新实例。通过RmRegisterRescources函数将资源注册到Restart Manager会话后 ,通过枚举RM_PROCESS_INFO数组,调用RmGetList函数以检查哪些应用程序正在使用特定文件。

通过连接到“重新启动管理器会话”来工作。

重新启动管理器使用在会话中注册的资源列表来确定必须关闭并重新启动哪些应用程序和服务。 可以通过文件名,服务简称或描述正在运行的应用程序的RM_UNIQUE_PROCESS结构来标识资源

这可能是有点过度设计为您的特定需求。但如果这是想要的,继续前进,抢VS-项目。


2

以我的经验,您通常要这样做,然后“保护”文件以做一些花哨的事情,然后使用“受保护”的文件。如果只有这样一个文件要使用,可以使用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发表的锁定建议。


嗨,由于答案的顺序发生了变化,因此您可以弄清楚上面哪个帖子对于该流行质量检查的读者意味着什么。谢谢。
杰里米·汤普森

1
@JeremyThompson您说得对,谢谢,我将编辑帖子。我会使用您的解决方案,主要是因为您正确使用FileShare并检查了锁。
atlast

2

据我所知,这是一些代码,它与接受的答案具有相同的功能,但是代码更少:

    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);
    }

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。


1
请不要仅仅发布一些工具或库作为答案。至少要在答案本身中证明它是如何解决问题的。
纸1111年

添加了演示:)对不起@ paper1111
TomaszŻmuda17

1
需要使用该文件的所有进程进行协作。不太可能适用于OP的原始问题。
哈里·约翰斯顿

2

我曾经需要将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
}

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。我可能还会在启动时清除应用程序存储,因为这些文件无论如何都是临时的。

我意识到这已经超出了OP仅检查文件是否正在使用的问题的范围,但这确实是我到达这里时要解决的问题,因此也许对其他人有用。


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)
    {

    }
}

-2

尝试将文件移动/复制到临时目录。如果可以的话,它没有锁,您可以安全地在temp目录中工作而不会获得锁。否则,请尝试在x秒内再次移动它。


@jcolebrand锁什么?您复制的那个?还是您放入临时目录的那个?
Cullub

5
如果您复制文件,希望没有其他人在使用它,并且您将使用临时文件,然后有人在复制文件后立即将其锁定,则可能会丢失数据。
jcolebrand 2014年

-3

我使用这种解决方法,但是当我使用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函数?

谢谢


4
什么是IsFileBeingUsed?IsFileBeingUsed的源代码?
Kiquenet
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.