Afficher la barre de progression tout en faisant du travail en C#?

Pour moi, le plus simple est certainement d'utiliser un BackgroundWorker , qui est spécifiquement conçu pour ce genre de tâche. L'événement ProgressChanged est parfaitement adapté pour mettre à jour une barre de progression, sans se soucier des appels de fils croisés

il y a une charge d'informations sur le filetage avec .NET/C# sur Stackoverflow, mais l'article qui a nettoyé les formes de windows threading pour moi était notre oracle résident, Jon Skeet " filetage dans les formes de fenêtres " .

toute la série vaut la peine d'être lue pour parfaire vos connaissances ou apprendre à partir de zéro.

je suis impatient, montre moi un peu de code

autant Que "montrer moi le code " va, ci-dessous est comment je le ferais avec C# 3.5. Le formulaire contient 4 contrôles:

"1519150920 une" zone de texte
• progressbar
• 2 boutons: "buttonLongTask" et "buttonAnother"

buttonAnother est là purement pour démontrer que L'UI n'est pas bloqué pendant que la tâche compte-à-100 est en cours.

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    private void buttonLongTask_Click(object sender, EventArgs e)
    {
        Thread thread = new Thread(LongTask);
        thread.IsBackground = true;
        thread.Start();
    }

    private void buttonAnother_Click(object sender, EventArgs e)
    {
        textBox1.Text = "Have you seen this?";
    }

    private void LongTask()
    {
        for (int i = 0; i < 100; i++)
        {
            Update1(i);
            Thread.Sleep(500);
        }
    }

    public void Update1(int i)
    {
        if (InvokeRequired)
        {
            this.BeginInvoke(new Action<int>(Update1), new object[] { i });
            return;
        }

        progressBar1.Value = i;
    }
}

et un autre exemple que le travailleur de fond est la bonne façon de le faire...

using System;
using System.ComponentModel;
using System.Threading;
using System.Windows.Forms;

namespace SerialSample
{
    public partial class Form1 : Form
    {
        private BackgroundWorker _BackgroundWorker;
        private Random _Random;

        public Form1()
        {
            InitializeComponent();
            _ProgressBar.Style = ProgressBarStyle.Marquee;
            _ProgressBar.Visible = false;
            _Random = new Random();

            InitializeBackgroundWorker();
        }

        private void InitializeBackgroundWorker()
        {
            _BackgroundWorker = new BackgroundWorker();
            _BackgroundWorker.WorkerReportsProgress = true;

            _BackgroundWorker.DoWork += (sender, e) => ((MethodInvoker)e.Argument).Invoke();
            _BackgroundWorker.ProgressChanged += (sender, e) =>
                {
                    _ProgressBar.Style = ProgressBarStyle.Continuous;
                    _ProgressBar.Value = e.ProgressPercentage;
                };
            _BackgroundWorker.RunWorkerCompleted += (sender, e) =>
            {
                if (_ProgressBar.Style == ProgressBarStyle.Marquee)
                {
                    _ProgressBar.Visible = false;
                }
            };
        }

        private void buttonStart_Click(object sender, EventArgs e)
        {
            _BackgroundWorker.RunWorkerAsync(new MethodInvoker(() =>
                {
                    _ProgressBar.BeginInvoke(new MethodInvoker(() => _ProgressBar.Visible = true));
                    for (int i = 0; i < 1000; i++)
                    {
                        Thread.Sleep(10);
                        _BackgroundWorker.ReportProgress(i / 10);
                    }
                }));
        }
    }
}

