De la tâche.Usine.StartNew(someMethod(withParam)).continueWith(sameMethod(differentParam)).Wait()

Quelle est la bonne syntaxe pour paralléliser le code suivant?

static void Main(string[] args)
{
    Task.Factory.StartNew(
        () =>
            doOne(SelectedTask.option1)
           .ContinueWith(
            task => 
            doOne(SelectedTask.option1)).Wait()
   ); 
}

Même méthode avec enum "selectedTask" pour déterminer le code à exécuter :

static enum SelectedTask
{
    option1,
    option2
}

static void doOne(SelectedTask Lunch)
{ 
    switch (lunch)
    {
        case SelectedTask.option1:
            Console.WriteLine("option1");
            break;
        case SelectedTask.option2:
            Console.WriteLine("option2");
            break;
        default:
            break;
    }
}
InformationsquelleAutor LoneXcoder | 2012-11-20
  1. 17

    Voulez-vous votre doOne appels à se produire en même temps? Ensuite, vous pouvez commencer directement à partir de la tâche de l'usine:

    //Start two concurrent tasks
var task1 = Task.Factory.StartNew(() => doOne(SelectedTask.option1));
var task2 = Task.Factory.StartNew(() => doOne(SelectedTask.option2));

//Block the current thread until all tasks complete
Task.WaitAll(task1, task2);

    Voulez-vous votre doOne appels à se produire de façon séquentielle? Ensuite, vous pouvez la chaîne d'eux à l'aide de ContinueWith:

    //Start a chain of tasks
var task1 = Task.Factory.StartNew(() => doOne(SelectedTask.option1));
var task2 = task1.ContinueWith(t => doOne(SelectedTask.option2));

//Block the current thread until the last task completes
task2.Wait();

    Le code dans le titre de votre post (avec quelques corrections) est essentiellement d'effectuer exactement la même fonction que mon séquentielle des tâches de la chaîne ci-dessus:

    Task.Factory.StartNew(() => doOne(SelectedTask.option1))
            .ContinueWith(t => doOne(SelectedTask.option2))
            .Wait();

    Réponse à votre question ci-dessous.

    Si je comprends bien, vous voulez être en mesure d'exécuter une tâche pour une liste de variables de SelectedTasks en parallèle:

    List<SelectedTask> selectedTaskOptions = new List<SelectedTask>()
{
    SelectedTask.option1,
    SelectedTask.option2,
    SelectedTask.option3,
    SelectedTask.option4,
    SelectedTask.option5
};

RunAllSelectedTaskOptions(selectedTaskOptions);

    RunAllSelectedTaskOptions à accepter et à exécuter une liste de SelectedTasks:

    public void RunAllSelectedTaskOptions(List<SelectedTask> selectedTaskOptions)
{
    List<Task> createdTasks = new List<Task>();

    foreach(var taskOption in selectedTaskOptions)
    {
        createdTasks.Add(Task.Factory.CreateNew(() => doOne(taskOption)));
    }

    Task.WaitAll(createdTasks);
}

    Un autre mode de mise en œuvre de RunAllSelectedTaskOptions serait d'utiliser Parallel.ForEach, qui vont s'exécuter en parallèle et bloquer jusqu'à ce que le plus lent/dernière itération est terminée:

    public void RunAllSelectedTaskOptions(List<SelectedTask> selectedTaskOptions)
{
    Parallel.ForEach(selectedTaskOptions, taskOption => doOne(taskOption));
}
    • Merci beaucoup, C'(dernier exemple en réponse) Accepte Également les Paramètres passés à doOne(), seulement...pas par l'exécution en parallèle mais dans Une Élégante Ligne de Code, une dernière Question si je peux demander, la seule option pour exécuter des tâches en parallèle serait le premier exemple? qui déclare chaque tâche séparée, déclaration, puis effectuer Task.WaitAll() À tous, connaissez-vous un moyen élégant pour prendre une classe qui va avoir de 5 à 10 méthodes comme (variante 1,2 3 4...) et d'exécuter le tas, l'avenir est d'avoir au moins 10 d'entre eux (n'a pas d'importance sera dans une classe ou pas (peut-être si nous choisissons) pourrait-il être fait?
    • Mise à jour de ma réponse! 🙂
    • ressemble beaucoup vais vérifier ça !! (tu savais que je suis en utilisant le protocole enum comme paramètre un peu sélecteur..)
    • désolé j'ai oublié, j'ai écrit tout le code dans mon post ... y compris la enum(:
    InformationsquelleAutor Dave New
  2. 1

    Je suppose que vous parlez de la parallélisation les deux doOne appels?

    Si oui, alors vous devez faire quelque chose comme ceci:

    var task1 = Task.Factory.StartNew(() => doOne(SelectedTask.option1));
var task2 = Task.Factory.StartNew(() => doOne(SelectedTask.option2));
var taskList = new List<Task>{task1, task2};
Task.WaitAll(taskList);

    *Le code ci-dessus est assez précise, mais la syntaxe n'a pas été validé.

    • donc je suppose que la Task.Factory est limitée à vide(pas de paramètres) des méthodes , et à l'aide d'une Liste<tâches> va se comporter de la même manière que Task.Factory.StartNew(), seulement differece est avec le code dans votre réponse, il vous permet de passer des paramètres à la méthode ?
    • la seule chose que vous n'obtenez pas précis, c'est ToArray() sur votre WaitAll ...paramètre peut seulement être ensemble plutôt que de dresser la liste
    • Vous pouvez passer des paramètres, soit par l'intermédiaire d'un dispositif de fermeture (mais vous devez le faire avec prudence) ou par l'intermédiaire de la version générique de StartNew de l'action: msdn.microsoft.com/en-us/library/dd321456.aspx
    InformationsquelleAutor Justin Pihony