C# move file as soon as it becomes available

I need to accomplish the following task:

Attempt to move a file. If file is locked schedule for moving as soon as it becomes available.

I am using File.Move which is sufficient for my program. Now the problems are that:

1) I can't find a good way to check if the file I need to move is locked. I am catching System.IO.IOException but reading o开发者_C百科ther posts around I discovered that the same exception may be thrown for different reasons as well.

2) Determining when the file gets unlocked. One way of doing this is probably using a timer/thread and checking the scheduled files lets say every 30 seconds and attempting to move them. But I hope there is a better way using FileSystemWatcher.

This is a .net 3.5 winforms application. Any comments/suggestions are appreciated. Thanks for attention.

---

You should really just try and catch an IOException. Use Marshal.GetHRForException to check for the cause of the exception. A notification would not be reliable. Another process might lock the file again before File.Move is executed.

---

It's simple:

        static void Main(string[] args)
        {
            //* Create Watcher object.
            FileSystemWatcher watcher = new FileSystemWatcher(@"C:\MyFolder\");

            //* Assign event handler. 
            watcher.Created += new FileSystemEventHandler(watcher_Created);

            //* Start watching. 
            watcher.EnableRaisingEvents = true;

            Console.ReadLine();
        }


        static void watcher_Created(object sender, FileSystemEventArgs e)
        {
            try
            {
                File.Move(e.FullPath, @"C:\MyMovedFolder\" + e.Name);
            }
            catch (Exception)
            {
                //* Something went wrong. You can do additional proceesing here, like fire-up new thread for retry move procedure.
            }
        }

---

One possible alternative is by using MoveFileEx with a MOVEFILE_DELAY_UNTIL_REBOOT flag. If you don't have access to move the file right now, you can schedule it to be moved on the next reboot when it's guaranteed to be accessible (the moving happens very early in the boot sequence).

Depending on your specific application, you could inform the user a reboot is necessary and initiate the reboot yourself in addition to the moving scheduling.

---

This is not specific to your problem, but generally you will always need to retain the 'try it and gracefully deal with a failure' mode of operation for this sort of action.

That's because however clever your 'detect that the file is available' mechanism is, there will always be some amount of time between you detecting that the file is available and moving it, and in that time someone else might mess with the file.

---

The scheduled retry on exception (probably increasing delays - up to a point) is probably the simplest way to achieve this (your (2) ). To do it properly you're going to have to drop to system level (with Kernel code) hooks to trap the file close event - which has its own idiosynchrases. It's a big job - several orders of magnitude more complex than the scheduled retry method. It's up to you and your application case to make that call, but I don't know of anything effective in between.

---

Have a look at the FileSystemWatcher.

http://msdn.microsoft.com/en-us/library/system.io.filesystemwatcher(VS.90).aspx

Listens to the file system change notifications and raises events when a directory, or file in a directory, changes

---

Very old question, but google led me here, so when I found a better answer I decided to post it:

There's a nice code I found in the dotnet CLI repo:

    /// <summary>
    /// Run Directory.Move and File.Move in Windows has a chance to get IOException with
    /// HResult 0x80070005 due to Indexer. But this error is transient.
    /// </summary>
    internal static void RetryOnMoveAccessFailure(Action action)
    {
        const int ERROR_HRESULT_ACCESS_DENIED = unchecked((int)0x80070005);
        int nextWaitTime = 10;
        int remainRetry = 10;

        while (true)
        {
            try
            {
                action();
                break;
            }
            catch (IOException e) when (e.HResult == ERROR_HRESULT_ACCESS_DENIED)
            {
                Thread.Sleep(nextWaitTime);
                nextWaitTime *= 2;
                remainRetry--;
                if (remainRetry == 0)
                {
                    throw;
                }
            }
        }
    }

There is also a method for just IOException. Here's the usage example:

FileAccessRetrier.RetryOnMoveAccessFailure(() => Directory.Move(packageDirectory.Value, tempPath));

Overall, this repo contains a lot of interesting ideas for file manipulations and installation/removal logic, like TransactionalAction, so I recommend it for reviewing. Unfortunately, these functions are not available as NuGet package.