en Effet, vous êtes sur la bonne voie. Vous devriez utiliser un autre fil, et vous avez identifié les meilleures façons de le faire. Le reste n'est qu'une mise à jour de la barre de progression. Dans le cas où vous ne voulez pas utiliser BackgroundWorker comme d'autres l'ont suggéré, il y a un truc à garder à l'esprit. L'astuce est que vous ne pouvez pas mettre à jour la barre de progression à partir du thread worker car L'UI ne peut être manipulée qu'à partir du thread UI. Vous utilisez donc la méthode Invoke. Il va quelque chose comme ceci (corriger les erreurs de syntaxe vous-même, j'écris juste un exemple rapide):

class MyForm: Form
{
    private void delegate UpdateDelegate(int Progress);

    private void UpdateProgress(int Progress)
    {
        if ( this.InvokeRequired )
            this.Invoke((UpdateDelegate)UpdateProgress, Progress);
        else
            this.MyProgressBar.Progress = Progress;
    }
}

la propriété InvokeRequired retournera true sur chaque fil sauf celui qui possède le formulaire. La méthode Invoke appellera la méthode sur le thread de L'interface utilisateur, et bloquera jusqu'à ce qu'elle soit terminée. Si vous ne voulez pas bloquer, vous pouvez appeler BeginInvoke à la place.

BackgroundWorker n'est pas la réponse parce qu'il se peut que je n'obtienne pas la notification de progrès...

qu'est-ce que le fait que vous ne receviez pas de notification de progrès a à voir avec l'utilisation de BackgroundWorker ? Si votre tâche de longue date ne dispose pas d'un mécanisme fiable pour rendre compte de ses progrès, il n'y a aucun moyen de rendre compte de manière fiable de ses progrès.

la façon la plus simple possible de rendre compte des progrès d'un long-running method est d'exécuter la méthode sur le thread D'UI et de lui faire rapport de progrès en mettant à jour la barre de progression et en appelant ensuite Application.DoEvents() . Ce sera, techniquement, le travail. Mais L'interface utilisateur ne répondra pas entre les appels à Application.DoEvents() . C'est la solution rapide et sale, et comme le remarque Steve McConnell, le problème avec les solutions rapides et Sales est que l'amertume de la sale reste longtemps après la douceur du rapide est oublié.

le suivant le plus simple manière, comme indiqué par une autre affiche, est d'implémenter une forme modale qui utilise un BackgroundWorker pour exécuter la méthode à long terme. Cela fournit généralement une meilleure expérience utilisateur, et cela vous libère d'avoir à résoudre le problème potentiellement compliqué de quelles parties de votre UI laisser fonctionnelle pendant que la tâche à long terme est l'exécution-alors que la forme modale est ouverte, aucun du reste de votre UI ne répondra aux actions de l'utilisateur. C'est rapide et propre solution.

Mais c'est quand même assez hostile aux utilisateurs. Il bloque toujours L'interface utilisateur pendant que la tâche à long terme est en cours d'exécution; il le fait simplement d'une jolie manière. Pour faire une solution conviviale, vous devez exécuter la tâche dans un autre thread. La façon la plus facile de le faire est avec un BackgroundWorker .

Cette approche ouvre la porte à beaucoup de problèmes. Ça ne "fuira" pas, peu importe ce que ça veut dire. Mais quelle que soit la méthode utilisée de longue date, elle doit maintenant le faire en totale isolement par rapport à les pièces de L'interface qui restent activées pendant qu'elle est en cours d'exécution. Et par complet, je veux dire complet. Si l'utilisateur peut cliquer n'importe où avec une souris et provoquer une mise à jour vers un objet que votre méthode de longue durée ne regarde jamais, vous aurez des problèmes. Tout objet que votre méthode de longue durée utilise qui peut soulever un événement est une route potentielle à la misère.

C'est ça, et ne pas obtenir BackgroundWorker pour fonctionner correctement, ça va être la source de toute la douleur.

j'ai jeter la réponse la plus simple là-bas. Vous pouvez toujours juste mettre en œuvre la barre de progrès et n'avoir aucun rapport avec quoi que ce soit de progrès réel. Il suffit de commencer à remplir la barre dire 1% par seconde, ou 10% par seconde ce qui semble similaire à votre action et si elle se remplit pour recommencer.

Cela donnera au moins à l'utilisateur l'apparence du traitement et leur fera comprendre d'attendre au lieu de simplement cliquer sur un bouton et de voir rien se produire puis en cliquant il plus.

voici un autre exemple de code pour utiliser BackgroundWorker pour mettre à jour ProgressBar , il suffit d'ajouter BackgroundWorker et Progressbar à votre formulaire principal et utiliser le code ci-dessous:

public partial class Form1 : Form
{
    public Form1()
    {
      InitializeComponent();
      Shown += new EventHandler(Form1_Shown);

    // To report progress from the background worker we need to set this property
    backgroundWorker1.WorkerReportsProgress = true;
    // This event will be raised on the worker thread when the worker starts
    backgroundWorker1.DoWork += new DoWorkEventHandler(backgroundWorker1_DoWork);
    // This event will be raised when we call ReportProgress
    backgroundWorker1.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker1_ProgressChanged);
}
void Form1_Shown(object sender, EventArgs e)
{
    // Start the background worker
    backgroundWorker1.RunWorkerAsync();
}
// On worker thread so do our thing!
void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
    // Your background task goes here
    for (int i = 0; i <= 100; i++)
    {
        // Report progress to 'UI' thread
        backgroundWorker1.ReportProgress(i);
        // Simulate long task
        System.Threading.Thread.Sleep(100);
    }
}
// Back on the 'UI' thread so we can update the progress bar
void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
    // The progress percentage is a property of e
    progressBar1.Value = e.ProgressPercentage;
}
}

