Merge pull request #313401 from MicrosoftDocs/main

Auto Publish – main to live - 2026-03-19 17:00 UTC

Author: Taojunshen

articles/azure-functions/durable/durable-functions-error-handling.md

@@ -83,6 +83,9 @@ public static async Task Run(
 > - The exception message typically identifies which activity functions or sub-orchestrations caused the failure. To access more detailed error information, inspect the [`FailureDetails`](/dotnet/api/microsoft.durabletask.taskfailuredetails) property.  
 > - By default, `FailureDetails` includes the **error type**, **error message**, **stack trace**, and any **nested inner exceptions** (each represented as a recursive `FailureDetails` object). To include additional exception properties in the failure output, see [Include Custom Exception Properties for FailureDetails (.NET Isolated)](#include-custom-exception-properties-for-failuredetails-net-isolated).  
 
+> [!IMPORTANT]
+> **Migration note (in-process to isolated):** In the in-process model, `FunctionFailedException.InnerException` contains the original exception object thrown by the activity, which you can cast and inspect directly. In the isolated worker model, `TaskFailedException` does **not** contain the original exception as an `InnerException`. Instead, error details are available only through the [`FailureDetails`](/dotnet/api/microsoft.durabletask.taskfailuredetails) property, which provides string-based properties (`ErrorType`, `ErrorMessage`, `StackTrace`). You can't cast or access the original exception object directly. Use [`FailureDetails.IsCausedBy<T>()`](/dotnet/api/microsoft.durabletask.taskfailuredetails.iscausedby) to check the original exception type.
+
 </details>
 <br>
 <details>
@@ -438,6 +441,102 @@ If the **CreditAccount** activity fails, the orchestrator catches the exception
 
 ::: zone pivot="durable-functions"
 
+## Errors with multiple activity calls (fan-out/fan-in)
+
+# [C#](#tab/csharp)
+
+When you use `Task.WhenAll` to run multiple activity calls in parallel (fan-out/fan-in pattern) and one or more activities fail, `await` throws only the first exception. To access all failures, inspect the `Exception` property on the `Task` returned by `Task.WhenAll`.
+
+<details>
+<summary><b>Isolated worker model</b></summary>
+
+```csharp
+var tasks = new[]
+{
+    context.CallActivityAsync("Activity1", input1),
+    context.CallActivityAsync("Activity2", input2),
+    context.CallActivityAsync("Activity3", input3),
+};
+
+var allTask = Task.WhenAll(tasks);
+try
+{
+    await allTask;
+}
+catch (TaskFailedException)
+{
+    // 'await' rethrows only the first exception. To inspect all failures,
+    // check allTask.Exception, which is an AggregateException.
+    if (allTask.Exception != null)
+    {
+        foreach (var inner in allTask.Exception.InnerExceptions)
+        {
+            if (inner is TaskFailedException taskFailed)
+            {
+                // Use taskFailed.FailureDetails to inspect error details
+                var errorType = taskFailed.FailureDetails.ErrorType;
+                var errorMessage = taskFailed.FailureDetails.ErrorMessage;
+            }
+        }
+    }
+}
+```
+
+</details>
+<br>
+<details>
+<summary><b>In-process model</b></summary>
+
+```csharp
+var tasks = new[]
+{
+    context.CallActivityAsync("Activity1", input1),
+    context.CallActivityAsync("Activity2", input2),
+    context.CallActivityAsync("Activity3", input3),
+};
+
+var allTask = Task.WhenAll(tasks);
+try
+{
+    await allTask;
+}
+catch (FunctionFailedException)
+{
+    // 'await' rethrows only the first exception. To inspect all failures,
+    // check allTask.Exception, which is an AggregateException.
+    if (allTask.Exception != null)
+    {
+        foreach (var inner in allTask.Exception.InnerExceptions)
+        {
+            if (inner is FunctionFailedException funcFailed)
+            {
+                // Use funcFailed.InnerException to access the original exception
+            }
+        }
+    }
+}
+```
+
+</details>
+
+# [JavaScript](#tab/javascript)
+
+In JavaScript, when you use `context.df.Task.all` to run multiple activity calls in parallel, the first failure causes the task to complete with an error. Wrap the call in a try/catch block to handle the error.
+
+# [Python](#tab/python)
+
+In Python, when you use `context.task_all` to run multiple activity calls in parallel, the first failure causes the task to complete with an error. Wrap the call in a try/except block to handle the error.
+
+# [PowerShell](#tab/powershell)
+
+In PowerShell, use `Wait-DurableTask` with multiple tasks. If any task fails, the error is raised.
+
+# [Java](#tab/java)
+
+In Java, when you use `ctx.allOf` to run multiple activity calls in parallel, the first failure causes the task to complete with an error. Use a try/catch block to handle the error.
+
+---
+
 ## Errors in entity functions
 Exception handling in entity functions depends on the Durable Functions hosting model:
 

articles/azure-functions/durable/durable-functions-fan-in-fan-out.md

@@ -90,17 +90,6 @@ This orchestrator function does the following:
 
 Here is the code that implements the orchestrator function:
 
-[!code-csharp[Main](~/samples-durable-functions/samples/precompiled/BackupSiteContent.cs?range=16-42)]
-
-> [!NOTE]
-> The sample linked in the prerequisites (`samples/precompiled`) uses the in-process model. The following **Isolated model** sections show equivalent code for the .NET isolated worker model.
-
-Notice the `await Task.WhenAll(tasks);` line. The code doesn't await the individual calls to `E2_CopyFileToBlob`, so they run in parallel. When the orchestrator passes the task array to `Task.WhenAll`, it returns a task that doesn't complete until all copy operations complete. If you're familiar with the Task Parallel Library (TPL) in .NET, this pattern is familiar. The difference is that these tasks could be running on multiple virtual machines concurrently, and the Durable Functions extension ensures that the end-to-end execution is resilient to process recycling.
-
-After the orchestrator awaits `Task.WhenAll`, all function calls are complete and return values. Each call to `E2_CopyFileToBlob` returns the number of bytes uploaded. Calculate the total by adding the return values.
-
-<br>
-
 <details>
 <summary><b>Isolated model</b></summary>
 
@@ -137,6 +126,22 @@ public static class BackupSiteContent
 }
 ```
 
+Notice the `await Task.WhenAll(tasks);` line. The code doesn't await the individual calls to `E2_CopyFileToBlob`, so they run in parallel. When the orchestrator passes the task array to `Task.WhenAll`, it returns a task that doesn't complete until all copy operations complete. If you're familiar with the Task Parallel Library (TPL) in .NET, this pattern is familiar. The difference is that these tasks could be running on multiple virtual machines concurrently, and the Durable Functions extension ensures that the end-to-end execution is resilient to process recycling.
+
+After the orchestrator awaits `Task.WhenAll`, all function calls are complete and return values. Each call to `E2_CopyFileToBlob` returns the number of bytes uploaded. Calculate the total by adding the return values.
+
+</details>
+
+<br>
+
+<details>
+<summary><b>In-process model</b></summary>
+
+[!code-csharp[Main](~/samples-durable-functions/samples/precompiled/BackupSiteContent.cs?range=16-42)]
+
+> [!NOTE]
+> The [in-process model sample](~/samples-durable-functions/samples/precompiled/BackupSiteContent.cs) uses deprecated in-process packages. The preceding code shows the recommended .NET isolated worker model.
+
 </details>
 
 <br>
@@ -364,10 +369,6 @@ The helper activity functions are regular functions that use the `activityTrigge
 
 # [C#](#tab/csharp)
 
-[!code-csharp[Main](~/samples-durable-functions/samples/precompiled/BackupSiteContent.cs?range=44-54)]
-
-<br>
-
 <details>
 <summary><b>Isolated model</b></summary>
 
@@ -400,6 +401,15 @@ public static class BackupSiteContent
 
 <br>
 
+<details>
+<summary><b>In-process model</b></summary>
+
+[!code-csharp[Main](~/samples-durable-functions/samples/precompiled/BackupSiteContent.cs?range=44-54)]
+
+</details>
+
+<br>
+
 # [JavaScript](#tab/javascript)
 
 <details>
@@ -457,18 +467,12 @@ Java sample coming soon.
 
 # [C#](#tab/csharp)
 
-[!code-csharp[Main](~/samples-durable-functions/samples/precompiled/BackupSiteContent.cs?range=56-81)]
-
-> [!NOTE]
-> To run the sample code, install the `Microsoft.Azure.WebJobs.Extensions.Storage` NuGet package.
-
-The function uses Azure Functions binding features like the [`Binder` parameter](../functions-dotnet-class-library.md#binding-at-runtime). You don't need those details for this walkthrough.
-
-<br>
-
 <details>
 <summary><b>Isolated model</b></summary>
 
+> [!NOTE]
+> To run the sample code, install the `Azure.Storage.Blobs` NuGet package.
+
 ```csharp
 using System;
 using System.IO;
@@ -518,6 +522,18 @@ public static class BackupSiteContent
 
 <br>
 
+<details>
+<summary><b>In-process model</b></summary>
+
+[!code-csharp[Main](~/samples-durable-functions/samples/precompiled/BackupSiteContent.cs?range=56-81)]
+
+> [!NOTE]
+> The in-process model sample requires the `Microsoft.Azure.WebJobs.Extensions.Storage` NuGet package and uses Azure Functions binding features like the [`Binder` parameter](../functions-dotnet-class-library.md#binding-at-runtime).
+
+</details>
+
+<br>
+
 # [JavaScript](#tab/javascript)
 
 <details>

articles/azure-functions/durable/durable-functions-orchestrations.md

@@ -24,6 +24,9 @@ This article gives you an overview of orchestrator functions and how they can he
 
 For information about the types of functions available in a Durable Functions app, see [Durable Task programming model](programming-model-overview.md).
 
+> [!TIP]
+> If you use C# with the .NET isolated worker model, you can write orchestrations using either a **function-based** approach (static methods with `[Function]` attributes) or a **class-based** approach (classes that inherit from `TaskOrchestrator<TInput, TOutput>`). The class-based approach requires the [Microsoft.DurableTask.Generators](https://www.nuget.org/packages/Microsoft.DurableTask.Generators) source generator package and provides strongly typed invocations. For more information, see [Class-based activities and orchestrations](durable-functions-dotnet-isolated-overview.md#source-generator-and-class-based-activities-and-orchestrations). The C# code examples in this article show both approaches.
+
 ::: zone-end
 
 ::: zone pivot="durable-task-sdks"
@@ -116,6 +119,36 @@ public static async Task<List<string>> Run(
 
 <br>
 
+<details>
+<summary><b>Class-based model (isolated worker)</b></summary>
+
+The class-based approach uses a source generator and requires the [Microsoft.DurableTask.Generators](https://www.nuget.org/packages/Microsoft.DurableTask.Generators) NuGet package.
+
+```csharp
+using Microsoft.DurableTask;
+
+[DurableTask]
+public class HelloCities : TaskOrchestrator<object?, List<string>>
+{
+    public override async Task<List<string>> RunAsync(
+        TaskOrchestrationContext context, object? input)
+    {
+        var outputs = new List<string>();
+
+        outputs.Add(await context.CallActivityAsync<string>("SayHello", "Tokyo"));
+        outputs.Add(await context.CallActivityAsync<string>("SayHello", "Seattle"));
+        outputs.Add(await context.CallActivityAsync<string>("SayHello", "London"));
+
+        // Return ["Hello Tokyo!", "Hello Seattle!", "Hello London!"].
+        return outputs;
+    }
+}
+```
+
+</details>
+
+<br>
+
 <details>
 <summary><b>In-process model</b></summary>
 

articles/azure-functions/durable/durable-functions-singletons.md

@@ -69,6 +69,9 @@ public static async Task<HttpResponseData> RunSingle(
 
 # [JavaScript](#tab/javascript)
 
+> [!NOTE]
+> This JavaScript example uses the Node.js programming model v3, which uses *function.json*. If you're using the Node.js programming model v4, use the v4 code-first pattern instead.
+
 **function.json**
 
 ```json
@@ -130,57 +133,37 @@ module.exports = async function(context, req) {
 
 # [Python](#tab/python)
 
-**function.json**
-
-```json
-{
-  "bindings": [
-    {
-      "authLevel": "function",
-      "name": "req",
-      "type": "httpTrigger",
-      "direction": "in",
-      "route": "orchestrators/{functionName}/{instanceId}",
-      "methods": ["post"]
-    },
-    {
-      "name": "starter",
-      "type": "orchestrationClient",
-      "direction": "in"
-    },
-    {
-      "name": "$return",
-      "type": "http",
-      "direction": "out"
-    }
-  ]
-}
-```
-
-**__init__.py**
+**function_app.py**
 
 ```python
 import logging
 import azure.functions as func
 import azure.durable_functions as df
 
-async def main(req: func.HttpRequest, starter: str) -> func.HttpResponse:
-    client = df.DurableOrchestrationClient(starter)
-    instance_id = req.route_params['instanceId']
-    function_name = req.route_params['functionName']
+app = df.DFApp(http_auth_level=func.AuthLevel.FUNCTION)
+
+@app.route(route="orchestrators/{functionName}/{instanceId}", methods=["POST"])
+@app.durable_client_input(client_name="client")
+async def http_start_single(req: func.HttpRequest, client):
+        instance_id = req.route_params["instanceId"]
+        function_name = req.route_params["functionName"]
 
     existing_instance = await client.get_status(instance_id)
 
-    if existing_instance.runtime_status in [df.OrchestrationRuntimeStatus.Completed, df.OrchestrationRuntimeStatus.Failed, df.OrchestrationRuntimeStatus.Terminated, None]:
+        if not existing_instance or existing_instance.runtime_status in [
+                df.OrchestrationRuntimeStatus.Completed,
+                df.OrchestrationRuntimeStatus.Failed,
+                df.OrchestrationRuntimeStatus.Terminated,
+        ]:
         event_data = req.get_body()
-        instance_id = await client.start_new(function_name, instance_id, event_data)
+                instance_id = await client.start_new(function_name, instance_id, event_data)
         logging.info(f"Started orchestration with ID = '{instance_id}'.")
         return client.create_check_status_response(req, instance_id)
-    else:
-        return {
-            'status': 409,
-            'body': f"An instance with ID '${existing_instance.instance_id}' already exists"
-        }
+
+        return func.HttpResponse(
+                body=f"An instance with ID '{instance_id}' already exists.",
+                status_code=409,
+        )
 
 ```
 

articles/backup/azure-kubernetes-service-cluster-backup.md

@@ -3,7 +3,7 @@ title: Back up Azure Kubernetes Service by using Azure Backup
 description: Learn how to back up Azure Kubernetes Service (AKS) by using Azure Backup.
 ms.topic: how-to
 ms.service: azure-backup
-ms.date: 03/24/2025
+ms.date: 03/16/2026
 author: AbhishekMallick-MS
 ms.author: v-mallicka
 # Customer intent: "As a DevOps engineer, I want to configure and manage Azure Backup for my AKS clusters so that I can ensure data protection and restore capabilities for my containerized applications."