revise propagation path for entity parameters

src/DurableTask.Core/Entities/OrchestrationEntityContext.cs

@@ -61,7 +61,7 @@ public OrchestrationEntityContext(
         /// <summary>
         /// Checks whether the configured backend supports entities.
         /// </summary>
-        public bool EntitiesAreSupported => this.innerContext.EntityBackendProperties != null; 
+        public bool EntitiesAreSupported => this.innerContext.EntityParameters != null; 
 
         /// <summary>
         /// Whether this orchestration is currently inside a critical section.
@@ -312,7 +312,7 @@ internal void AdjustOutgoingMessage(string instanceId, RequestMessage requestMes
                     requestMessage,
                     instanceId,
                     this.innerContext.CurrentUtcDateTime,
-                    this.innerContext.EntityBackendProperties.EntityMessageReorderWindow);
+                    this.innerContext.EntityParameters.EntityMessageReorderWindow);
 
                 eventName = EntityMessageEventNames.RequestMessageEventName;
             }

src/DurableTask.Core/Entities/TaskOrchestrationEntityParameters.cs

@@ -0,0 +1,48 @@
+//  ----------------------------------------------------------------------------------
+//  Copyright Microsoft Corporation
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//  http://www.apache.org/licenses/LICENSE-2.0
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//  ----------------------------------------------------------------------------------
+#nullable enable
+namespace DurableTask.Core.Entities
+{
+    using System;
+    using DurableTask.Core.Serializing;
+
+    /// <summary>
+    /// Settings that determine how a task orchestrator interacts with entities.
+    /// </summary>
+    public class TaskOrchestrationEntityParameters
+    {
+        /// <summary>
+        /// The time window within which entity messages should be deduplicated and reordered.
+        /// This is zero for providers that already guarantee exactly-once and ordered delivery.
+        /// </summary>
+        public TimeSpan EntityMessageReorderWindow { get; set; }
+
+        /// <summary>
+        /// Construct a <see cref="TaskOrchestrationEntityParameters"/> based on the given backend properties.
+        /// </summary>
+        /// <param name="properties">The backend properties.</param>
+        /// <returns>The constructed object, or null if <paramref name="properties"/> is null.</returns>
+        public static TaskOrchestrationEntityParameters? FromEntityBackendProperties(EntityBackendProperties? properties)
+        {
+            if (properties == null)
+            {
+                return null;
+            }
+
+            return new TaskOrchestrationEntityParameters()
+            {
+                EntityMessageReorderWindow = properties.EntityMessageReorderWindow,
+            };
+        }
+    }
+}

src/DurableTask.Core/OrchestrationContext.cs

@@ -71,7 +71,7 @@ public abstract class OrchestrationContext
         /// <summary>
         /// Information about backend entity support, or null if the configured backend does not support entities.
         /// </summary>
-        internal EntityBackendProperties EntityBackendProperties { get; set; }
+        internal TaskOrchestrationEntityParameters EntityParameters { get; set; }
 
         /// <summary>
         ///     Create a proxy client class to schedule remote TaskActivities via a strongly typed interface.

src/DurableTask.Core/TaskEntityDispatcher.cs

@@ -867,12 +867,6 @@ await this.dispatchPipeline.RunAsync(dispatchContext, async _ =>
                         new TypeMissingException($"Entity not found: {entityName}"));
                 }
 
-                var options = new EntityExecutionOptions()
-                {
-                    EntityBackendProperties = this.entityBackendProperties,
-                    ErrorPropagationMode = this.errorPropagationMode,
-                };
-
                 var result = await taskEntity.ExecuteOperationBatchAsync(request);
 
                 dispatchContext.SetProperty(result);

src/DurableTask.Core/TaskOrchestrationContext.cs

