[Lambda] petit probleme d'ecriture

Version imprimable

bonjour

voila j'ai ce code

Code:

1
2
3
4
5
6
7
8
public delegate void ThreadStackParameter( params object[] o );
 
    public static class XThreadStack
    {
        public static void QueueUserWorkItem(ThreadStackParameter parameters)
        {
        }
    }

Code:

1
2
3
4
5
6
7
 private void button3_Click(object sender, RoutedEventArgs e)
        {           
            for (int i = 0, time = 10; i < 10; i++, time--)
            {
                XThreadStack.QueueUserWorkItem(n);
            }
        }

j'aimerais utiliser une lambda dans XThreadStack.QueueUserWorkItem pour passer i et time
dans le style

Code:

1
2
3
4
 XThreadStack.QueueUserWorkItem((int i, in time) =>
                {
                    // mon code 
                });;

auriez vous une idée pour l'ecrire ?
merci

ceci etant ca marche pas non plus avec

Code:

1
2
3
4
XThreadStack.QueueUserWorkItem(delegate(i, time)
                {
                    // mon code 
                });;

22/01/2013, 11h58
popo
La signature de ton délégué prend en paramètre un tableau d'objet.

Pourquoi essaie-tu d'y passer un entier "n" (car vu le nom il doit s'agir d'un entier) ? Je suis d'ailleurs persuadé que ça ne doit même pas compiler.

Ensuite si le but est de passer deux entiers, autant crée directement un tableau d'entier

Code:

public delegate void ThreadStackParameter( params int[] parameters);
Code:

1 2 int[] parameters= {i, time}; XThreadStack.QueueUserWorkItem(parameters);
ou puisque tu utilise params

Code:

XThreadStack.QueueUserWorkItem(i,time);

Je me trompe peut être mais je ne crois pas qu'on puisse utiliser des expression lambda sur un simple array. D'ailleurs j'avoue que je ne comprends pas trop ton besoin

merci popo en fait j'ai trouvé voici ce que j'ai fait
ton avis m'interresse evidement (j'ai changé le nom de ma classe static)

Code:

