Discussion :

[Shypster]

Quand tu appelles ta fonction run dirrectement ça marche ?

oui quand je l'appelle avec un seul thread ça marche mais quand je lance plusieurs thread dans ma boucle elle n'a pas l'air de s'éxécuter. Est ce que ça peut écraser les threads précédents quand on fait une boucle ?

[smyley]

Non
lance deux thread et regarde pas à pas en debugant ce que ça fait

[SirJulio]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
// acc_config est une instance d'une autre classe
// acc_config.table_appli est un tableau de string contenant des noms 
// de programmes
for (z = 0; z < acc_config.table_appli.Length-1;z++ )
            {
                // on lance les différentes copies
                MethodInvoker met = new MethodInvoker(delegate
                {
                    // func = instance d'une classe
                    // run = procédure publique de cette même classe (copies)
                    // a pour paramètre le nom de l'application
                    func.run(acc_config.table_appli[z]);
                });
                met.BeginInvoke(null, null);
            }

Salut,

Je pense que tu as un probleme de capture de variable, d'ou l'impression, qu'il n'y a pas toutes les variables traitées, c'est le danger du melange thread + iteration + methode anonyme, le temps que le thread demarre concretement ton acc_confog...[i] (et plus precisement le i) ont changé. Essaie comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
for (z = 0; z < acc_config.table_appli.Length-1;z++ )
            {
                // on lance les différentes copies
                MethodInvoker met = new MethodInvoker(delegate
                {
                    // func = instance d'une classe
                    // run = procédure publique de cette même classe (copies)
                    // a pour paramètre le nom de l'application
                    string s = acc_config.table_appli[z];
                    func.run(s);
                });
                met.BeginInvoke(null, null);
            }

On créé un string local, pour forcer la capture à chaque tour de boucle par la methode anonyme. Ca devrait normalement resoudre ton probleme.

Bon courage.

[Shypster]

Salut,

Je pense que tu as un probleme de capture de variable, d'ou l'impression, qu'il n'y a pas toutes les variables traitées, c'est le danger du melange thread + iteration + methode anonyme, le temps que le thread demarre concretement ton acc_confog...[i] (et plus precisement le i) ont changé. Essaie comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
for (z = 0; z < acc_config.table_appli.Length-1;z++ )
            {
                // on lance les différentes copies
                MethodInvoker met = new MethodInvoker(delegate
                {
                    // func = instance d'une classe
                    // run = procédure publique de cette même classe (copies)
                    // a pour paramètre le nom de l'application
                    string s = acc_config.table_appli[z];
                    func.run(s);
                });
                met.BeginInvoke(null, null);
            }

On créé un string local, pour forcer la capture à chaque tour de boucle par la methode anonyme. Ca devrait normalement resoudre ton probleme.

Bon courage.

Salut,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
private void Form1_Load(object sender, EventArgs e)
        {
            Class1 func = new Class1();
 
            for (int z = 0; z <= 2; z++)
            {
                // on lance les différentes copies
                MethodInvoker met = new MethodInvoker(delegate
                {
                    // func = instance d'une classe
                    // run = procédure publique de cette même classe (copies)
                    // a pour paramètre le nom de l'application
                    string s = "C:\\dossier" + z;
                    func.run("F:\\Partage fichiers",s);
                });
                met.BeginInvoke(null, null);
            }
        }

Voilà run() est une fonction qui copie un dossier.
Pour moi le code ci-dessus devrait me créer systématiquement 3 dossiers dans "C:\\" avec le contenu de "F:\\Partage fichiers" : Dossier0, Dossier1 et Dossier2.

En pratique, ce n'est pas le cas ça me crée aléatoirement les dossiers voulus c'est à dire que je peux avoir que dossier0 et dossier2 ou alors dossier3 qui n'a pas lieu d'être. Je te rejoins en disant que la variable z ne doit pas avoir le temps de bien s'incrémenter on dirait. Le fait que j'appelle la même fonction peut perturber le travail simultané de plusieurs threads. Je ne comprends pas ce qui se passe.

Merci en tout cas pour ton aide.

[smyley]

essayes de séparer dans une autre fonction pour voir

