Less restrictive contract.Read types, support for properties + fields

Author: 0xFirekeeper

Assets/Thirdweb/Core/Scripts/Contract.cs

@@ -246,11 +246,18 @@ public async Task<T> Read<T>(string functionName, params object[] args)
             // Single
             if (rawResults.Count == 1)
             {
-                return ConvertValue<T>(rawResults[0]);
+                try
+                {
+                    return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(rawResults[0]));
+                }
+                catch
+                {
+                    return ConvertValue<T>(rawResults[0]);
+                }
             }
 
             // List or array
-            if ((typeof(T).IsGenericType && typeof(T).GetGenericTypeDefinition() == typeof(List<>)) || (typeof(T).IsArray))
+            if ((typeof(T).IsGenericType && typeof(T).GetGenericTypeDefinition() == typeof(List<>)) || typeof(T).IsArray)
             {
                 return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(rawResults));
             }
@@ -261,11 +268,13 @@ public async Task<T> Read<T>(string functionName, params object[] args)
                 var targetType = typeof(T);
                 var properties = targetType.GetProperties();
                 var fields = targetType.GetFields();
+                var combinedCount = properties.Length + fields.Length;
 
-                if (rawResults.Count == properties.Length)
-                {
-                    var instance = Activator.CreateInstance<T>();
+                var instance = Activator.CreateInstance<T>();
 
+                if (rawResults.Count == combinedCount)
+                {
+                    // Assign values to properties
                     for (int i = 0; i < properties.Length; i++)
                     {
                         try
@@ -275,18 +284,51 @@ public async Task<T> Read<T>(string functionName, params object[] args)
                         catch (ArgumentException ex)
                         {
                             throw new UnityException(
-                                $"Type mismatch assigning value to property {properties[i].Name}: expected {rawResults[i].GetType().Name}, got {properties[i].PropertyType.Name}",
+                                $"Type mismatch assigning value to property {properties[i].Name} of type {typeof(T).Name}: expected {rawResults[i].GetType().Name}, got {properties[i].PropertyType.Name}",
+                                ex
+                            );
+                        }
+                    }
+
+                    // Assign values to fields
+                    for (int i = 0; i < fields.Length; i++)
+                    {
+                        try
+                        {
+                            fields[i].SetValue(instance, rawResults[properties.Length + i]);
+                        }
+                        catch (ArgumentException ex)
+                        {
+                            throw new UnityException(
+                                $"Type mismatch assigning value to field {fields[i].Name} of type {typeof(T).Name}: expected {rawResults[properties.Length + i].GetType().Name}, got {fields[i].FieldType.Name}",
                                 ex
                             );
                         }
                     }
 
                     return instance;
                 }
-                else if (rawResults.Count == fields.Length)
+                else if (rawResults.Count == properties.Length) // Just Properties
                 {
-                    var instance = Activator.CreateInstance<T>();
+                    for (int i = 0; i < properties.Length; i++)
+                    {
+                        try
+                        {
+                            properties[i].SetValue(instance, rawResults[i]);
+                        }
+                        catch (ArgumentException ex)
+                        {
+                            throw new UnityException(
+                                $"Type mismatch assigning value to property {properties[i].Name} of type {typeof(T).Name}: expected {rawResults[i].GetType().Name}, got {properties[i].PropertyType.Name}",
+                                ex
+                            );
+                        }
+                    }
 
+                    return instance;
+                }
+                else if (rawResults.Count == fields.Length) // Just Fields
+                {
                     for (int i = 0; i < fields.Length; i++)
                     {
                         try
@@ -295,7 +337,10 @@ public async Task<T> Read<T>(string functionName, params object[] args)
                         }
                         catch (ArgumentException ex)
                         {
-                            throw new UnityException($"Type mismatch assigning value to field {fields[i].Name}: expected {rawResults[i].GetType().Name}, got {fields[i].FieldType.Name}", ex);
+                            throw new UnityException(
+                                $"Type mismatch assigning value to field {fields[i].Name} of type {typeof(T).Name}: expected {rawResults[i].GetType().Name}, got {fields[i].FieldType.Name}",
+                                ex
+                            );
                         }
                     }
 
@@ -304,7 +349,7 @@ public async Task<T> Read<T>(string functionName, params object[] args)
                 else
                 {
                     throw new UnityException(
-                        $"The number of properties or fields in the target type do not match the number of results: expected {rawResults.Count}, got {properties.Length} properties and {fields.Length} fields"
+                        $"The number of combined properties and fields in type {typeof(T).Name} does not match the number of results: expected {combinedCount}, got {properties.Length} properties and {fields.Length} fields with {rawResults.Count} results."
                     );
                 }
             }