C#多线程访问FileStream文件提示已打开

最新推荐文章于 2024-11-24 16:39:21 发布

转载最新推荐文章于 2024-11-24 16:39:21 发布 · 3.8k 阅读

本文介绍了一种在C#中处理文件被多个进程锁定的问题的方法。通过使用AutoResetEvent和FileSystemWatcher，可以确保在文件被其他进程占用时等待文件解锁，并在文件可用时进行安全操作。

System.IO.FileStream fs = new System.IO.FileStream(fileName, System.IO.FileMode.Open)

这个方法打开文件的时候是以只读共享的方式打开的，但若此文件已被一个拥有写权限的进程打开的话，就无法读取了，

因此需要使用

System.IO.FileStream fs = new System.IO.FileStream(fileName, System.IO.FileMode.Open,System.IO.FileAccess.Read,FileShare.ReadWrite);

设置文件共享方式为读写，FileShare.ReadWrite，这样的话，就可以打开了

                C# FileStream Lock. How to wait for a file to get released and lock safely.
		                            
FileStream has Lock and Unlo      
Let's say we have a file - the one to be used with multiple processes. 

I start with an assumption that file gets Write locked to get changed. If that is not the case for you, then my approach will not work. So if it sounds reasonable for you, then see the solution.


public static void Lock(string path, Action<FileStream> action)
{
    var autoResetEvent = new AutoResetEvent(false);
 
    while(true)
    {
        try
        {
            using (var file = File.Open(path,
                                        FileMode.OpenOrCreate,
                                        FileAccess.ReadWrite,
                                        FileShare.Write))
            {
                action(file);
                break;
            }
        }
        catch (IOException)
        {
            var fileSystemWatcher =
                new FileSystemWatcher(Path.GetDirectoryName(path))
                        {
                            EnableRaisingEvents = true
                        };
 
            fileSystemWatcher.Changed +=
                (o, e) =>
                    {
                        if(Path.GetFullPath(e.FullPath) == Path.GetFullPath(path))
                        {
                            autoResetEvent.Set();
                        }
                    };
 
            autoResetEvent.WaitOne();
        }
    }
}

So as you can see, we do an infinite loop which exits only on non IOException or when the block finishes successfully. 

To wait and not consume 100% CPU AutoResetEvent which gets Set by FileSystemWatcher.Changed event. 

So the flow looks like that: 

1) We try to open the file
2) If we have an IOException, we wait until the file gets changed
3) We try to open file again, if failed - wait again
4) If file opened successfully, we perform an action passed as a parameter

You should carefully handle IOException inside your action. See the example:

FileLocker.Lock(@"c:\file",
        (f) =>
            {
                try
                {
                    f.Write(buf, 0, buf.Length);
                }
                catch(IOException ioe)
                {
// handle IOException
                }
            });

If you have any ideas on how to improve the solution, feel free to comment.