fix: support deserializing timespan properties (Azure#49967)

* fix: support deserializing timespan properties

* Update sdk/tables/Azure.Data.Tables/tests/TableClientLiveTests.cs

Co-authored-by: Copilot <[email protected]>

* pr feedback

* minor cleanup

* update changelog

---------

Co-authored-by: Copilot <[email protected]>

Author: jorgerangel-msft

sdk/tables/Azure.Data.Tables/CHANGELOG.md

@@ -7,6 +7,8 @@
 ### Breaking Changes
 
 ### Bugs Fixed
+- Fixed an issue where `TimeSpan` properties in strongly typed table entities were not being deserialized.
+- Fixed an issue when deserializing strongly typed table entities with enum properties. Enum values that aren't defined in the enum type are now skipped during deserialization of the table entity.
 
 ### Other Changes
 
@@ -313,4 +315,4 @@ Thank you to our developer community members who helped to make Azure Tables bet
 This is the first beta of the `Azure.Data.Tables` client library. The Azure Tables client library can seamlessly target either Azure Table storage or Azure Cosmos DB table service endpoints with no code changes.
 
 This package's [documentation](https://github.com/Azure/azure-sdk-for-net/blob/main/sdk/tables/Azure.Data.Tables/README.md)
-and [samples](https://github.com/Azure/azure-sdk-for-net/tree/main/sdk/tables/Azure.Data.Tables/samples) demonstrate the new API.
+and [samples](https://github.com/Azure/azure-sdk-for-net/tree/main/sdk/tables/Azure.Data.Tables/samples) demonstrate the new API.

sdk/tables/Azure.Data.Tables/assets.json

@@ -2,5 +2,5 @@
   "AssetsRepo": "Azure/azure-sdk-assets",
   "AssetsRepoPrefixPath": "net",
   "TagPrefix": "net/tables/Azure.Data.Tables",
-  "Tag": "net/tables/Azure.Data.Tables_9bdee2bad4"
+  "Tag": "net/tables/Azure.Data.Tables_f74f623264"
 }

sdk/tables/Azure.Data.Tables/src/Extensions/TablesTypeBinder.cs

@@ -139,32 +139,46 @@ protected override bool TryGet<T>(BoundMemberInfo memberInfo, IDictionary<string
             {
                 value = (T)(object) DateTime.Parse(propertyValue as string, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
             }
+            else if (typeof(T) == typeof(TimeSpan))
+            {
+                value = (T)(object)TypeFormatters.ParseTimeSpan(propertyValue as string, "P");
+            }
+            else if (typeof(T) == typeof(TimeSpan?))
+            {
+                value = (T)(object)TypeFormatters.ParseTimeSpan(propertyValue as string, "P");
+            }
             else if (typeof(T) == typeof(string))
             {
-                value = (T)(object) (propertyValue as string);
+                value = (T)(object)(propertyValue as string);
             }
             else if (typeof(T) == typeof(int))
             {
-                value = (T)(object) (int)propertyValue;
+                value = (T)(object)(int)propertyValue;
             }
             else if (typeof(T) == typeof(int?))
             {
-                value = (T)(object) (int?)propertyValue;
+                value = (T)(object)(int?)propertyValue;
             }
             else if (typeof(T).IsEnum)
             {
-                value = (T)Enum.Parse(memberInfo.Type, propertyValue as string );
+                if (!Enum.IsDefined(memberInfo.Type, propertyValue as string))
+                    return false;
+
+                value = (T)Enum.Parse(memberInfo.Type, propertyValue as string);
             }
             else if (typeof(T).IsGenericType &&
                      typeof(T).GetGenericTypeDefinition() == typeof(Nullable<>) &&
                      typeof(T).GetGenericArguments() is { Length: 1 } arguments &&
                      arguments[0].IsEnum)
             {
-                value = (T)Enum.Parse(arguments[0], propertyValue as string );
+                if (!Enum.IsDefined(arguments[0], propertyValue as string))
+                    return false;
+
+                value = (T)Enum.Parse(arguments[0], propertyValue as string);
             }
             else if (typeof(T) == typeof(ETag))
             {
-                value = (T)(object) new ETag(propertyValue as string);
+                value = (T)(object)new ETag(propertyValue as string);
             }
 
             return true;

sdk/tables/Azure.Data.Tables/tests/TableClientLiveTests.cs

@@ -937,6 +937,29 @@ public async Task CustomEntityCanBeUpserted()
             Assert.That(updatedEntity[propertyName], Is.EqualTo(updatedValue), $"The property value should be {updatedValue}");
         }
 
+        [RecordedTest]
+        public async Task TimespanPropertyInCustomEntityCanBeUpsertedAndRead()
+        {
+            const string rowKeyValue = "1";
+            DateTime date1 = new DateTime(2010, 1, 1, 8, 0, 15);
+            DateTime date2 = new DateTime(2010, 8, 18, 13, 30, 30);
+            TimeSpan interval = date2 - date1;
+            var entity = new TimeSpanTestEntity { PartitionKey = PartitionKeyValue, RowKey = rowKeyValue, TimespanProperty = interval, };
+
+            // Create the new entity.
+            await client.UpsertEntityAsync(entity, TableUpdateMode.Replace).ConfigureAwait(false);
+
+            // Fetch the created entity from the service.
+            var retrievedEntity = (await client.QueryAsync<TimeSpanTestEntity>($"PartitionKey eq '{PartitionKeyValue}' and RowKey eq '{rowKeyValue}'")
+                .ToEnumerableAsync()
+                .ConfigureAwait(false)).Single();
+
+            Assert.IsNotNull(retrievedEntity, "The entity should not be null");
+            Assert.IsTrue(TimeSpan.Compare(
+                retrievedEntity!.TimespanProperty.Value, interval) == 0,
+                "The property value should be equal to the original value");
+        }
+
         /// <summary>
         /// Validates the functionality of the TableClient.
         /// </summary>

sdk/tables/Azure.Data.Tables/tests/TableClientTests.cs

@@ -6,7 +6,6 @@
 using System.Diagnostics.Tracing;
 using System.Linq;
 using System.Net;
-using System.Reflection.Metadata;
 using System.Threading.Tasks;
 using Azure.Core;
 using Azure.Core.Diagnostics;
@@ -370,6 +369,33 @@ public void EnumPropertiesAreDeSerializedProperly()
             Assert.That(dictEntity.TryGetValue(TableConstants.PropertyNames.Timestamp, out var _), Is.False, "Only PK, RK, and user properties should be sent");
         }
 
+        // This test validates that a table entity with an enum property that has an unknown enum value is not deserialized.
+        [Test]
+        public void EnumPropertiesWithUnknownValuesAreNotDeserialized()
+        {
+            Foo foo = (Foo)3;
+            NullableFoo? nullableFoo = (NullableFoo)3;
+            var entity = new EnumEntity
+            {
+                PartitionKey = "partitionKey",
+                RowKey = "01",
+                Timestamp = DateTime.Now,
+                MyFoo = foo,
+                MyNullableFoo = nullableFoo,
+                ETag = ETag.All
+            };
+
+            // Create the new entities.
+            var dictEntity = entity.ToOdataAnnotatedDictionary();
+            var deserializedEntity = dictEntity.ToTableEntity<EnumEntity>();
+            Assert.That(deserializedEntity.PartitionKey, Is.EqualTo(entity.PartitionKey), "The entities should be equivalent");
+            Assert.That(deserializedEntity.RowKey, Is.EqualTo(entity.RowKey), "The entities should be equivalent");
+            Assert.That(deserializedEntity.MyFoo.ToString(), Is.EqualTo(default(Foo).ToString()), "The non-existing enum value should not be deserialized.");
+            Assert.IsNull(deserializedEntity.MyNullableFoo, "The non-existing nullable enum value should not be deserialized.");
+            Assert.IsNull(deserializedEntity.MyNullableFoo2, "The entities should be equivalent.");
+            Assert.That(dictEntity.TryGetValue(TableConstants.PropertyNames.Timestamp, out var _), Is.False, "Only PK, RK, and user properties should be sent");
+        }
+
         [Test]
         public void RoundTripContinuationTokenWithPartitionKeyAndRowKey()
         {

sdk/tables/Azure.Data.Tables/tests/TableServiceLiveTestsBase.cs

@@ -421,6 +421,15 @@ public class SimpleTestEntity : ITableEntity
             public ETag ETag { get; set; }
         }
 
+        public class TimeSpanTestEntity : ITableEntity
+        {
+            public string PartitionKey { get; set; }
+            public string RowKey { get; set; }
+            public DateTimeOffset? Timestamp { get; set; }
+            public ETag ETag { get; set; }
+            public TimeSpan? TimespanProperty { get; set; }
+        }
+
         public class ComplexEntity : ITableEntity
         {
             public const int NumberOfNonNullProperties = 28;