réference: from codeproject

utilise le composant BackgroundWorker il est conçu pour exactement ce scénario.

vous pouvez vous connecter à ses événements progress update et mettre à jour votre barre de progression. La classe BackgroundWorker garantit que les callbacks sont placés dans le thread de L'interface utilisateur, de sorte que vous n'avez pas à vous soucier de ces détails non plus.

lire vos exigences la façon la plus simple serait d'afficher une forme sans mode et d'utiliser un système standard.Windows.Forms timer pour mettre à jour la progression sur le mode-less form. Pas de fils, pas de possibles fuites de mémoire.

comme ceci n'utilise qu'un seul thread, vous devez aussi appeler Application.DoEvents () à certains moments de votre traitement principal pour garantir que la barre de progression est mise à jour visuellement.

Re: Votre montage. Vous avez besoin d'un BackgroundWorker ou D'un Thread pour faire le travail, mais il doit appeler ReportProgress() périodiquement pour dire au thread QU'il fait. DotNet ne peut pas calculer comme par magie la quantité de travail que vous avez fait, vous devez donc lui dire (a) Quel est le montant maximum de progrès que vous atteindrez, et (b) environ 100 fois au cours du processus, lui dire quel montant vous êtes prêt. (Si vous signalez des progrès moins de 100 fois, la barre de progression sautera par grands pas. Si vous rapport de plus de 100 fois, vous serez juste de gaspiller du temps à essayer de rapport d'une manière plus fine que la barre de progression sera utilement affichage)

si votre fil D'UI peut continuer pendant que le travailleur d'arrière-plan est en cours d'exécution, alors votre travail est fait.

cependant, de façon réaliste, dans la plupart des situations où l'indication de progrès doit être en cours d'exécution, votre UI doit être très prudent pour éviter un appel de rentrée. par exemple, si vous utilisez un affichage de progression en exportant des données, vous ne voulez pas permettre à l'utilisateur de recommencer à exporter des données alors que l'exportation est en cours.

Vous pouvez gérer cela de deux façons:

• l'opération d'exportation vérifie si le travailleur d'arrière-plan est en cours d'exécution, et a désactivé l'option d'exportation alors qu'il importe déjà. Cela permettra à l'utilisateur de faire n'importe quoi dans votre programme sauf exporter - cela pourrait encore être dangereux si l'utilisateur pourrait (par exemple) de modifier les données exportées.

