Azure Functions for .NET

Trigger On

• working on Azure Functions in .NET
• migrating from the in-process model to the isolated worker model
• adding Durable Functions, bindings, or host configuration

Documentation

• Guide for running C# Azure Functions in an isolated worker process
• Differences between in-process and isolated worker process
• Migrate C# app from in-process to isolated worker model
• Durable Functions overview
• Durable Functions best practices and diagnostic tools

References

• Patterns - Isolated worker patterns, Durable Functions patterns, advanced binding patterns
• Anti-Patterns - Common Azure Functions mistakes and how to avoid them

Workflow

1. Use isolated worker model for all new work:

   • In-process model reaches end of support on November 10, 2026
   • Runtime v1.x ends support on September 14, 2026
   • Target .NET 8+ for longest support window

2. Detect current project shape:

   • Target framework and runtime version
   • Worker model (isolated vs in-process)
   • Binding packages and host configuration

3. Use standard .NET patterns in isolated model:

   • Normal dependency injection
   • Middleware pipeline

   • IOptions<T>

     for configuration

   • ILogger<T>

     for logging

4. For Durable Functions:

   • Validate orchestration determinism constraints
   • Handle replay behavior correctly
   • Use typed activity patterns

5. Verify both local and deployment behavior.

Isolated Worker Model Setup

Basic Function with DI

// Program.cs
var host = new HostBuilder()
    .ConfigureFunctionsWebApplication()
    .ConfigureServices(services =>
    {
        services.AddApplicationInsightsTelemetryWorkerService();
        services.ConfigureFunctionsApplicationInsights();
        services.AddSingleton<IMyService, MyService>();
    })
    .Build();

host.Run();

HTTP Trigger Function

public class HttpFunctions(ILogger<HttpFunctions> logger, IMyService myService)
{
    [Function("GetItems")]
    public async Task<IActionResult> GetItems(
        [HttpTrigger(AuthorizationLevel.Function, "get", Route = "items")] HttpRequest req)
    {
        logger.LogInformation("Processing GetItems request");
        var items = await myService.GetItemsAsync();
        return new OkObjectResult(items);
    }
}

Queue Trigger with Options

public class QueueFunctions(ILogger<QueueFunctions> logger, IOptions<ProcessingOptions> options)
{
    [Function("ProcessMessage")]
    public async Task ProcessMessage(
        [QueueTrigger("myqueue", Connection = "AzureWebJobsStorage")] string message)
    {
        logger.LogInformation("Processing message: {Message}", message);
        // Process with retry policy from options
    }
}

Middleware Pattern

Custom Middleware

// Program.cs
var host = new HostBuilder()
    .ConfigureFunctionsWebApplication(builder =>
    {
        builder.UseMiddleware<ExceptionHandlingMiddleware>();
        builder.UseMiddleware<CorrelationIdMiddleware>();
    })
    .Build();

// CorrelationIdMiddleware.cs
public class CorrelationIdMiddleware : IFunctionsWorkerMiddleware
{
    public async Task Invoke(FunctionContext context, FunctionExecutionDelegate next)
    {
        var correlationId = context.Features.Get<IHttpRequestFeature>()?.Headers["X-Correlation-Id"]
            ?? Guid.NewGuid().ToString();

        context.Items["CorrelationId"] = correlationId;

        await next(context);
    }
}

Durable Functions Patterns

Function Chaining

[Function(nameof(ChainOrchestrator))]
public static async Task<string> ChainOrchestrator(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    var result1 = await context.CallActivityAsync<string>(nameof(Step1), "input");
    var result2 = await context.CallActivityAsync<string>(nameof(Step2), result1);
    var result3 = await context.CallActivityAsync<string>(nameof(Step3), result2);
    return result3;
}

[Function(nameof(Step1))]
public static string Step1([ActivityTrigger] string input) => $"Step1({input})";

[Function(nameof(Step2))]
public static string Step2([ActivityTrigger] string input) => $"Step2({input})";

[Function(nameof(Step3))]
public static string Step3([ActivityTrigger] string input) => $"Step3({input})";

Fan-Out/Fan-In

[Function(nameof(FanOutFanInOrchestrator))]
public static async Task<int[]> FanOutFanInOrchestrator(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    var workItems = await context.CallActivityAsync<string[]>(nameof(GetWorkItems), null);

    // Fan out - process all items in parallel
    var tasks = workItems.Select(item =>
        context.CallActivityAsync<int>(nameof(ProcessWorkItem), item));

    // Fan in - wait for all to complete
    var results = await Task.WhenAll(tasks);

    return results;
}

[Function(nameof(ProcessWorkItem))]
public static int ProcessWorkItem([ActivityTrigger] string item)
{
    // Process item and return result
    return item.Length;
}

Human Interaction Pattern

[Function(nameof(ApprovalOrchestrator))]
public static async Task<string> ApprovalOrchestrator(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    var request = context.GetInput<ApprovalRequest>();

    // Send notification
    await context.CallActivityAsync(nameof(SendApprovalRequest), request);

    // Wait for external event with timeout
    using var cts = new CancellationTokenSource();
    var approvalTask = context.WaitForExternalEvent<bool>("ApprovalEvent");
    var timeoutTask = context.CreateTimer(context.CurrentUtcDateTime.AddDays(7), cts.Token);

    var winner = await Task.WhenAny(approvalTask, timeoutTask);

    if (winner == approvalTask)
    {
        cts.Cancel();
        return approvalTask.Result ? "Approved" : "Rejected";
    }

    return "Timed out";
}

Best Practices

1. Use isolated worker model for new development - Full .NET ecosystem access, middleware support, and longer support lifecycle
2. Inject dependencies via constructor - Use

   ILogger<T>

   and service interfaces for testability
3. Keep orchestrator code deterministic - No I/O, random, DateTime.Now, or Guid.NewGuid() in orchestrators
4. Handle sensitive data in activities - Fetch secrets from Key Vault in activity functions, never in orchestrators
5. Use unique task hub names - Prevent accidental sharing when multiple apps use the same storage
6. Avoid large inputs/outputs - Serialize to blob storage for large payloads to prevent history bloat
7. Configure concurrency limits - Set appropriate limits in host.json for resource-intensive functions
8. Keep SDK and extensions updated - Latest versions include performance improvements and bug fixes

Anti-Patterns to Avoid

context.CurrentUtcDateTime

await

Deployment Considerations

Linux Consumption Plan Limitations

.NET 10+ apps cannot run on Linux Consumption plan.
Use Flex Consumption plan or App Service for .NET 10+.
.NET 9 is the last version supported on Linux Consumption.

host.json Configuration

{
  "version": "2.0",
  "extensions": {
    "durableTask": {
      "hubName": "MyUniqueTaskHub",
      "maxConcurrentActivityFunctions": 10,
      "maxConcurrentOrchestratorFunctions": 5
    }
  },
  "logging": {
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    }
  }
}

Deliver

• correct Functions project setup for the isolated worker model
• clear binding and host configuration
• middleware for cross-cutting concerns
• Durable Functions with proper orchestration patterns
• migration-safe guidance when upgrading execution models

Validate

• execution model guidance is consistent (isolated only for new work)
• orchestrator code is deterministic
• bindings and host settings match the target runtime
• large payloads are externalized to blob storage
• retry policies are configured for transient failures
• local and deployment behavior are both verified