From 8f6f515cfd043afffe83ea4bc02fd0428d53e61b Mon Sep 17 00:00:00 2001
From: busterwood <chris.j.austin@gmail.com>
Date: Fri, 18 Mar 2016 12:39:17 +0000
Subject: [PATCH] Rename datareader extension methods from "To..." to "Read..."
 to avoid conflicts with Linq extension methods names

---
 Mapper/CommandExtension.cs        | 40 +++++++++++++++----------------
 Mapper/ConnectionExtension.cs     | 28 +++++++++++-----------
 Mapper/DataReaderExtensions.cs    | 21 ++++++++--------
 Mapper/Mapper.nuspec              |  2 +-
 Mapper/Properties/AssemblyInfo.cs |  4 ++--
 README.md                         | 20 ++++++++--------
 6 files changed, 57 insertions(+), 58 deletions(-)

diff --git a/Mapper/CommandExtension.cs b/Mapper/CommandExtension.cs
index dff6f0a..695f9c2 100644
--- a/Mapper/CommandExtension.cs
+++ b/Mapper/CommandExtension.cs
@@ -17,117 +17,117 @@ public static class DbCommandExtensions
 
         /// <summary>Executes the <paramref name="cmd"/> reading exactly one item</summary>
         /// <exception cref="InvalidOperationException"> when zero values read or more than one value can be read</exception>
-        public static T ReadSingle<T>(this IDbCommand cmd)
+        public static T ExecuteSingle<T>(this IDbCommand cmd)
         {
             Contract.Requires(cmd != null);
             Contract.Ensures(Contract.Result<T>() != null);
             using (var reader = cmd.ExecuteReader(CommandBehavior.SingleRow))
             {
-                return reader.Single<T>();
+                return reader.ReadSingle<T>();
             }
         }
 
         /// <summary>Executes the <paramref name="cmd"/> reading exactly one item</summary>
         /// <exception cref="InvalidOperationException"> when zero values read or more than one value can be read</exception>
-        public static async Task<T> ReadSingleAsync<T>(this SqlCommand cmd)
+        public static async Task<T> ExecuteSingleAsync<T>(this SqlCommand cmd)
         {
             Contract.Requires(cmd != null);
             Contract.Ensures(Contract.Result<T>() != null);
             using (var reader = await cmd.ExecuteReaderAsync(CommandBehavior.SingleRow))
             {
-                return await reader.SingleAsync<T>();
+                return await reader.ReadSingleAsync<T>();
             }
         }
 
         /// <summary>Executes the <paramref name="cmd"/> reading one item</summary>
         /// <remarks>Returns the default vaue of T if no values be read, i.e may return null</remarks>
-        public static T ReadSingleOrDefault<T>(this IDbCommand cmd)
+        public static T ExecuteSingleOrDefault<T>(this IDbCommand cmd)
         {
             Contract.Requires(cmd != null);
             using (var reader = cmd.ExecuteReader(CommandBehavior.SingleRow))
             {
-                return reader.SingleOrDefault<T>();
+                return reader.ReadSingleOrDefault<T>();
             }
         }
 
         /// <summary>Executes the <paramref name="cmd"/> reading one item</summary>
         /// <remarks>Returns the default vaue of T if no values be read, i.e may return null</remarks>
-        public static async Task<T> ReadSingleOrDefaultAsync<T>(this SqlCommand cmd)
+        public static async Task<T> ExecuteSingleOrDefaultAsync<T>(this SqlCommand cmd)
         {
             Contract.Requires(cmd != null);
             using (var reader = await cmd.ExecuteReaderAsync(CommandBehavior.SingleRow))
             {
-                return await reader.SingleOrDefaultAsync<T>();
+                return await reader.ReadSingleOrDefaultAsync<T>();
             }
         }
 
         /// <summary>Executes the <paramref name="cmd"/> and reads all the records into a list</summary>
-        public static List<T> ReadList<T>(this IDbCommand cmd)
+        public static List<T> ExecuteList<T>(this IDbCommand cmd)
         {
             Contract.Requires(cmd != null);
             Contract.Ensures(Contract.Result<List<T>>() != null);
             using (var reader = cmd.ExecuteReader())
             {
-                return reader.ToList<T>();
+                return reader.ReadList<T>();
             }
         }
 
         /// <summary>Executes the <paramref name="cmd"/> and reads all the records into a list</summary>
