Azure Functions with .NET: Isolated Worker and Durable Functions

using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;
using Microsoft.Extensions.Logging;

public static class FulfillmentOrchestration
{
    private static readonly TaskOptions Retry = TaskOptions.FromRetryPolicy(
        new RetryPolicy(maxNumberOfAttempts: 3, firstRetryInterval: TimeSpan.FromSeconds(5),
            backoffCoefficient: 2.0));

    [Function(nameof(FulfillOrder))]
    public static async Task<string[]> FulfillOrder(
        [OrchestrationTrigger] TaskOrchestrationContext context, OrderRequest order)
    {
        ILogger logger = context.CreateReplaySafeLogger(nameof(FulfillOrder));

        // Chaining: each step starts after the previous one completes
        await context.CallActivityAsync(nameof(FulfillmentActivities.ReserveStock), order, Retry);
        await context.CallActivityAsync(nameof(FulfillmentActivities.ChargePayment), order, Retry);

        // Fan-out/fan-in: one shipment per line, awaited together
        var shipments = order.Lines
            .Select(line => context.CallActivityAsync<string>(
                nameof(FulfillmentActivities.CreateShipment), line, Retry))
            .ToList();
        string[] trackingNumbers = await Task.WhenAll(shipments);

        logger.LogInformation("Order {OrderId} shipped in {Count} parcels",
            order.Id, trackingNumbers.Length);
        return trackingNumbers;
    }
}

public sealed class FulfillmentActivities(IInventoryService inventory,
    IPaymentService payments, IShippingService shipping)
{
    [Function(nameof(ReserveStock))]
    public Task ReserveStock([ActivityTrigger] OrderRequest order) =>
        inventory.ReserveAsync(order);

    [Function(nameof(ChargePayment))]
    public Task ChargePayment([ActivityTrigger] OrderRequest order) =>
        payments.ChargeAsync(order);

    [Function(nameof(CreateShipment))]
    public Task<string> CreateShipment([ActivityTrigger] OrderLine line) =>
        shipping.CreateShipmentAsync(line);
}

using System.Net;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.DurableTask;
using Microsoft.DurableTask.Client;

public static class RefundWorkflow
{
    [Function(nameof(StartRefund))]
    public static async Task<HttpResponseData> StartRefund(
        [HttpTrigger(AuthorizationLevel.Function, "post", Route = "refunds")] HttpRequestData req,
        [DurableClient] DurableTaskClient client)
    {
        var refund = await req.ReadFromJsonAsync<RefundRequest>();
        if (refund is null)
        {
            return req.CreateResponse(HttpStatusCode.BadRequest);
        }

        string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(
            nameof(RefundApproval), refund);

        // 202 Accepted with statusQueryGetUri, sendEventPostUri and terminatePostUri
        return await client.CreateCheckStatusResponseAsync(req, instanceId);
    }

    [Function(nameof(RefundApproval))]
    public static async Task<string> RefundApproval(
        [OrchestrationTrigger] TaskOrchestrationContext context, RefundRequest refund)
    {
        await context.CallActivityAsync(nameof(RefundActivities.NotifyApprover), refund);

        using var timeoutCts = new CancellationTokenSource();
        DateTime deadline = context.CurrentUtcDateTime.AddHours(24);
        Task timeout = context.CreateTimer(deadline, timeoutCts.Token);
        Task<bool> decision = context.WaitForExternalEvent<bool>("RefundDecision");

        if (await Task.WhenAny(decision, timeout) == decision)
        {
            timeoutCts.Cancel();   // cancel timers you no longer need
            return decision.Result
                ? await context.CallActivityAsync<string>(
                    nameof(RefundActivities.IssueRefund), refund)
                : "Rejected";
        }

        return await context.CallActivityAsync<string>(nameof(RefundActivities.Escalate), refund);
    }
}