C# 在WF 4.0中并发运行多个工作流的最佳方法

我有一个例程，它创建一个特定工作流的n个实例，并连续运行它们。我怎样才能异步启动它们

当前p代码：

前环

//创造 var syncEvent=新的自动重置事件（false）； WorkflowInstance myInstance=新的WorkflowInstance（新的SomeWorkflow（），参数）

---

我认为从这里到那里最简单的方法就是创建多个等待句柄并以WaitAll（）结束。这不是最优雅的解决方案，但它会对您有效。顺便说一句，我建议使用一个真正的类来保存对相关等待句柄的引用，并避免使用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());

List items=newlist（）；
foreach（在队列中键入作业）
{
WorkflowInstance myInstance=新的WorkflowInstance（作业，参数）；
ManualResetEvent syncEvent=新的ManualResetEvent（错误）；
添加（同步事件）；
//完成
myInstance.OnCompleted=委托（WorkflowCompletedEventArgs e）
{ 
syncEvent.Set（）；
};
//未处理的异常
myInstance.OnUnhandledException=委托（WorkflowUnhandledExceptionEventArgs e）
{
//信息
Console.WriteLine（例如UnhandledException.ToString（））；
返回未处理的异常操作。终止；
};
//流产
myInstance.OnAborted=委托（WorkflowAbortedEventArgs e）
{
//信息
控制台。写线（如原因）；
syncEvent.Set（）；
};
//跑
myInstance.Run（）；
}
//等等
WaitHandle.WaitAll（items.ToArray（））；

使用并行框架会更容易。

您真的需要它们在单独的线程上运行吗？我在想，既然你已经在使用工作流，那么通过使用工作流来“组织你的工作”应该是最容易解决问题的

{
    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}
        });
}

{
var ArgsToProcess=新列表{“arg_one”、“arg_two”、“arg_two”}；
var delegateArg=新的DelegateInArgument{Name=“s”}；
Activity toRun=新的ParallelForEach
{
Body=新活动action
{
参数=delegateArg，
Handler=new Workflow1（）//在此处插入您的工作流
{
Arg=delegateArg
}
}
};
WorkflowInvoker.Invoke（toRun，新字典
{
{“值”，ArgsToProcess}
});
}

我想运行相同的工作流N次，但每个工作流的触发器都由主机进程实例化，因此我认为这不会起作用。您正在避免的anon方法的缺点是什么？

{
    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}
        });
}