-        public static async Task<List<T>> ReadListAsync<T>(this SqlCommand cmd)
+        public static async Task<List<T>> ExecuteListAsync<T>(this SqlCommand cmd)
         {
             Contract.Requires(cmd != null);
             Contract.Ensures(Contract.Result<List<T>>() != null);
             using (var reader = await cmd.ExecuteReaderAsync())
             {
-                return await reader.ToListAsync<T>();
+                return await reader.ReadListAsync<T>();
             }
         }
 
         /// <summary>Executes the <paramref name="cmd"/> and reads all the records into a dictionary, using the supplied <paramref name="keyFunc"/> to generate the key</summary>
-        public static Dictionary<TKey, TValue> ReadDictionary<TKey, TValue>(this IDbCommand cmd, Func<TValue, TKey> keyFunc)
+        public static Dictionary<TKey, TValue> ExecuteDictionary<TKey, TValue>(this IDbCommand cmd, Func<TValue, TKey> keyFunc)
         {
             Contract.Requires(cmd != null);
             Contract.Requires(keyFunc != null);
             Contract.Ensures(Contract.Result<Dictionary<TKey, TValue>>() != null);
             using (var reader = cmd.ExecuteReader())
             {
-                return reader.ToDictionary(keyFunc);
+                return reader.ReadDictionary(keyFunc);
             }
         }
 
         /// <summary>Executes the <paramref name="cmd"/> and reads all the records into a dictionary, using the supplied <paramref name="keyFunc"/> to generate the key</summary>
-        public static async Task<Dictionary<TKey, TValue>> ReadDictionaryAsync<TKey, TValue>(this SqlCommand cmd, Func<TValue, TKey> keyFunc)
+        public static async Task<Dictionary<TKey, TValue>> ExecuteDictionaryAsync<TKey, TValue>(this SqlCommand cmd, Func<TValue, TKey> keyFunc)
         {
             Contract.Requires(cmd != null);
             Contract.Requires(keyFunc != null);
             Contract.Ensures(Contract.Result<Dictionary<TKey, TValue>>() != null);
             using (var reader = await cmd.ExecuteReaderAsync())
             {
-                return await reader.ToDictionaryAsync(keyFunc);
+                return await reader.ReadDictionaryAsync(keyFunc);
             }
         }
 
         /// <summary>Executes the <paramref name="cmd"/> and reads all the records in a lookup, grouped by key, using the supplied <paramref name="keyFunc"/> to generate the key</summary>
-        public static HashLookup<TKey, TValue> ReadLookup<TKey, TValue>(this IDbCommand cmd, Func<TValue, TKey> keyFunc)
+        public static HashLookup<TKey, TValue> ExecuteLookup<TKey, TValue>(this IDbCommand cmd, Func<TValue, TKey> keyFunc)
         {
             Contract.Requires(cmd != null);
             Contract.Requires(keyFunc != null);
             Contract.Ensures(Contract.Result<HashLookup<TKey, TValue>>() != null);
             using (var reader = cmd.ExecuteReader())
             {
-                return reader.ToLookup(keyFunc);
+                return reader.ReadLookup(keyFunc);
             }
         }
 
         /// <summary>Executes the <paramref name="cmd"/> and reads all the records in a lookup, grouped by key, using the supplied <paramref name="keyFunc"/> to generate the key</summary>
-        public static async Task<HashLookup<TKey, TValue>> ReadLookupAsync<TKey, TValue>(this SqlCommand cmd, Func<TValue, TKey> keyFunc)
+        public static async Task<HashLookup<TKey, TValue>> ExecuteLookupAsync<TKey, TValue>(this SqlCommand cmd, Func<TValue, TKey> keyFunc)
         {
             Contract.Requires(cmd != null);
             Contract.Requires(keyFunc != null);
             Contract.Ensures(Contract.Result<HashLookup<TKey, TValue>>() != null);
             using (var reader = await cmd.ExecuteReaderAsync())
             {
-                return await reader.ToLookupAsync(keyFunc);
+                return await reader.ReadLookupAsync(keyFunc);
             }
         }
 