Code c# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
for (z = 0; z < acc_config.table_appli.Length-1;z++ )
            {
              BiduleTruc(z, acc_config.table_appli[z]);
 
            }
...
void BiduleTruc(int z,string s)
{
// on lance les différentes copies
                MethodInvoker met = new MethodInvoker(delegate
                {
                    // func = instance d'une classe
                    // run = procédure publique de cette même classe (copies)
                    // a pour paramètre le nom de l'application
                    func.run(s);
                });
                met.BeginInvoke(null, null);
}

[SirJulio]

En pratique, ce n'est pas le cas ça me crée aléatoirement les dossiers voulus c'est à dire que je peux avoir que dossier0 et dossier2 ou alors dossier3 qui n'a pas lieu d'être. Je te rejoins en disant que la variable z ne doit pas avoir le temps de bien s'incrémenter on dirait. Le fait que j'appelle la même fonction peut perturber le travail simultané de plusieurs threads. Je ne comprends pas ce qui se passe.

Salut,

en fait, mon exemple ne t'a pas aidé car il etait faux, desolé.

Pour forcer la capture de la variable, il faut proceder à une assignation à chaque iteration, et en dehors de la methode anonyme.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
private void Form1_Load(object sender, EventArgs e)
        {
            Class1 func = new Class1();
 
            for (int z = 0; z <= 2; z++)
            {
                string s = "C:\\dossier" + z;
                // on lance les différentes copies
                MethodInvoker met = new MethodInvoker(delegate
                {
                    // func = instance d'une classe
                    // run = procédure publique de cette même classe (copies)
                    // a pour paramètre le nom de l'application
                    func.run("F:\\Partage fichiers",s);
                });
                met.BeginInvoke(null, null);
            }
        }

Normalement avec ca, la capture devrait se faire comme il faut, et tu ne devrais plus avoir de resultat aleatoire. La solution de Smyley est tout aussi viable.

Desolé pour l'erreur et bon courage.

[Shypster]

Salut,

Merci vos deux méthodes marchent impec. J'ai une dernière question.
Sur ma form, j'ai un bouton qui lance les threads et deux progressbar pour suivre l'état d'avancement.

Code du lancement des threads :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
private void button1_Click(object sender, EventArgs e)
        {
            List<string> chemin = new List<string>(); 
 
 
            chemin.Add("D:\\x");
            chemin.Add("F:\\y");
 
            for (int z = 0; z == 1; z++)
            {
                string s = "C:\\dossier" + z;
 
                // on lance les différentes copies
                MethodInvoker met = new MethodInvoker(delegate
                {
                    // func = instance d'une classe
                    // run = procédure publique de cette même classe (copies)
                    // a pour paramètre le nom de l'application
 
                        (new Class1()).run(this,chemin[z], s);
 
                });
                met.BeginInvoke(null, null);
            }
        }

Code de la fonction de copie :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
public void run(Form1 status,string sourceDir, string destDir)
        {
            int temp_z = z;
            DirectoryInfo dir = new DirectoryInfo(sourceDir); if (dir.Exists)
            {
                string realDestDir;
                if (dir.Root.Name != dir.Name)
                {
                    realDestDir = Path.Combine(destDir, dir.Name);
                    if (!Directory.Exists(realDestDir))
                        Directory.CreateDirectory(realDestDir);
                }
                else realDestDir = destDir;
                foreach (string d in Directory.GetDirectories(sourceDir))
                    run(status,d, realDestDir);
                foreach (string file in Directory.GetFiles(sourceDir))
                {
 
                    string fileNameDest = Path.Combine(realDestDir, Path.GetFileName(file));
                    //if (!File.Exists(fileNameDest))
 
                    File.Copy(file, fileNameDest, true);
                    FileInfo taille = new FileInfo(file);
 
                    status.Invoke(new MethodInvoker(delegate
                {
                            // fonction qui incrémente la valeur des progressbar
                            status.affiche_progression();
                }));
 
                }
            }
 
        }

Mon objectif étant que dés qu'un thread copie un fichier, il incrémente la progressbar lui correspondant mais comment faire ?

Merci.

[SirJulio]

Salut,

