Meilleure façon d'exécuter simultanément plusieurs flux de travail dans WF 4.0

Question

J'ai une routine qui crée n instances d'un flux de travail particulier et les exécute chacune en série. Comment pourrais-je les renvoyer asynchrones?

p-code actuel:

forloop

// Création var SyncEvent = new AutoResetEvent (false); WorkflowInstance myInstance = new WorkflowInstance (nouveaux paramètres SomeWorkflow());

  // Events 

      // Completed 
      myInstance.OnCompleted = delegate(WorkflowCompletedEventArgs e) { syncEvent.Set(); }; 

      // Unhandled Exception 
      myInstance.OnUnhandledException = delegate(WorkflowUnhandledExceptionEventArgs e) 
      { 
       // Message 
       Console.WriteLine(e.UnhandledException.ToString()); 
       return UnhandledExceptionAction.Terminate; 
      }; 

      // Aborted 
      myInstance.OnAborted = delegate(WorkflowAbortedEventArgs e) 
      { 
       // Message 
       Console.WriteLine(e.Reason); 
       syncEvent.Set(); 
      }; 

      // Run 
      myInstance.Run(); 

      // Wait 
      syncEvent.WaitOne(); 

Answer 1

Je pense que la meilleure façon d'obtenir d'ici à là serait juste pour créer plusieurs poignées d'attente et se terminent par un WaitAll(). Pas la solution la plus élégante, mais cela fonctionnera pour vous. BTW, je recommanderais d'utiliser une classe réelle qui contient une référence à la poignée d'attente associée et d'éviter les méthodes anon.

 List<ManualResetEvent> items = new List<ManualResetEvent>(); 

     foreach (Type job in queue) 
     { 
      WorkflowInstance myInstance = new WorkflowInstance(job, parameters); 

      ManualResetEvent syncEvent = new ManualResetEvent(false); 
      items.Add(syncEvent); 

      // Completed 
      myInstance.OnCompleted = delegate(WorkflowCompletedEventArgs e) 
      { 
       syncEvent.Set(); 
      }; 
      // Unhandled Exception 
      myInstance.OnUnhandledException = delegate(WorkflowUnhandledExceptionEventArgs e) 
      { 
       // Message 
       Console.WriteLine(e.UnhandledException.ToString()); 
       return UnhandledExceptionAction.Terminate; 
      }; 

      // Aborted 
      myInstance.OnAborted = delegate(WorkflowAbortedEventArgs e) 
      { 
       // Message 
       Console.WriteLine(e.Reason); 
       syncEvent.Set(); 
      }; 

      // Run 
      myInstance.Run(); 
     } 

     // Wait 
     WaitHandle.WaitAll(items.ToArray()); 

Answer 2

Utiliser un cadre parallèle, ce sera plus facile.

Answer 3

Avez-vous vraiment besoin qu'ils fonctionnent sur des threads séparés? Je pense que puisque vous utilisez déjà Workflow, il devrait être plus facile de résoudre le problème en utilisant le workflow pour «organiser votre travail».

{ 
    var ArgsToProcess = new List<string> { "arg_one", "arg_two", "arg_three" }; 

    var delegateArg = new DelegateInArgument<string> { Name = "s" }; 

    Activity toRun = new ParallelForEach<string> 
    { 
     Body = new ActivityAction<string> 
     { 
      Argument = delegateArg, 
      Handler = new Workflow1() //Plug your workflow here 
      { 
       Arg = delegateArg 
      } 
     } 
    }; 

    WorkflowInvoker.Invoke(toRun, new Dictionary<string, object> 
     { 
      {"Values", ArgsToProcess} 
     }); 
}