Easier syntax for C# 3.9

Dapper/SqlMapper.cs

@@ -347,6 +347,28 @@ public bool Equals(Identity other)
             }
         }
 
+#if CSHARP30
+        /// <summary>
+        /// Execute parameterized SQL  
+        /// </summary>
+        /// <returns>Number of rows affected</returns>
+        public static int Execute(this IDbConnection cnn, string sql, object param)
+        {
+            return Execute(cnn, sql, param, null, null, null);
+        }
+        /// <summary>
+        /// Executes a query, returning the data typed as per T
+        /// </summary>
+        /// <remarks>the dynamic param may seem a bit odd, but this works around a major usability issue in vs, if it is Object vs completion gets annoying. Eg type new <space> get new object</remarks>
+        /// <returns>A sequence of data of the supplied type; if a basic type (int, string, etc) is queried then the data from the first column in assumed, otherwise an instance is
+        /// created per row, and a direct column-name===member-name mapping is assumed (case insensitive).
+        /// </returns>
+        public static IEnumerable<T> Query<T>(this IDbConnection cnn, string sql, object param)
+        {
+            return Query<T>(cnn, sql, param, null, true, null, null);
+        }
+
+#endif
         /// <summary>
         /// Execute parameterized SQL  
         /// </summary>
@@ -405,8 +427,14 @@ public static IEnumerable<dynamic> Query(this IDbConnection cnn, string sql, dyn
             return Query<FastExpando>(cnn, sql, param as object, transaction, buffered, commandTimeout, commandType);
         }
 #endif
-
-        // the dynamic param may seem a bit odd, but this works around a major usability issue in vs, if it is Object vs completion gets annoying. Eg type new <space> get new object
+        
+        /// <summary>
+        /// Executes a query, returning the data typed as per T
+        /// </summary>
+        /// <remarks>the dynamic param may seem a bit odd, but this works around a major usability issue in vs, if it is Object vs completion gets annoying. Eg type new <space> get new object</remarks>
+        /// <returns>A sequence of data of the supplied type; if a basic type (int, string, etc) is queried then the data from the first column in assumed, otherwise an instance is
+        /// created per row, and a direct column-name===member-name mapping is assumed (case insensitive).
+        /// </returns>
         public static IEnumerable<T> Query<T>(
 #if CSHARP30
             this IDbConnection cnn, string sql, object param, IDbTransaction transaction, bool buffered, int? commandTimeout, CommandType? commandType

DapperTests NET35/Tests.cs

@@ -11,14 +11,12 @@ public class Tests
 
         public void TestBasicStringUsage()
         {
-            var arr = connection.Query<string>("select 'abc' as [Value] union all select @txt", new {txt = "def"}, null, false, null, null).
-                ToArray();
+            var arr = connection.Query<string>("select 'abc' as [Value] union all select @txt", new {txt = "def"}).ToArray();
             arr.IsSequenceEqualTo(new[] { "abc", "def" });
         }
         public void TestClassWithStringUsage()
         {
-            var arr = connection.Query<BasicType>("select 'abc' as [Value] union all select @txt", new { txt = "def" }, null, false, null, null).
-                ToArray();
+            var arr = connection.Query<BasicType>("select 'abc' as [Value] union all select @txt", new { txt = "def" }).ToArray();
             arr.Select(x => x.Value).IsSequenceEqualTo(new[] { "abc", "def" });
         }
         class BasicType