.NET Denying Access to Directories After Copy Operations

I'm performing a "safe" copy of a directory over another directory as follows:

Given the source C:\Source and target C:\Target

• Copy C:\Source to C:\Target-incoming
• Move C:\Target (if it exists) to C:\Target-outgoing
• Move C:\Target-incoming to C:\Target
• Delete C:\Target-outgoing (if it exists)

If any of the first three steps fail, I'll attempt to put things back as they were to prevent data loss.

However, the move of C:\Target-incoming to C:\Target fails with "Access to the path C:\Target-incoming is denied" most of the time.

At the moment, inserting Thread.Sleep(100) just before the move operation fixes the problem for me. However, waiting .1 of a second seems ridiculous to me. Thread.Sleep(10) isn't enough to fix it. I also have the sinking feeling that the value I have to wait depends on the speed of disk IO.

So, my questions:

• Can I prevent this from happening?
• If not, is there a way of finding out when the lock on the directory is released after copying it?

Edit: For clarity, I'm doing all these operations in one method on one thread, and I'm just using Thread.Sleep() to pause code flow for a moment. The moves and copies are being done with standard .NET Directory.Move(), Directory.CreateDirectory() and File.CopyTo开发者_如何学编程() methods. It would appear that the .NET methods are returning before the locks on the respective files are being released, causing the necessity to wait an amount of time before continuing.

What could be happening is probably that your thread is trying to "Move C:\Target-incoming to C:\Target" WHILE the "Move C:\Target to C:\Target-outgoing" is NOT finished YET. This track is confirmed by the success of your process after short Thread Sleep. Try to Chain your processes, i.e : Divide each step into specific methods, and call the methods one after the other (sync'ing the start of a method to the end of the previous one) There are various ways to do that (among others syncing/locking/chaining different threads per process/step)

You could check Thread Synchronization in .NET

But of course, this is not the only possible cause for your problem.

After a bunch of testing, it seems like the very act of trying to move a locked folder gets the OS to hurry up and release the lock, even if the first attempt fails.

I wrote this extension method to DirectoryInfo:

public static void TryToMoveTo(this DirectoryInfo o, string targetPath) {

    int attemptsRemaining = 5;

    while (true) {
        try {
            o.MoveTo(targetPath);
            break;

        } catch (Exception) {

            if (attemptsRemaining == 0) {
                throw;
            } else {
                attemptsRemaining--;
                System.Threading.Thread.Sleep(10);
            }
        }
    }
}

While debugging the original problem, I settled on waiting for 100ms as anything less seemed to cause exceptions (I tried 10, 25, 50, 75 and 100ms). However, in the method above I wait 10ms before retrying, and I never, ever got more than one exception thrown in each of my hundreds of test runs.

You can always try waiting in a loop, up till a maximum # of tries. You can check to see if the directory is locked by calling CreateFile and checking it's return code. Be sure to read through the "flags" section of the docs because you need to pass in a special flag to open a directory.

Someone else mentioned in a comment that you may want to try Transactional NTFS. If you can, you might want to try that.

check wethere source and target directories exist before copying or moving using io.directory.exists

the access deneied error is caused by either source or target are not found.