3

We have an application that stores files in a temporary location until the user decides to finalize their transaction. The temp directory is unique for each transaction. Once they do finalize, the files are moved from the temp location to a final location, which is also unique for each transaction. This is all working without any issues.

I'm rather surprised, but when searching Google and SO, we were unable to find any topics on which is generally considered a best practice:

  1. Call System.IO.Directory.Move(src, des) to simply move the whole directory at once, or
  2. Call System.IO.File.Move(src, des) to move the files one at a time.

As these decisions typically rely on a number of factors, I should note the following conditions:

  1. The source and destination directories will always be on the same machine, but the application making the calls will be on a different machine on the same network. I believe the application server and file server are separate VM's on the same physical machine, but I am not positive.
  2. The number of files could range from 1 to 10, or more. I do not monitor the production system myself, so I am unsure of the average file count, or how spread the count is.
Eric
  • 53
  • 9
  • Are the source and destination on the same volume / partition? – vcsjones Oct 13 '15 at 14:24
  • Yes. The generalized directory structure is \temp\, and \final\. – Eric Oct 13 '15 at 14:35
  • I'd say just set up a small little test environment and record the speeds using `Directory.Move()` compare to `File.Move()`. Do it a bunch of times and go with whichever's faster. – sab669 Oct 13 '15 at 14:54
  • 3
    @sab669 I would use `Directory.Move` if he wants to move the whole directory. Only if there *is* a performance issue would I start testing which is better. It is highly unlikely that there will be a big difference. Use the most obvious way first. – Lasse V. Karlsen Oct 14 '15 at 11:22
  • That's a fair point, suppose from a pure readability standpoint it makes more sense to just use Directory – sab669 Oct 14 '15 at 11:24

2 Answers2

4

I'm not sure if there is any fixed "best practice" other than that you should use the most appropriate tool for the job.

Since what you're doing is moving the entire directory from its temporary location/status to a permanent location/status I would suggest using Directory.Move. This means that your code will more obviously reflect your logical intent.

And if you're more concerned about the technical difference between the two methods...

In the Microsoft version of .NET, both Directory.Move and File.Move eventually call out to the Win32 MoveFile or MoveFileEx functions. You can confirm this by looking at the Reference Source:

With this in mind, it seems likely that calling out to MoveFile once (via Directory.Move) would generally be preferable to calling it many times for each transaction (via File.Move).

LukeH
  • 263,068
  • 57
  • 365
  • 409
1

I think the biggest issue is not speed but rather: what happens on a move error?

I'm going to use the information in LukeH's answer rather than repeating it here.

The behaviour of MoveFile for a directory move should be appropriate for if it fails to move a single file. If you use a per file move, then you have to handle the error conditions yourself in an appropriate manner. This requires some careful thought.

Note that the documentation of MoveFile specifies that:

The one caveat is that the MoveFile function will fail on directory moves when the destination is on a different volume.

That might or might not be an issue for you and reason to use a per-file Move. The Directory.Move documentation explicitly mentions this (and the reference source for Directory.Move explicitly checks for source and destination having the same root).

MicroVirus
  • 5,324
  • 2
  • 28
  • 53