Discussion :

[Invité]

J'essaie de faire une petite application multithreading afin de pouvoir mieux comprendre comment ça fonctionne. Néanmoins, bien que je commence à être pas si mal niveau compréhension, je n'arrive toujours pas à faire quelque chose de très simple, c'est en fait de créer un nouveau thread .... avec certains paramètres.

En somme, on peut créer une classe ce qui n'est pas un problème, mais comment peut on faire pour envoyer un paramètre à cette classe comme un constructeur ( du genre Maclasse objet = new Maclasse("param1", "param2"); ) J'ai bien pu voir plusieurs tutoriels sur google ou même ici notamment sur le backgroundworker qui semblent intéressant, néanmoins aucun ne traite d'envoyer des paramètres...

[tomlev]

Tu peux utiliser le delegate ParameterizedThreadStart à la place de ThreadStart. Ca ne prend qu'un objet en paramètre, mais tu peux (par exemple) créer une classe qui encapsule les paramètres de ton thread, et passer une instance de cette classe à Thread.Start :

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
 
private void MonThreadStart(object parameter)
{
    MesParametres prm = parameter as MesParametres;
    // le traitement ici
}
 
...
 
public void DemarrerThread()
{
    MesParametres prm = new MesParametres("hello", "world", 42);
    monThread = new Thread(new ParameterizedThreadStart(MonThread));
    monThread.Start(prm);
}

Tu peux aussi utiliser le BackgroundWorker selon le même principe, en passant les paramètres sous forme d'un objet passé à la méthode RunWorkerAsync. C'est un peu plus simple à utiliser qu'un simple thread (à mon avis), notamment si ton thread doit intervenir sur l'interface graphique (qui ne peut être modifiée que par le thread qui l'a créée)

[Invité]

Normalement je vais en faire un service donc le GUI ne seras pas en cause. C'est intéressant à voir cette méthode je vais faire des tests. Par interface on implique autant dos que winforms ?

[tomlev]

Par interface on implique autant dos que winforms ?

Non, seulement les interfaces graphiques (WinForms, WPF), pas la console.

[_skip]

Personnellement je n'apprécie pas trop la méthode proposée par tomlev (bien qu'elle soit pertinente).

Le problème c'est que les paramètres ne sont pas typés, et rien n'est vérifié à la compilation ce qui selon moi, est source potentiel de problèmes de maintenance.
J'ai donc tendance à utiliser cette approche là :

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
 
public class MonThread
{
    string monParam1;
    int monParam2;
 
    public MonThread (string monParam1, int monParam2)
    {
        this.monParam1 = monParam1;
        this.monParam2 = monParam2;
    }
 
    public void Run()
    {
        // utiliser les paramètres ici
    }
}

Puis dans une autre classe :

Code :

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

1
2
3
 
MonThread montrd = new MonThread( "hello", 42);
new Thread (new ThreadStart (montrd.Run)).Start();

Elle permet de passer les paramètres de façon fortement typée...
Une autre solution :

Si tu veux pas passer par un objet externe, tu peux aussi utiliser un delegate pour déclarer une méthode anonyme :

Code :

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

1
2
ThreadStart starter = delegate { Run ("Hello", 42); };
new Thread(starter).Start();

Dans ce cas aussi, le type et le nombre des paramètres sont vérifiés a la compilation, donc si tu changes la méthode exécutée et que les paramètres envoyés ne correspondent plus aux paramètres attendus, tu t'en rends compte plus facilement. Ne sous-estimez jamais l'importance du typage.

[tomlev]

Bonne approche en effet, surtout celle avec le delegate anonyme.
Je me demande s'il n'y aurait pas moyen de faire encore mieux, en utilisant des génériques... je vais y réfléchir

[harz62]

Sa peut marcher je pense si je remplace ceci...

Code :

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

1
2
ThreadStart starter = delegate { Run ("Hello", 42); };
new Thread(starter).Start();

par cela

Code :

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

1
2
 
new Thread(()=>Run("Hello",42)).Start();

Enfin les expressions lambda c'est du C#3, faut voir avec quelle version il travaille...

[tomlev]

Sa peut marcher je pense si je remplace ceci...

Code :

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

1
2
ThreadStart starter = delegate { Run ("Hello", 42); };
new Thread(starter).Start();

par cela

Code :

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

1
2
 
new Thread(()=>Run("Hello",42)).Start();

Enfin les expressions lambda c'est du C#3, faut voir avec quelle version il travaille...

Pas mal aussi... en plus ça reste assez lisible

[harz62]

Je me demande s'il n'y aurait pas moyen de faire encore mieux, en utilisant des génériques... je vais y réfléchir

Peut être en rendant la méthode Run générique, dans ce cas on pourrait avoir une inférence de type lors de l'appel de celle ci

[Invité]

Intéressant. Mais bon je travaille en .Net 2.0 donc le 3 c'est pas pour tout de suite. À moins qu'il n'apporte de significatifs changement niveau performance... à voir. Le fait est que ce sera un service que je vais utilise sur un VPS donc à la limite ça peut être n'importe quelle version mais il faut quand même que le changement en vaille la peine.

[harz62]

Par contre les méthodes anonymes c'est du C#2 donc tu peux utiliser

Il me semble qu'avec la version 2.0 on gagne 3s comparé à du .NET 1.1 alors peut être que C#3 est plus rapide que le 2en tout cas je pense la CLR Performance Team s'y emploie...

[_skip]

Peut être en rendant la méthode Run générique, dans ce cas on pourrait avoir une inférence de type lors de l'appel de celle ci

Oui pour le type des paramètres, mais reste leur nombre...

[Invité]

Et bien tout semble bien fonctionner très bien. Donc [Résolu] !