Add HasState and default value to GetState<T>

samples/AzureFunctionsApp/Entities/Counter.cs

@@ -97,6 +97,40 @@ public static Task DispatchAsync([EntityTrigger] TaskEntityDispatcher dispatcher
     }
 }
 
+public static class ManualCounter
+{
+    [Function("Counter_Manual")]
+    public static Task DispatchAsync([EntityTrigger] TaskEntityDispatcher dispatcher)
+    {
+        return dispatcher.DispatchAsync(operation =>
+        {
+            if (operation.State.GetState(typeof(int)) is null)
+            {
+                operation.State.SetState(0);
+            }
+
+            switch (operation.Name.ToLowerInvariant())
+            {
+                case "add":
+                    int state = operation.State.GetState<int>();
+                    state += operation.GetInput<int>();
+                    operation.State.SetState(state);
+                    return new(state);
+                case "reset":
+                    operation.State.SetState(0);
+                    break;
+                case "get":
+                    return new((operation.State.GetState(typeof(int)) as int?) ?? 0);
+                case "delete": 
+                    operation.State.SetState(null);
+                    break; 
+            }
+
+            return default;
+        });
+    }
+}
+
 public static class CounterApis
 {
     /// <summary>
@@ -113,6 +147,10 @@ public static class CounterApis
     /// Add to <see cref="Counter"/>, using the static method.
     /// POST /api/counters/{id}/add/{value}?&mode=2
     /// POST /api/counters/{id}/add/{value}?&mode=static
+    /// 
+    /// Add to <see cref="ManualCounter"/>.
+    /// POST /api/counters/{id}/add/{value}?&mode=3
+    /// POST /api/counters/{id}/add/{value}?&mode=manual
     /// </summary>
     [Function("Counter_Add")]
     public static async Task<HttpResponseData> AddAsync(
@@ -242,6 +280,7 @@ static EntityInstanceId GetEntityId(HttpRequestData request, string key)
             {
                 1 => "counter_state",
                 2 => "counter_alt",
+                3 => "counter_manual",
                 _ => "counter",
             };
         }
@@ -251,6 +290,7 @@ static EntityInstanceId GetEntityId(HttpRequestData request, string key)
             {
                 "state" => "counter_state",
                 "static" => "counter_alt",
+                "manual" => "counter_manual",
                 _ => "counter",
             };
         }

samples/AzureFunctionsApp/Entities/counters.http

@@ -6,6 +6,7 @@
 // mode=0 or mode=entity (default) - dispatch to "counter" entity
 // mode=1 or mode=state - dispatch to "counter_state" entity
 // mode=2 or mode=static - dispatch to "counter_alt" entity
+// mode=3 or mode=manual - dispatch to "counter_manual" entity
 //
 // "counter" and "counter_alt" are the same entities, however they use
 // two different functions to dispatch, and thus are different entities when

src/Abstractions/Entities/TaskEntityState.cs

@@ -8,13 +8,32 @@ namespace Microsoft.DurableTask.Entities;
 /// </summary>
 public abstract class TaskEntityState
 {
+    /// <summary>
+    /// Gets a value indicating whether this entity has state or not yet / anymore.
+    /// </summary>
+    public abstract bool HasState { get; }
+
     /// <summary>
     /// Gets the current state of the entity. This will return <c>null</c> if no state is present, regardless if
     /// <typeparamref name="T"/> is a value-type or not.
     /// </summary>
     /// <typeparam name="T">The type to retrieve.</typeparam>
+    /// <param name="defaultValue">The default value to return if no state is present.</param>
     /// <returns>The entity state.</returns>
-    public virtual T? GetState<T>() => (T?)this.GetState(typeof(T));
+    /// <remarks>
+    /// If no state is present, then <paramref see="defaultValue"/> will be returned but it will <b>not</b> be persisted
+    /// to <see cref="SetState"/>. This must be manually called.
+    /// </remarks>
+    public virtual T? GetState<T>(T? defaultValue = default)
+    {
+        object? state = this.GetState(typeof(T));
+        if (state is T typedState)
+        {
+            return typedState;
+        }
+
+        return defaultValue;
+    }
 
     /// <summary>
     /// Gets the current state of the entity. This will return <c>null</c> if no state is present, regardless if

src/Worker/Core/Shims/TaskEntityShim.cs

@@ -100,14 +100,16 @@ class StateShim : TaskEntityState
 
         string? value;
         object? cachedValue;
-        bool cacheValid;
         string? checkpointValue;
 
         public StateShim(DataConverter dataConverter)
         {
             this.dataConverter = dataConverter;
         }
 
+        /// <inheritdoc />
+        public override bool HasState => this.value != null;
+
         public string? CurrentState
         {
             get => this.value;
@@ -117,7 +119,6 @@ public string? CurrentState
                 {
                     this.value = value;
                     this.cachedValue = null;
-                    this.cacheValid = false;
                 }
             }
         }
@@ -130,29 +131,30 @@ public void Commit()
         public void Rollback()
         {
             this.CurrentState = this.checkpointValue;
+            this.cachedValue = null;
         }
 
         public void Reset()
         {
             this.CurrentState = default;
+            this.cachedValue = null;
         }
 
         public override object? GetState(Type type)
         {
-            if (!this.cacheValid)
+            if (this.cachedValue?.GetType() is Type t && t.IsAssignableFrom(type))
             {
-                this.cachedValue = this.dataConverter.Deserialize(this.value, type);
-                this.cacheValid = true;
+                return this.cachedValue;
             }
 
+            this.cachedValue = this.dataConverter.Deserialize(this.value, type);
             return this.cachedValue;
         }
 
         public override void SetState(object? state)
         {
             this.value = this.dataConverter.Serialize(state);
             this.cachedValue = state;
-            this.cacheValid = true;
         }
     }
 

test/Abstractions.Tests/Entities/Mocks/TestEntityState.cs

@@ -10,6 +10,8 @@ public TestEntityState(object? state)
         this.State = state;
     }
 
+    public override bool HasState => this.State != null;
+
     public object? State { get; private set; }
 
     public override object? GetState(Type type)