Question

我有一些代码，当它执行时，会抛出IOException，说

该进程无法访问文件＆＃39;文件名＆＃39;因为它正被使用另一个过程

这是什么意思，我能做些什么呢？

Answer 1

原因是什么？

错误消息非常明确：您正在尝试访问某个文件，而且无法访问该文件，因为另一个进程（甚至是同一个进程）正在使用该文件（并且它没有＆＃39 ; t允许任何共享）。

调试

根据您的具体情况，可能很容易解决（或很难理解）。让我们看一些。

您的进程是唯一访问该文件的进程
您确定其他进程是您自己的进程。如果您知道在程序的另一部分中打开该文件，那么首先必须检查每次使用后是否正确关闭文件句柄。以下是带有此错误的代码示例：

var stream = new FileStream(path, FileAccess.Read);
var reader = new StreamReader(stream);
// Read data from this file, when I'm done I don't need it any more
File.Delete(path); // IOException: file is in use

幸运的是FileStream实现了IDisposable，因此很容易将所有代码包装在using语句中：

using (var stream = File.Open("myfile.txt", FileMode.Open)) {
    // Use stream
}

// Here stream is not accessible and it has been closed (also if
// an exception is thrown and stack unrolled

此模式还将确保文件在异常情况下不会保持打开状态（可能是文件正在使用的原因：出现问题，没有人关闭它;请参阅{{3}例如）。

如果一切似乎都很好（你确定你总是关闭你打开的每个文件，即使出现例外情况）并且你有多个工作线程，那么你有两个选择：重新编写代码以序列化文件访问（不是总是可行而且并不总是想要）或应用重试模式。它是I / O操作的一种非常常见的模式：您尝试做某事并在出现错误的情况下等待并再试一次（例如，您是否问自己为什么，Windows Shell需要一些时间来通知您文件正在使用中，无法删除？）。在C＃中，它很容易实现（另请参阅有关this post，disk I/O和networking的更好示例）。

private const int NumberOfRetries = 3;
private const int DelayOnRetry = 1000;

for (int i=1; i <= NumberOfRetries; ++i) {
    try {
        // Do stuff with file
        break; // When done we can break loop
    }
    catch (IOException e) when (i <= NumberOfRetries) {
        // You may check error code to filter some exceptions, not every error
        // can be recovered.
        Thread.Sleep(DelayOnRetry);
    }
}

请注意我们在StackOverflow上经常看到的常见错误：

var stream = File.Open(path, FileOpen.Read);
var content = File.ReadAllText(path);

在这种情况下，ReadAllText()将失败，因为该文件正在使用中（之前的行中为File.Open()）。预先打开文件不仅是不必要的，而且也是错误的。这同样适用于所有File函数，这些函数不会将句柄返回到您正在使用的文件中：File.ReadAllText()，File.WriteAllText()， File.ReadAllLines()，File.WriteAllLines()和其他人（如File.AppendAllXyz()个函数）将自行打开和关闭文件。

您的流程不是唯一访问该文件的人
如果您的进程不是唯一访问该文件的进程，那么交互可能会更难。 重试模式将有所帮助（如果该文件不应由其他任何人打开，但它是，那么您需要像Process Explorer这样的实用程序来检查正在做什么什么）。

避免的方法

如果适用，请始终使用使用语句打开文件。如前一段所述，它会主动帮助您避免许多常见错误（有关如何不使用的示例，请参阅database access）。

如果可能，尝试决定谁拥有对特定文件的访问权限，并通过一些众所周知的方法集中访问权限。例如，如果您有一个程序读写的数据文件，那么您应该将所有I / O代码放在一个类中。它可以使调试变得更容易（因为你总是可以在那里放置一个断点，看看谁在做什么），并且它也是多重访问的同步点（如果需要的话）。

不要忘记I / O操作总是会失败，一个常见的例子是：

if (File.Exists(path))
    File.Delete(path);

如果某人在File.Exists()之后但在File.Delete()之前删除了该文件，那么它会在您可能错误的地方抛出IOException安全

只要有可能，请应用重试模式，如果您正在使用FileSystemWatcher，请考虑推迟操作（因为您会收到通知，但是应用程序可能仍然只使用该文件。）

高级方案
它并不总是那么容易，因此您可能需要与其他人共享访问权限。例如，如果您从头开始阅读并写到最后，则至少有两个选项。

1）使用适当的同步功能共享相同的FileStream（因为它不是线程安全的）。有关示例，请参阅this post和this帖子。

2）使用FileShare枚举来指示操作系统允许其他进程（或您自己进程的其他部分）同时访问同一文件。

using (var stream = File.Open(path, FileMode.Open, FileAccess.Write, FileShare.Read))
{
}

在这个例子中，我展示了如何打开文件进行写作和分享阅读;请注意，在读取和写入重叠时，会导致数据未定义或无效。这是阅读时必须处理的情况。另请注意，这不能访问stream线程安全，因此除非以某种方式同步访问，否则不能与多个线程共享此对象（请参阅前面的链接）。可以使用其他共享选项，它们可以打开更复杂的场景。有关详细信息，请参阅this。

一般来说， N 进程可以从同一个文件中一起读取，但只有一个应该写入，在受控方案中，您甚至可以启用并发写入，但这不能在几个文本段落中进行概括在这个答案里面。

是否可以解锁其他进程使用的文件？它并不总是安全且不那么容易，但是，MSDN。

Answer 2

使用 FileShare 修复了我打开文件的问题，即使它是由其他进程打开的。

using (var stream = File.Open(path, FileMode.Open, FileAccess.Write, FileShare.ReadWrite))
{
}

Answer 3

上传图片时出现问题但无法删除并找到解决方案。 gl hf

//C# .NET
var image = Image.FromFile(filePath);

image.Dispose(); // this removes all resources

//later...

File.Delete(filePath); //now works

Answer 4

我收到此错误是因为我正在执行File.Move到没有文件名的文件路径，需要指定目标中的完整路径。

Answer 5

我正在使用FileStream并遇到相同的问题。每当两次请求尝试读取同一文件时，它将引发此异常。

解决方案使用FileShare

export default class DynamicArticleList extends React.Component {
    
    constructor(){
        super();
         this.state={
            
             targetElement: '',
            
             
        }
     
        this.showModal = this.showModal.bind(this);
        this.hideModal = this.hideModal.bind(this);
 
    }
 
    showModal(e){
        
        this.setState({
            targetElement: e.target.getAttribute("id")
        })
    }
    
    hideModal(e){
        this.setState({
            showing: false,
            showSource: '#',
        })
        
    }
  

 
    


    render() {
      

        return (
       

            <div className="wrapper container-fluid DynamicArticleList">
                <div className="width-control">
                   <img src="../img/journey.jpg" onDoubleClick={this.showModal} id="Img0"/>
                   <CropperModal targetElement={this.state.targetElement}/>                   
                
                </div>
            </div>

        );
    }
}

我正在同时读取文件using FileStream fs = System.IO.File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);解决了我的问题。