1
2
3
4
5
6
7
8
   public delegate void ThreadStackParameter(params object[] o);
 
    public static class ThreadStackManager
    {
        public static void QueueUserWorkItem(ThreadStackParameter parameters, params object[] o)
        {
            parameters(o);
        }

avec

Code:

1
2
3
4
5
6
7
8
  for (int i = 0, time = 10; i < 10; i++, time--)
            {
                ThreadStackManager.QueueUserWorkItem((object[] o) =>
                {
                    // mon code 
                    Add(" I = " + (int)o[0] + " Time = " + (int)o[1]);
                }, i, time); ;
            }

comment tu trouve ?

en fait ce que je veux faire c'est une classe qui empile des thread et les exécute l'un après l'autre avec un ensemble de paramètres ....

j'ai pas trouvé ca dans le framework

22/01/2013, 12h38
Bluedeep

Citation:

Envoyé par ikeas

en fait ce que je veux faire c'est une classe qui empile des thread et les exécute l'un après l'autre avec un ensemble de paramètres ....

j'ai pas trouvé ca dans le framework

Dans ce cas, peut être partir de la classe ThreadPool et développer les fonctionnalités spécifiques.

http://msdn.microsoft.com/fr-fr/libr...(v=vs.80).aspx
22/01/2013, 12h48
popo

+1 pour Bluedeep

ikeas, il ne m'est jamais venu à l'esprit d'utiliser des lambdas avec de simple array. En règle générale, je les utilise sur des structure plus complexes.
Je ne sais pas si tu as absoluement besoin d'avoir un tableau d'objets mais je maintiens que pour ce cas précis, il serait plus simple à lire comme à écrire d'utiliser directement un tableau d'entiers
22/01/2013, 14h45
ikeas

j'ai deja regardé les threadpool
mais ce que je veux faire c'est d’exécuter des tread l'un apres l'autre
par concomitamment (ce que fait le trheadpool)

en fait il me faut une FIFO de thread en etant sur que ceux ci sont executé l'un apres l'autre

popo : en fait je fais une classe qui doit accepter n'importe quoi comme paramatre pour pouvoir etre utilisé par n'importe qui
chacun des thread pouvant avoir des parametres differents
22/01/2013, 15h00
Bluedeep

Citation:

Envoyé par ikeas

j'ai deja regardé les threadpool
mais ce que je veux faire c'est d’exécuter des tread l'un apres l'autre
par concomitamment (ce que fait le trheadpool)

La question qui vient immédiatement à l'esprit est : quel est l'interêt des threads dans ce cas ???? 8O
22/01/2013, 15h05
ikeas

voila j'ai un traitement d'image assez gourmand en temps
je travaille toujours sur la même image de mon UI
je reçois des trames d'image qui me permette de mettre a jour l'image d'origine
si je fais ça sans thread mon interface se bloque souvent
donc des que je reçois une trame, j'ajoute un thread dans mon FIFO
qui sera exécuté l'un après l'autre
comme le traitement n'est jamais d'une durée exactement la même (ça depand essentiellement de la taille de la trame)

si tu connais teamviewer je fais un peu la même chose
22/01/2013, 15h14
Bluedeep

Citation:

Envoyé par ikeas

voila j'ai un traitement d'image assez gourmand en temps
je travaille toujours sur la même image de mon UI
je reçois des trames d'image qui me permette de mettre a jour l'image d'origine
si je fais ça sans thread mon interface se bloque souvent
donc des que je reçois une trame, j'ajoute un thread dans mon FIFO
qui sera exécuté l'un après l'autre
comme le traitement n'est jamais d'une durée exactement la même (ça depand essentiellement de la taille de la trame)

Donc un seul thread secondaire; donc tout ce que tu décrits ne sert à rien.

Citation:

si tu connais teamviewer je fais un peu la même chose

Entendu parler, mais jamais utilisé.

Bref, on ne voit toujours pas pourquoi tu n'emplie pas dans un Queue<T> tes traitements, avec un thread secondaire qui les dépilerait au fur et à mesure. En bref, 10 lignes de code maxi.
22/01/2013, 15h54
ikeas

oui de toute facon dans la classe y'a forcement une Queue
mais comme les fonctions et les paramètres peuvent être différents en fonctions des caractéristiques des images
j'avais pensé que pile de thread c’était sympa

maintenant si tu as du code....

mais si j'ai bien compris tu me suggérerais de faire un thread
qui contiendrais une Queue de par exemple
une classe { metode { get; set;} object[] param { get; set; }}

et dont le thread principale serait de desempiler la queue pour executer chaque fonction aves ses parametres ?

ce qui est embêtant avec la Queue c'est qu'elle dispose pas d'event sur le Enqueue mais bon c de la gestion de thread apres lol
22/01/2013, 15h58
Bluedeep

Citation:

Envoyé par ikeas

oui de toute facon dans la classe y'a forcement une Queue
mais comme les fonctions et les paramètres peuvent être différents en fonctions des caractéristiques des images
j'avais pensé que pile de thread c’était sympa

Il n'y pas possibilité de paramètre différents pour les thread; il y a juste "rien" ou "object".

Citation:

mais si j'ai bien compris tu me suggérerais de faire un thread
qui contiendrais une Queue de par exemple
une classe { metode { get; set;} object[] param { get; set; }}

et dont le thread principale serait de desempiler la queue pour executer chaque fonction aves ses parametres ?

Exactement ce que je te suggère.
22/01/2013, 16h03
ikeas

oui c une bonne idée
c'est d'ailleurs ce que je vais faire
- quand la queue est vide le thread se suspend ou s’arrête, sinon il desempile et execute
- en améliorant le Enqueue pour vérifier si le thread est suspendu ou arrêté et si tel est le cas le reprend ou le relance

je collerais le code ici tu me dirra ce que tu en pense
22/01/2013, 16h14
Babyneedle

En C# 5, il y a le parallelisme qui répond à beaucoup de besoins pour lesquels les threadpools créent trop de 'boilerplate code'.

Programmation asynchrone

Programmation parallèle

Ça a diminué mon code multithread par 95% et c'est beaucoup plus clair.
22/01/2013, 16h15
ikeas

Babyneedle
je veux justement pas utiliser de programmation parallèle
vu qu'ils doivent s'executer l'un apres l'autre

voila ca que ca donne

Code:

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
43
44
45
46
47
48
49
50
51
52
 public delegate void ThreadStackParameter(params object[] o);
 
    public static class ThreadStackManager
    {
        static Thread thread = new Thread(ThreadFunc);
        static Queue<QueueInfo> queue = new Queue<QueueInfo>();
        static object locker = new object();
        static bool IsSuspended = false;
 
        static ThreadStackManager()
        {
            thread.IsBackground = true;
            thread.Start();
        }
 
        public static void QueueUserWorkItem(ThreadStackParameter function, params object[] o)
        {
            lock (locker)
            {
                queue.Enqueue(new QueueInfo { ThreadStackParameter = function, Parameters = o });
                if (IsSuspended)
                {
                    thread.Resume();
                    IsSuspended = false;
                }
            }
        }
 
        private static void ThreadFunc()
        {
            while (true)
            {
                if (queue.Count == 0)
                {
                    lock (locker)
                    {
                        IsSuspended = true;
                    }
                    thread.Suspend();
                }
                QueueInfo qi = queue.Dequeue();
                qi.ThreadStackParameter(qi.Parameters);
            }
        }
 
    }
 
    public class QueueInfo
    {
        public ThreadStackParameter ThreadStackParameter { get; set; }
        public object[] Parameters { get; set; }
    }

avec le code d'excution suivant

Code:

1
2
3
4
5
6
7
8
9
10
11
 for (int i = 0, time = 5; i < 5; i++, time--)
            {
                ThreadStackManager.QueueUserWorkItem((object[] o) =>
                {
                    Add("Start " + (int)o[0]);
                    // mon code 
                    //Add(" I = " + (int)o[0] + " Time = " + (int)o[1]);
                    Thread.Sleep((int)o[1] * 1000);
                    Add("End " + (int)o[0]);
                }, i, time); ;
            }

vous en penser quoi ?

y'a t'il un object plus sympa que le thread a utiliser puisque suspend et resume sont obsolet

Citation:

Envoyé par ikeas

y'a t'il un object plus sympa que le thread a utiliser puisque suspend et resume sont obsolet

Un petit code que j'ai depuis quelques temps. Dans ton cas workerCount = 1

Code:

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
    public abstract class TaskQueue<T> : IDisposable where T : class
    {
        readonly object _locker = new object();
        readonly Thread[] _workers;
        readonly Queue<T> _taskQueue = new Queue<T>();
 
        protected TaskQueue(int workerCount)
        {
            if (workerCount < 1)
                throw new ArgumentOutOfRangeException("workerCount");
 
            _workers = new Thread[workerCount];
 
            // Create and start a separate thread for each worker
            for (int i = 0; i < workerCount; i++)
            {
                _workers[i] = new Thread(Consume);
                _workers[i].Start();
            }
        }
 
        public virtual void Dispose()
        {
            // Enqueue one null obj per worker to make each exit.
            foreach (Thread worker in _workers) EnqueueTask(null);
            foreach (Thread worker in _workers) worker.Join();
        }
 
        public void EnqueueTask(T obj)
        {
            lock (_locker)
            {
                _taskQueue.Enqueue(obj);
                Monitor.PulseAll(_locker);
            }
        }
 
        void Consume()
        {
            while (true)
            {
                T task;
                lock (_locker)
                {
                    while (_taskQueue.Count == 0) Monitor.Wait(_locker);
                    task = _taskQueue.Dequeue();
                }
 
                if (task == null)
                    return; // This signals our exit
 
                Process(task);
            }
        }
 
        public abstract void Process(T obj);
    }

merci

avec

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 public class QueueManager : TaskQueue<QueueInfo>
    {
        public QueueManager()
            : base(1)
        {
        }
 
        public override void Process(QueueInfo qi)
        {
            qi.Function(qi.Parameters);
        }
    }

ca marche tres bien

j'ai toutefois modifié mon QueueInfo pour que l'appel soit plus sympa
donc ca donne

Code:

1
2
3
4
5
6
7
8
9
10
 public class QueueInfo
    {
        public QueueInfo(ThreadStackParameter Function, params object[] Parameters)
        {
            this.Function = Function;
            this.Parameters = Parameters;
        }
        public ThreadStackParameter Function { get; private set; }
        public object[] Parameters { get; private set; }
    }

et l'appel

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
   QueueManager queue = new QueueManager();
        private void button6_Click(object sender, RoutedEventArgs e)
        {
            for (int i = 0, time = 5; i < 5; i++, time--)
            {
                queue.EnqueueTask(
                    new QueueInfo(
                        (object[] o) =>
                            {
                                Add("Start " + (int)o[0]);
                                // mon code 
                                //Add(" I = " + (int)o[0] + " Time = " + (int)o[1]);
                                Thread.Sleep((int)o[1] * 1000);
                                Add("End " + (int)o[0]);
                            },
                         i, time)
                    );
            }
        }