sers toi de la procedure de finalisation des methodes async. L'idée generale :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
    class Program
    {
        delegate string OneStringDel(string s);
 
        static void Main(string[] args)
        {
            for (int i = 0; i < 2; i++)
            {
                OneStringDel del = new OneStringDel(Run);
                del.BeginInvoke(i.ToString(), FinishHim, del);
            }
            Thread.Sleep(5000);
        }
 
        public static string Run(string s)
        {
            Console.WriteLine(s);
            Thread.Sleep(1000);
            return s;
        }
 
        public static void FinishHim(IAsyncResult e)
        {
            OneStringDel del = e.AsyncState as OneStringDel;
            string s = del.EndInvoke(e);
            Console.WriteLine("Operation Terminée : " + s);
        }
    }

La finalisation est appelé une fois que la meth async retourne. Dans ton cas, assigne cette finalisation à une methode de ta form, comme ca tu pourras invoker la barre de progression directement.

[smyley]

Pour pouvoir afficher une barre de progression il faudrait à l'avance que tu énumère le nombre d'étapes qui seront requises afin d'effectuer tes copies. Donc faire deux même récursions. Ce n'est pas ce qu'il y a de mieux. Tu pourrai par exemple faire une première récursion en ajoutant dans une liste les paramètres nécessaires à chaque étape (fichier source, fichier de destination) et faire une deuxième méthode pour parcourir cette liste (et là, tu pourrai avoir une barre de progression).

[Shypster]

Salut,

Salut,

sers toi de la procedure de finalisation des methodes async. L'idée generale :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
    class Program
    {
        delegate string OneStringDel(string s);
 
        static void Main(string[] args)
        {
            for (int i = 0; i < 2; i++)
            {
                OneStringDel del = new OneStringDel(Run);
                del.BeginInvoke(i.ToString(), FinishHim, del);
            }
            Thread.Sleep(5000);
        }
 
        public static string Run(string s)
        {
            Console.WriteLine(s);
            Thread.Sleep(1000);
            return s;
        }
 
        public static void FinishHim(IAsyncResult e)
        {
            OneStringDel del = e.AsyncState as OneStringDel;
            string s = del.EndInvoke(e);
            Console.WriteLine("Operation Terminée : " + s);
        }
    }

La finalisation est appelé une fois que la meth async retourne. Dans ton cas, assigne cette finalisation à une methode de ta form, comme ca tu pourras invoker la barre de progression directement.

Excuse moi mais je n'ai pas compris et je ne vois pas du tout comment implémenter ça.

Pour pouvoir afficher une barre de progression il faudrait à l'avance que tu énumère le nombre d'étapes qui seront requises afin d'effectuer tes copies. Donc faire deux même récursions. Ce n'est pas ce qu'il y a de mieux. Tu pourrai par exemple faire une première récursion en ajoutant dans une liste les paramètres nécessaires à chaque étape (fichier source, fichier de destination) et faire une deuxième méthode pour parcourir cette liste (et là, tu pourrai avoir une barre de progression).

J'ai une procédure qui compte le nombre de fichiers dans les dossiers à copier pour affecter la valeur maximum aux progressbar. Lorsque je copie un fichier, j'incrémente de +1 mes barres de progression. Enfin c'est comme ça que je le voie pour le moment.

[SirJulio]

Bon, tu declenches tes copies asynchrone, jusque la pas de probleme, c'est ce que tu fais depuis le debut, le fait de passer une methode de finalisation permet d'eviter le passage de la form dans la procedure de copie (elle n'a rien à faire la).

Un autre exemple serait peut etre plus parlant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            if (numericUpDown1.Value != 0)
            {
                progressBar1.Step = 100 / (int)numericUpDown1.Value;
 
                for (int i = 0; i < (int)numericUpDown1.Value; i++)
                {
                    MethodInvoker inv = new MethodInvoker(new TaskClass().Run);
                    inv.BeginInvoke(IncrementProgress, null);
                }
            }
        }
 
        public void IncrementProgress(IAsyncResult e)
        {
            if (InvokeRequired)
            {
                this.Invoke(new AsyncCallback(IncrementProgress), e);
                return;
            }
            progressBar1.PerformStep();
        }
    }
 
    class TaskClass
    {
        static int s_i;
 
        public void Run()
        {
            Trace.WriteLine("Job " + (++s_i).ToString() + "!");
            Thread.Sleep(1000);
        }
    }

