Ist es möglich, eine Kopie einer (großen) Datei zu starten, ohne auf das Ergebnis zu warten?

Question

Ich denke, es ist ziemlich offensichtlich im Titel; Ich möchte eine Datei kopieren, ohne auf das Ergebnis zu warten.

functionaly möchte ich dies:

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 !"); 
    } 

Grundsätzlich mein Haupt-Thread nach wenigen Millisekunden freigegeben wird. Ich versuche, wie dies zu tun:

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); 
      } 
     } 
    } 

Mein mytestfile.fil in meinem Zielordner erstellt wird, aber seine Größe ist 0kb.

Grüße,

Answer 1

Ihre Main-Methode kehrt vor der Aufgabe wurde erfolgreich abgeschlossen, so dass Ihre Anwendung beendet.

Answer 2

Grundsätzlich ist mein Haupt-Thread nach wenigen Millisekunden freigegeben. Ich versuche, so zu tun

Sie müssen den Prozess irgendwie am Leben erhalten. Der einfachste Weg, dies zu tun - wenn Sie tatsächlich die Dateikopie an einem Faden seines eigenen zu tun haben - ist Ihre Copy-Methode auf einen Vordergrund Thread ausgeführt:

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); 
      } 
     } 
    } 
} 

... oder Sie könnten ausführen auf dem Haupt-Thread, da Ihre Anwendung nicht alles anders scheinen:

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); 
      } 
     } 
    } 
} 

Eine dritte Möglichkeit ist Ihre Methode Asynchron zu machen und warten, bis es synchron im Hauptverfahren abzuschließen:

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); 
      } 
     } 
    } 
} 

Beachten Sie, dass Sie die asynchrone CopyToAsync-Methode nicht verwenden sollten, wenn Sie nicht darauf warten. Nicht synchronen und asynchronen Code mischen :)

Answer 3

OK mehr als einen Fehler.

• Ihr Programm wird beendet, bevor die Kopie abgeschlossen ist. Sie brauchen so etwas wie:

• copyToAsync nicht

  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 4

Es scheint, erwartet wurde wie könnte dies eine Instanz des XY problem sein.

Beachten Sie, dass das OS/Rahmen im Allgemeinen Ihr Prozess wird unter Angabe der eigenen „Raum“ in laufen, so dass die folgenden:

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); 
     } 
    } 
} 

ist nicht anders in Bezug auf die Leistung als nur

tun

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

Da Ihre Konsolenanwendung grundsätzlich nichts anderes tut als das Kopieren der Datei, fügt der zusätzliche Thread nur zusätzlichen Aufwand hinzu.

Auch, wenn Sie asynchrone Operationen innerhalb der Copy-Methode sind, sollen Sie Ihre Methode deklarieren async Task anstatt void denn sonst können Sie nicht das await Schlüsselwort innerhalb der Copy Methode verwenden oder warten, bis die Copy Methode an anderer Stelle zu vervollständigen in Code. Also:

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

Wie geschrieben, dies hat eine eklatante Racebedingung und wird wahrscheinlich nicht richtig funktionieren, weil DestinationStream und SourceStream können entsorgt werden, bevor SourceStream.CopyToAsync(DestinationStream) tatsächlich beendet. Sie müssen

await SourceStream.CopyToAsync(DestinationStream); 

innerhalb Ihrer Methode tun, um dies zu verhindern.

Wenn Sie den Kopiervorgang sind startet mit

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

Sie bereits effektiv diese asynchron aus der Sicht des Programms ausgeführt wird, der es ins Leben gerufen, weil das Programm, das sie ins Leben gerufen nicht für den Prozess warten um abzuschließen, bevor es weitergeht. Ich gehe übrigens davon aus, dass diese Konsolenanwendung etwas anderes tut, als nur den Prozess zu starten, richtig? (Wenn nicht, scheint es ein wenig überflüssig).