fils activation C#

Question

i ont ce code en C#:

Thread t1 = new Thread(functionsActivations(3, 4000, 0, 4)); 
Thread t2 = new Thread(functionsActivations(3, 4000, 5, 9)); 
t1.start(); 
t2.Start(); 
Thread t3 = new Thread(functionsActivations(4, 4000, 0, 4)); 
Thread t4 = new Thread(functionsActivations(4, 4000, 5, 9)); 

Il ne fonctionne pas. Comment puis-je lui dire d'appeler la méthode que je lui ai donnée? Deuxièmement, je veux que t3 et t4 soient activés après la fin de t1 et t2. Comment puis je faire ça? Troisièmement, je veux que t1 et t2 ne bloquent pas (de sorte que t2 ne devrait pas attendre jusqu'à la fin de t1). Est ce que j'ai corrigé?

Answer 1

"Cela ne fonctionne pas" n'est pas un ensemble de symptômes très clair. Qu'observez-vous?

EDIT: Bon, maintenant que vous avez dit ce qu'est l'erreur du compilateur, c'est beaucoup plus facile à diagnostiquer. Vous appelez actuellement une méthode et essayez d'utiliser le résultat en tant que tâche à exécuter par le thread. En supposant que vous réellement veulent faire cet appel de la méthode lorsque le thread est démarré, vous voulez quelque chose comme ceci:

C# 2:

Thread t1 = new Thread(delegate() { functionsActivations(3, 4000, 0, 4); }); 

C# 3:

Thread t1 = new Thread(() => functionsActivations(3, 4000, 0, 4)); 

Un altnerative à avoir des expressions lambda partout serait d'écrire une méthode d'utilité:

private static Action DeferFunctionActivations(int a, int b, int c, int d) 
{ 
    return() => functionsActivations(a, b, d, d); 
} 

Ensuite, vous pouvez utiliser:

Thread t1 = new Thread(DeferFunctionActivations(3, 4000, 0, 4)); 

etc.

Pour le reste du post, je vais supposer que C# 3.

En outre, t1.start() devrait être t1.Start() - C# est sensible à la casse. Pour répondre à votre dernier point, t1 et t2 sont actuellement indépendants - ils ne se bloqueront pas sauf si vous avez synchronisé quelque part dans le code qu'ils exécutent.

Si vous ne souhaitez que t3 et t4 commencer quand t1 et t2 ont terminé, vous pouvez utiliser Thread.Join:

Thread t1 = new Thread(() => functionsActivations(3, 4000, 0, 4)); 
Thread t2 = new Thread(() => functionsActivations(3, 4000, 5, 9)); 
t1.Start(); 
t2.Start(); 
t1.Join(); 
t2.Join(); 
Thread t3 = new Thread(() => functionsActivations(4, 4000, 0, 4)); 
Thread t4 = new Thread(() => functionsActivations(4, 4000, 5, 9)); 
t3.Start(); 
t4.Start(); 

Notez que cela signifie que ce fil attendra jusqu'à ce que t1 et t2 ont fini, aussi. Si ce n'est pas assez bon pour vous, il existe plusieurs options, mais vous aurez besoin d'autre chose pour attendre de manière asynchrone que t1 et t2 se terminent. Par exemple, vous pouvez attacher un fil supplémentaire pour le faire:

Thread t1 = new Thread(() => functionsActivations(3, 4000, 0, 4)); 
Thread t2 = new Thread(() => functionsActivations(3, 4000, 5, 9)); 
t1.Start(); 
t2.Start(); 
Thread t3 = new Thread(() => functionsActivations(4, 4000, 0, 4)); 
Thread t4 = new Thread(() => functionsActivations(4, 4000, 5, 9)); 
Thread t5 = new Thread(() => 
{ 
    t1.Join(); 
    t2.Join(); 
    t3.Start(); 
    t4.Start(); 
}); 
t5.Start(); 

Un peu dégueu, mais cela devrait fonctionner.

Pouvez-vous utiliser .NET 4.0? Si c'est le cas, le framework Parallel Extensions rend beaucoup plus facile cette opération.