高效地移动文件

Question

我正在尝试在我的WPF应用程序中移动文件夹，同时查看进度条。移动操作非常缓慢，我找不到任何解决方案来提高速度（测试速度是38 Mb移动需要2:30分钟）。但我不知道如何有效地移动它。目前的移动方式虽然能用，但效率极低。

public delegate void ProgressChangeDelegate(double percentage);
    public delegate void CompleteDelegate();

    class FileMover
    { 
        public string SourceFilePath { get; set; }
        public string DestFilePath { get; set; }

        public event ProgressChangeDelegate OnProgressChanged;
        public event CompleteDelegate OnComplete;

        public FileMover(string Source, string Dest)
        {
            SourceFilePath = Source;
            DestFilePath = Dest;

            OnProgressChanged += delegate { };
            OnComplete += delegate { };
        }

        public void Copy()
        {
            byte[] buffer = new byte[1024 * 1024]; // 1MB buffer
            using (FileStream source = new FileStream(SourceFilePath, FileMode.Open, FileAccess.Read))
            {
                long fileLength = source.Length;
                using (FileStream dest = new FileStream(DestFilePath, FileMode.CreateNew, FileAccess.Write))
                {
                    long totalBytes = 0;
                    int currentBlockSize = 0;

                    while ((currentBlockSize = source.Read(buffer, 0, buffer.Length)) > 0)
                    {
                        totalBytes += currentBlockSize;
                        double percentage = (double) totalBytes * 100.0 / fileLength;

                        dest.Write(buffer, 0, currentBlockSize);
                        OnProgressChanged(percentage);
                    }
                }
            }
            OnComplete();
        }
    }

        private async void MoveFile(string source, string outDir)
        {
            if (!string.IsNullOrEmpty(outDir) && !string.IsNullOrEmpty(source))
            {
                //InputButtonText.Text = "Please be patient while we move your file.";
                //Task.Run(() => { new FileInfo(source).MoveTo(Path.Combine(outDir, Path.GetFileName(source))); }).GetAwaiter().OnCompleted(
                //    () =>
                //    {
                //        OutputScanned.ItemsSource = null;
                //        InputButtonText.Text = "Click to select a file";
                //    });

                var mover = new FileMover(source, Path.Combine(outDir, Path.GetFileName(source)));
                await Task.Run(() => { mover.Copy(); });

                mover.OnProgressChanged += percentage =>
                {
                    MoveProgress.Value = percentage;
                    InputButtonText.Text = percentage.ToString();
                };

                mover.OnComplete += () => { File.Delete(source); };
            }
        }

- Torben Van Assche

---

你好像有一些问题，具体来说你需要在这里寻求什么帮助？ - Trevor

你需要将问题拆分成单独的几个问题。逐个解决每个问题，为每个问题提供好的 [mcve]，这样人们才能帮助你。话虽如此，你不应该通过显式复制来移动文件。而是使用 System.IO.File.Move() 方法。只要文件在同一卷中移动，这个操作就非常快，而且独立于文件大小。如果你试图跨卷移动，文件将被复制而不是移动（如果你想要删除源文件，你必须自己删除），但操作仍然会高效完成。 - Peter Duniho

@PeterDuniho，如果OP选择使用System.IO.File.Move()，您会建议他们如何显示此移动的进度？ - Trevor

@Çöđěxěŕ：对于同一卷内的移动，进度条完全是不必要的。如果他们关心跨卷情况并仍然想要一个进度条，那么还有其他选项，包括自己实现复制，但首先他们需要确定他们想要解决的问题是什么。 - Peter Duniho

跟踪器是一个事件监听器，所以不应该影响任何事情。这对我来说毫无意义。我会将其删除并查看是否有任何影响。我的初学者想法是增加缓冲区大小，以便一次复制更多内容，但我不确定那是否有效。我也忘了删除最后一部分。跟踪器是另一个问题，在解决此问题之后再处理。 - Torben Van Assche

Answer 1

移动操作非常慢，我找不到任何方法使其更快。

导致文件移动缓慢的原因有很多，例如：反恶意软件应用程序 - 可能会扫描文件，网络负载（如果移动到另一个卷/驱动器），文件大小本身，以及可能存在的代码问题。

我猜想您之所以选择了这种方式处理代码，是因为您可以处理到目前为止已经移动了多少，这没问题，但是有一些替代方案可以很好地移动这些文件并且速度更快。

一些选项。

