rename schedulehandle and ch to abstract

YunchuWang · YunchuWang · commit 7d76f8c46e0d · 2025-02-25T09:08:22.000-08:00
diff --git a/samples/ScheduleConsoleApp/ScheduleOperations.cs b/samples/ScheduleConsoleApp/ScheduleOperations.cs
@@ -34,7 +34,7 @@ async Task DeleteExistingSchedulesAsync()
         // Delete each existing schedule
         await foreach (ScheduleDescription schedule in schedules)
         {
-            IScheduleHandle handle = this.scheduledTaskClient.GetScheduleHandle(schedule.ScheduleId);
+            ScheduleClient handle = this.scheduledTaskClient.GetDefaultScheduleClient(schedule.ScheduleId);
             await handle.DeleteAsync();
             Console.WriteLine($"Deleted schedule {schedule.ScheduleId}");
         }
@@ -53,28 +53,28 @@ async Task CreateAndManageScheduleAsync()
         };
 
         // Create the schedule and get a handle to it
-        IScheduleHandle scheduleHandle = await this.scheduledTaskClient.CreateScheduleAsync(scheduleOptions);
+        ScheduleClient DefaultScheduleClient = await this.scheduledTaskClient.CreateScheduleAsync(scheduleOptions);
 
         // Get and print the initial schedule description
-        await PrintScheduleDescriptionAsync(scheduleHandle);
+        await PrintScheduleDescriptionAsync(DefaultScheduleClient);
 
         // Pause the schedule
         Console.WriteLine("\nPausing schedule...");
-        await scheduleHandle.PauseAsync();
-        await PrintScheduleDescriptionAsync(scheduleHandle);
+        await DefaultScheduleClient.PauseAsync();
+        await PrintScheduleDescriptionAsync(DefaultScheduleClient);
 
         // Resume the schedule
         Console.WriteLine("\nResuming schedule...");
-        await scheduleHandle.ResumeAsync();
-        await PrintScheduleDescriptionAsync(scheduleHandle);
+        await DefaultScheduleClient.ResumeAsync();
+        await PrintScheduleDescriptionAsync(DefaultScheduleClient);
 
         // Wait for a while to let the schedule run
         await Task.Delay(TimeSpan.FromMinutes(30));
     }
 
-    static async Task PrintScheduleDescriptionAsync(IScheduleHandle scheduleHandle)
+    static async Task PrintScheduleDescriptionAsync(ScheduleClient DefaultScheduleClient)
     {
-        ScheduleDescription scheduleDescription = await scheduleHandle.DescribeAsync();
+        ScheduleDescription scheduleDescription = await DefaultScheduleClient.DescribeAsync();
         Console.WriteLine(scheduleDescription);
         Console.WriteLine("\n\n");
     }
diff --git a/samples/ScheduleWebApp/ScheduleController.cs b/samples/ScheduleWebApp/ScheduleController.cs
@@ -56,7 +56,7 @@ public async Task<ActionResult<ScheduleDescription>> CreateSchedule([FromBody] C
                 StartImmediatelyIfLate = true
             };
 
-            IScheduleHandle handle = await this.scheduledTaskClient.CreateScheduleAsync(creationOptions);
+            ScheduleClient handle = await this.scheduledTaskClient.CreateScheduleAsync(creationOptions);
             ScheduleDescription description = await handle.DescribeAsync();
 
             this.logger.LogInformation("Created new schedule with ID: {ScheduleId}", createScheduleRequest.Id);
