是否可以在不等待结果的情况下“启动”（大）文件的副本？

Question

我认为这在标题中很明显；我想在不等待结果的情况下复制文件。

功能上我想要这个：

    static void Main(string[] args)
    {
        string strCmdText = @"/C xcopy c:\users\florian\desktop\mytestfile.fil p:\";
        System.Diagnostics.Process.Start("CMD.exe", strCmdText);
        Console.WriteLine("Finished !");
    }

基本上我的主线程在几毫秒后被释放。 我尝试这样做：

    static void Main(string[] args)
    {
        var t = Task.Run(() => Copy(@"c:\Users\florian\Desktop\mytestfile.fil", "p:"));
    }

    private static void Copy(string source, string destination)
    {
        using (FileStream SourceStream = File.Open(source, FileMode.Open))
        {
            using (FileStream DestinationStream = File.Create(destination + source.Substring(source.LastIndexOf('\\'))))
            {
                SourceStream.CopyToAsync(DestinationStream);
            }
        }
    }

我的 mytestfile.fil 是在我的目标文件夹中创建的，但它的大小是 0kb。

问候，

Answer 1

基本上我的主线程在几毫秒后被释放。我试着这样做

您必须以某种方式保持该过程的活力。最简单的方法——如果你真的必须在它自己的线程上进行文件复制——是在 foreground 线程上执行你的 Copy 方法：

class Program
{
    static void Main(string[] args)
    {
        System.Threading.Thread thread = new System.Threading.Thread(()=> Copy(@"c:\Users\florian\Desktop\mytestfile.fil", "p:"));
        thread.Start();
    }

    private static void Copy(string source, string destination)
    {
        using (FileStream SourceStream = File.Open(source, FileMode.Open))
        {
            using (FileStream DestinationStream = File.Create(destination + source.Substring(source.LastIndexOf('\\'))))
            {
                SourceStream.CopyTo(DestinationStream);
            }
        }
    }
}

...或者您可以在主线程上执行它，因为您的应用程序似乎没有其他任何东西：

class Program
{
    static void Main(string[] args)
    {
        string source = @"c:\Users\florian\Desktop\mytestfile.fil";
        string destination = "p";
        using (FileStream SourceStream = File.Open(source, FileMode.Open))
        {
            using (FileStream DestinationStream = File.Create(destination + source.Substring(source.LastIndexOf('\\'))))
            {
                SourceStream.CopyTo(DestinationStream);
            }
        }
    }
}

第三种选择是使您的方法异步并等待它在 Main 方法中同步完成：

class Program
{
    static void Main(string[] args)
    {
        CopyAsync(@"c:\Users\florian\Desktop\mytestfile.fil", "p:").Wait();
    }

    private static async Task CopyAsync(string source, string destination)
    {
        using (FileStream SourceStream = File.Open(source, FileMode.Open))
        {
            using (FileStream DestinationStream = File.Create(destination + source.Substring(source.LastIndexOf('\\'))))
            {
                await SourceStream.CopyToAsync(DestinationStream);
            }
        }
    }
}

请注意，除非您实际等待，否则不应使用异步 CopyToAsync 方法。不要混合同步和异步代码:)

Answer 2

确定不止一个错误。

• 您的程序在复制完成之前退出。你需要这样的东西：

• 没有等待 CopyToAsync

  class Program
  {
      private static void Main(string[] args)
      {
          var source = new CancellationTokenSource();
          Console.CancelKeyPress += (s, e) =>
          {
              e.Cancel = true;
              source.Cancel();
          };
  
      try
      {
          MainAsync(args, source.Token).GetAwaiter().GetResult();
          return;
      }
      catch (OperationCanceledException)
      {
          return;
      }
  }
  
  static async Task MainAsync(string[] args, CancellationToken token)
  {
      var t = Task.Run(() => Copy(@"c:\test.txt", @"c:\dest\"));
      Console.WriteLine("doing more stuff while copying");
      await t;
      Console.WriteLine("Finished !");
  }
  
  private static void Copy(string source, string destination)
  {
      using (FileStream SourceStream = File.Open(source, FileMode.Open))
      {
          using (FileStream DestinationStream = File.Create(destination + source.Substring(source.LastIndexOf('\\'))))
          {
              SourceStream.CopyTo(DestinationStream);
          }
      }
  }
  

  }

Answer 3

您的 Main 方法在任务完成之前返回，因此您的应用程序结束。

Answer 4

这似乎是XY problem 的一个实例。

请记住，操作系统/框架基本上是为您的进程提供了自己的“空间”来运行，因此如下：

static void Main(string[] args)
{
    var t = Task.Run(() => Copy(@"c:\Users\florian\Desktop\mytestfile.fil", "p:"));
}

private static void Copy(string source, string destination)
{
    using (FileStream SourceStream = File.Open(source, FileMode.Open))
    {
        using (FileStream DestinationStream = File.Create(destination + source.Substring(source.LastIndexOf('\\'))))
        {
            SourceStream.CopyToAsync(DestinationStream);
        }
    }
}

在性能方面与只是做没有什么不同

static void Main(string[] args)
{
    Copy(@"c:\Users\florian\Desktop\mytestfile.fil", "p:");
}

由于您的控制台应用程序基本上除了复制文件之外什么都不做，额外的线程只会增加开销。

另外，如果您在 Copy 方法中使用异步操作，您应该声明您的方法 async Task 而不是 void，否则您不能在 Copy 方法中使用 await 关键字或等待Copy 方法在代码的其他地方完成。所以：

private static async Task Copy(string source, string destination)

正如所写，这有一个明显的竞争条件，可能无法正常工作，因为DestinationStream 和SourceStream 可能在SourceStream.CopyToAsync(DestinationStream) 实际完成之前被处理掉。你需要做的

await SourceStream.CopyToAsync(DestinationStream);

在你的方法中防止这种情况发生。

如果您使用

启动复制操作

System.Diagnostics.Process.Start(...);

从启动它的程序的角度来看，您已经有效地异步运行它，因为启动它的程序在继续之前不会等待进程完成。顺便说一句，我假设该控制台应用程序会做一些事情，而不仅仅是启动进程，对吗？ （如果不是，那似乎有点多余）。