IOException：他のプロセスによって使用されているため、プロセスはファイル 'file path'にアクセスできません

Question

私はいくつかのコードを持っていて、それが実行されると、それはIOExceptionを投げます。

ファイル 'filename'は別のプロセスによって使用されているため、プロセスはファイル 'filename'にアクセスできません

これはどういう意味ですか、そして私はそれについて何ができますか？

Answer 1

原因は何ですか？

エラーメッセージは非常に明確です。ファイルにアクセスしようとしていますが、別のプロセス（または同じプロセス）がファイルで何かを実行しているため、アクセスできません（共有が許可されていません）。

デバッグ

特定のシナリオに応じて、解決するのは非常に簡単です（または理解するのは非常に困難です）。いくつか見てみましょう。

あなたのプロセスはそのファイルにアクセスする唯一のものです
otherプロセスはあなた自身のプロセスであると確信しています。プログラムの別の部分でそのファイルを開いていることがわかっている場合は、まず、使用するたびにファイルハンドルを適切に閉じていることを確認する必要があります。このバグを含むコードの例を次に示します。

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

また、このパターンは、例外の場合にファイルが開いたままにならないようにします（ファイルが使用されている理由である可能性があります：何かがうまくいかず、誰もそれを閉じなかった; この投稿 例）。

すべてが正常に見える場合（例外が発生した場合でも、開いているすべてのファイルを常に閉じていることを確認してください）、複数の作業スレッドがある場合は、2つのオプションがあります：コードを修正してファイルアクセスをシリアル化する（常に実行可能であるとは限らない）または）再試行パターンを適用します。これはI/O操作の非常に一般的なパターンです：何かを実行しようとし、エラーが発生した場合は待機してから再試行します（たとえば、Windowsシェルがファイルが使用中であることを通知するのに時間がかかる削除できませんか？）。 C＃では、実装は非常に簡単です（ ディスクI/O 、 ネットワーク 、および データベースアクセス のより良い例を参照してください）。

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()）。事前にファイルを開くことは不要であるだけでなく、間違っています。同じことが、作業中のファイルにhandleを返さないすべてのFile関数にも適用されます：File.ReadAllText()、File.WriteAllText() 、File.ReadAllLines()、File.WriteAllLines()およびその他（File.AppendAllXyz()関数など）はすべて、ファイルを自分で開いたり閉じたりします。

そのファイルにアクセスするプロセスはあなただけではありません
プロセスがそのファイルにアクセスする唯一のプロセスではない場合、やり取りが難しくなる可能性があります。 再試行パターンが役立ちます（ファイルを他の人が開いてはいけないが、そうでない場合は、Process Explorerなどのユーティリティをチェックする必要があります whoがやっているwhat）。

回避する方法

該当する場合は、常にusingステートメントを使用してファイルを開きます。前の段落で述べたように、多くの一般的なエラーを回避するのに積極的に役立ちます（ this post の例を参照してくださいそれを使用しない方法））。

可能であれば、特定のファイルへのアクセスを所有するユーザーを決定し、いくつかのよく知られた方法でアクセスを集中化してください。たとえば、プログラムが読み書きするデータファイルがある場合は、すべてのI/Oコードを単一のクラス内にボックス化する必要があります。デバッグを簡単にします（いつでもブレークポイントをそこに置いて、誰が何をしているのかを確認できるため）。また、マルチアクセスの同期ポイント（必要な場合）になります。

I/O操作は常に失敗する可能性があることを忘れないでください。一般的な例は次のとおりです。

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

someoneがFile.Exists()の後、File.Delete()の前にファイルを削除する場合、誤って感じる可能性のある場所にIOExceptionをスローします安全。

可能な場合はいつでも、再試行パターンを適用し、FileSystemWatcherを使用している場合は、アクションを延期することを検討してください（通知が表示されますが、アプリケーションはまだそのファイルでのみ動作します）。

高度なシナリオ
それは必ずしも簡単ではないため、他の人とアクセスを共有する必要がある場合があります。たとえば、最初から読み取り、最後まで書き込む場合、少なくとも2つのオプションがあります。

1）同じFileStreamを適切な同期関数と共有します（スレッドセーフではないため）。 this および this の例を参照してください。

2）FileShare列挙を使用して、他のプロセス（または独自のプロセスの他の部分）が同じファイルに同時にアクセスできるようにOSに指示します。

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