@@ -48,7 +48,7 @@ public void AddEventToNextIteration(HistoryEvent he)
         public TaskOrchestrationContext(
             OrchestrationInstance orchestrationInstance,
             TaskScheduler taskScheduler,
-            EntityBackendProperties entityBackendProperties = null,
+            TaskOrchestrationEntityParameters entityParameters = null,
             ErrorPropagationMode errorPropagationMode = ErrorPropagationMode.SerializeExceptions)
         {
             Utils.UnusedParameter(taskScheduler);
@@ -60,7 +60,7 @@ public TaskOrchestrationContext(
             this.ErrorDataConverter = JsonDataConverter.Default;
             OrchestrationInstance = orchestrationInstance;
             IsReplaying = false;
-            this.EntityBackendProperties = entityBackendProperties;
+            this.EntityParameters = entityParameters;
             ErrorPropagationMode = errorPropagationMode;
             this.eventsWhileSuspended = new Queue<HistoryEvent>();
         }

src/DurableTask.Core/TaskOrchestrationDispatcher.cs

@@ -45,6 +45,7 @@ public class TaskOrchestrationDispatcher
         readonly NonBlockingCountdownLock concurrentSessionLock;
         readonly IEntityOrchestrationService? entityOrchestrationService;
         readonly EntityBackendProperties? entityBackendProperties;
+        readonly TaskOrchestrationEntityParameters? entityParameters;
 
         internal TaskOrchestrationDispatcher(
             IOrchestrationService orchestrationService,
@@ -59,8 +60,9 @@ internal TaskOrchestrationDispatcher(
             this.dispatchPipeline = dispatchPipeline ?? throw new ArgumentNullException(nameof(dispatchPipeline));
             this.logHelper = logHelper ?? throw new ArgumentNullException(nameof(logHelper));
             this.errorPropagationMode = errorPropagationMode;
-            this.entityOrchestrationService = entityOrchestrationService;
-            this.entityBackendProperties = this.entityOrchestrationService?.GetEntityBackendProperties();
+            this.entityOrchestrationService = orchestrationService as IEntityOrchestrationService;
+            this.entityBackendProperties = this.entityOrchestrationService?.EntityBackendProperties;
+            this.entityParameters = TaskOrchestrationEntityParameters.FromEntityBackendProperties(this.entityBackendProperties);
 
             this.dispatcher = new WorkItemDispatcher<TaskOrchestrationWorkItem>(
                 "TaskOrchestrationDispatcher",
@@ -682,6 +684,7 @@ async Task<OrchestrationExecutionCursor> ExecuteOrchestrationAsync(Orchestration
             dispatchContext.SetProperty(runtimeState);
             dispatchContext.SetProperty(workItem);
             dispatchContext.SetProperty(GetOrchestrationExecutionContext(runtimeState));
+            dispatchContext.SetProperty(this.entityParameters);
 
             TaskOrchestrationExecutor? executor = null;
 
@@ -709,8 +712,9 @@ await this.dispatchPipeline.RunAsync(dispatchContext, _ =>
                     runtimeState,
                     taskOrchestration,
                     this.orchestrationService.EventBehaviourForContinueAsNew,
-                    this.entityBackendProperties,
-                    this.errorPropagationMode); ;
+                    this.entityParameters,
+                    this.errorPropagationMode);
+
                 OrchestratorExecutionResult resultFromOrchestrator = executor.Execute();
                 dispatchContext.SetProperty(resultFromOrchestrator);
                 return CompletedTask;

src/DurableTask.Core/TaskOrchestrationExecutor.cs

@@ -43,22 +43,21 @@ public class TaskOrchestrationExecutor
         /// <param name="orchestrationRuntimeState"></param>
         /// <param name="taskOrchestration"></param>
         /// <param name="eventBehaviourForContinueAsNew"></param>
-        /// <param name="entityBackendProperties"></param>
+        /// <param name="entityParameters"></param>
         /// <param name="errorPropagationMode"></param>
         public TaskOrchestrationExecutor(
             OrchestrationRuntimeState orchestrationRuntimeState,
             TaskOrchestration taskOrchestration,
             BehaviorOnContinueAsNew eventBehaviourForContinueAsNew,
-            EntityBackendProperties? entityBackendProperties,
+            TaskOrchestrationEntityParameters? entityParameters,
             ErrorPropagationMode errorPropagationMode = ErrorPropagationMode.SerializeExceptions)
         {
             this.decisionScheduler = new SynchronousTaskScheduler();
             this.context = new TaskOrchestrationContext(
                 orchestrationRuntimeState.OrchestrationInstance,
                 this.decisionScheduler,
-                entityBackendProperties,
-                errorPropagationMode
-                );
+                entityParameters,
+                errorPropagationMode);
             this.orchestrationRuntimeState = orchestrationRuntimeState;
             this.taskOrchestration = taskOrchestration;
             this.skipCarryOverEvents = eventBehaviourForContinueAsNew == BehaviorOnContinueAsNew.Ignore;
@@ -77,7 +76,7 @@ public TaskOrchestrationExecutor(
             TaskOrchestration taskOrchestration,
             BehaviorOnContinueAsNew eventBehaviourForContinueAsNew,
             ErrorPropagationMode errorPropagationMode = ErrorPropagationMode.SerializeExceptions)
-            : this(orchestrationRuntimeState, taskOrchestration, eventBehaviourForContinueAsNew, null, errorPropagationMode)
+            : this(orchestrationRuntimeState, taskOrchestration, eventBehaviourForContinueAsNew, entityParameters: null, errorPropagationMode)
         {
         }