System.Net.FtpClient openwrite lädt die Datei nicht, es sei denn, ich füge einen Ruhezustand ein, bevor ich ihn ausschalte

Question

Ich benutze die System.Net.FtpClient-Assembly, um eine Datei auf eine Test-FTP-Site hochzuladen. Wenn ich den folgenden Code ausführen wird die Datei nicht in der entfernten Stelle angezeigt, wenn ich eine Thread.Sleep nach unten verwenden (was ich würde es vorziehen, nicht zu verwenden):

using System; 
using System.IO; 
using System.Net; 
using System.Net.FtpClient; 
using System.Security.Cryptography.X509Certificates; 
using System.Threading; 

namespace FtpsUploadTest 
{ 
    /// <summary> 
    /// The ftp publisher. 
    /// </summary> 
    public class FtpPublisher 
    { 
     private readonly FtpsSettings _settings; 
     private readonly IFtpClient _ftpClient; 

     /// <summary> 
     /// Initializes a new instance of the <see cref="FtpPublisher"/> class. 
     /// </summary> 
     public FtpPublisher() 
     { 
      _ftpClient = new FtpClient(); 
      _settings = SettingsReader.GetMySettings(); 
      Init(); 
     } 


     /// <summary> 
     /// The publish. 
     /// </summary> 
     /// <param name="fileToUpload"> 
     /// The input file path. 
     /// </param> 
     public void Publish(string fileToUpload) 
     { 
      var remoteFileName = Path.GetFileName(fileToUpload); 

      Console.WriteLine("FTPS host: {0} remote path: {1}", _settings.FtpsRemoteHost, _settings.FtpsRemotePath); 

      if (!_ftpClient.IsConnected) 
      { 
       _ftpClient.Connect(); 
      } 

      var fullRemotePath = string.Format("{0}/{1}", _settings.FtpsRemotePath, remoteFileName); 

      using (var ftpStream = _ftpClient.OpenWrite(fullRemotePath)) 
      using (var inputStream = new FileStream(fileToUpload, FileMode.Open)) 
      { 
       inputStream.CopyTo(ftpStream); 
       Thread.Sleep(5000); // <------------------- DOESNT WORK IF REMOVE THIS SLEEP!! 
      } 

      Console.WriteLine("File '{0}' published successfully", fileToUpload); 
     } 


     private void Init() 
     { 
      _ftpClient.Host = _settings.FtpsRemoteHost; 
      _ftpClient.Port = _settings.FtpsRemotePort; 
      _ftpClient.DataConnectionConnectTimeout = 60000; 
      _ftpClient.ConnectTimeout = 60000; 
      _ftpClient.Credentials = new NetworkCredential(_settings.FtpsUserId, string.Empty); 
      _ftpClient.DataConnectionType = 0; 

      if (string.IsNullOrEmpty(_settings.CertFile) || string.IsNullOrEmpty(_settings.CertPassword)) 
      { 
       return; 
      } 

      _ftpClient.ClientCertificates.Add(CreateCertificate(_settings.CertFile, _settings.CertPassword)); 
      _ftpClient.EncryptionMode = (FtpEncryptionMode)2; 
      _ftpClient.DataConnectionEncryption = true; 
     } 


     private X509Certificate CreateCertificate(string certFile, string certPassword) 
     { 
      return new X509Certificate(certFile, certPassword, X509KeyStorageFlags.MachineKeySet | X509KeyStorageFlags.PersistKeySet); 
     } 
    } 
} 

Wer weiß, wie ich bekommen kann funktioniert es ohne Verwendung eines Thread.Sleep? Ich habe versucht, Flushing, Schließen von Streams, aber das hilft nicht.

Answer 1

Der Remote-FTP-Server agiert vollständig asynchron von Ihrem Code. Abhängig von der Konfiguration des Servers kann es beispielsweise nach Viren oder anderer Buchführung suchen, bevor die Datei verfügbar gemacht wird. Möglicherweise können Sie nichts dagegen tun, es sei denn, Sie haben direkte Kontrolle über den FTP-Server. Selbst dann werden einige Konfigurationsänderungen oder sogar ein anderes Softwarepaket benötigt.

Eine Sache, die für Sie arbeiten könnte, ist, nach Abschluss des Uploads für die Datei "abzufragen". Machen Sie eine Schleife, die nach der Datei sucht, 1 Sekunde wartet und dann wiederholt, bis sie die Datei findet oder aufgibt. Das Async/Await-Muster oder ein Rückruf von einem anderen Thread kann Ihnen dabei helfen, bei einem Problem alle UI-Einfrierungen zu entfernen.

Answer 2

Dank Bradleys Antwort habe ich eine Problemumgehung geschafft: Hochladen der Datei mit FtpClient.OpenWrite (...) und danach überprüfe ich ständig die Dateigröße auf dem Server, was das Problem des während des Hochladens ausgeführten Codes löste sollte danach ausgeführt werden.

Dann stieß ich auf ein anderes Problem, für das ich eine Umgehung für: Wenn Sie die Dateigröße der Upload-Datei auf dem Remote-FTP-Server überprüfen, können Sie nicht immer die Dateigröße über FtpClient.GetFileSize (...) aufgrund eines FTP-Befehls (SIZE), der nicht von allen FTP-Servern unterstützt wird. Die Lösung war folgende: Wenn FtpClient.GetFileSize (...) zurückgibt, ist größer als -1, der SIZE-Befehl funktioniert und kann verwandt werden. Wenn die Funktion -1 zurückgibt, können Sie einfach eine Liste von Dateien im angegebenen Ordner auf dem Server durchlaufen. Dort erhalten Sie ein Array von FtpListItem mit einer Eigenschaft namens "Size". Größe gibt den gleichen Wert wie FtpClient.GetFileSize (...) eigentlich zurück.

Beispielcode:

const string folderPath = "/media/"; 
string fileName = "image.png"; 
string fullRemotePath = folderPath + fileName; 
string fileToUpload = @"C:\image.png"; 
FtpClient ftpClient = new FtpClient(); 
// start FtpClient connection etc 

FileInfo fileInfo = new FileInfo(fileToUpload); 
long actualFileSize = fileInfo.Length; 
using (var ftpStream = ftpClient.OpenWrite(fullRemotePath)) 
{ 
    using (var inputStream = new FileStream(fileToUpload, FileMode.Open)) 
    { 
     inputStream.CopyTo(ftpStream); 
     //Thread.Sleep(5000); <-- not necessary anymore 
    } 
} 
long fileSizeOnFtp = ftpClient.GetFileSize(fullRemotePath); 
while (fileSizeOnFtp < actualFileSize) 
{ 
    if (fileSizeOnFtp > -1) 
    { 
     fileSizeOnFtp = ftpClient.GetFileSize(fullRemotePath); 
    } 
    else 
    { 
     var ftpListItem = ftpClient.GetListing(folderPath).Where(x => x.Name == fileName).FirstOrDefault(); 
     if (ftpListItem != null) 
     { 
      fileSizeOnFtp = ftpListItem.Size; 
     } 
     else 
     { 
      // the program only could run into this issue if the folder couldn't be listed 
      throw new Exception(); 
     } 
    } 
} 
// execute everything else after ftp upload has finished