この例では、書き込み用にファイルを開き、読み取り用に共有する方法を示しました。読み取りと書き込みが重複すると、未定義または無効なデータになることに注意してください。これは、読み取り時に処理する必要がある状況です。また、これはstreamスレッドセーフにアクセスしないため、アクセスが何らかの方法で同期されない限り、このオブジェクトを複数のスレッドと共有することはできません（前のリンクを参照）。他の共有オプションも利用でき、より複雑なシナリオを開きます。詳細については MSDN を参照してください。

一般にNプロセスは同じファイルからすべてを読み取ることができますが、1つだけを書き込む必要があります。制御されたシナリオでは、同時書き込みを有効にすることもできますが、これを少数で一般化することはできませんこの回答内のテキスト段落。

別のプロセスで使用されているファイルをunlockすることは可能ですか？それは常に安全ではなく、それほど簡単ではありませんが、はい、 それは可能です 。

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

私は同じエラーを引き起こしていた次のシナリオがありました：

• サーバーにファイルをアップロードする
• それらがアップロードされた後、それから古いファイルを取り除く

ほとんどのファイルはサイズが小さかったが、いくつかは大きかったので、それらを削除しようとすると ファイルにアクセスできません エラーが発生しました。

見つけるのは容易ではありませんでしたが、解決策は Waiting "タスクの実行が完了するまで"と同じくらい簡単でした。

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

Answer 6

このエラーは、別のプロセスがファイルにアクセスしようとしていることを示しています。書き込みを試みているときに、あなたや他の誰かが開いている可能性があります。通常、「読み取り」または「コピー」はこれを引き起こしませんが、書き込みまたは削除を呼び出します。

他の答えが述べているように、これを避けるための基本的なことがいくつかあります。

1. FileStream操作で、FileShare.ReadWriteアクセスモードのusingブロックに配置します。

   例えば：

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

   FileAccess.ReadWriteを使用する場合、FileMode.Appendは使用できないことに注意してください。

2. ファイルが使用されているときに、入力ストリームを使用してFile.SaveAsを実行していたときに、この問題に遭遇しました。私の場合、実際にファイルシステムに保存する必要はまったくなかったので、それを削除するだけでしたが、おそらくusingステートメントでFileStreamを作成しようとしたかもしれませんFileAccess.ReadWrite、上のコードとよく似ています。

3. データを別のファイルとして保存し、使用されなくなった古いファイルを削除して、元のファイルの名前に正常に保存されたファイルの名前を変更するオプションがあります。使用中のファイルをテストする方法は、

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

   以下のコードの行で、Windowsサービスでループで実行できます。特定のファイルが見たい場合は、それを置き換えたいときに定期的に削除してください。常に同じファイルがあるとは限らない場合、テキストファイルまたはデータベーステーブルを更新して、サービスが常にファイル名をチェックし、プロセスのチェックを実行し、続いてプロセスの削除と削除を実行することができます。次のオプションで。もちろん、プロセスの削除と終了を実行するには、特定のコンピューターの管理者権限を持つアカウントユーザー名とパスワードが必要です。

4. 保存しようとしているときにファイルが使用中かどうかわからない場合は、保存する前に、Wordのようにファイルを使用している可能性のあるすべてのプロセスを閉じることができます。

   ローカルの場合、これを行うことができます：

   ProcessHandler.localProcessKill("winword.exe");
   

   リモートである場合、これを行うことができます：

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

   ここで、txtUserNameはDOMAIN\userの形式です。

5. ファイルをロックしているプロセス名がわからないとしましょう。次に、これを行うことができます：

   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パスである必要があることに注意してください：Processがどのコンピューター上にあるかを判断し、\\computer\share\yourdoc.docxが有効になるためには、p.MachineNameでなければなりません。

   以下はこれらの関数が使用するクラスで、System.Managementへの参照を追加する必要があります。コードは 元は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 7

このスレッドの他の回答が指摘しているように、このエラーを解決するには、ファイルをロックしている場所を理解するためにコードを注意深く調べる必要があります。

私の場合は、移動操作を実行する前に、ファイルを電子メールの添付ファイルとして送信していました。

そのため、SMTPクライアントがEメールの送信を終了するまで、ファイルは数秒間ロックされていました。

私が採用した解決策は、まずファイルを移動してからEメールを送信することでした。これで問題は解決しました。

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