diff --git a/Mapper/ConnectionExtension.cs b/Mapper/ConnectionExtension.cs
index bc3e943..b4b7689 100644
--- a/Mapper/ConnectionExtension.cs
+++ b/Mapper/ConnectionExtension.cs
@@ -46,7 +46,7 @@ public static T QuerySingle<T>(this IDbConnection cnn, string sql, object parame
             using (var cmd = cnn.CreateCommand())
             {
                 SetupCommand(cmd, cnn, sql, parameters);
-                return cmd.ReadSingle<T>();
+                return cmd.ExecuteSingle<T>();
             }
         }
 
@@ -59,7 +59,7 @@ public static Task<T> QuerySingleAsync<T>(this SqlConnection cnn, string sql, ob
             using (var cmd = cnn.CreateCommand())
             {
                 SetupCommand(cmd, cnn, sql, parameters);
-                return cmd.ReadSingleAsync<T>();
+                return cmd.ExecuteSingleAsync<T>();
             }
         }
 
@@ -71,7 +71,7 @@ public static T QuerySingleOrDefault<T>(this IDbConnection cnn, string sql, obje
             using (var cmd = cnn.CreateCommand())
             {
                 SetupCommand(cmd, cnn, sql, parameters);
-                return cmd.ReadSingleOrDefault<T>();
+                return cmd.ExecuteSingleOrDefault<T>();
             }
         }
 
@@ -83,7 +83,7 @@ public static Task<T> QuerySingleOrDefaultAsync<T>(this SqlConnection cnn, strin
             using (var cmd = cnn.CreateCommand())
             {
                 SetupCommand(cmd, cnn, sql, parameters);
-                return cmd.ReadSingleOrDefaultAsync<T>();
+                return cmd.ExecuteSingleOrDefaultAsync<T>();
             }
         }
 
@@ -97,7 +97,7 @@ public static List<T> QueryList<T>(this IDbConnection cnn, string sql, object pa
             using (var cmd = cnn.CreateCommand())
             {
                 SetupCommand(cmd, cnn, sql, parameters);
-                return cmd.ReadList<T>();
+                return cmd.ExecuteList<T>();
             }
         }
 
@@ -111,7 +111,7 @@ public static Task<List<T>> QueryListAsync<T>(this SqlConnection cnn, string sql
             using (var cmd = cnn.CreateCommand())
             {
                 SetupCommand(cmd, cnn, sql, parameters);
-                return cmd.ReadListAsync<T>();
+                return cmd.ExecuteListAsync<T>();
             }
         }
 
@@ -126,7 +126,7 @@ public static Dictionary<TKey, TValue> QueryDictionary<TKey, TValue>(this IDbCon
             using (var cmd = cnn.CreateCommand())
             {
                 SetupCommand(cmd, cnn, sql, null);
-                return cmd.ReadDictionary(keyFunc);
+                return cmd.ExecuteDictionary(keyFunc);
             }
         }
 
@@ -141,7 +141,7 @@ public static Task<Dictionary<TKey, TValue>> QueryDictionaryAsync<TKey, TValue>(
             using (var cmd = cnn.CreateCommand())
             {
                 SetupCommand(cmd, cnn, sql, null);
-                return cmd.ReadDictionaryAsync(keyFunc);
+                return cmd.ExecuteDictionaryAsync(keyFunc);
             }
         }
 
@@ -157,7 +157,7 @@ public static Dictionary<TKey, TValue> QueryDictionary<TKey, TValue>(this IDbCon
             using (var cmd = cnn.CreateCommand())
             {
                 SetupCommand(cmd, cnn, sql, parameters);
-                return cmd.ReadDictionary(keyFunc);
+                return cmd.ExecuteDictionary(keyFunc);
             }
         }
 
@@ -173,7 +173,7 @@ public static Task<Dictionary<TKey, TValue>> QueryDictionaryAsync<TKey, TValue>(
             using (var cmd = cnn.CreateCommand())
             {
                 SetupCommand(cmd, cnn, sql, parameters);
-                return cmd.ReadDictionaryAsync(keyFunc);
+                return cmd.ExecuteDictionaryAsync(keyFunc);
             }
         }
 
