UploadFileAsync non asynchrone?

Question

Aight, a fait un peu de googling et de recherche ici, la seule question que j'ai trouvé liée était this, bien que la seule réponse, il n'a pas été marqué comme accepté, est vieux et est source de confusion.

Mon problème est fondamentalement ce que j'ai dit dans le titre. Ce qui se passe, c'est que l'interface graphique se bloque pendant le téléchargement. Mon code:

// stuff above snipped 

public partial class Form1 : Form 
{ 
    WebClient wcUploader = new WebClient(); 

    public Form1() 
    { 
     InitializeComponent(); 

     wcUploader.UploadFileCompleted += new UploadFileCompletedEventHandler(UploadFileCompletedCallback); 
     wcUploader.UploadProgressChanged += new UploadProgressChangedEventHandler(UploadProgressCallback); 
    } 

    private void button1_Click(object sender, EventArgs e) 
    { 
     if (openFileDialog1.ShowDialog() == DialogResult.OK) 
     { 
      string toUpload = openFileDialog1.FileName; 
      wcUploader.UploadFileAsync(new Uri("http://anyhub.net/api/upload"), "POST", toUpload); 
     } 
    } 

    void UploadFileCompletedCallback(object sender, UploadFileCompletedEventArgs e) 
    { 
     textBox1.Text = System.Text.Encoding.UTF8.GetString(e.Result); 
    } 

    void UploadProgressCallback(object sender, UploadProgressChangedEventArgs e) 
    { 
     textBox1.Text = (string)e.UserState + "\n\n" 
      + "Uploaded " + e.BytesSent + "/" + e.TotalBytesToSend + "b (" + e.ProgressPercentage + "%)"; 
    } 
} 

EDIT: Pour plus de précisions, voici ce qui se passe dans l'ordre:

1. je clique button1
2. Je sélectionnez un fichier
3. L'interface graphique cesse de répondre, comme dans quand je clique dessus, rien ne se passe
4. Après quelques secondes, 50% apparaît dans la zone de texte En outre, les résultats de la réalisation. Voir mon commentaire à la question que je Marquée comme la solution
5. Après une seconde ou avec l'interface graphique ne répond pas en entre elle est remplacée par la réponse

Answer 1

Bien sûr, il est.

Le code fonctionne très bien.

wcUploader.UploadFileAsync(...) initie la requête et l'exécution continue, pendant ce temps la progression est mise à jour dans TextBox1 et à la fin j'obtiens du JSON.

C'est Async. Si vous appelez simplement wcUploader.UploadFile, l'exécution bloquera jusqu'à ce que le fichier ait été téléchargé et vous n'obtiendrez aucun événement de progression.

Bottom line:

L'interface utilisateur est pas bloqué, les progrès événements sont appelés et l'interface utilisateur est mis à jour en temps réel.

Mise à jour:

Pour éliminer le bloc initial lorsque le webclient établit la connexion http, il suffit d'appeler le téléchargement sur un autre fil. Dans ce scénario, vous devez utiliser l'invocation pour éviter des exceptions de fil croisées:

using System; 
using System.Net; 
using System.Text; 
using System.Threading; 
using System.Windows.Forms; 

namespace WindowsFormsApplication1 
{ 
    public partial class Form1 : Form 
    { 
     private readonly WebClient wcUploader = new WebClient(); 

     public Form1() 
     { 
      InitializeComponent(); 

      wcUploader.UploadFileCompleted += UploadFileCompletedCallback; 
      wcUploader.UploadProgressChanged += UploadProgressCallback; 
     } 


     private void UploadFileCompletedCallback(object sender, UploadFileCompletedEventArgs e) 
     { 
      // a clever way to handle cross-thread calls and avoid the dreaded 
      // "Cross-thread operation not valid: Control 'textBox1' accessed 
      // from a thread other than the thread it was created on." exception 

      // this will always be called from another thread, 
      // no need to check for InvokeRequired 
      BeginInvoke(
       new MethodInvoker(() => 
        { 
         textBox1.Text = Encoding.UTF8.GetString(e.Result); 
         button1.Enabled = true; 
        })); 
     } 

     private void UploadProgressCallback(object sender, UploadProgressChangedEventArgs e) 
     { 
      // a clever way to handle cross-thread calls and avoid the dreaded 
      // "Cross-thread operation not valid: Control 'textBox1' accessed 
      // from a thread other than the thread it was created on." exception 

      // this will always be called from another thread, 
      // no need to check for InvokeRequired 

      BeginInvoke(
       new MethodInvoker(() => 
        { 
         textBox1.Text = (string)e.UserState + "\n\n" 
             + "Uploaded " + e.BytesSent + "/" + e.TotalBytesToSend 
             + "b (" + e.ProgressPercentage + "%)"; 
        })); 
     } 

     private void button1_Click(object sender, EventArgs e) 
     { 
      textBox1.Text = ""; 

      if (openFileDialog1.ShowDialog() == DialogResult.OK) 
      { 
       button1.Enabled = false; 
       string toUpload = openFileDialog1.FileName; 
       textBox1.Text = "Initiating connection"; 
       new Thread(() => 
          wcUploader.UploadFileAsync(new Uri("http://anyhub.net/api/upload"), "POST", toUpload)).Start(); 
      } 
     } 
    } 
} 

Answer 2

Il y a un bug dans votre code qui vaut la fixation de toute façon, quel que soit le verrouillage de l'interface utilisateur:

Vous spécifiez deux callbacks qui asynchrone l'uploader devrait se déclencher. Dans ces rappels, vous serez en cours d'exécution sur le fil de l'uploader; Cependant, vous ne pouvez toucher l'interface graphique que depuis le thread principal de l'interface graphique. Vos rappels peuvent donc corrompre l'état de l'interface graphique.

Vous ne devez pas toucher textBox1.Text dans les deux rappels. Il est peu probable que ce soit le problème, mais néanmoins, vous devriez le réparer pour éviter les bugs de crash et de corruption. La question que vous avez liée illustre une façon d'éviter cela: vérifier la propriété Control.InvokeRequired du formulaire (dans les coulisses, cela vérifie si vous êtes sur le bon thread), ou simplement supposer qu'une invocation est requise et ensuite - utiliser Control.BeginInvoke pour déclencher une méthode sur le fil de l'interface graphique.

N'importe lequel de vos contrôles fera car ils s'exécutent tous dans le même thread; donc if (textBox1.InvokeRequired) textBox1.BeginInvoke... est aussi bon que if (this.InvokeRequired) this.BeginInvoke...