Merge branch 'main' into release-aio-2603

Author: v-alje

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-instance-management.md

@@ -67,7 +67,7 @@ public static async Task Run(
 ```
 
 > [!NOTE]
-> The previous C# code is for Durable Functions 2.x. For Durable Functions 1.x, use the `OrchestrationClient` attribute instead of the `DurableClient` attribute, and use the `DurableOrchestrationClient` parameter type instead of `IDurableOrchestrationClient`. For more information about the differences between versions, see [Durable Functions versions](durable-functions-versions.md).
+> The previous C# code uses the in-process model with `IDurableOrchestrationClient`, which is marked as obsolete in newer versions of the Durable Functions extension. For new .NET projects, consider using the [.NET isolated worker model](durable-functions-dotnet-isolated-overview.md) with `DurableTaskClient`. For more information, see the [Durable Functions versions](durable-functions-versions.md) article.
 
 # [JavaScript](#tab/javascript)
 
@@ -381,7 +381,7 @@ public static async Task Run(
 ```
 
 > [!NOTE]
-> The previous C# code is for Durable Functions 2.x. For Durable Functions 1.x, use the `OrchestrationClient` attribute instead of the `DurableClient` attribute, and use the `DurableOrchestrationClient` parameter type instead of `IDurableOrchestrationClient`. For more information about the differences between versions, see the [Durable Functions versions](durable-functions-versions.md) article.
+> The previous C# code uses the in-process model with `IDurableOrchestrationClient`, which is marked as obsolete in newer versions of the Durable Functions extension. For new .NET projects, consider using the [.NET isolated worker model](durable-functions-dotnet-isolated-overview.md) with `DurableTaskClient`. For more information, see the [Durable Functions versions](durable-functions-versions.md) article.
 
 # [JavaScript](#tab/javascript)
 
@@ -547,7 +547,7 @@ public static async Task Run(
 ```
 
 > [!NOTE]
-> The previous C# code is for Durable Functions 2.x. For Durable Functions 1.x, you must use `OrchestrationClient` attribute instead of the `DurableClient` attribute, and you must use the `DurableOrchestrationClient` parameter type instead of `IDurableOrchestrationClient`. For more information about the differences between versions, see the [Durable Functions versions](durable-functions-versions.md) article.
+> The previous C# code uses the in-process model with `IDurableOrchestrationClient`, which is marked as obsolete in newer versions of the Durable Functions extension. For new .NET projects, consider using the [.NET isolated worker model](durable-functions-dotnet-isolated-overview.md) with `DurableTaskClient`. For more information, see the [Durable Functions versions](durable-functions-versions.md) article.
 
 # [JavaScript](#tab/javascript)
 
@@ -713,7 +713,7 @@ public static async Task Run(
 ```
 
 > [!NOTE]
-> The previous C# code is for Durable Functions 2.x. For Durable Functions 1.x, you must use `OrchestrationClient` attribute instead of the `DurableClient` attribute, and you must use the `DurableOrchestrationClient` parameter type instead of `IDurableOrchestrationClient`. For more information about the differences between versions, see the [Durable Functions versions](durable-functions-versions.md) article.
+> The previous C# code uses the in-process model with `IDurableOrchestrationClient`, which is marked as obsolete in newer versions of the Durable Functions extension. For new .NET projects, consider using the [.NET isolated worker model](durable-functions-dotnet-isolated-overview.md) with `DurableTaskClient`. For more information, see the [Durable Functions versions](durable-functions-versions.md) article.
 
 # [JavaScript](#tab/javascript)
 
@@ -907,7 +907,7 @@ public static Task Run(
 ```
 
 > [!NOTE]
-> The previous C# code is for Durable Functions 2.x. For Durable Functions 1.x, you must use `OrchestrationClient` attribute instead of the `DurableClient` attribute, and you must use the `DurableOrchestrationClient` parameter type instead of `IDurableOrchestrationClient`. For more information about the differences between versions, see the [Durable Functions versions](durable-functions-versions.md) article.
+> The previous C# code uses the in-process model with `IDurableOrchestrationClient`, which is marked as obsolete in newer versions of the Durable Functions extension. For new .NET projects, consider using the [.NET isolated worker model](durable-functions-dotnet-isolated-overview.md) with `DurableTaskClient`. For more information, see the [Durable Functions versions](durable-functions-versions.md) article.
 
 # [JavaScript](#tab/javascript)
 
@@ -1233,7 +1233,7 @@ public static Task Run(
 ```
 
 > [!NOTE]
-> The previous C# code is for Durable Functions 2.x. For Durable Functions 1.x, you must use `OrchestrationClient` attribute instead of the `DurableClient` attribute, and you must use the `DurableOrchestrationClient` parameter type instead of `IDurableOrchestrationClient`. For more information about the differences between versions, see the [Durable Functions versions](durable-functions-versions.md) article.
+> The previous C# code uses the in-process model with `IDurableOrchestrationClient`, which is marked as obsolete in newer versions of the Durable Functions extension. For new .NET projects, consider using the [.NET isolated worker model](durable-functions-dotnet-isolated-overview.md) with `DurableTaskClient`. For more information, see the [Durable Functions versions](durable-functions-versions.md) article.
 
 # [JavaScript](#tab/javascript)
 
@@ -1612,7 +1612,7 @@ public static void SendInstanceInfo(
 ```
 
 > [!NOTE]
-> The previous C# code is for Durable Functions 2.x. For Durable Functions 1.x, use `DurableActivityContext` instead of `IDurableActivityContext`, use the `OrchestrationClient` attribute instead of the `DurableClient` attribute, and use the `DurableOrchestrationClient` parameter type instead of `IDurableOrchestrationClient`. For more information about the differences between versions, see the [Durable Functions versions](durable-functions-versions.md) article.
+> The previous C# code uses the in-process model with `IDurableOrchestrationClient` and `IDurableActivityContext`, which are marked as obsolete in newer versions of the Durable Functions extension. For new .NET projects, consider using the [.NET isolated worker model](durable-functions-dotnet-isolated-overview.md) with `DurableTaskClient`. For more information, see the [Durable Functions versions](durable-functions-versions.md) article.
 
 # [JavaScript](#tab/javascript)
 
@@ -1704,7 +1704,7 @@ public static Task Run(
 ```
 
 > [!NOTE]
-> The previous C# code is for Durable Functions 2.x. For Durable Functions 1.x, you must use `OrchestrationClient` attribute instead of the `DurableClient` attribute, and you must use the `DurableOrchestrationClient` parameter type instead of `IDurableOrchestrationClient`. For more information about the differences between versions, see the [Durable Functions versions](durable-functions-versions.md) article.
+> The previous C# code uses the in-process model with `IDurableOrchestrationClient`, which is marked as obsolete in newer versions of the Durable Functions extension. For new .NET projects, consider using the [.NET isolated worker model](durable-functions-dotnet-isolated-overview.md) with `DurableTaskClient`. For more information, see the [Durable Functions versions](durable-functions-versions.md) article.
 
 # [JavaScript](#tab/javascript)
 
@@ -1823,7 +1823,7 @@ public static Task Run(
 ```
 
 > [!NOTE]
-> The previous C# code is for Durable Functions 2.x. For Durable Functions 1.x, you must use `OrchestrationClient` attribute instead of the `DurableClient` attribute, and you must use the `DurableOrchestrationClient` parameter type instead of `IDurableOrchestrationClient`. For more information about the differences between versions, see the [Durable Functions versions](durable-functions-versions.md) article.
+> The previous C# code uses the in-process model with `IDurableOrchestrationClient`, which is marked as obsolete in newer versions of the Durable Functions extension. For new .NET projects, consider using the [.NET isolated worker model](durable-functions-dotnet-isolated-overview.md) with `DurableTaskClient`. For more information, see the [Durable Functions versions](durable-functions-versions.md) article.
 
 # [JavaScript](#tab/javascript)
 
@@ -2046,7 +2046,7 @@ public static Task Run(
 ```
 
 > [!NOTE]
-> The previous C# code is for Durable Functions 2.x. For Durable Functions 1.x, you must use `OrchestrationClient` attribute instead of the `DurableClient` attribute, and you must use the `DurableOrchestrationClient` parameter type instead of `IDurableOrchestrationClient`. For more information about the differences between versions, see the [Durable Functions versions](durable-functions-versions.md) article.
+> The previous C# code uses the in-process model with `IDurableOrchestrationClient`, which is marked as obsolete in newer versions of the Durable Functions extension. For new .NET projects, consider using the [.NET isolated worker model](durable-functions-dotnet-isolated-overview.md) with `DurableTaskClient`. For more information, see the [Durable Functions versions](durable-functions-versions.md) article.
 
 # [JavaScript](#tab/javascript)
 

articles/azure-functions/flex-consumption-plan.md

@@ -199,6 +199,7 @@ Keep these other considerations in mind when using Flex Consumption plan:
 + **Certificates**: Loading certificates with the WEBSITE_LOAD_CERTIFICATES app setting, managed certificates, app service certificates, and other platform certificate-based features like endToEndEncryptionEnabled are currently not supported.
 + **Timezones**: `WEBSITE_TIME_ZONE` and `TZ` app settings aren't currently supported when running on Flex Consumption plan.
 + **Azure Functions Runtime Version and Proxies**: Flex Consumption only supports version 4.x and later of the Azure Functions runtime. Azure Functions proxies was a feature of versions 1.x through 3.x of the Azure Functions runtime and is not available in Flex Consumption.
++ **Plan migration**: In-place migration of an existing function app from another hosting plan to the Flex Consumption plan isn't supported, and neither is migrating from Flex Consumption to another plan. To move to Flex Consumption, you must create a new function app in a Flex Consumption plan and redeploy your code.
 
 ## Related articles
 

articles/azure-functions/functions-how-to-use-azure-function-app-settings.md

@@ -193,7 +193,7 @@ In the previous example, replace `<RESOURCE_GROUP>` and `<FUNCTION_APP_NAME>` wi
 You can migrate a function app between a Consumption plan and a Premium plan on Windows. 
 
 >[!TIP]  
->We recommend you migrate your Consumption plan app to run in a Flex Consumption plan instead of a Premium plan. Migration to the Flex Consumption plan is the only migration option for a Linux Consumption plan app. For more information, see [Migrate Consumption plan apps to the Flex Consumption plan](migration/migrate-plan-consumption-to-flex.md).   
+>We recommend you run your Consumption plan app in a Flex Consumption plan instead of a Premium plan. For a Linux Consumption plan app, moving to the Flex Consumption plan is the only option. Because in-place plan migration to and from Flex Consumption isn't supported, you must create a new function app in the Flex Consumption plan. For more information, see [Migrate Consumption plan apps to the Flex Consumption plan](migration/migrate-plan-consumption-to-flex.md), which walks you through creating a new Flex Consumption app with the same settings as your existing app.   
 
 When migrating between plans, keep in mind the following considerations:
 
@@ -203,6 +203,7 @@ When migrating between plans, keep in mind the following considerations:
 + The specific CLI commands depend on the direction of the migration.
 + Downtime in your function executions occurs as the function app is migrated between plans.
 + State and other app-specific content is maintained, because the same Azure Files share is used by the app both before and after migration.
++ In-place plan migration to or from the Flex Consumption plan isn't supported. You must create a new function app in the Flex Consumption plan.
 
 You can migrate your plan using these tools:
 

articles/azure-maps/migrate-route-v1-api.md

@@ -35,11 +35,11 @@ This article explains how to migrate the [Azure Maps Route v1.0] APIs to [Azure
 | Batch operations           | Sync and async requests | Sync requests                            |
 | Coordinate format          | Latitude/longitude | Longitude/latitude, as defined by [GeoJSON].  |
 | Electric consumption model | Supported      | Not supported                                     |
-| Localization               | Use the "language" parameter to localize the language of the route instructions. | Use the “Accept-Language” request header to input a localization code to localize the language of the route instructions. |
+| Localization               | Use the "language" parameter to localize the language of the route instructions. | Use the "Accept-Language" request header to input a localization code to localize the language of the route instructions. |
 | Request type               | GET, POST      | POST                                              |
 | Response format            | XML, JSON      | GeoJSON                                           |
 | Travel mode                | Car, truck, pedestrian.<BR>Beta profiles: Bus, bicycle, motorcycle, taxi, van. | Car, truck, pedestrian. |
-| Waypoint Optimization      | Supported      | Currently only supported for truck routing.       |
+| Waypoint Optimization      | Supported      | supported       |
 | Waypoints                  | Supported      | Supported. Also supports `viaWaypoints` for driving and walking modes. |
 
 ### Route Matrix notable differences