CODEWITHSUNDEEP
workflow-foundation-4
Redzon
Redzon

Reputation: 401

Parallel activities appear to execute sequentially

I am learning WF4 and got stuck at the following place. Please help.Thanks.

1) I have created a static method, MyMethod in a static class called Worker. Within this method I call Thread.Sleep(3000) and then print "MyMethod" called.
2) I then created an activity, DoWork (DoWork.xaml) which consists of a InvokeMethod (The target type is the Worker class in step 1 and MethodName = MyMethod).
3) In the main method, I call 2 methods called OutputSequence() and OutputParallel() which are as follows 

private static void OutputSequence()            
{        
    Sequence s = new Sequence() { Activities = new DoWork(), new DoWork() } };    
    WorkflowInvoker.Invoke(s);    
}

private static void OutputParallel()            
{        
    Parallel p = new Parallel() { Branches = new DoWork(), new DoWork() } };    
    WorkflowInvoker.Invoke(p);    
}

The OutputSequence() is OK as it calls the target method twice (in sequence) but the parallel one seems to execute sequentially as well. I expected it to execute in parallel.
What am I missing.

Upvotes: 2

Views: 1998

Answers (2)

oleksa
oleksa

Reputation: 4037

Actually Parallel activity really executes all branches one-by-one and has nothing related to concurrent code execution, like two thread do.

But there is MS sample, that shows "true" concurrent execution for blocks inside of parallel activity. There is the AsyncCodeActivity in the .net 4 that allows to get concurrent execution of activities. Please check http://msdn.microsoft.com/en-us/library/ee358731(VS.100).aspx Below you can find copy-pasted sample from link above:

public sealed class GenerateRandom : AsyncCodeActivity<int>
{
    static Random r = new Random();

    protected override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback, object state)
    {
        // Create a delegate that references the method that implements
        // the asynchronous work. Assign the delegate to the UserState,
        // invoke the delegate, and return the resulting IAsyncResult.
        Func<int> GetRandomDelegate = new Func<int>(GetRandom);
        context.UserState = GetRandomDelegate;
        return GetRandomDelegate.BeginInvoke(callback, state);
    }

    protected override int EndExecute(AsyncCodeActivityContext context, IAsyncResult result)
    {
        // Get the delegate from the UserState and call EndInvoke
        Func<int> GetRandomDelegate = (Func<int>)context.UserState;
        return (int)GetRandomDelegate.EndInvoke(result);
    }

    int GetRandom()
    {
        // This activity simulates taking a few moments
        // to generate the random number. This code runs
        // asynchronously with respect to the workflow thread.
        Thread.Sleep(5000);

        return r.Next(1, 101);
    }
}

hope this will help for someone else

Upvotes: 1

Richard Blewett
Richard Blewett

Reputation: 6109

The Parallel activity is not what you think it is - it allows you to wait for things in parallel not to execute CPU based code in parallel. The WF4 threading mode is that there is exactly one thread at a time active in the workflow.

If you put two delays in the parallel then both of those waits would occur in parallel as opposed to sequentially as they would in a sequence

The idea is you want to wait for a number of actions when you don;t know the order in which they will occur. Then the parallel activity is complete when all of its child branches have completed

Upvotes: 7

Related Questions