• exécutez la barre de progression comme un affichage "modal" de sorte que votre programme se réalimente "alive" pendant l'exportation, mais l'utilisateur ne peut pas réellement faire quoi que ce soit (autre que d'annuler) jusqu'à ce que l'exportation complète. DotNet est nul à soutenir cela, même si c'est l'approche la plus courante. Dans ce cas, vous devez mettre le fil UI dans une boucle d'attente occupée où il appelle Application.DoEvents () pour garder le message gestion de l'exécution (de sorte que la barre de progression fonctionnera), mais vous devez ajouter un filtre de messagerie qui ne permet à votre application de répondre à des événements "sûrs" (par exemple, il permettrait aux événements de peinture de sorte que votre application windows continue à redessiner, mais il filtrerait les messages de la souris et du clavier de sorte que l'utilisateur ne peut pas réellement faire quoi que ce soit dans le proigram pendant que l'exportation est en cours. Il ya aussi un couple de messages sournois que vous aurez besoin de passer à travers pour permettre à la fenêtre de fonctionner comme d'habitude, et de calcul ces de prendre quelques minutes - j'ai une liste d'entre eux au travail, mais ne pas les avoir à part ici, je le crains. Ce sont tous les évidents comme NCHITTEST plus un .net un sournois (evilly dans la gamme WM_USER) qui est essentiel pour obtenir ce fonctionnement).

le dernier" gotcha "avec l'horrible barre de progression dotNet est que lorsque vous terminez votre opération et fermez la barre de progression, vous constaterez qu'elle disparaît généralement lorsque vous déclarez une valeur comme"80%". Même si vous le forcer à 100% et attendez environ une demi-seconde, il pourrait ne pas atteindre les 100%. Arrrgh! La solution est de définir l'état d'avancement à 100%, à 99%, puis à 100% - lorsque la barre de progression est dit d'aller de l'avant, il s'anime lentement vers la valeur cible. Mais si vous lui dites d'aller "vers l'arrière", il saute immédiatement à cette position. Par l'inverser momentanément à la fin, vous pouvez l'obtenir pour réellement montrer la valeur que vous avez demandé.

si vous voulez une barre de progression" rotative", pourquoi ne pas mettre le style de la barre de progression à" Marquee "et utiliser un BackgroundWorker pour garder L'UI responsive? Vous n'obtiendrez pas une barre de progression rotative plus facile que d'utiliser le style "Marquee"...

nous utilisons la forme modale avec BackgroundWorker pour une telle chose.

Voici la solution rapide:

  public class ProgressWorker<TArgument> : BackgroundWorker where TArgument : class 
    {
        public Action<TArgument> Action { get; set; }

        protected override void OnDoWork(DoWorkEventArgs e)
        {
            if (Action!=null)
            {
                Action(e.Argument as TArgument);
            }
        }
    }


public sealed partial class ProgressDlg<TArgument> : Form where TArgument : class
{
    private readonly Action<TArgument> action;

    public Exception Error { get; set; }

    public ProgressDlg(Action<TArgument> action)
    {
        if (action == null) throw new ArgumentNullException("action");
        this.action = action;
        //InitializeComponent();
        //MaximumSize = Size;
        MaximizeBox = false;
        Closing += new System.ComponentModel.CancelEventHandler(ProgressDlg_Closing);
    }
    public string NotificationText
    {
        set
        {
            if (value!=null)
            {
                Invoke(new Action<string>(s => Text = value));  
            }

        }
    }
    void ProgressDlg_Closing(object sender, System.ComponentModel.CancelEventArgs e)
    {
        FormClosingEventArgs args = (FormClosingEventArgs)e;
        if (args.CloseReason == CloseReason.UserClosing)
        {
            e.Cancel = true;
        }
    }



    private void ProgressDlg_Load(object sender, EventArgs e)
    {

    }

    public void RunWorker(TArgument argument)
    {
        System.Windows.Forms.Application.DoEvents();
        using (var worker = new ProgressWorker<TArgument> {Action = action})
        {
            worker.RunWorkerAsync();
            worker.RunWorkerCompleted += worker_RunWorkerCompleted;                
            ShowDialog();
        }
    }

    void worker_RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e)
    {
        if (e.Error != null)
        {
            Error = e.Error;
            DialogResult = DialogResult.Abort;
            return;
        }

        DialogResult = DialogResult.OK;
    }
}

et comment nous l'utilisons:

var dlg = new ProgressDlg<string>(obj =>
                                  {
                                     //DoWork()
                                     Thread.Sleep(10000);
                                     MessageBox.Show("Background task completed "obj);
                                   });
dlg.RunWorker("SampleValue");
if (dlg.Error != null)
{
  MessageBox.Show(dlg.Error.Message, "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
dlg.Dispose();