minor refactor to avoid copying a list fix test names

SqlMapper.cs

@@ -118,10 +118,26 @@ public static int ExecuteMapperCommand(this IDbConnection cnn, string sql, objec
             return ExecuteCommand(cnn, transaction, sql, GetParamInfo(param));
         }
 
+
+        static class DynamicStub
+        {
+            public static Type Type = typeof(DynamicStub);
+        }
+
         public static List<dynamic> ExecuteMapperQuery (this IDbConnection cnn, string sql, object param = null, SqlTransaction transaction = null)
         {
-            // TODO: get rid of casting hackery
-            return ExecuteMapperQuery<ExpandoObject>(cnn, sql, param, transaction).Select(s => s as dynamic).ToList();
+            var identity = new Identity(sql, DynamicStub.Type);
+            var list = new List<dynamic>();
+
+            using (var reader = GetReader(cnn, transaction, sql, GetParamInfo(param)))
+            {
+                Func<IDataReader, ExpandoObject> deserializer = GetDeserializer<ExpandoObject>(identity, reader);
+                while (reader.Read())
+                {
+                    list.Add(deserializer(reader));
+                }
+            }
+            return list;
         }
 
        
@@ -131,11 +147,25 @@ public static List<T> ExecuteMapperQuery<T>(this IDbConnection cnn, string sql,
             var rval = new List<T>();
 
             using (var reader = GetReader(cnn, transaction, sql, GetParamInfo(param)))
+            {
+                Func<IDataReader, T> deserializer = GetDeserializer<T>(identity, reader);
+                while (reader.Read())
+                {
+                    rval.Add(deserializer(reader));
+                }
+                // ignore any other grids; note that this might mean we miss exceptions that happen
+                // late in the TDS stream, but that is bad design anyhow
+            }
+
+            return rval;
+        }
+
+        private static Func<IDataReader, T> GetDeserializer<T>(Identity identity, IDataReader reader)
         {
             object oDeserializer;
             if (!cachedSerializers.TryGetValue(identity, out oDeserializer))
             {
-                    if (typeof(T) == typeof(ExpandoObject))
+                if (typeof(T) == DynamicStub.Type || typeof(T) == typeof(ExpandoObject))
                 {
                     oDeserializer = GetDynamicDeserializer(reader);
                 }
@@ -151,15 +181,7 @@ public static List<T> ExecuteMapperQuery<T>(this IDbConnection cnn, string sql,
                 cachedSerializers[identity] = oDeserializer;
             }
             Func<IDataReader, T> deserializer = (Func<IDataReader, T>)oDeserializer;
-                while (reader.Read())
-                {
-                    rval.Add(deserializer(reader));
-                }
-                // ignore any other grids; note that this might mean we miss exceptions that happen
-                // late in the TDS stream, but that is bad design anyhow
-            }
-
-            return rval;
+            return deserializer;
         }
 
         private static List<ParamInfo> GetParamInfo(object param)

Tests.cs

@@ -9,7 +9,7 @@ namespace SqlMapper
     static class TestAssertions
     {
 
-        public static void IsEquals<T>(this T obj, T other)
+        public static void IsEqualTo<T>(this T obj, T other)
         {
             if (!obj.Equals(other))
             {
@@ -17,7 +17,7 @@ public static void IsEquals<T>(this T obj, T other)
             }
         }
 
-        public static void IsSequenceEqual<T>(this IEnumerable<T> obj, IEnumerable<T> other)
+        public static void IsSequenceEqualTo<T>(this IEnumerable<T> obj, IEnumerable<T> other)
         {
             if (!obj.SequenceEqual(other))
             {
@@ -51,20 +51,20 @@ class Tests
         public void SelectListInt()
         {
             connection.ExecuteMapperQuery<int>("select 1 union all select 2 union all select 3")
-              .IsSequenceEqual(new[] { 1, 2, 3 });
+              .IsSequenceEqualTo(new[] { 1, 2, 3 });
         }
 
         public void PassInIntArray()
         {
             connection.ExecuteMapperQuery<int>("select * from (select 1 as Id union all select 2 union all select 3) as X where Id in @Ids", new { Ids = new int[] { 1, 2, 3 }.AsEnumerable() })
-             .IsSequenceEqual(new[] { 1, 2, 3 });
+             .IsSequenceEqualTo(new[] { 1, 2, 3 });
         }
 
 
         public void TestDoubleParam()
         {
             connection.ExecuteMapperQuery<double>("select @d", new { d = 0.1d }).First()
-                .IsEquals(0.1d);
+                .IsEqualTo(0.1d);
         }
 
         public void TestBoolParam()
@@ -76,7 +76,7 @@ public void TestBoolParam()
         public void TestStrings()
         {
             connection.ExecuteMapperQuery<string>(@"select 'a' a union select 'b'")
-                .IsSequenceEqual(new[] { "a", "b" });
+                .IsSequenceEqualTo(new[] { "a", "b" });
         }
 
         public class Dog
@@ -95,13 +95,13 @@ public void TestStrongType()
             var dog = connection.ExecuteMapperQuery<Dog>("select Age = @Age, Id = @Id", new { Age = (int?)null, Id = guid });
             
             dog.Count()
-                .IsEquals(1);
+                .IsEqualTo(1);
 
             dog.First().Age
                 .IsNull();
 
             dog.First().Id
-                .IsEquals(guid);
+                .IsEqualTo(guid);
         }
 
         public void TestExpando()
@@ -109,22 +109,22 @@ public void TestExpando()
             var rows = connection.ExecuteMapperQuery("select 1 A, 2 B union all select 3, 4");
 
             ((int)rows[0].A)
-                .IsEquals(1);
+                .IsEqualTo(1);
 
             ((int)rows[0].B)
-                .IsEquals(2);
+                .IsEqualTo(2);
 
             ((int)rows[1].A)
-                .IsEquals(3);
+                .IsEqualTo(3);
 
             ((int)rows[1].B)
-                .IsEquals(4);
+                .IsEqualTo(4);
         }
 
         public void TestStringList()
         {
             connection.ExecuteMapperQuery<string>("select * from (select 'a' as x union all select 'b' union all select 'c') as T where x in @strings", new {strings = new[] {"a","b","c"}})
-                .IsSequenceEqual(new[] {"a","b","c"});
+                .IsSequenceEqualTo(new[] {"a","b","c"});
         }
 
         public void TestExecuteCommand()
@@ -136,14 +136,14 @@ public void TestExecuteCommand()
     insert #t 
     select @a a union all select @b 
     set nocount on 
-    drop table #t", new {a=1, b=2 }).IsEquals(2);
+    drop table #t", new {a=1, b=2 }).IsEqualTo(2);
         }
 
         public void TestMassiveStrings()
         { 
             var str = new string('X', 20000);
             connection.ExecuteMapperQuery<string>("select @a", new { a = str }).First()
-                .IsEquals(str);
+                .IsEqualTo(str);
         }
 
     }