Merge pull request #313366 from MicrosoftDocs/main

Auto Publish – main to live - 2026-03-18 22:03 UTC

Author: learn-build-service-prod[bot]

articles/azure-functions/durable/durable-functions-dotnet-entities.md

@@ -151,13 +151,65 @@ public class Counter : TaskEntity<int>
 
 ### Deleting entities in the isolated model
 
-Deleting an entity in the isolated model is accomplished by setting the entity state to `null`, and this process depends on the entity implementation path used:
+Deleting an entity in the isolated model is accomplished by setting the entity state to `null`, and this process depends on the entity implementation path used.
+
+#### Delete with ITaskEntity or function-based syntax
+
+When deriving from `ITaskEntity` or using [function based syntax](#function-based-syntax), delete is accomplished by calling `TaskEntityOperation.State.SetState(null)`:
+
+```csharp
+// Inside a function-based entity dispatch
+switch (operation.Name.ToLowerInvariant())
+{
+    case "delete":
+        operation.State.SetState(null);
+        break;
+}
+```
+
+#### Delete with TaskEntity\<TState\>
+
+When deriving from `TaskEntity<TState>`, a delete operation is implicitly defined. However, it can be overridden by defining a method `Delete` on the entity. State can also be deleted from any operation via `this.State = null`.
+
+- To delete by setting state to `null` requires `TState` to be nullable.
+- The implicitly defined delete operation deletes non-nullable `TState`.
+
+The following example shows a `TaskEntity<int?>` with nullable state that overrides the default delete:
+
+```csharp
+public class Counter : TaskEntity<int?>
+{
+    public void Delete()
+    {
+        // Custom logic before deleting, such as logging
+        this.State = null;
+    }
+
+    [Function(nameof(Counter))]
+    public static Task Run([EntityTrigger] TaskEntityDispatcher dispatcher)
+        => dispatcher.DispatchAsync<Counter>();
+}
+```
+
+#### Delete with a POCO entity
+
+When using a POCO as your state (not deriving from `TaskEntity<TState>`), a delete operation is implicitly defined. It's possible to override the delete operation by defining a method `Delete` on the POCO. However, there isn't a way to set state to `null` in the POCO route, so the implicitly defined delete operation is the only true delete.
+
+```csharp
+public class Counter
+{
+    public int Value { get; set; }
+
+    // The implicit delete operation handles state removal.
+    // Defining a Delete method here overrides the implicit behavior,
+    // but you cannot set state to null from within a POCO entity.
+
+    [Function(nameof(Counter))]
+    public static Task Run([EntityTrigger] TaskEntityDispatcher dispatcher)
+        => dispatcher.DispatchAsync<Counter>();
+}
+```
 
-- When deriving from `ITaskEntity` or using [function based syntax](#function-based-syntax), delete is accomplished by calling `TaskEntityOperation.State.SetState(null)`.
-- When deriving from `TaskEntity<TState>`, delete is implicitly defined. However, it can be overridden by defining a method `Delete` on the entity. State can also be deleted from any operation via `this.State = null`.
-    - To delete by setting state to null requires `TState` to be nullable.
-    - The implicitly defined delete operation deletes non-nullable `TState`.
-- When using a POCO as your state (not deriving from `TaskEntity<TState>`), delete is implicitly defined. It's possible to override the delete operation by defining a method `Delete` on the POCO. However, there isn't a way to set state to `null` in the POCO route, so the implicitly defined delete operation is the only true delete.
 ::: zone-end
 
 ::: zone pivot="in-proc"

articles/azure-functions/durable/durable-functions-dotnet-isolated-overview.md

@@ -53,24 +53,66 @@ public static class MyFunctions
 }
 ```
 
-#### Class-based example
+#### Class-based example (with input/output)
 
 ```csharp
-[Function(nameof(MyOrchestration))]
-public static async Task<string> MyOrchestration(
-    [OrchestrationTrigger] TaskOrchestrationContext context)
+using Microsoft.DurableTask;
+
+[DurableTask]
+public class MyOrchestration : TaskOrchestrator<string, string>
+{
+    public override async Task<string> RunAsync(TaskOrchestrationContext context, string input)
+    {
+        return await context.CallActivityAsync<string>(nameof(MyActivity), input);
+    }
+}
+
+[DurableTask]
+public class MyActivity : TaskActivity<string, string>
+{
+    public override Task<string> RunAsync(TaskActivityContext context, string input)
+    {
+        return Task.FromResult($"Processed: {input}");
+    }
+}
+```
+
+#### Class-based example (no input/output, `ILogger` in activity)
+
+```csharp
+using Microsoft.DurableTask;
+using Microsoft.Extensions.Logging;
+
+[DurableTask]
+public class MaintenanceOrchestration : TaskOrchestrator<object?, object?>
 {
-    string input = context.GetInput<string>()!;
-    return await context.CallActivityAsync<string>(nameof(MyActivity), input);
+    public override async Task<object?> RunAsync(TaskOrchestrationContext context, object? input)
+    {
+        await context.CallActivityAsync(nameof(WriteHeartbeatLogActivity), (object?)null);
+        return null;
+    }
 }
 
-[Function(nameof(MyActivity))]
-public static string MyActivity([ActivityTrigger] string input)
+[DurableTask]
+public class WriteHeartbeatLogActivity : TaskActivity<object?, object?>
 {
-    return $"Processed: {input}";
+    private readonly ILogger<WriteHeartbeatLogActivity> _logger;
+
+    public WriteHeartbeatLogActivity(ILogger<WriteHeartbeatLogActivity> logger)
+    {
+        _logger = logger;
+    }
+
+    public override Task<object?> RunAsync(TaskActivityContext context, object? input)
+    {
+        _logger.LogInformation("Heartbeat logged at {Timestamp}.", DateTimeOffset.UtcNow);
+        return Task.FromResult<object?>(null);
+    }
 }
 ```
 
+Use `object?` as the generic type argument for class-based orchestrations and activities that don't need functional input or output. This pattern lets you use dependency injection (for example, `ILogger<T>`) in activities while still using the class-based model.
+
 ## Durable entities
 
 Durable entities are supported in the .NET isolated worker. For more information, see the [developer's guide](./durable-functions-dotnet-entities.md).

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

@@ -92,10 +92,55 @@ 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>
+
+```csharp
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.DurableTask;
+
+namespace SampleApp;
+
+public static class BackupSiteContent
+{
+    [Function("E2_BackupSiteContent")]
+    public static async Task<long> Run(
+        [OrchestrationTrigger] TaskOrchestrationContext context)
+    {
+        string rootDirectory = context.GetInput<string>()?.Trim();
+        if (string.IsNullOrEmpty(rootDirectory))
+        {
+            rootDirectory = Directory.GetParent(typeof(BackupSiteContent).Assembly.Location)!.FullName;
+        }
+
+        string[] files = await context.CallActivityAsync<string[]>("E2_GetFileList", rootDirectory);
+
+        Task<long>[] tasks = files
+            .Select(file => context.CallActivityAsync<long>("E2_CopyFileToBlob", file))
+            .ToArray();
+
+        long[] results = await Task.WhenAll(tasks);
+        return results.Sum();
+    }
+}
+```
+
+</details>
+
+<br>
+
 # [JavaScript](#tab/javascript)
 
 <details>
@@ -321,6 +366,40 @@ The helper activity functions are regular functions that use the `activityTrigge
 
 [!code-csharp[Main](~/samples-durable-functions/samples/precompiled/BackupSiteContent.cs?range=44-54)]
 
+<br>
+
+<details>
+<summary><b>Isolated model</b></summary>
+
+```csharp
+using System.IO;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Extensions.Logging;
+
+namespace SampleApp;
+
+public static class BackupSiteContent
+{
+    [Function("E2_GetFileList")]
+    public static string[] GetFileList(
+        [ActivityTrigger] string rootDirectory,
+        FunctionContext executionContext)
+    {
+        ILogger logger = executionContext.GetLogger("E2_GetFileList");
+        logger.LogInformation("Searching for files under '{RootDirectory}'...", rootDirectory);
+
+        string[] files = Directory.GetFiles(rootDirectory, "*", SearchOption.AllDirectories);
+        logger.LogInformation("Found {FileCount} file(s) under {RootDirectory}.", files.Length, rootDirectory);
+
+        return files;
+    }
+}
+```
+
+</details>
+
+<br>
+
 # [JavaScript](#tab/javascript)
 
 <details>
@@ -385,6 +464,60 @@ Java sample coming soon.
 
 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>
+
+```csharp
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using Azure.Storage.Blobs;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Extensions.Logging;
+
+namespace SampleApp;
+
+public static class BackupSiteContent
+{
+    [Function("E2_CopyFileToBlob")]
+    public static async Task<long> CopyFileToBlob(
+        [ActivityTrigger] string filePath,
+        FunctionContext executionContext)
+    {
+        ILogger logger = executionContext.GetLogger("E2_CopyFileToBlob");
+        long byteCount = new FileInfo(filePath).Length;
+
+        string blobPath = filePath
+            .Substring(Path.GetPathRoot(filePath)!.Length)
+            .Replace('\\', '/');
+        string outputLocation = $"backups/{blobPath}";
+
+        string? connectionString = Environment.GetEnvironmentVariable("AzureWebJobsStorage");
+        if (string.IsNullOrEmpty(connectionString))
+        {
+            throw new InvalidOperationException("AzureWebJobsStorage is not configured.");
+        }
+
+        BlobContainerClient containerClient = new(connectionString, "backups");
+        await containerClient.CreateIfNotExistsAsync();
+        BlobClient blobClient = containerClient.GetBlobClient(blobPath);
+
+        logger.LogInformation("Copying '{FilePath}' to '{OutputLocation}'. Total bytes = {ByteCount}.", filePath, outputLocation, byteCount);
+
+        await using Stream source = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
+        await blobClient.UploadAsync(source, overwrite: true);
+
+        return byteCount;
+    }
+}
+```
+
+</details>
+
+<br>
+
 # [JavaScript](#tab/javascript)
 
 <details>