Answer 6

我遇到了导致相同错误的以下情况：

将文件上传到服务器
然后在上传文件后删除旧文件

大多数文件都很小，但有些文件很大，因此尝试删除这些文件会导致无法访问文件错误。

要找到它并不容易，但解决方案就像完成执行任务一样简单Waiting“：

using (var wc = new WebClient())
{
   var tskResult = wc.UploadFileTaskAsync(_address, _fileName);
   tskResult.Wait(); 
}

Answer 7

正如该线程中的其他答案所指出的那样，要解决此错误，您需要仔细检查代码，以了解文件在何处被锁定。

就我而言，我是在执行移动操作之前以电子邮件附件的形式发送文件的。

因此文件被锁定了几秒钟，直到SMTP客户端完成发送电子邮件为止。

我采用的解决方案是先移动文件，然后发送电子邮件。这为我解决了这个问题。

Hudson先前指出的另一种可能的解决方法是在使用后处置该物体。

public static SendEmail()
{
           MailMessage mMailMessage = new MailMessage();
           //setup other email stuff

            if (File.Exists(attachmentPath))
            {
                Attachment attachment = new Attachment(attachmentPath);
                mMailMessage.Attachments.Add(attachment);
                attachment.Dispose(); //disposing the Attachment object
            }
}

Answer 8

该错误表明另一个进程正在尝试访问该文件。尝试写入时，可能您或其他人将其打开。 “读取”或“复制”通常不会导致这种情况，但是会对其进行写入或调用删除操作。

有一些基本的方法可以避免这种情况，正如其他答案所提到的：

在FileStream操作中，将其放在具有using访问模式的FileShare.ReadWrite块中。

