在我的例子中，这个问题通过打开文件进行 共享写入/读取 。以下是共享读取和写入的示例代码：- Stream Writer

using(FileStream fs = new FileStream("D:\\test.txt", 
FileMode.Append, FileAccess.Write, FileShare.ReadWrite))
using (StreamWriter sw = new StreamWriter(fs))
{
    sw.WriteLine("any thing which you want to write");
}

流读取器

using (FileStream fs = new FileStream("D:\\test.txt", FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (StreamReader rr=new StreamReader(fs))
{
    rr.ReadLine())
}

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

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

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

然而，这并不容易找到，解决方案很简单，只需 等待 “任务完成执行”：

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

我遇到了一种非常特殊的情况，我得到了一个 无法 访问文件‘文件路径’\'

File.Delete(fileName);

在 NUnit 测试中如下所示：

Assert.Throws<IOException>(() =>
{
    using (var sr = File.OpenText(fileName) {
        var line = sr.ReadLine();
    }
});
File.Delete(fileName);

事实证明，NUnit 3 使用了一种他们称之为“隔离上下文”的东西来进行异常断言。这可能在单独的线程上运行。

我的解决办法是将其放在 File.Delete 相同的上下文 中

Assert.Throws<IOException>(() =>
{
    try
    {
        using (var sr = File.OpenText(fileName) {
            var line = sr.ReadLine();
        }
    }
    catch
    {
        File.Delete(fileName);
        throw;
    }
});

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

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

该错误表示另一个进程正在尝试访问该文件。也许您或其他人在您尝试写入文件时打开了该文件。\'读取\'或\'复制\'通常不会导致这种情况，但写入或调用删除操作会导致这种情况。

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

1. 点2

   点3

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

   点4

2. p5

3. p6

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

   p7

4. p8

   p9

   ProcessHandler.localProcessKill("winword.exe");

   p10

   ProcessHandler.remoteProcessKill(computerName, txtUserName, txtPassword, "winword.exe");

   p11

5. p12

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

   p13

   p14

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

而且不仅仅是没有文件名。非法的（目标）文件名 - 在我的情况下是 \'...\file.\' - 也会出现同样愚蠢的错误，并让你在错误的方向迷失半天！

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

我遇到过类似的情况。发送电子邮件后我无法移动文件。就我而言：发送电子邮件后使用 mailMessageObj.Attachments.Dispose() 对我有用。

如果文件正在使用中，File.Move() 将不起作用并给出相同的错误。如果只是将文件添加到电子邮件中，我不认为在 Attachments.Add() 操作期间使用时会出错，因为这只是一个复制操作。如果出于某种原因出错，您可以将其复制到 Temp 目录，附加副本，然后删除复制的文件。但我不认为，如果 OP 想要修改文件并使用该文件，这种解决方案（您没有显示代码，只有附加部分）会起作用。.Dispose() 始终是一个好主意，但在这里不相关，除非文件在先前的操作中打开。

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

就我而言，我在执行移动操作之前将文件作为电子邮件附件发送出去。

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

我采取的解决办法是 先移动文件，然后发送电子邮件。 这解决了我的问题。

正如哈德森先前指出的那样，另一个可能的解决方案是在使用后丢弃该物体。

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

这对我来说非常有效，解决了我确切的问题。我想处理一个 Tiff 文件文件夹，将它们转换为字节[]流并发送到服务，然后将 Tiff 文件文件夹移动到“已处理”存档文件夹。Image.FromFile 对 Tiff 文件进行了锁定，并且没有及时释放它，因此当我移动 Tiff 文件和包含文件夹时，我会收到“正在被另一个进程使用”错误，因为锁仍然存在。在获取 Tiff 文件的字节后立即执行 .Release 完全解决了这个锁定文件问题。

上传图片时遇到问题，无法删除，找到了解决方案。gl hf

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

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

//later...

File.Delete(filePath); //now works

抱歉，我们不能接受代码、数据、文档或错误的图像。请以文本形式发布这些内容，这样文本就易于阅读，而不必重新输入所有内容，并且您的帖子可以正确编入索引或由屏幕阅读器读取。

这个解决方案对我来说是最好的。我最初的代码与上述相同，但没有 FileShare.Read，这会导致异常。添加 FileShare.Read 后问题立即得到解决。

问题

有人试图 System.IO.File.Open(path, FileMode) 用这种方法打开文件，并希望对文件进行共享访问，但

如果你读过 System.IO.File.Open(path, FileMode) ，它明确地说它不允许 共享

解决方案

使用你必须使用其他替代 FileShare

using FileStream fs = System.IO.File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);

和 FileShare.Read

使用 FileShare 解决了我打开文件的问题，即使它是由另一个进程打开的。

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

我已投票赞成此答案，因为延迟重试对我有用。我编写了一个单线程程序，用于将媒体文件从 iPhone 下载到 PC 上的备用 SSD，并在每次成功下载后更新 Creation/LastModified/LastAccess 时间戳。随着文件处理计数的增加，IO 错误会随机发生。这不应该发生，但确实发生了，我唯一的解决办法是使用延迟重试。

一个很好的建议是谨慎使用不需要使用 {} 的新语法。因为我正在使用 var stream = File.Open(path, FileMode.Open, FileAccess.Write, FileShare.Read); 我试图用另一种方法再次读取该文件，但忘记了 using 尚未关闭

@KyleDelaney 我想说你需要等到文件夹关闭，如果这不是几秒钟的事情，那么一切都会很快变得复杂（保留一个带有待处理操作的后台队列？文件系统观察器？轮询？）你可能需要发布一个包含更多详细信息的问题以获得临时答案