1# Durable Task Scheduler — .NET
2 
3## Learn More
4 
5- [Durable Task Scheduler documentation](https://learn.microsoft.com/azure/durable-task-scheduler/)
6- [Durable Functions .NET isolated worker guide](https://learn.microsoft.com/azure/azure-functions/durable/durable-functions-dotnet-isolated-overview)
7 
8## Durable Functions Setup
9 
10### Required NuGet Packages
11 
12```xml
13<ItemGroup>
14  <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.DurableTask" Version="1.14.1" />
15  <PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.DurableTask.AzureManaged" Version="1.4.0" />
16  <PackageReference Include="Azure.Identity" Version="1.17.1" />
17</ItemGroup>
18```
19 
20> **💡 Finding latest versions**: Search [nuget.org](https://www.nuget.org/) for each package name to find the current stable version. Look for the `Microsoft.Azure.Functions.Worker.Extensions.DurableTask` and `Microsoft.Azure.Functions.Worker.Extensions.DurableTask.AzureManaged` packages.
21 
22### host.json
23 
24```json
25{
26  "version": "2.0",
27  "extensions": {
28    "durableTask": {
29      "storageProvider": {
30        "type": "azureManaged",
31        "connectionStringName": "DURABLE_TASK_SCHEDULER_CONNECTION_STRING"
32      },
33      "hubName": "default"
34    }
35  }
36}
37```
38 
39> **💡 NOTE**: .NET isolated uses the `DurableTask.AzureManaged` NuGet package, which registers the `azureManaged` storage provider type. Other runtimes (Python, Java, JavaScript) use extension bundles and require `durabletask-scheduler` instead — see the respective language files. All runtimes use the same `DURABLE_TASK_SCHEDULER_CONNECTION_STRING` environment variable.
40 
41### local.settings.json
42 
43```json
44{
45  "IsEncrypted": false,
46  "Values": {
47    "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated",
48    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
49    "DURABLE_TASK_SCHEDULER_CONNECTION_STRING": "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None"
50  }
51}
52```
53 
54## Minimal Example
55 
56```csharp
57using Microsoft.Azure.Functions.Worker;
58using Microsoft.DurableTask;
59using Microsoft.DurableTask.Client;
60 
61public static class DurableFunctionsApp
62{
63    [Function("HttpStart")]
64    public static async Task<HttpResponseData> HttpStart(
65        [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
66        [DurableClient] DurableTaskClient client)
67    {
68        string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(nameof(MyOrchestration));
69        return await client.CreateCheckStatusResponseAsync(req, instanceId);
70    }
71 
72    [Function(nameof(MyOrchestration))]
73    public static async Task<string> MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context)
74    {
75        var result1 = await context.CallActivityAsync<string>(nameof(SayHello), "Tokyo");
76        var result2 = await context.CallActivityAsync<string>(nameof(SayHello), "Seattle");
77        return $"{result1}, {result2}";
78    }
79 
80    [Function(nameof(SayHello))]
81    public static string SayHello([ActivityTrigger] string name) => $"Hello {name}!";
82}
83```
84 
85## Workflow Patterns
86 
87### Fan-Out/Fan-In
88 
89```csharp
90[Function(nameof(FanOutFanIn))]
91public static async Task<string[]> FanOutFanIn([OrchestrationTrigger] TaskOrchestrationContext context)
92{
93    string[] cities = { "Tokyo", "Seattle", "London", "Paris", "Berlin" };
94 
95    // Fan-out: schedule all in parallel
96    var tasks = cities.Select(city => context.CallActivityAsync<string>(nameof(SayHello), city));
97 
98    // Fan-in: wait for all
99    return await Task.WhenAll(tasks);
100}
101```
102 
103### Human Interaction
104 
105```csharp
106[Function(nameof(ApprovalWorkflow))]
107public static async Task<string> ApprovalWorkflow([OrchestrationTrigger] TaskOrchestrationContext context)
108{
109    await context.CallActivityAsync(nameof(SendApprovalRequest), context.GetInput<string>());
110    
111    // Wait for approval event with timeout
112    using var cts = new CancellationTokenSource();
113    var approvalTask = context.WaitForExternalEvent<bool>("ApprovalEvent");
114    var timeoutTask = context.CreateTimer(context.CurrentUtcDateTime.AddDays(3), cts.Token);
115    
116    var winner = await Task.WhenAny(approvalTask, timeoutTask);
117    
118    if (winner == approvalTask)
119    {
120        cts.Cancel();
121        return await approvalTask ? "Approved" : "Rejected";
122    }
123    return "Timed out";
124}
125```
126 
127## Orchestration Determinism
128 
129| ❌ NEVER | ✅ ALWAYS USE |
130|----------|--------------|
131| `DateTime.Now` | `context.CurrentUtcDateTime` |
132| `Guid.NewGuid()` | `context.NewGuid()` |
133| `Random` | Pass random values from activities |
134| `Task.Delay()`, `Thread.Sleep()` | `context.CreateTimer()` |
135| Direct I/O, HTTP, database | `context.CallActivityAsync()` |
136 
137### Replay-Safe Logging
138 
139```csharp
140[Function(nameof(MyOrchestration))]
141public static async Task<string> MyOrchestration([OrchestrationTrigger] TaskOrchestrationContext context)
142{
143    ILogger logger = context.CreateReplaySafeLogger(nameof(MyOrchestration));
144    logger.LogInformation("Started");  // Only logs once, not on replay
145    return await context.CallActivityAsync<string>(nameof(MyActivity), "input");
146}
147```
148 
149## Error Handling & Retry
150 
151```csharp
152var retryOptions = new TaskOptions
153{
154    Retry = new RetryPolicy(
155        maxNumberOfAttempts: 3,
156        firstRetryInterval: TimeSpan.FromSeconds(5),
157        backoffCoefficient: 2.0,
158        maxRetryInterval: TimeSpan.FromMinutes(1))
159};
160 
161var input = context.GetInput<string>();
162 
163try
164{
165    await context.CallActivityAsync<string>(nameof(UnreliableService), input, retryOptions);
166}
167catch (TaskFailedException ex)
168{
169    context.SetCustomStatus(new { Error = ex.Message });
170    await context.CallActivityAsync(nameof(CompensationActivity), input);
171}
172```
173 
174## Durable Task SDK (Non-Functions)
175 
176For applications running outside Azure Functions (containers, VMs, Azure Container Apps, Azure Kubernetes Service):
177 
178```csharp
179var connectionString = "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None";
180 
181// Worker
182builder.Services.AddDurableTaskWorker()
183    .AddTasks(registry => registry.AddAllGeneratedTasks())
184    .UseDurableTaskScheduler(connectionString);
185 
186// Client
187var client = DurableTaskClientBuilder.UseDurableTaskScheduler(connectionString).Build();
188string instanceId = await client.ScheduleNewOrchestrationInstanceAsync("MyOrchestration", input);
189```
190 
191