@@ -154,7 +154,7 @@ public async Task<ActionResult<ScheduleDescription>> UpdateSchedule(string id, [
 
         try
         {
-            IScheduleHandle handle = this.scheduledTaskClient.GetScheduleHandle(id);
+            ScheduleClient handle = this.scheduledTaskClient.GetDefaultScheduleClient(id);
 
             ScheduleUpdateOptions updateOptions = new ScheduleUpdateOptions
             {
@@ -194,7 +194,7 @@ public async Task<IActionResult> DeleteSchedule(string id)
     {
         try
         {
-            IScheduleHandle handle = this.scheduledTaskClient.GetScheduleHandle(id);
+            ScheduleClient handle = this.scheduledTaskClient.GetDefaultScheduleClient(id);
             await handle.DeleteAsync();
             return this.NoContent();
         }
@@ -219,7 +219,7 @@ public async Task<ActionResult<ScheduleDescription>> PauseSchedule(string id)
     {
         try
         {
-            IScheduleHandle handle = this.scheduledTaskClient.GetScheduleHandle(id);
+            ScheduleClient handle = this.scheduledTaskClient.GetDefaultScheduleClient(id);
             await handle.PauseAsync();
             return this.Ok(await handle.DescribeAsync());
         }
@@ -244,7 +244,7 @@ public async Task<ActionResult<ScheduleDescription>> ResumeSchedule(string id)
     {
         try
         {
-            IScheduleHandle handle = this.scheduledTaskClient.GetScheduleHandle(id);
+            ScheduleClient handle = this.scheduledTaskClient.GetDefaultScheduleClient(id);
             await handle.ResumeAsync();
             return this.Ok(await handle.DescribeAsync());
         }
diff --git a/src/ScheduledTasks/Client/DefaultScheduleClient.cs b/src/ScheduledTasks/Client/DefaultScheduleClient.cs
@@ -11,38 +11,33 @@ namespace Microsoft.DurableTask.ScheduledTasks;
 /// <summary>
 /// Represents a handle to a scheduled task, providing operations for managing the schedule.
 /// </summary>
-class ScheduleHandle : IScheduleHandle
+class DefaultScheduleClient : ScheduleClient
 {
     readonly DurableTaskClient durableTaskClient;
     readonly ILogger logger;
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="ScheduleHandle"/> class.
+    /// Initializes a new instance of the <see cref="DefaultScheduleClient"/> class.
     /// </summary>
     /// <param name="client">The durable task client.</param>
     /// <param name="scheduleId">The ID of the schedule.</param>
     /// <param name="logger">The logger.</param>
     /// <exception cref="ArgumentNullException">Thrown if <paramref name="client"/> or <paramref name="scheduleId"/> is null.</exception>
-    public ScheduleHandle(DurableTaskClient client, string scheduleId, ILogger logger)
+    public DefaultScheduleClient(DurableTaskClient client, string scheduleId, ILogger logger)
+        : base(scheduleId)
     {
         this.durableTaskClient = client ?? throw new ArgumentNullException(nameof(client));
-        this.ScheduleId = scheduleId ?? throw new ArgumentNullException(nameof(scheduleId));
         this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
         this.EntityId = new EntityInstanceId(nameof(Schedule), this.ScheduleId);
     }
 
-    /// <summary>
-    /// Gets the ID of the schedule.
-    /// </summary>
-    public string ScheduleId { get; }
-
     /// <summary>
     /// Gets the entity ID of the schedule.
     /// </summary>
     EntityInstanceId EntityId { get; }
 
     /// <inheritdoc/>
-    public async Task<ScheduleDescription> DescribeAsync(CancellationToken cancellation = default)
+    public override async Task<ScheduleDescription> DescribeAsync(CancellationToken cancellation = default)
     {
         try
         {
@@ -91,7 +86,7 @@ public async Task<ScheduleDescription> DescribeAsync(CancellationToken cancellat
     }
 
     /// <inheritdoc/>
-    public async Task PauseAsync(CancellationToken cancellation = default)
+    public override async Task PauseAsync(CancellationToken cancellation = default)
     {
         try
         {
@@ -126,7 +121,7 @@ public async Task PauseAsync(CancellationToken cancellation = default)
     }
 
     /// <inheritdoc/>
-    public async Task ResumeAsync(CancellationToken cancellation = default)
+    public override async Task ResumeAsync(CancellationToken cancellation = default)
     {
         try
         {
@@ -161,7 +156,7 @@ public async Task ResumeAsync(CancellationToken cancellation = default)
     }
 
     /// <inheritdoc/>
-    public async Task UpdateAsync(ScheduleUpdateOptions updateOptions, CancellationToken cancellation = default)
+    public override async Task UpdateAsync(ScheduleUpdateOptions updateOptions, CancellationToken cancellation = default)
     {
         try
         {
@@ -199,7 +194,7 @@ public async Task UpdateAsync(ScheduleUpdateOptions updateOptions, CancellationT
     // TODO: verify deleting non existent wont throw exception
 
     /// <inheritdoc/>
-    public async Task DeleteAsync(CancellationToken cancellation = default)
+    public override async Task DeleteAsync(CancellationToken cancellation = default)
     {
         try
         {
diff --git a/src/ScheduledTasks/Client/IScheduleHandle.cs b/src/ScheduledTasks/Client/IScheduleHandle.cs
diff --git a/src/ScheduledTasks/Client/IScheduledTaskClient.cs b/src/ScheduledTasks/Client/IScheduledTaskClient.cs
@@ -13,7 +13,7 @@ public interface IScheduledTaskClient
     /// </summary>
     /// <param name="scheduleId">The ID of the schedule.</param>
     /// <returns>A handle to manage the schedule.</returns>
-    IScheduleHandle GetScheduleHandle(string scheduleId);
+    ScheduleClient GetDefaultScheduleClient(string scheduleId);
 
     /// <summary>
     /// Gets a schedule description by its ID.
@@ -36,5 +36,5 @@ public interface IScheduledTaskClient
     /// <param name="creationOptions">The options for creating the schedule.</param>
     /// <param name="cancellation">Optional cancellation token.</param>
     /// <returns>A handle to the created schedule.</returns>
-    Task<IScheduleHandle> CreateScheduleAsync(ScheduleCreationOptions creationOptions, CancellationToken cancellation = default);
+    Task<ScheduleClient> CreateScheduleAsync(ScheduleCreationOptions creationOptions, CancellationToken cancellation = default);
 }
diff --git a/src/ScheduledTasks/Client/ScheduleClient.cs b/src/ScheduledTasks/Client/ScheduleClient.cs
@@ -0,0 +1,72 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Microsoft.DurableTask.ScheduledTasks;
+
+/// <summary>
+/// Represents a handle to a schedule, allowing operations on a specific schedule instance.
+/// </summary>
+public abstract class ScheduleClient
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ScheduleClient"/> class.
+    /// </summary>
+    /// <param name="scheduleId">Id of schedule.</param>
+    protected ScheduleClient(string scheduleId)
+    {
+        this.ScheduleId = Check.NotNullOrEmpty(scheduleId, nameof(scheduleId));
+    }
+
+    /// <summary>
+    /// Gets the ID of this schedule.
+    /// </summary>
+    public string ScheduleId { get; }
+
+    /// <summary>
+    /// Retrieves the current details of this schedule.
+    /// </summary>
+    /// <param name="cancellation">The cancellation token that can be used to cancel the operation.</param>
+    /// <returns>A task that returns the schedule details when complete.</returns>
+    public abstract Task<ScheduleDescription> DescribeAsync(CancellationToken cancellation = default);
+
+    /// <summary>
+    /// Deletes this schedule.
+    /// </summary>
+    /// <remarks>
+    /// The schedule will stop executing and be removed from the system.
+    /// </remarks>
+    /// <param name="cancellation">The cancellation token that can be used to cancel the operation.</param>
+    /// <returns>A task that completes when the schedule has been deleted.</returns>
+    public abstract Task DeleteAsync(CancellationToken cancellation = default);
+
+    /// <summary>
+    /// Pauses this schedule.
+    /// </summary>
+    /// <remarks>
+    /// The schedule will stop executing but remain in the system.
+    /// </remarks>
+    /// <param name="cancellation">The cancellation token that can be used to cancel the operation.</param>
+    /// <returns>A task that completes when the schedule has been paused.</returns>
+    public abstract Task PauseAsync(CancellationToken cancellation = default);
+
+    /// <summary>
+    /// Resumes this schedule.
+    /// </summary>
+    /// <remarks>
+    /// The schedule will continue executing from where it was paused.
+    /// </remarks>
+    /// <param name="cancellation">The cancellation token that can be used to cancel the operation.</param>
+    /// <returns>A task that completes when the schedule has been resumed.</returns>
+    public abstract Task ResumeAsync(CancellationToken cancellation = default);
+
+    /// <summary>
+    /// Updates this schedule with new configuration.
+    /// </summary>
+    /// <remarks>
+    /// The schedule will continue executing with the new configuration.
+    /// </remarks>
+    /// <param name="updateOptions">The options for updating the schedule configuration.</param>
+    /// <param name="cancellation">The cancellation token that can be used to cancel the operation.</param>
+    /// <returns>A task that completes when the schedule has been updated.</returns>
+    public abstract Task UpdateAsync(ScheduleUpdateOptions updateOptions, CancellationToken cancellation = default);
+}
diff --git a/src/ScheduledTasks/Client/ScheduledTaskClient.cs b/src/ScheduledTasks/Client/ScheduledTaskClient.cs
@@ -17,7 +17,7 @@ public class ScheduledTaskClient(DurableTaskClient durableTaskClient, ILogger lo
     readonly ILogger logger = Check.NotNull(logger, nameof(logger));
 
     /// <inheritdoc/>
-    public async Task<IScheduleHandle> CreateScheduleAsync(ScheduleCreationOptions creationOptions, CancellationToken cancellation = default)
+    public async Task<ScheduleClient> CreateScheduleAsync(ScheduleCreationOptions creationOptions, CancellationToken cancellation = default)
     {
         Check.NotNull(creationOptions, nameof(creationOptions));
         this.logger.ClientCreatingSchedule(creationOptions);
@@ -43,7 +43,7 @@ public async Task<IScheduleHandle> CreateScheduleAsync(ScheduleCreationOptions c
             }
 
             // Return a handle to the schedule
-            return new ScheduleHandle(this.durableTaskClient, scheduleId, this.logger);
+            return new DefaultScheduleClient(this.durableTaskClient, scheduleId, this.logger);
         }
         catch (OperationCanceledException ex)
         {
@@ -108,10 +108,10 @@ public async Task<IScheduleHandle> CreateScheduleAsync(ScheduleCreationOptions c
     }
 
     /// <inheritdoc/>
-    public IScheduleHandle GetScheduleHandle(string scheduleId)
+    public ScheduleClient GetDefaultScheduleClient(string scheduleId)
     {
         Check.NotNullOrEmpty(scheduleId, nameof(scheduleId));
-        return new ScheduleHandle(this.durableTaskClient, scheduleId, this.logger);
+        return new DefaultScheduleClient(this.durableTaskClient, scheduleId, this.logger);
     }
 
     /// <inheritdoc/>

Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ public async Task<ActionResult<ScheduleDescription>> CreateSchedule([FromBody] C`
`56`	`56`	`StartImmediatelyIfLate = true`
`57`	`57`	`};`
`58`	`58`
`59`		`- IScheduleHandle handle = await this.scheduledTaskClient.CreateScheduleAsync(creationOptions);`
	`59`	`+ ScheduleClient handle = await this.scheduledTaskClient.CreateScheduleAsync(creationOptions);`
`60`	`60`	`ScheduleDescription description = await handle.DescribeAsync();`
`61`	`61`
`62`	`62`	`this.logger.LogInformation("Created new schedule with ID: {ScheduleId}", createScheduleRequest.Id);`
`@@ -154,7 +154,7 @@ public async Task<ActionResult<ScheduleDescription>> UpdateSchedule(string id, [`
`154`	`154`
`155`	`155`	`try`
`156`	`156`	`{`
`157`		`- IScheduleHandle handle = this.scheduledTaskClient.GetScheduleHandle(id);`
	`157`	`+ ScheduleClient handle = this.scheduledTaskClient.GetDefaultScheduleClient(id);`
`158`	`158`
`159`	`159`	`ScheduleUpdateOptions updateOptions = new ScheduleUpdateOptions`
`160`	`160`	`{`
`@@ -194,7 +194,7 @@ public async Task<IActionResult> DeleteSchedule(string id)`
`194`	`194`	`{`
`195`	`195`	`try`
`196`	`196`	`{`
`197`		`- IScheduleHandle handle = this.scheduledTaskClient.GetScheduleHandle(id);`
	`197`	`+ ScheduleClient handle = this.scheduledTaskClient.GetDefaultScheduleClient(id);`
`198`	`198`	`await handle.DeleteAsync();`
`199`	`199`	`return this.NoContent();`
`200`	`200`	`}`
`@@ -219,7 +219,7 @@ public async Task<ActionResult<ScheduleDescription>> PauseSchedule(string id)`
`219`	`219`	`{`
`220`	`220`	`try`
`221`	`221`	`{`
`222`		`- IScheduleHandle handle = this.scheduledTaskClient.GetScheduleHandle(id);`
	`222`	`+ ScheduleClient handle = this.scheduledTaskClient.GetDefaultScheduleClient(id);`
`223`	`223`	`await handle.PauseAsync();`
`224`	`224`	`return this.Ok(await handle.DescribeAsync());`
`225`	`225`	`}`
`@@ -244,7 +244,7 @@ public async Task<ActionResult<ScheduleDescription>> ResumeSchedule(string id)`
`244`	`244`	`{`
`245`	`245`	`try`
`246`	`246`	`{`
`247`		`- IScheduleHandle handle = this.scheduledTaskClient.GetScheduleHandle(id);`
	`247`	`+ ScheduleClient handle = this.scheduledTaskClient.GetDefaultScheduleClient(id);`
`248`	`248`	`await handle.ResumeAsync();`
`249`	`249`	`return this.Ok(await handle.DescribeAsync());`
`250`	`250`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,38 +11,33 @@ namespace Microsoft.DurableTask.ScheduledTasks;`
`11`	`11`	`/// <summary>`
`12`	`12`	`/// Represents a handle to a scheduled task, providing operations for managing the schedule.`
`13`	`13`	`/// </summary>`
`14`		`-class ScheduleHandle : IScheduleHandle`
	`14`	`+class DefaultScheduleClient : ScheduleClient`
`15`	`15`	`{`
`16`	`16`	`readonly DurableTaskClient durableTaskClient;`
`17`	`17`	`readonly ILogger logger;`
`18`	`18`
`19`	`19`	`/// <summary>`
`20`		`- /// Initializes a new instance of the <see cref="ScheduleHandle"/> class.`
	`20`	`+ /// Initializes a new instance of the <see cref="DefaultScheduleClient"/> class.`
`21`	`21`	`/// </summary>`
`22`	`22`	`/// <param name="client">The durable task client.</param>`
`23`	`23`	`/// <param name="scheduleId">The ID of the schedule.</param>`
`24`	`24`	`/// <param name="logger">The logger.</param>`
`25`	`25`	`/// <exception cref="ArgumentNullException">Thrown if <paramref name="client"/> or <paramref name="scheduleId"/> is null.</exception>`
`26`		`- public ScheduleHandle(DurableTaskClient client, string scheduleId, ILogger logger)`
	`26`	`+ public DefaultScheduleClient(DurableTaskClient client, string scheduleId, ILogger logger)`
	`27`	`+ : base(scheduleId)`
`27`	`28`	`{`
`28`	`29`	`this.durableTaskClient = client ?? throw new ArgumentNullException(nameof(client));`
`29`		`- this.ScheduleId = scheduleId ?? throw new ArgumentNullException(nameof(scheduleId));`
`30`	`30`	`this.logger = logger ?? throw new ArgumentNullException(nameof(logger));`
`31`	`31`	`this.EntityId = new EntityInstanceId(nameof(Schedule), this.ScheduleId);`
`32`	`32`	`}`
`33`	`33`
`34`		`- /// <summary>`
`35`		`- /// Gets the ID of the schedule.`
`36`		`- /// </summary>`
`37`		`- public string ScheduleId { get; }`
`38`		`-`
`39`	`34`	`/// <summary>`
`40`	`35`	`/// Gets the entity ID of the schedule.`
`41`	`36`	`/// </summary>`
`42`	`37`	`EntityInstanceId EntityId { get; }`
`43`	`38`
`44`	`39`	`/// <inheritdoc/>`
`45`		`- public async Task<ScheduleDescription> DescribeAsync(CancellationToken cancellation = default)`
	`40`	`+ public override async Task<ScheduleDescription> DescribeAsync(CancellationToken cancellation = default)`
`46`	`41`	`{`
`47`	`42`	`try`
`48`	`43`	`{`
`@@ -91,7 +86,7 @@ public async Task<ScheduleDescription> DescribeAsync(CancellationToken cancellat`
`91`	`86`	`}`
`92`	`87`
`93`	`88`	`/// <inheritdoc/>`
`94`		`- public async Task PauseAsync(CancellationToken cancellation = default)`
	`89`	`+ public override async Task PauseAsync(CancellationToken cancellation = default)`
`95`	`90`	`{`
`96`	`91`	`try`
`97`	`92`	`{`
`@@ -126,7 +121,7 @@ public async Task PauseAsync(CancellationToken cancellation = default)`
`126`	`121`	`}`
`127`	`122`
`128`	`123`	`/// <inheritdoc/>`
`129`		`- public async Task ResumeAsync(CancellationToken cancellation = default)`
	`124`	`+ public override async Task ResumeAsync(CancellationToken cancellation = default)`
`130`	`125`	`{`
`131`	`126`	`try`
`132`	`127`	`{`
`@@ -161,7 +156,7 @@ public async Task ResumeAsync(CancellationToken cancellation = default)`
`161`	`156`	`}`
`162`	`157`
`163`	`158`	`/// <inheritdoc/>`
`164`		`- public async Task UpdateAsync(ScheduleUpdateOptions updateOptions, CancellationToken cancellation = default)`
	`159`	`+ public override async Task UpdateAsync(ScheduleUpdateOptions updateOptions, CancellationToken cancellation = default)`
`165`	`160`	`{`
`166`	`161`	`try`
`167`	`162`	`{`
`@@ -199,7 +194,7 @@ public async Task UpdateAsync(ScheduleUpdateOptions updateOptions, CancellationT`
`199`	`194`	`// TODO: verify deleting non existent wont throw exception`
`200`	`195`
`201`	`196`	`/// <inheritdoc/>`
`202`		`- public async Task DeleteAsync(CancellationToken cancellation = default)`
	`197`	`+ public override async Task DeleteAsync(CancellationToken cancellation = default)`
`203`	`198`	`{`
`204`	`199`	`try`
`205`	`200`	`{`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public class ScheduledTaskClient(DurableTaskClient durableTaskClient, ILogger lo`
`17`	`17`	`readonly ILogger logger = Check.NotNull(logger, nameof(logger));`
`18`	`18`
`19`	`19`	`/// <inheritdoc/>`
`20`		`- public async Task<IScheduleHandle> CreateScheduleAsync(ScheduleCreationOptions creationOptions, CancellationToken cancellation = default)`
	`20`	`+ public async Task<ScheduleClient> CreateScheduleAsync(ScheduleCreationOptions creationOptions, CancellationToken cancellation = default)`
`21`	`21`	`{`
`22`	`22`	`Check.NotNull(creationOptions, nameof(creationOptions));`
`23`	`23`	`this.logger.ClientCreatingSchedule(creationOptions);`
`@@ -43,7 +43,7 @@ public async Task<IScheduleHandle> CreateScheduleAsync(ScheduleCreationOptions c`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`// Return a handle to the schedule`
`46`		`- return new ScheduleHandle(this.durableTaskClient, scheduleId, this.logger);`
	`46`	`+ return new DefaultScheduleClient(this.durableTaskClient, scheduleId, this.logger);`
`47`	`47`	`}`
`48`	`48`	`catch (OperationCanceledException ex)`
`49`	`49`	`{`
`@@ -108,10 +108,10 @@ public async Task<IScheduleHandle> CreateScheduleAsync(ScheduleCreationOptions c`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`/// <inheritdoc/>`
`111`		`- public IScheduleHandle GetScheduleHandle(string scheduleId)`
	`111`	`+ public ScheduleClient GetDefaultScheduleClient(string scheduleId)`
`112`	`112`	`{`
`113`	`113`	`Check.NotNullOrEmpty(scheduleId, nameof(scheduleId));`
`114`		`- return new ScheduleHandle(this.durableTaskClient, scheduleId, this.logger);`
	`114`	`+ return new DefaultScheduleClient(this.durableTaskClient, scheduleId, this.logger);`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`/// <inheritdoc/>`