@@ -188,7 +188,7 @@ public static ILookup<TKey, TValue> QueryLookup<TKey, TValue>(this IDbConnection
             using (var cmd = cnn.CreateCommand())
             {
                 SetupCommand(cmd, cnn, sql, null);
-                return cmd.ReadLookup(keyFunc);
+                return cmd.ExecuteLookup(keyFunc);
             }
         }
 
@@ -204,7 +204,7 @@ public static ILookup<TKey, TValue> QueryLookup<TKey, TValue>(this IDbConnection
             using (var cmd = cnn.CreateCommand())
             {
                 SetupCommand(cmd, cnn, sql, parameters);
-                return cmd.ReadLookup(keyFunc);
+                return cmd.ExecuteLookup(keyFunc);
             }
         }
 
@@ -219,7 +219,7 @@ public static async Task<HashLookup<TKey, TValue>> QueryLookupAsync<TKey, TValue
             using (var cmd = cnn.CreateCommand())
             {
                 SetupCommand(cmd, cnn, sql, null);
-                return await cmd.ReadLookupAsync(keyFunc);
+                return await cmd.ExecuteLookupAsync(keyFunc);
             }
         }
 
@@ -235,7 +235,7 @@ public static async Task<HashLookup<TKey, TValue>> QueryLookupAsync<TKey, TValue
             using (var cmd = cnn.CreateCommand())
             {
                 SetupCommand(cmd, cnn, sql, parameters);
-                return await cmd.ReadLookupAsync(keyFunc);
+                return await cmd.ExecuteLookupAsync(keyFunc);
             }
         }
 
diff --git a/Mapper/DataReaderExtensions.cs b/Mapper/DataReaderExtensions.cs
index 05a8082..cb5c30e 100644
--- a/Mapper/DataReaderExtensions.cs
+++ b/Mapper/DataReaderExtensions.cs
@@ -16,7 +16,7 @@ public static class DataReaderExtensions
 
         /// <summary>Reads exactly one item from the reader</summary>
         /// <exception cref="InvalidOperationException"> when zero values read or more than one value can be read</exception>
