Elsa 2.0 Why is this workflow executing both the branches of a fork, when I am expecting only one?

[AvtsVivek]

Posted this same question here on SO as well .

Looks like I am missing something trivial here.

Elsa is executing both the branches of the workflow, when I am expecting only one, either A or B. Here are the files for console app.

I have pushed the full example here as well .

class Program
{
    static async Task Main(string[] args)
    {
        var services = new ServiceCollection()
            .AddElsa(options => options
                .AddConsoleActivities()
                .AddActivity<ForkBranchDecisionActivity>()
                .AddWorkflow<SimpleForkWorkflow>())
            .BuildServiceProvider();

        var workflowStarter = services.GetRequiredService<IBuildsAndStartsWorkflow>();

        await workflowStarter.BuildAndStartWorkflowAsync<SimpleForkWorkflow>();
        Console.WriteLine("Done. Good bye");
    }
}

When I type 'A', the outcome will be 'A', else it will be 'B'.

public class ForkBranchDecisionActivity : Activity
{
    protected override IActivityExecutionResult OnExecute()
    {
        Console.WriteLine("Choose a branch. A or B");
        Console.WriteLine("Typing 'a' will result in going through branch A");
        Console.WriteLine("Any other key will result in branch B");
        var userChoosenBranch = Console.ReadLine();

        if (userChoosenBranch!.ToUpper() == "A")
            return Outcome("A");
        
        return Outcome("B");
    }
}

Is the branch chosen not based on the outcome of the previous activity? If not then what determines the branch to be executed? How come both branches are executed in my case? I tried figuring this out from the examples here but could not.

public class SimpleForkWorkflow : IWorkflow
{
    public void Build(IWorkflowBuilder builder)
    {
        builder
            .WriteLine("This demonistrates a simple workflow with fork .")
            .WriteLine("Using forks we can branch a workflow.")
            .Then<ForkBranchDecisionActivity>()
            .Then<Fork>(
                fork => fork.WithBranches("A", "B"),
                fork =>
                {
                    var aBranch = fork
                        .When("A")
                        .WriteLine("You are in A branch. First line")
                        .WriteLine("You are in A branch. Second line.")
                        .ThenNamed("AfterJoin");

                    var bBranch = fork
                        .When("B")
                        .WriteLine("You are in B branch. First line")
                        .WriteLine("You are in B branch. Second line.")
                        .ThenNamed("AfterJoin");
                })
            .WithName("AB Fork")
            .Add<Join>(x => x.WithMode(Join.JoinMode.WaitAny)).WithName("AfterJoin")
            .WriteLine("Workflow finished.");
    }
}

My final console output looks as follows.

This demonistrates a simple workflow with fork .
Using forks we can branch a workflow.
Choose a branch. A or B
Typing a will resulting in going through branch A
Any other key will result in branch B
a
You are in B branch. First line
You are in B branch. Second line.
Workflow finished.
You are in A branch. First line
You are in A branch. Second line.
Workflow finished.
Done. Good bye

As you can see its executing both the branches. What am I missing?

[sfmskywalker]

This is by design: the Fork activity will schedule all branches. It is a way to split workflow execution into multiple branches.

This allows you to do things like waiting for some user input in one branch, but continue with another branch after some timeout event. A good example of this scenario is described here.

To implement your workflow, all you need is this:

public class SimpleForkWorkflow : IWorkflow
{
    public void Build(IWorkflowBuilder builder)
    {
        builder
            .WriteLine("This demonstrates a simple workflow with switch.")
            .WriteLine("Using switch we can branch a workflow.")
            .Then<ForkBranchDecisionActivity>(fork =>
            {
                fork.When("A")
                    .WriteLine("You are in A branch. First line")
                    .WriteLine("You are in A branch. Second line.")
                    .ThenNamed("Finish");

                fork.When("B")
                    .WriteLine("You are in B branch. First line")
                    .WriteLine("You are in B branch. Second line.")
                    .ThenNamed("Finish");
                
            })
            .WriteLine("Workflow finished.").WithName("Finish");
    }
}

Notice that the Then<ForkBranchDecisionActivity> call accepts a parameter that allows you to connect arbitrary outcomes to your activity ("A" and "B" in your case).

When you run this workflow, the outcome will be as expected:

This demonstrates a simple workflow with switch.
Using switch we can branch a workflow.
Choose a branch. A or B
Typing 'a' will result in going through branch A
Any other key will result in branch B
a
You are in A branch. First line
You are in A branch. Second line.
Workflow finished.