1. System.IO.File.Move() 方法 - 这个方法可以很好地使用，但是您对进度没有控制能力。在幕后, 它实际上调用了 Win32Native.MoveFile c++函数，它运行得非常好。
2. FileInfo.MoveTo - 它只是将工作委托给 Win32.MoveFile。
3. 您的方法 - 使用来自 Kernel32.dll 的一些函数 - 这允许完全控制以及进度等...

我马上会回到上面的内容，因为我想提一下您之前发布的有关进度未更新的问题。

这里的调用 await Task.Run(() => { mover.Copy(); }); 将会等待直到完成，但是你在这之后才注册事件，例如：mover.OnProgressChanged += percentage => 在 Copy() 调用之后，所以不会收到任何变化。

即使你收到了变化，你也会遇到异常，因为你不在UI线程上，而是在另一个线程上。例如：

 mover.OnProgressChanged += percentage =>
 {
    MoveProgress.Value = percentage;
    InputButtonText.Text = percentage.ToString();
 };

你正在尝试从另一个线程更新UI (progressbar.value)，但这是不可能的。为了解决这个问题，你需要从Dispatcher中调用。例如:

 Application.Current.Dispatcher.Invoke(() =>
 {
    pbProgress.Value = percentage;
 });

返回文件操作

老实说，您仍然可以按照自己的方式进行操作，只需要移动一些东西即可。否则，请参见下方我编写的类，您可以使用它来移动文件并报告进度等。请看下面。

注意：我测试了一个500MB的文件，从本地驱动器移动到不同卷中，用时2.78秒；850MB的文件用时3.37秒。

 using System;
 using System.IO;
 using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using System.Transactions; // must add reference to System.Transactions     