-        public static T Single<T>(this IDataReader reader)
+        public static T ReadSingle<T>(this IDataReader reader)
         {
             Contract.Requires(reader != null);
             Contract.Requires(reader.IsClosed == false);
@@ -30,7 +30,7 @@ public static T Single<T>(this IDataReader reader)
 
         /// <summary>Reads exactly one item from the reader</summary>
         /// <exception cref="InvalidOperationException"> when zero values read or more than one value can be read</exception>
-        public static async Task<T> SingleAsync<T>(this SqlDataReader reader)
+        public static async Task<T> ReadSingleAsync<T>(this SqlDataReader reader)
         {
             Contract.Requires(reader != null);
             Contract.Requires(reader.IsClosed == false);
@@ -44,7 +44,7 @@ public static async Task<T> SingleAsync<T>(this SqlDataReader reader)
 
         /// <summary>Reads zero or one items from the reader</summary>
         /// <remarks>Returns the default vaue of T if no values be read, i.e may return null</remarks>
-        public static T SingleOrDefault<T>(this IDataReader reader)
+        public static T ReadSingleOrDefault<T>(this IDataReader reader)
         {
             Contract.Requires(reader != null);
             Contract.Requires(reader.IsClosed == false);
@@ -55,7 +55,7 @@ public static T SingleOrDefault<T>(this IDataReader reader)
 
         /// <summary>Reads zero or one items from the reader</summary>
         /// <remarks>Returns the default vaue of T if no values be read, i.e may return null</remarks>
-        public static async Task<T> SingleOrDefaultAsync<T>(this SqlDataReader reader)
+        public static async Task<T> ReadSingleOrDefaultAsync<T>(this SqlDataReader reader)
         {
             Contract.Requires(reader != null);
             Contract.Requires(reader.IsClosed == false);
@@ -65,7 +65,7 @@ public static async Task<T> SingleOrDefaultAsync<T>(this SqlDataReader reader)
         }
 
         /// <summary>Reads all the records in the reader into a list</summary>
-        public static List<T> ToList<T>(this IDataReader reader)
+        public static List<T> ReadList<T>(this IDataReader reader)
         {
             Contract.Requires(reader != null);
             Contract.Requires(reader.IsClosed == false);
@@ -80,7 +80,7 @@ public static List<T> ToList<T>(this IDataReader reader)
         }
 
         /// <summary>Reads all the records in the reader into a list</summary>
-        public static async Task<List<T>> ToListAsync<T>(this SqlDataReader reader)
+        public static async Task<List<T>> ReadListAsync<T>(this SqlDataReader reader)
         {
             Contract.Requires(reader != null);
             Contract.Requires(reader.IsClosed == false);
@@ -95,7 +95,7 @@ public static async Task<List<T>> ToListAsync<T>(this SqlDataReader reader)
         }
 
         /// <summary>Reads all the records in the reader into a dictionary, using the supplied <paramref name="keyFunc"/> to generate the key</summary>
-        public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IDataReader reader, Func<TValue, TKey> keyFunc)
+        public static Dictionary<TKey, TValue> ReadDictionary<TKey, TValue>(this IDataReader reader, Func<TValue, TKey> keyFunc)
         {
             Contract.Requires(reader != null);
             Contract.Requires(keyFunc != null);
@@ -113,7 +113,7 @@ public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IDataRead
         }
 
         /// <summary>Reads all the records in the reader into a dictionary, using the supplied <paramref name="keyFunc"/> to generate the key</summary>
-        public static async Task<Dictionary<TKey, TValue>> ToDictionaryAsync<TKey, TValue>(this SqlDataReader reader, Func<TValue, TKey> keyFunc)
+        public static async Task<Dictionary<TKey, TValue>> ReadDictionaryAsync<TKey, TValue>(this SqlDataReader reader, Func<TValue, TKey> keyFunc)
         {
             Contract.Requires(reader != null);
             Contract.Requires(keyFunc != null);
@@ -131,7 +131,7 @@ public static async Task<Dictionary<TKey, TValue>> ToDictionaryAsync<TKey, TValu
         }
 
         /// <summary>Reads all the records in the lookup, group by key, using the supplied <paramref name="keyFunc"/> to generate the key</summary>
-        public static HashLookup<TKey, TValue> ToLookup<TKey, TValue>(this IDataReader reader, Func<TValue, TKey> keyFunc)
+        public static HashLookup<TKey, TValue> ReadLookup<TKey, TValue>(this IDataReader reader, Func<TValue, TKey> keyFunc)
         {
             Contract.Requires(reader != null);
             Contract.Requires(keyFunc != null);
@@ -148,7 +148,7 @@ public static HashLookup<TKey, TValue> ToLookup<TKey, TValue>(this IDataReader r
         }
 
         /// <summary>Reads all the records in the lookup, group by key, using the supplied <paramref name="keyFunc"/> to generate the key</summary>
-        public static async Task<HashLookup<TKey, TValue>> ToLookupAsync<TKey, TValue>(this SqlDataReader reader, Func<TValue, TKey> keyFunc)
+        public static async Task<HashLookup<TKey, TValue>> ReadLookupAsync<TKey, TValue>(this SqlDataReader reader, Func<TValue, TKey> keyFunc)
         {
             Contract.Requires(reader != null);
             Contract.Requires(keyFunc != null);
@@ -164,7 +164,6 @@ public static async Task<HashLookup<TKey, TValue>> ToLookupAsync<TKey, TValue>(t
             return lookup;
         }
 
-
         private static Func<IDataReader, T> GetMappingFunc<T>(IDataReader reader)
         {
             var columns = CreateColumnList(reader);
diff --git a/Mapper/Mapper.nuspec b/Mapper/Mapper.nuspec
index 1c08412..1be65a9 100644
--- a/Mapper/Mapper.nuspec
+++ b/Mapper/Mapper.nuspec
@@ -2,7 +2,7 @@
 <package >
   <metadata>
     <id>Mapper</id>
-    <version>1.0.1.5</version>
+    <version>1.0.2.0</version>
     <authors>BusterWood</authors>
     <description>A convention-based object cloner, object-object mapper (like AutoMapper), IDataReader to object mapper, object to IDbDataParameter mapper, etc.</description>
     <projectUrl>https://github.com/busterwood/mapper</projectUrl>
diff --git a/Mapper/Properties/AssemblyInfo.cs b/Mapper/Properties/AssemblyInfo.cs
index ccaf7df..54b63f3 100644
--- a/Mapper/Properties/AssemblyInfo.cs
+++ b/Mapper/Properties/AssemblyInfo.cs
@@ -11,7 +11,7 @@
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 [assembly: ComVisible(false)]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.1.5")]
+[assembly: AssemblyVersion("1.0.2.0")]
+[assembly: AssemblyFileVersion("1.0.2.0")]
 
 [assembly: InternalsVisibleTo("Mapper.UnitTests")]
\ No newline at end of file
diff --git a/README.md b/README.md
index ae9f62c..c66d8d4 100644
--- a/README.md
+++ b/README.md
@@ -69,11 +69,11 @@ ILookup<int, Order> list = connection.QueryLookup<int, Order>("select * from dbo
 ### IDataReader methods
 `IDataReader` has the following extension methods:
 
-* `Single<T>()` for reading exactly one row
-* `SingleOrDefault<T>()` for reading zero or one rows
-* `ToList<T>()` for reading all records into a `List<T>`
-* `ToDictinary<TKey,TValue>(Func<TKey,TValue> keyFunc)` for reading all records into a `Dictinary<TKey,TValue>` using the supplied function to get work out the key.  Note that the key must be unique.
-* `ToLookup<TKey,TValue>(Func<TKey,TValue> keyFunc)` for reading all records into a `ILookup<TKey,TValue>` using the supplied function to get work out the key.  Each key may have multiple values.
+* `ReadSingle<T>()` for reading exactly one row
+* `ReadSingleOrDefault<T>()` for reading zero or one rows
+* `ReadList<T>()` for reading all records into a `List<T>`
+* `ReadDictinary<TKey,TValue>(Func<TKey,TValue> keyFunc)` for reading all records into a `Dictinary<TKey,TValue>` using the supplied function to get work out the key.  Note that the key must be unique.
+* `ReadLookup<TKey,TValue>(Func<TKey,TValue> keyFunc)` for reading all records into a `ILookup<TKey,TValue>` using the supplied function to get work out the key.  Each key may have multiple values.
 
 ### SqlDataReader async methods
 
@@ -85,11 +85,11 @@ Additionally `SqlDataReader` has the same set of methods as `IDataReader` but wi
 
 For convenience `Mapper` adds the following extension method to `IDbCommand`:
 
-* `ReadSingle<T>()` for exeucting the command and reading exactly one row
-* `ReadSingleOrDefault<T>()` for exeucting the command and reading zero or one rows
-* `ReadList<T>()` for exeucting the command and reading all records into a `List<T>`
-* `ReadDictinary<TKey,TValue>(Func<TKey,TValue> keyFunc)` for exeucting the command and reading all records into a `Dictinary<TKey,TValue>` using the supplied function to get work out the key.  Note that the key must be unique.
-* `ReadLookup<TKey,TValue>(Func<TKey,TValue> keyFunc)` for exeucting the command and reading all records into a `ILookup<TKey,TValue>` using the supplied function to get work out the key.  Each key may have multiple values.
+* `ExecuteSingle<T>()` for exeucting the command and reading exactly one row
+* `ExecuteSingleOrDefault<T>()` for exeucting the command and reading zero or one rows
+* `ExecuteList<T>()` for exeucting the command and reading all records into a `List<T>`
+* `ExecuteDictinary<TKey,TValue>(Func<TKey,TValue> keyFunc)` for exeucting the command and reading all records into a `Dictinary<TKey,TValue>` using the supplied function to get work out the key.  Note that the key must be unique.
+* `ExecuteLookup<TKey,TValue>(Func<TKey,TValue> keyFunc)` for exeucting the command and reading all records into a `ILookup<TKey,TValue>` using the supplied function to get work out the key.  Each key may have multiple values.
 
 ### SqlCommand async methods