Add support for async ValueTuple

Author: mythz

src/ServiceStack.OrmLite/Async/OrmLiteUtilExtensionsAsync.cs

@@ -22,7 +22,6 @@ public static T CreateInstance<T>()
 
         public static Task<T> ConvertToAsync<T>(this IDataReader reader, IOrmLiteDialectProvider dialectProvider, CancellationToken token)
         {
-            var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition, dialectProvider);
             return dialectProvider.ReaderRead(reader, () =>
             {
                 if (typeof(T) == typeof(List<object>))
@@ -33,10 +32,11 @@ public static Task<T> ConvertToAsync<T>(this IDataReader reader, IOrmLiteDialect
 
                 var values = new object[reader.FieldCount];
 
-                if (typeof(T).Name.StartsWith("ValueTuple`"))
+                if (typeof(T).IsValueTuple())
                     return reader.ConvertToValueTuple<T>(values, dialectProvider);
 
                 var row = CreateInstance<T>();
+                var indexCache = reader.GetIndexFieldsCache(ModelDefinition<T>.Definition, dialectProvider);
                 row.PopulateWithSqlReader(dialectProvider, reader, indexCache, values);
                 return row;
             }, token).Then(t => { 
@@ -51,8 +51,9 @@ public static Task<List<T>> ConvertToListAsync<T>(this IDataReader reader, IOrmL
             var isObjectList = typeof(T) == typeof(List<object>);
             var isObjectDict = typeof(T) == typeof(Dictionary<string,object>);
             var isDynamic = typeof(T) == typeof(object);
-            var isTuple = typeof(T).Name.StartsWith("Tuple`");
-            var indexCache = isObjectDict || isObjectDict || isTuple
+            var isValueTuple = typeof(T).IsValueTuple();
+            var isTuple = typeof(T).IsTuple();
+            var indexCache = isObjectDict || isObjectDict || isValueTuple || isTuple
                 ? null
                 : reader.GetIndexFieldsCache(ModelDefinition<T>.Definition, dialectProvider, onlyFields);
 
@@ -93,6 +94,11 @@ public static Task<List<T>> ConvertToListAsync<T>(this IDataReader reader, IOrmL
                     }
                     return (T)(object)row;
                 }
+                if (isValueTuple)
+                {
+                    var row = reader.ConvertToValueTuple<T>(values, dialectProvider);
+                    return (T)row;
+                }
                 if (isTuple)
                 {
                     var tupleArgs = reader.ToMultiTuple(dialectProvider, modelIndexCaches, genericArgs, values);

src/ServiceStack.OrmLite/OrmLiteUtils.cs

@@ -81,9 +81,13 @@ public static T CreateInstance<T>()
             return (T)ReflectionExtensions.CreateInstance<T>();
         }
 
+        internal static bool IsTuple(this Type type) => type.Name.StartsWith("Tuple`", StringComparison.Ordinal);
+
+        internal static bool IsValueTuple(this Type type) => type.Name.StartsWith("ValueTuple`", StringComparison.Ordinal);
+
         public static bool IsScalar<T>()
         {
-            var isScalar = typeof(T).IsValueType && !typeof(T).Name.StartsWith("ValueTuple`", StringComparison.Ordinal) || typeof(T) == typeof(string);
+            var isScalar = typeof(T).IsValueType && !typeof(T).IsValueTuple() || typeof(T) == typeof(string);
             return isScalar;
         }
 
@@ -101,7 +105,7 @@ public static T ConvertTo<T>(this IDataReader reader, IOrmLiteDialectProvider di
 
                     var values = new object[reader.FieldCount];
 
-                    if (typeof(T).Name.StartsWith("ValueTuple`"))
+                    if (typeof(T).IsValueTuple())
                         return reader.ConvertToValueTuple<T>(values, dialectProvider);
 
                     var row = CreateInstance<T>();
@@ -222,7 +226,7 @@ public static List<T> ConvertToList<T>(this IDataReader reader, IOrmLiteDialectP
                 }
                 return (List<T>)(object)to.ToList();
             }
-            if (typeof(T).Name.StartsWith("ValueTuple`", StringComparison.Ordinal))
+            if (typeof(T).IsValueTuple())
             {
                 var to = new List<T>();
                 var values = new object[reader.FieldCount];
@@ -236,7 +240,7 @@ public static List<T> ConvertToList<T>(this IDataReader reader, IOrmLiteDialectP
                 }
                 return to;
             }
-            if (typeof(T).Name.StartsWith("Tuple`", StringComparison.Ordinal))
+            if (typeof(T).IsTuple())
             {
                 var to = new List<T>();
                 using (reader)

tests/ServiceStack.OrmLite.Tests/Expression/SqlExpressionTests.cs

@@ -200,6 +200,53 @@ public void Can_Select_as_List_ValueTuple()
             }
         }
 
+        [Test]
+        public async System.Threading.Tasks.Task Can_Select_as_List_ValueTuple_Async()
+        {
+            using (var db = OpenDbConnection())
+            {
+                InitLetters(db);
+                GetIdStats(db);
+
+                //var a = new ValueTuple<int, int, int, int>();
+                //a.Item1 = 1;
+
+                var query = db.From<LetterFrequency>()
+                    .Select("COUNT(*), MIN(Letter), MAX(Letter), Sum(Id)");
+
+                var results = await db.SelectAsync<(int count, string min, string max, int sum)>(query);
+
+                Assert.That(results.Count, Is.EqualTo(1));
+
+                var result = results[0];
+                Assert.That(result.count, Is.EqualTo(10));
+                Assert.That(result.min, Is.EqualTo("A"));
+                Assert.That(result.max, Is.EqualTo("D"));
+                Assert.That(result.sum, Is.EqualTo(letterFrequencySumId));
+
+                var single = await db.SingleAsync<(int count, string min, string max, int sum)>(query);
+                Assert.That(single.count, Is.EqualTo(10));
+                Assert.That(single.min, Is.EqualTo("A"));
+                Assert.That(single.max, Is.EqualTo("D"));
+                Assert.That(single.sum, Is.EqualTo(letterFrequencySumId));
+
+                single = await db.SingleAsync<(int count, string min, string max, int sum)>(
+                    db.From<LetterFrequency>()
+                        .Select(x => new
+                        {
+                            Count = Sql.Count("*"),
+                            Min = Sql.Min(x.Letter),
+                            Max = Sql.Max(x.Letter),
+                            Sum = Sql.Sum(x.Id)
+                        }));
+
+                Assert.That(single.count, Is.EqualTo(10));
+                Assert.That(single.min, Is.EqualTo("A"));
+                Assert.That(single.max, Is.EqualTo("D"));
+                Assert.That(single.sum, Is.EqualTo(letterFrequencySumId));
+            }
+        }
+
         private void CheckDbTypeInsensitiveEquivalency(List<object> result)
         {
             Assert.That(Convert.ToInt64(result[0]), Is.EqualTo(10));