Comment utiliser la barre de progression WinForms ?

Question

Je veux montrer la progression des calculs, qui sont effectués dans une bibliothèque externe.

Par exemple, si j'ai une méthode de calcul, et que je veux l'utiliser pour 100000 valeurs dans ma classe Form, je peux écrire :

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

    private void Caluculate(int i)
    {
        double pow = Math.Pow(i, i);
    }

    private void button1_Click(object sender, EventArgs e)
    {
        progressBar1.Maximum = 100000;
        progressBar1.Step = 1;

        for(int j = 0; j < 100000; j++)
        {
            Caluculate(j);
            progressBar1.PerformStep();
        }
    }
}

Je dois effectuer une étape après chaque calcul. Mais que se passe-t-il si j'effectue les 100 000 calculs dans une méthode externe ? Quand dois-je "exécuter l'étape" si je ne veux pas que cette méthode dépende de la barre de progression ? Je peux, par exemple, écrire

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

    private void CaluculateAll(System.Windows.Forms.ProgressBar progressBar)
    {
        progressBar.Maximum = 100000;
        progressBar.Step = 1;

        for(int j = 0; j < 100000; j++)
        {
            double pow = Math.Pow(j, j); //Calculation
            progressBar.PerformStep();
        }
    }

    private void button1_Click(object sender, EventArgs e)
    {
        CaluculateAll(progressBar1);
    }
}

mais je ne veux pas faire ça.

Answer 1

Je vous suggère de jeter un coup d'œil à Travailleur d'arrière-plan . Si vous avez une boucle aussi grande dans votre WinForm, elle se bloquera et votre application aura l'air d'être suspendue.

Regardez BackgroundWorker.ReportProgress() pour voir comment rapporter la progression au thread de l'interface utilisateur.

Par exemple :

private void Calculate(int i)
{
    double pow = Math.Pow(i, i);
}

private void button1_Click(object sender, EventArgs e)
{
    progressBar1.Maximum = 100;
    progressBar1.Step = 1;
    progressBar1.Value = 0;
    backgroundWorker.RunWorkerAsync();
}

private void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
    var backgroundWorker = sender as BackgroundWorker;
    for (int j = 0; j < 100000; j++)
    {
        Calculate(j);
        backgroundWorker.ReportProgress((j * 100) / 100000);
    }
}

private void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
    progressBar1.Value = e.ProgressPercentage;
}

private void backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    // TODO: do something with final calculation.
}

Answer 2

Depuis .NET 4.5, vous pouvez utiliser une combinaison de asynchrone y attendre con Progrès pour l'envoi des mises à jour au fil de l'interface utilisateur :

private void Calculate(int i)
{
    double pow = Math.Pow(i, i);
}

public void DoWork(IProgress<int> progress)
{
    // This method is executed in the context of
    // another thread (different than the main UI thread),
    // so use only thread-safe code
    for (int j = 0; j < 100000; j++)
    {
        Calculate(j);

        // Use progress to notify UI thread that progress has
        // changed
        if (progress != null)
            progress.Report((j + 1) * 100 / 100000);
    }
}

private async void button1_Click(object sender, EventArgs e)
{
    progressBar1.Maximum = 100;
    progressBar1.Step = 1;

    var progress = new Progress<int>(v =>
    {
        // This lambda is executed in context of UI thread,
        // so it can safely update form controls
        progressBar1.Value = v;
    });

    // Run operation in another thread
    await Task.Run(() => DoWork(progress));

    // TODO: Do something after all calculations
}

Les tâches sont actuellement le moyen privilégié pour mettre en œuvre ce que les BackgroundWorker fait.

Tâches et Progress sont expliqués plus en détail ici :

• Async dans 4.5 : Activation de la progression et de l'annulation dans les API asynchrones
• Rapport d'avancement des tâches asynchrones par Stephen Cleary
• La bibliothèque de tâches parallèles remplace-t-elle BackgroundWorker ?

Answer 3

Voici un tutoriel utile sur les perles Dot Net : http://www.dotnetperls.com/progressbar

En accord avec Peter, vous devez utiliser une certaine quantité de threading ou le programme se bloquera, ce qui va à l'encontre du but recherché.

Exemple qui utilise ProgressBar et BackgroundWorker : C#

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

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

        private void Form1_Load(object sender, System.EventArgs e)
        {
            // Start the BackgroundWorker.
            backgroundWorker1.RunWorkerAsync();
        }

        private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            for (int i = 1; i <= 100; i++)
            {
                // Wait 100 milliseconds.
                Thread.Sleep(100);
                // Report progress.
                backgroundWorker1.ReportProgress(i);
            }
        }

        private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            // Change the value of the ProgressBar to the BackgroundWorker progress.
            progressBar1.Value = e.ProgressPercentage;
            // Set the text.
            this.Text = e.ProgressPercentage.ToString();
        }
    }
} //closing here

Answer 4

Il y a Task existe, c'est une absurdité d'utiliser BackgroundWorker , Task est plus simple. par exemple :

ProgressDialog.cs :

   public partial class ProgressDialog : Form
    {
        public System.Windows.Forms.ProgressBar Progressbar { get { return this.progressBar1; } }

        public ProgressDialog()
        {
            InitializeComponent();
        }

        public void RunAsync(Action action)
        {
            Task.Run(action);
        }
    }

C'est fait ! Vous pouvez alors réutiliser ProgressDialog n'importe où :

var progressDialog = new ProgressDialog();
progressDialog.Progressbar.Value = 0;
progressDialog.Progressbar.Maximum = 100;

progressDialog.RunAsync(() =>
{
    for (int i = 0; i < 100; i++)
    {
        Thread.Sleep(1000)
        this.progressDialog.Progressbar.BeginInvoke((MethodInvoker)(() => {
            this.progressDialog.Progressbar.Value += 1;
        }));
    }
});

progressDialog.ShowDialog();