manera más rápida de ejecutar dos tareas de forma asíncrona y esperar hasta que terminan

Question

Está bien que es necesario cambiar este ..

void foo() 
{ 
    DoSomething(1, 0); 
    DoSomething(2, 3); 
} 

a algo como esto ...

void foo() 
{ 
    //this functions is sync.. I need to run them async somehow 
    new Thread(DoSomething(1, 0)); 
    new Thread(DoSomething(2, 3)); 

    //Now I need to wait until both async functions will end 
    WaitUntilBothFunctionsWillEnd(); 
} 

¿Hay una manera de hacerlo esto en Silverlight?

Answer 1

void foo() 
{ 
    var thread1 = new Thread(() => DoSomething(1, 0)); 
    var thread2 = new Thread(() => DoSomething(2, 3)); 

    thread1.Start(); 
    thread2.Start(); 

    thread1.Join(); 
    thread2.Join(); 
} 

El método Thread.Join() bloqueará la ejecución hasta que el subproceso termina, por lo que unirse a ambos hilos se asegurará de que foo() volverá sólo después de los dos hilos han terminado.

Answer 2

Task task1 = Task.Factory.StartNew(() => {DoSomething(1,0);}); 
Task task2 = Task.Factory.StartNew(() => {DoSomething(2,3);}); 
Task.WaitAll(task1,task2); 

Usted tendrá que añadir el paquete Microsoft Async (y es) a cargo de su proyecto de Silverlight.

Answer 3

Aunque el TPL como la respuesta de Ralph sugerida no está disponible en Silverlight, realmente me gusta el modelo de Tarea ... Entonces, ¿por qué no escribir un delicado envoltorio de hilo que funcionaría de manera similar.

using System; 
using System.Threading; 
using System.Linq; 

public class Task { 
    ManualResetEvent _mre = new ManualResetEvent(false); 

    public Task(Action action) { 
     ThreadPool.QueueUserWorkItem((s) => { 
      action(); 
      _mre.Set(); 
     }); 
    } 

    public static void WaitAll(params Task[] tasks) { 
     WaitHandle.WaitAll(tasks.Select(t => t._mre).ToArray()); 
    } 
} 

Posteriormente, se podría utilizar este mucho a la TPL:

int param1 = 1; 
int param2 = 2; 
Task.WaitAll(
    new Task(() => DoSomething(param1, param2)), 
    new Task(() => DoSomething(param1, param2)) 
); 

Debajo de las sábanas Esto pone la responsabilidad en el ThreadPool de limitar los hilos en el sistema a un recuento razonable.