Coder Perfect

IOException: Another process is using the file ‘file path,’ hence the process cannot access it.


I have some code that throws an IOException when it runs, stating that

What does this imply, and how may I respond?

Asked by Adriano Repetti

Solution #1

The error message is straightforward: you’re trying to access a file, but it’s unavailable because another (or even the same) process is working on it (and sharing isn’t allowed).

Depending on the circumstances, it may be simple to solve (or difficult to comprehend). Let’s take a look at a few.

That file can only be accessed by your process. You’re confident that the other process is your own. If you know you’ll be opening that file in another portion of your program, make sure you close the file handle appropriately after each use. Here’s an example of code that contains this flaw:

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

Because FileStream implements IDisposable, it’s simple to encapsulate all of your code in a using statement:

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

In the event of an exception, this pattern will ensure that the file is not left open (it may be the reason the file is in use: something went wrong, and no one closed it; see this post for an example).

If everything appears to be in order (you’re certain you always close every file you open, even if there are exceptions) and you have many working threads, you have two choices: modify your code to serialize file access (which isn’t always possible or desirable) or use a retry pattern. It’s a frequent pattern for I/O operations: you try something, wait for an error, and then try again (have you ever wondered why Windows Shell takes so long to notify you that a file is in use and cannot be deleted?). It’s rather simple to implement in C# (see also more advanced examples of disk I/O, networking, and database access).

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.

Please take note of the following typical StackOverflow error:

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

Because the file is open (File.Open() in the previous line), ReadAllText() will fail in this situation. It is not only unnecessary, but also incorrect, to open the file first. All File functions that don’t return a handle to the file you’re working with are the same: File.ReadAllText(), File.WriteAllText(), File.ReadAllLines(), File.WriteAllLines(), and other functions (such as File.AppendAllXyz()) will open and shut the file on their own.

That file is accessed by more than just your process. Interaction can be difficult if your process isn’t the only one who has access to that file. A retry pattern will help (if the file shouldn’t be open by anybody else but is, you’ll need a tool like Process Explorer to figure out who’s doing what).

Always utilize using statements to open files when possible. It will actively assist you avoid numerous typical blunders, as stated in the preceding paragraph (see this post for an example on how not to use it).

Try to determine who has access to a certain file and centralize access using a few well-known ways if at all possible. If your software reads and writes to a data file, for example, all I/O code should be contained within a single class. It’ll make debugging easier (since you can always put a breakpoint there and observe who’s doing what), and it’ll also serve as a synchronization point for multiple access (if needed).

Don’t forget that I/O operations might always fail; here’s one example:

if (File.Exists(path))

If you remove a file after File.Exists() but before File.Delete(), you’ll get an IOException in a location where you could mistakenly believe you’re safe.

Apply a retry pattern whenever possible, and consider postponing action if you’re using FileSystemWatcher (since you’ll be notified, but an application may still be working exclusively with that file).

Sophisticated situations Because it isn’t always straightforward, you may need to delegate access to someone else. You have at least two possibilities if you’re reading from the beginning and writing to the conclusion, for example.

1) utilize the same FileStream and synchronization routines (because it is not thread-safe). As an example, see this and this posts.

S to allow other processes (or sections of your own process) to simultaneously access the same file.

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

I demonstrated how to open a file for writing and share it for reading in this example; please note that when reading and writing overlap, undefined or invalid data results. When reading, this is a circumstance that must be dealt with. Also, because access to the stream is not thread-safe, this object cannot be shared by many threads unless access is synchronised in some way (see previous links). Other sharing methods exist, and they allow for more complicated scenarios. Please refer to MSDN for more details.

In general, N processes can read from the same file simultaneously, but only one should write; in a controlled scenario, concurrent writting may be allowed, but this cannot be generalized in a few text paragraphs inside this response.

Is it feasible to unlock a file that is being used by another application? It is not always safe or simple, but it is feasible.

Answered by 11 revs, 3 users 88%

Solution #2

Using FileShare, I was able to open a file even though it was already open by another process.

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

Answered by Muhammad Umar

Solution #3

I had a problem submitting an image that I couldn’t delete, and I figured out how to fix it. hf hf hf hf hf hf

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

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


File.Delete(filePath); //now works

Answered by Hudson

Solution #4


One is attempting to open the System.IO file. File. If you use this method to open(path, FileMode) a file and want to distribute access to it, but

If you read the documentation for System.IO.File.Open(path, FileMode), it expressly states that sharing is not permitted.


With FileShare, you’ll need to utilize another override.

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

with FileShare.Read

Answered by hanan

Solution #5

Because I was doing File, I got this error. If you want to move to a file path that doesn’t have a name, you’ll need to specify the whole path in the destination.

Answered by live-love

Post is based on