public class FileHelper
    {
        #region | Public Events |

        /// <summary>
        /// Occurs when any progress changes occur with file.
        /// </summary>
        public event ProgressChangeDelegate OnProgressChanged;

        /// <summary>
        /// Occurs when file process has been completed.
        /// </summary>
        public event OnCompleteDelegate OnComplete;

        #endregion

        #region | Enums |

        [Flags]
        enum MoveFileFlags : uint
        {
        MOVE_FILE_REPLACE_EXISTSING = 0x00000001,
        MOVE_FILE_COPY_ALLOWED = 0x00000002,
        MOVE_FILE_DELAY_UNTIL_REBOOT = 0x00000004,
        MOVE_FILE_WRITE_THROUGH = 0x00000008,
        MOVE_FILE_CREATE_HARDLINK = 0x00000010,
        MOVE_FILE_FAIL_IF_NOT_TRACKABLE = 0x00000020
        }

        enum CopyProgressResult : uint
        {
        PROGRESS_CONTINUE = 0,
        PROGRESS_CANCEL = 1,
        PROGRESS_STOP = 2,
        PROGRESS_QUIET = 3,
        }

        enum CopyProgressCallbackReason : uint
        {
        CALLBACK_CHUNK_FINISHED = 0x00000000,
        CALLBACK_STREAM_SWITCH = 0x00000001
        }

        #endregion

        #region | Delegates |

        private delegate CopyProgressResult CopyProgressRoutine(
        long TotalFileSize,
        long TotalBytesTransferred,
        long StreamSize,
        long StreamBytesTransferred,
        uint dwStreamNumber,
        CopyProgressCallbackReason dwCallbackReason,
        IntPtr hSourceFile,
        IntPtr hDestinationFile,
        IntPtr lpData);

        public delegate void ProgressChangeDelegate(double percentage);

        public delegate void OnCompleteDelegate(bool completed);

        #endregion

        #region | Imports |

        [DllImport("Kernel32.dll")]
        private static extern bool CloseHandle(IntPtr handle);

        [DllImport("Kernel32.dll")]
        private static extern bool MoveFileTransactedW([MarshalAs(UnmanagedType.LPWStr)]string existingfile, [MarshalAs(UnmanagedType.LPWStr)]string newfile,
            IntPtr progress, IntPtr lpData, IntPtr flags, IntPtr transaction);

        [DllImport("Kernel32.dll")]
        private static extern bool MoveFileWithProgressA(string existingfile, string newfile,
            CopyProgressRoutine progressRoutine, IntPtr lpData, MoveFileFlags flags);

        [ComImport]
        [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
        [Guid("79427A2B-F895-40e0-BE79-B57DC82ED231")]
        private interface IKernelTransaction
        {
            void GetHandle([Out] out IntPtr handle);
        }

        #endregion

        #region | Public Routines |

        /// <summary>
        /// Will attempt to move a file using a transaction, if successful then the source file will be deleted.
        /// </summary>
        /// <param name="existingFile"></param>
        /// <param name="newFile"></param>
        /// <returns></returns>
        public static bool MoveFileTransacted(string existingFile, string newFile)
        {
            bool success = true;
            using (TransactionScope tx = new TransactionScope())
            {
                if (Transaction.Current != null)
                {
                    IKernelTransaction kt = (IKernelTransaction)TransactionInterop.GetDtcTransaction(Transaction.Current);
                    IntPtr txh;
                    kt.GetHandle(out txh);

                    if (txh == IntPtr.Zero) { success = false; return success; }

                    success = MoveFileTransactedW(existingFile, newFile, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, txh);

                    if (success)
                    {
                        tx.Complete();
                    }
                    CloseHandle(txh);
                }
                else
                {
                    try
                    {
                        File.Move(existingFile, newFile);
                        return success;
                    }
                    catch (Exception ex) { success = false; }
                }

                return success;
            }
        }

        /// <summary>
        /// Attempts to move a file from one destination to another. If it succeeds, then the source
        /// file is deleted after successful move.
        /// </summary>
        /// <param name="fileToMove"></param>
        /// <param name="newFilePath"></param>
        /// <returns></returns>
        public async Task<bool> MoveFileAsyncWithProgress(string fileToMove, string newFilePath)
        {
            bool success = false;

            try
            {
                await Task.Run(() =>
                {
                    success = MoveFileWithProgressA(fileToMove, newFilePath, new CopyProgressRoutine(CopyProgressHandler), IntPtr.Zero, MoveFileFlags .MOVE_FILE_REPLACE_EXISTSING|MoveFileFlags.MOVE_FILE_WRITE_THROUGH|MoveFileFlags.MOVE_FILE_COPY_ALLOWED);
                });
            }
            catch (Exception ex)
            {
                success = false;
            }
            finally
            {
                OnComplete(success);
            }

            return success;
        }

        private CopyProgressResult CopyProgressHandler(long total, long transferred, long streamSize, long StreamByteTrans, uint dwStreamNumber,CopyProgressCallbackReason reason, IntPtr hSourceFile, IntPtr hDestinationFile, IntPtr lpData)
        {
            double percentage = transferred * 100.0 / total;
            OnProgressChanged(percentage);

            return CopyProgressResult.PROGRESS_CONTINUE;
        }

        #endregion
    }

如何使用

一个示例 -

 // Just a public property to hold an instance we need
 public FileHelper FileHelper { get; set; }

在加载时注册事件...

 FileHelper = new FileHelper();
 FileHelper.OnProgressChanged += FileHelper_OnProgressChanged;
 FileHelper.OnComplete += FileHelper_OnComplete;

这是逻辑...

 private async void Button_Click(object sender, RoutedEventArgs e)
 {
    bool success = await FileHelper.MoveFileAsyncWithProgress("FILETOMOVE", "DestinationFilePath");
 }

 // This is called when progress changes, if file is small, it
 // may not even hit this.
 private void FileHelper_OnProgressChanged(double percentage)
 {
        Application.Current.Dispatcher.Invoke(() =>
        {
            pbProgress.Value = percentage;
        });
 }

 // This is called after a move, whether it succeeds or not
 private void FileHelper_OnComplete(bool completed)
 {
        Application.Current.Dispatcher.Invoke(() =>
        {
            MessageBox.Show("File process succeded: " + completed.ToString());
        });
 }

*注意：在该帮助类中还有另一个函数MoveFileTransacted，你实际上不需要使用它。它是另一个帮助函数，允许你使用事务移动文件；如果发生异常，则文件不会移动等...

- Trevor

---

这是一个非常好的解释，我认为我理解了大部分内容。但是，该死的，它比我预期的要复杂得多（看起来）。非常感谢您！我手动输入并确保我理解了它所说的内容。 - Torben Van Assche

虽然我不得不承认，DLL导入让我非常困惑。 - Torben Van Assche

我正在移动一个大约2GB的文件，大约花了25秒钟。我非常惊讶它的速度有多快！下一步将是观察文件系统中的更改并自动化该过程。如果有多个文件被移动，这段代码会出现问题吗？我预计会有显着的减速。回复有点晚了，因为我现在正在工作，所以去睡觉了哈哈。 - Torben Van Assche

@TorbenVanAssche 我认为如果移动多个文件，这不应该会引起问题，但实施和测试应该是最小的。所有主要工作都在新线程上完成，当然，如果你有成千上万的文件需要移动，你可能会看到一些减速，但更有可能的情况是不会出现这种情况。 - Trevor

好的，是时候开始着手处理我的文件系统监视器了。 - Torben Van Assche