例如：
```
using (FileStream stream = File.Open(path, FileMode.Open, FileAccess.Write, FileShare.ReadWrite))
{
}
```
请注意，如果您使用FileAccess.ReadWrite，则FileMode.Append是不可能的。
当我在使用文件时使用输入流执行File.SaveAs时遇到了这个问题。以我为例，我实际上根本不需要将其保存回文件系统，因此我最终只是删除了该文件，但是我可能可以尝试在using语句中使用以下命令创建FileStream FileAccess.ReadWrite，就像上面的代码一样。
将数据另存为文件，然后在发现旧文件不再使用时回去删除，然后将成功保存的文件重命名为原始文件的名称。您可以通过
完成如何测试正在使用的文件
```
List<Process> lstProcs = ProcessHandler.WhoIsLocking(file);
```
在下面的代码中
行，并且可以在Windows服务中循环执行，如果您有一个特定的文件要观看并在替换时定期删除。如果您不总是拥有相同的文件，则可以更新文本文件或数据库表，以使该服务始终检查文件名，然后执行该检查以检查进程并随后对其执行进程终止和删除操作，如我所述在下一个选项中。请注意，您当然需要在给定计算机上具有管理员权限的帐户用户名和密码，才能执行进程的删除和结束。
如果在尝试保存文件时不知道文件是否正在使用中，则可以在文件之前关闭所有可能正在使用的进程，例如Word（如果是Word文档）。保存。

如果它是本地的，您可以这样做：
```
ProcessHandler.localProcessKill("winword.exe");
```
如果它是远程的，您可以这样做：
```
ProcessHandler.remoteProcessKill(computerName, txtUserName, txtPassword, "winword.exe");
```
其中txtUserName的格式为DOMAIN\user。

比方说，您不知道锁定文件的进程名称。然后，您可以执行以下操作：

List<Process> lstProcs = new List<Process>();
lstProcs = ProcessHandler.WhoIsLocking(file);

foreach (Process p in lstProcs)
{
    if (p.MachineName == ".")
        ProcessHandler.localProcessKill(p.ProcessName);
    else
        ProcessHandler.remoteProcessKill(p.MachineName, txtUserName, txtPassword, p.ProcessName);
}

请注意，file必须是UNC路径：\\computer\share\yourdoc.docx，以便Process弄清它所在的计算机，并且p.MachineName是有效的。

下面是这些函数使用的类，需要添加对System.Management的引用。代码为originally written by Eric J.：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System.Management;

namespace MyProject
{
    public static class ProcessHandler
    {
        [StructLayout(LayoutKind.Sequential)]
        struct RM_UNIQUE_PROCESS
        {
            public int dwProcessId;
            public System.Runtime.InteropServices.ComTypes.FILETIME ProcessStartTime;
        }

        const int RmRebootReasonNone = 0;
        const int CCH_RM_MAX_APP_NAME = 255;
        const int CCH_RM_MAX_SVC_NAME = 63;

