Fold newInput and preserveUnprocessedEvents into ContinueAsNewOptions

Address review feedback from cgillum: fold newInput and
preserveUnprocessedEvents into ContinueAsNewOptions so the new overload
takes a single ContinueAsNewOptions parameter.

- Add NewInput and PreserveUnprocessedEvents properties to ContinueAsNewOptions
- Change ContinueAsNew(ContinueAsNewOptions?, object?, bool) to ContinueAsNew(ContinueAsNewOptions)
- Update TaskOrchestrationContextWrapper to match
- Update unit and integration tests

Author: YunchuWang

src/Abstractions/ContinueAsNewOptions.cs

@@ -4,10 +4,26 @@
 namespace Microsoft.DurableTask;
 
 /// <summary>
-/// Options for <see cref="TaskOrchestrationContext.ContinueAsNew(ContinueAsNewOptions, object?, bool)"/>.
+/// Options for <see cref="TaskOrchestrationContext.ContinueAsNew(ContinueAsNewOptions)"/>.
 /// </summary>
 public class ContinueAsNewOptions
 {
+    /// <summary>
+    /// Gets or sets the JSON-serializable input data to re-initialize the instance with.
+    /// </summary>
+    public object? NewInput { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to preserve unprocessed external events
+    /// across the restart. Defaults to <c>true</c>.
+    /// </summary>
+    /// <remarks>
+    /// When set to <c>true</c>, any unprocessed external events are re-added into the new execution
+    /// history when the orchestration instance restarts. When <c>false</c>, any unprocessed
+    /// external events will be discarded when the orchestration instance restarts.
+    /// </remarks>
+    public bool PreserveUnprocessedEvents { get; set; } = true;
+
     /// <summary>
     /// Gets or sets the new version for the restarted orchestration instance.
     /// </summary>

src/Abstractions/TaskOrchestrationContext.cs

@@ -416,34 +416,29 @@ public virtual Task CallSubOrchestratorAsync(
     public abstract void ContinueAsNew(object? newInput = null, bool preserveUnprocessedEvents = true);
 
     /// <summary>
-    /// Restarts the orchestration, optionally with a new version, clearing the history.
+    /// Restarts the orchestration with the specified options, clearing the history.
     /// </summary>
     /// <remarks>
     /// <para>
-    /// This overload accepts <see cref="ContinueAsNewOptions"/> to control the restart behavior.
+    /// This overload accepts <see cref="ContinueAsNewOptions"/> to control the restart behavior,
+    /// including the new input, whether to preserve unprocessed events, and an optional new version.
     /// When <see cref="ContinueAsNewOptions.NewVersion"/> is set, the framework uses the new version
     /// to route the restarted instance to the appropriate orchestrator implementation, enabling
-    /// version-based dispatch. When no version is specified (i.e., <paramref name="options"/> is
-    /// <c>null</c> or <c>NewVersion</c> is not set), this method behaves identically to
-    /// <see cref="ContinueAsNew(object?, bool)"/>.
+    /// version-based dispatch.
     /// </para><para>
-    /// The default implementation ignores <paramref name="options"/> and delegates to
-    /// <see cref="ContinueAsNew(object?, bool)"/>. Subclasses that support version-based
+    /// The default implementation delegates to
+    /// <see cref="ContinueAsNew(object?, bool)"/> using the input and preserve-events values
+    /// from <paramref name="options"/>. Subclasses that support version-based
     /// dispatch should override this method.
     /// </para><para>
     /// Orchestrator implementations should complete immediately after calling this method.
     /// </para>
     /// </remarks>
-    /// <param name="options">Options for the continue-as-new operation, including an optional new version.</param>
-    /// <param name="newInput">The JSON-serializable input data to re-initialize the instance with.</param>
-    /// <param name="preserveUnprocessedEvents">
-    /// If set to <c>true</c>, re-adds any unprocessed external events into the new execution
-    /// history when the orchestration instance restarts. If <c>false</c>, any unprocessed
-    /// external events will be discarded when the orchestration instance restarts.
-    /// </param>
-    public virtual void ContinueAsNew(ContinueAsNewOptions? options, object? newInput, bool preserveUnprocessedEvents)
+    /// <param name="options">Options for the continue-as-new operation.</param>
+    public virtual void ContinueAsNew(ContinueAsNewOptions options)
     {
-        this.ContinueAsNew(newInput, preserveUnprocessedEvents);
+        Check.NotNull(options);
+        this.ContinueAsNew(options.NewInput, options.PreserveUnprocessedEvents);
     }
 
     /// <summary>

src/Worker/Core/Shims/TaskOrchestrationContextWrapper.cs

@@ -337,22 +337,28 @@ public override void SetCustomStatus(object? customStatus)
     /// <inheritdoc/>
     public override void ContinueAsNew(object? newInput = null, bool preserveUnprocessedEvents = true)
     {
-        this.ContinueAsNew(options: null, newInput, preserveUnprocessedEvents);
+        this.ContinueAsNew(new ContinueAsNewOptions
+        {
+            NewInput = newInput,
+            PreserveUnprocessedEvents = preserveUnprocessedEvents,
+        });
     }
 
     /// <inheritdoc/>
-    public override void ContinueAsNew(ContinueAsNewOptions? options, object? newInput, bool preserveUnprocessedEvents)
+    public override void ContinueAsNew(ContinueAsNewOptions options)
     {
-        if (!string.IsNullOrWhiteSpace(options?.NewVersion))
+        Check.NotNull(options);
+
+        if (!string.IsNullOrWhiteSpace(options.NewVersion))
         {
-            this.innerContext.ContinueAsNew(options.NewVersion, newInput);
+            this.innerContext.ContinueAsNew(options.NewVersion, options.NewInput);
         }
         else
         {
-            this.innerContext.ContinueAsNew(newInput);
+            this.innerContext.ContinueAsNew(options.NewInput);
         }
 
-        if (preserveUnprocessedEvents)
+        if (options.PreserveUnprocessedEvents)
         {
             // Send all the buffered external events to ourself.
             OrchestrationInstance instance = new() { InstanceId = this.InstanceId };

test/Grpc.IntegrationTests/OrchestrationPatterns.cs

@@ -593,7 +593,7 @@ public async Task ContinueAsNewWithNewVersion()
                 {
                     // First generation: migrate to "v2"
                     await ctx.CreateTimer(TimeSpan.Zero, CancellationToken.None);
-                    ctx.ContinueAsNew(new ContinueAsNewOptions { NewVersion = "v2" }, input + 1, true);
+                    ctx.ContinueAsNew(new ContinueAsNewOptions { NewVersion = "v2", NewInput = input + 1 });
                     return string.Empty;
                 }
 

test/Worker/Core.Tests/Shims/TaskOrchestrationContextWrapperTests.cs

@@ -71,23 +71,32 @@ public void ContinueAsNew_WithVersion_CallsInnerContextWithVersion()
         TaskOrchestrationContextWrapper wrapper = new(innerContext, invocationContext, "input");
 
         // Act
-        wrapper.ContinueAsNew(new ContinueAsNewOptions { NewVersion = "v2" }, "new-input", preserveUnprocessedEvents: false);
+        wrapper.ContinueAsNew(new ContinueAsNewOptions
+        {
+            NewVersion = "v2",
+            NewInput = "new-input",
+            PreserveUnprocessedEvents = false,
+        });
 
         // Assert
         innerContext.LastContinueAsNewInput.Should().Be("new-input");
         innerContext.LastContinueAsNewVersion.Should().Be("v2");
     }
 
     [Fact]
-    public void ContinueAsNew_WithNullOptions_CallsInnerContextWithoutVersion()
+    public void ContinueAsNew_WithOptionsNoVersion_CallsInnerContextWithoutVersion()
     {
         // Arrange
         TrackingOrchestrationContext innerContext = new();
         OrchestrationInvocationContext invocationContext = new("Test", new(), NullLoggerFactory.Instance, null);
         TaskOrchestrationContextWrapper wrapper = new(innerContext, invocationContext, "input");
 
         // Act
-        wrapper.ContinueAsNew(options: null, newInput: "new-input", preserveUnprocessedEvents: false);
+        wrapper.ContinueAsNew(new ContinueAsNewOptions
+        {
+            NewInput = "new-input",
+            PreserveUnprocessedEvents = false,
+        });
 
         // Assert
         innerContext.LastContinueAsNewInput.Should().Be("new-input");