Ici, j'ai une form avec un bouton, un numericupdown et une progressbar. En cliquant, je lance en parallele le nombre d'operation precisé dans le NUD, en placant le step de la progressbar comme il faut (si j'ai 8 operation je place un step de 100/8, etc ...). Je donne un callback de finalisation sur ma form, et je n'ai plus qu'à invoker ma form pour faire un performstep sur la progressbar.

L'avantage de cela est qu'à aucun moment ma procedure de traitement (Taskclass ici) n'a connu un element graphique, c'est la form qui lance les procedures, et donne la maniere de recuperer leurs finalisations, Taskclass fait juste son boulot, sans consideration pour l'affichage.

Pour note, si tu ne peux pas connaitre le nombre de job à l'avance (et donc tu ne peux pas donner une progression exacte dans ta progressbar), tu peux utiliser une progressbar en marquee (me souviens plus la propriété exacte ...).

[Shypster]

Quelle est l'utilité du "Thread.Sleep(1000);" ?
Sinon j'ai bien compris maintenant et je te remercie pour toutes tes explications.

[smyley]

Simuler une action qui prend du temps.

[Shypster]

Simuler une action qui prend du temps.

Comment ça ?
Je pensais que cela rendait la main au thread principal pendant 1 seconde non ?

[smyley]

Cela bloque le thread appelant cette fonction pendant 1 seconde, ce qui a le même effet qu'une longue opération effectuée par ce même thread pendant 1 seconde ...

[Shypster]

Bon, tu declenches tes copies asynchrone, jusque la pas de probleme, c'est ce que tu fais depuis le debut, le fait de passer une methode de finalisation permet d'eviter le passage de la form dans la procedure de copie (elle n'a rien à faire la).

Un autre exemple serait peut etre plus parlant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            if (numericUpDown1.Value != 0)
            {
                progressBar1.Step = 100 / (int)numericUpDown1.Value;
 
                for (int i = 0; i < (int)numericUpDown1.Value; i++)
                {
                    MethodInvoker inv = new MethodInvoker(new TaskClass().Run);
                    inv.BeginInvoke(IncrementProgress, null);
                }
            }
        }
 
        public void IncrementProgress(IAsyncResult e)
        {
            if (InvokeRequired)
            {
                this.Invoke(new AsyncCallback(IncrementProgress), e);
                return;
            }
            progressBar1.PerformStep();
        }
    }
 
    class TaskClass
    {
        static int s_i;
 
        public void Run()
        {
            Trace.WriteLine("Job " + (++s_i).ToString() + "!");
            Thread.Sleep(1000);
        }
    }

Ici, j'ai une form avec un bouton, un numericupdown et une progressbar. En cliquant, je lance en parallele le nombre d'operation precisé dans le NUD, en placant le step de la progressbar comme il faut (si j'ai 8 operation je place un step de 100/8, etc ...). Je donne un callback de finalisation sur ma form, et je n'ai plus qu'à invoker ma form pour faire un performstep sur la progressbar.

L'avantage de cela est qu'à aucun moment ma procedure de traitement (Taskclass ici) n'a connu un element graphique, c'est la form qui lance les procedures, et donne la maniere de recuperer leurs finalisations, Taskclass fait juste son boulot, sans consideration pour l'affichage.

Pour note, si tu ne peux pas connaitre le nombre de job à l'avance (et donc tu ne peux pas donner une progression exacte dans ta progressbar), tu peux utiliser une progressbar en marquee (me souviens plus la propriété exacte ...).

Salut,

J'ai implémenté ton code mais cela est viable pour une progressbar globale à tous les threads alors que moi dans l'idéal je voudrais pouvoir afficher une progressbar pour chaque thread qui est lancé dans ma boucle "For". En tout cas ton code est trés intéressant car je ne connaissais pas du tout cette méthode.

Merci.

[mikyfpc]

Bonjour,

Je ne suis pas sur que lancer plusieurs copies simultanéees soit une bonne idée, ca ralentira le traitement de copie.

Faire cela peut-être valable pour une copie vers un FTP, mais de disque à disque ce n'est pas valable.

Mickaël