Allow As<T> to return null for reference types (#38611)

* Allow As<T> to return null for reference types * Improve cast exception message
Azure · Sep 11, 2023 · 8a37c31 · 8a37c31
1 parent 3a998b0
commit 8a37c31
Show file tree

Hide file tree

Showing 2 changed files with 51 additions and 4 deletions.
diff --git a/sdk/core/Azure.Core.Experimental/src/Variant/Variant.cs b/sdk/core/Azure.Core.Experimental/src/Variant/Variant.cs
@@ -77,7 +77,17 @@ public Variant(object? value)
         }
 
         [DoesNotReturn]
-        private static void ThrowInvalidCast() => throw new InvalidCastException();
+        private static void ThrowInvalidCast(Type? source, Type target)
+        {
+            if (source is null)
+            {
+                throw new InvalidCastException($"Unable to cast null Variant to type '{target}'.");
+            }
+            else
+            {
+                throw new InvalidCastException($"Unable to cast Variant of type '{source}' to type '{target}'.");
+            }
+        }
 
         [DoesNotReturn]
         private static void ThrowArgumentNull(string paramName) => throw new ArgumentNullException(paramName);
@@ -1296,11 +1306,12 @@ private Variant(object o, ulong u)
         {
             // Single return has a significant performance benefit.
 
-            bool result = false;
+            bool result;
 
             if (_object is null)
             {
                 value = default!;
+                result = true;
             }
             else if (typeof(T) == typeof(char[]))
             {
@@ -1380,9 +1391,9 @@ private Variant(object o, ulong u)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public readonly T As<T>()
         {
-            if (!TryGetValue<T>(out T value))
+            if (!TryGetValue(out T value))
             {
-                ThrowInvalidCast();
+                ThrowInvalidCast(Type, typeof(T));
             }
 
             return value;

diff --git a/sdk/core/Azure.Core.Experimental/tests/Variant/VariantUsage.cs b/sdk/core/Azure.Core.Experimental/tests/Variant/VariantUsage.cs
@@ -91,6 +91,42 @@ public void VariantAssignmentHasReferenceSemantics()
             Assert.AreEqual("3", b.As<List<string>>()[0]);
         }
 
+        [Test]
+        public void ReferenceTypesCanBeNull()
+        {
+            string s = null;
+            Variant stringVariant = new(s);
+
+            Assert.AreEqual(Variant.Null, stringVariant);
+            Assert.IsNull(stringVariant.As<string>());
+
+            List<int> list = null;
+            Variant listVariant = new(list);
+
+            Assert.AreEqual(Variant.Null, listVariant);
+            Assert.IsNull(listVariant.As<string>());
+        }
+
+        [Test]
+        public void NonNullableValueTypesCannotBeNull()
+        {
+            int? i = null;
+            Variant intVariant = new(i);
+
+            Assert.AreEqual(Variant.Null, intVariant);
+            Assert.Throws<InvalidCastException>(() => intVariant.As<int>());
+        }
+
+        [Test]
+        public void NullableValueTypesCanBeNull()
+        {
+            int? i = null;
+            Variant intVariant = new(i);
+
+            Assert.AreEqual(Variant.Null, intVariant);
+            Assert.IsNull(intVariant.As<int?>());
+        }
+
         #region Helpers
         public static IEnumerable<Variant[]> VariantValues()
         {