Durable Functions Chaining: Basic Orchestration

1. The Function Chaining Pattern

As a quick refresher, function chaining is a pattern where you execute a sequence of functions in a specific order. Critically, the output of one function can be passed as the input to the next, allowing you to build a sequential workflow.

Think of it like an assembly line. Each station (an Activity Function) performs a specific task on the product before passing it to the next station. The Orchestrator Function acts as the assembly line's manager, ensuring the product moves through the stations in the correct order.

Your experience designing multi-step processes and service-based architectures will be very relevant here, as we are essentially codifying a distributed workflow.

2. Creating Your First Durable Functions Project

Let's start by creating the project in Visual Studio. We will use the built-in template, which provides the basic scaffolding for a Durable Function app, including the client, orchestrator, and activity functions we discussed previously.

The following quickstart guide from Microsoft Learn will walk you through creating the project. Since you use Visual Studio 2022, please focus on that section of the guide.

After completing these steps, you will have a project with a file named Function1.cs (or similar). This file contains the three essential function types:

• RunOrchestrator: The orchestrator function, decorated with [Function("Function1")] and taking an OrchestrationContext.
• SayHello: The activity function, decorated with [Function("SayHello")] and taking an ActivityTrigger.
• HttpStart: The client function, decorated with [Function("Function1_HttpStart")] and using an HttpTrigger to start the orchestration.

This structure should look familiar from our last lesson. The template has given us a working, albeit simple, function chain that calls the SayHello activity three times.

3. Implementing a Custom Function Chain

Now, let's modify this boilerplate code to create a more descriptive and practical function chain. We will build a simple financial transaction workflow. The logic will be:

1. Get cash from an ATM.
2. Use the cash to buy groceries.
3. Deposit the remaining money back into the bank.

This example is great because it's a clear, sequential process. We'll use a video tutorial to guide us through modifying the code and running it.

Let's review the code for the orchestrator function, which is the core of the chain. It should look something like this, based on the video's logic.

[Function("Function1")] // This is the Orchestrator
public static async Task<List<string>> RunOrchestrator(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    ILogger logger = context.CreateReplaySafeLogger(nameof(Function1));
    logger.LogInformation("Saying hello.");
    var outputs = new List<string>();

    // The function chain:
    // 1. Call the GetCash activity
    outputs.Add(await context.CallActivityAsync<string>("GetCash", "200"));
    
    // 2. Call the BuyGrocery activity
    outputs.Add(await context.CallActivityAsync<string>("BuyGrocery", "Potato"));
    
    // 3. Call the DepositMoney activity
    outputs.Add(await context.CallActivityAsync<string>("DepositMoney", "Citibank"));

    return outputs;
}

And one of the new activity functions would be:

[Function("GetCash")] // This is an Activity
public static string GetCash([ActivityTrigger] string amount, FunctionContext executionContext)
{
    ILogger logger = executionContext.GetLogger("GetCash");
    logger.LogInformation("Withdrawing {amount}", amount);
    return $"Cash {amount} withdrawn.";
}

Notice how the RunOrchestrator function contains the workflow logic, calling each activity with await context.CallActivityAsync. This C# code cleanly describes a complex, distributed process, and the Durable Functions framework handles all the underlying state management and reliability.

For an official reference on the C# syntax, you can consult the Microsoft Learn documentation on function chaining.

4. Running and Testing the Orchestration Locally

With the code in place, it's time to run it and see the result. You'll start the function app locally, which will also start the Azurite storage emulator to manage the orchestration's state. Then, you'll use an HTTP tool like Postman to trigger the workflow and check its status.

Your background with C#, Visual Studio, and REST APIs will make this process feel very familiar.

Let's return to the video tutorial, which provides an excellent walkthrough of the local testing process.

When you query the status URL, the runtimeStatus should be "Completed," and the output field should contain an array of the strings returned by your three activity functions, proving that the chain executed successfully.

Conclusion

Congratulations! You have successfully built and run your first stateful serverless workflow using Durable Functions. You've applied the architectural concepts from the previous lesson to a hands-on exercise, creating a sequence of functions that pass data and execute in a specific order.

Key Takeaways:

• The "Durable Functions Orchestration" template in Visual Studio provides the necessary client, orchestrator, and activity functions to get started quickly.
• You implement a function chain by making a series of await context.CallActivityAsync<T>() calls within an orchestrator function.
• The orchestrator defines the what and when of the workflow, while the activity functions do the actual work.
• You can test orchestrations locally using the storage emulator (Azurite) and an HTTP client to trigger the workflow and poll for its status.

Next Steps

Function chaining is powerful for sequential processes. But what if you need to perform many independent tasks at once and wait for them all to finish? In our next lesson, we will tackle another common durable pattern by learning to implement the fan-out/fan-in pattern in a Durable Functions orchestration. This will allow you to execute activities in parallel, dramatically improving performance for certain types of workflows.