        enum RM_APP_TYPE
        {
            RmUnknownApp = 0,
            RmMainWindow = 1,
            RmOtherWindow = 2,
            RmService = 3,
            RmExplorer = 4,
            RmConsole = 5,
            RmCritical = 1000
        }

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
        struct RM_PROCESS_INFO
        {
            public RM_UNIQUE_PROCESS Process;

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = CCH_RM_MAX_APP_NAME + 1)]
            public string strAppName;

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = CCH_RM_MAX_SVC_NAME + 1)]
            public string strServiceShortName;

            public RM_APP_TYPE ApplicationType;
            public uint AppStatus;
            public uint TSSessionId;
            [MarshalAs(UnmanagedType.Bool)]
            public bool bRestartable;
        }

        [DllImport("rstrtmgr.dll", CharSet = CharSet.Unicode)]
        static extern int RmRegisterResources(uint pSessionHandle,
                                            UInt32 nFiles,
                                            string[] rgsFilenames,
                                            UInt32 nApplications,
                                            [In] RM_UNIQUE_PROCESS[] rgApplications,
                                            UInt32 nServices,
                                            string[] rgsServiceNames);

        [DllImport("rstrtmgr.dll", CharSet = CharSet.Auto)]
        static extern int RmStartSession(out uint pSessionHandle, int dwSessionFlags, string strSessionKey);

        [DllImport("rstrtmgr.dll")]
        static extern int RmEndSession(uint pSessionHandle);

        [DllImport("rstrtmgr.dll")]
        static extern int RmGetList(uint dwSessionHandle,
                                    out uint pnProcInfoNeeded,
                                    ref uint pnProcInfo,
                                    [In, Out] RM_PROCESS_INFO[] rgAffectedApps,
                                    ref uint lpdwRebootReasons);

        /// <summary>
        /// Find out what process(es) have a lock on the specified file.
        /// </summary>
        /// <param name="path">Path of the file.</param>
        /// <returns>Processes locking the file</returns>
        /// <remarks>See also:
        /// http://msdn.microsoft.com/en-us/library/windows/desktop/aa373661(v=vs.85).aspx
        /// http://wyupdate.googlecode.com/svn-history/r401/trunk/frmFilesInUse.cs (no copyright in code at time of viewing)
        /// 
        /// </remarks>
        static public List<Process> WhoIsLocking(string path)
        {
            uint handle;
            string key = Guid.NewGuid().ToString();
            List<Process> processes = new List<Process>();

            int res = RmStartSession(out handle, 0, key);
            if (res != 0) throw new Exception("Could not begin restart session.  Unable to determine file locker.");

            try
            {
                const int ERROR_MORE_DATA = 234;
                uint pnProcInfoNeeded = 0,
                    pnProcInfo = 0,
                    lpdwRebootReasons = RmRebootReasonNone;

                string[] resources = new string[] { path }; // Just checking on one resource.

                res = RmRegisterResources(handle, (uint)resources.Length, resources, 0, null, 0, null);

                if (res != 0) throw new Exception("Could not register resource.");

                //Note: there's a race condition here -- the first call to RmGetList() returns
                //      the total number of process. However, when we call RmGetList() again to get
                //      the actual processes this number may have increased.
                res = RmGetList(handle, out pnProcInfoNeeded, ref pnProcInfo, null, ref lpdwRebootReasons);

                if (res == ERROR_MORE_DATA)
                {
                    // Create an array to store the process results
                    RM_PROCESS_INFO[] processInfo = new RM_PROCESS_INFO[pnProcInfoNeeded];
                    pnProcInfo = pnProcInfoNeeded;

                    // Get the list
                    res = RmGetList(handle, out pnProcInfoNeeded, ref pnProcInfo, processInfo, ref lpdwRebootReasons);
                    if (res == 0)
                    {
                        processes = new List<Process>((int)pnProcInfo);

                        // Enumerate all of the results and add them to the 
                        // list to be returned
                        for (int i = 0; i < pnProcInfo; i++)
                        {
                            try
                            {
                                processes.Add(Process.GetProcessById(processInfo[i].Process.dwProcessId));
                            }
                            // catch the error -- in case the process is no longer running
                            catch (ArgumentException) { }
                        }
                    }
                    else throw new Exception("Could not list processes locking resource.");
                }
                else if (res != 0) throw new Exception("Could not list processes locking resource. Failed to get size of result.");
            }
            finally
            {
                RmEndSession(handle);
            }

            return processes;
        }

        public static void remoteProcessKill(string computerName, string userName, string pword, string processName)
        {
            var connectoptions = new ConnectionOptions();
            connectoptions.Username = userName;
            connectoptions.Password = pword;

            ManagementScope scope = new ManagementScope(@"\\" + computerName + @"\root\cimv2", connectoptions);

            // WMI query
            var query = new SelectQuery("select * from Win32_process where name = '" + processName + "'");

            using (var searcher = new ManagementObjectSearcher(scope, query))
            {
                foreach (ManagementObject process in searcher.Get()) 
                {
                    process.InvokeMethod("Terminate", null);
                    process.Dispose();
                }
            }            
        }

        public static void localProcessKill(string processName)
        {
            foreach (Process p in Process.GetProcessesByName(processName))
            {
                p.Kill();
            }
        }

        [DllImport("kernel32.dll")]
        public static extern bool MoveFileEx(string lpExistingFileName, string lpNewFileName, int dwFlags);

        public const int MOVEFILE_DELAY_UNTIL_REBOOT = 0x4;

    }
}

Answer 9

我遇到了这个问题，可以通过下面的代码来解决

var _path=MyFile.FileName;
using (var stream = new FileStream
    (_path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
  { 
    // Your Code! ;
  }

Answer 10

您也可以通过这种方式完成

我第一次喜欢上thread.sleep，但这是错误的。

if (System.IO.File.Exists(filePath))
                        {
                            System.GC.Collect();
                            System.GC.WaitForPendingFinalizers();
                            //System.Threading.Thread.Sleep(100);
                            System.IO.File.Delete(filePath);
                            //System.Threading.Thread.Sleep(20);
                        }
                        using (FileStream FS = new FileStream(filePath, FileMode.Create))
                        {
                            ObjModel.CategoryImage.CopyTo(FS);
                        }

Answer 11

我下面的代码解决了这个问题，但我建议首先，您需要了解导致此问题的原因并尝试通过更改代码来找到解决方案

我可以提供另一种方法来解决此问题，但是更好的解决方案是检查您的编码结构并尝试分析造成这种情况的原因，如果找不到任何解决方案，则可以在下面使用此代码

try{
Start:
///Put your file access code here


}catch (Exception ex)
 {
//by anyway you need to handle this error with below code
   if (ex.Message.StartsWith("The process cannot access the file"))
    {
         //Wait for 5 seconds to free that file and then start execution again
         Thread.Sleep(5000);
         goto Start;
    }
 }

IOException：进程无法访问文件＆＃39;文件路径＆＃39;因为它正被另一个进程使用

11 个答案:

原因是什么？

调试

避免的方法