Added async capabilities to SQLHelper.

Author: James Craig

src/SQLHelper.DB/ExtensionMethods/DbCommandExtensions.cs

@@ -19,6 +19,7 @@ limitations under the License.
 using System;
 using System.Data;
 using System.Data.Common;
+using System.Threading.Tasks;
 
 namespace SQLHelper.ExtensionMethods
 {
@@ -188,6 +189,21 @@ public static DbCommand Commit(this DbCommand command)
             return command.ExecuteScalar().To(defaultValue);
         }
 
+        /// <summary>
+        /// Executes the stored procedure as a scalar query async
+        /// </summary>
+        /// <param name="command">Command object</param>
+        /// <param name="defaultValue">Default value if there is an issue</param>
+        /// <returns>The object of the first row and first column</returns>
+        public static async Task<DataType> ExecuteScalarAsync<DataType>(this DbCommand command, DataType defaultValue = default(DataType))
+        {
+            if (command == null)
+                return defaultValue;
+            command.Open();
+            var ReturnValue = await command.ExecuteScalarAsync();
+            return ReturnValue.To(defaultValue);
+        }
+
         /// <summary>
         /// Gets a parameter or creates it, if it is not found
         /// </summary>

src/SQLHelper.DB/HelperClasses/Batch.cs

@@ -24,6 +24,7 @@ limitations under the License.
 using System.Globalization;
 using System.Linq;
 using System.Text.RegularExpressions;
+using System.Threading.Tasks;
 
 namespace SQLHelper.HelperClasses
 {
@@ -133,6 +134,15 @@ public IList<IList<dynamic>> Execute()
             return ExecuteCommands();
         }
 
+        /// <summary>
+        /// Executes the commands and returns the results (async)
+        /// </summary>
+        /// <returns>The results of the batched commands</returns>
+        public async Task<IList<IList<dynamic>>> ExecuteAsync()
+        {
+            return await ExecuteCommandsAsync();
+        }
+
         /// <summary>
         /// Removes duplicate commands from the batch
         /// </summary>
@@ -177,6 +187,61 @@ protected bool CheckTransaction()
                               });
         }
 
+        private static void GetResults(List<IList<dynamic>> ReturnValue, DbCommand ExecutableCommand, List<IParameter> FinalParameters, bool Finalizable, string FinalSQLCommand)
+        {
+            ExecutableCommand.CommandText = FinalSQLCommand;
+            FinalParameters.ForEach(x => x.AddParameter(ExecutableCommand));
+            if (Finalizable)
+            {
+                using (DbDataReader TempReader = ExecutableCommand.ExecuteReader())
+                {
+                    ReturnValue.Add(GetValues(TempReader));
+                    while (TempReader.NextResult())
+                    {
+                        ReturnValue.Add(GetValues(TempReader));
+                    }
+                }
+            }
+            else
+            {
+                var TempValue = new List<dynamic>
+                                {
+                                    ExecutableCommand.ExecuteNonQuery()
+                                };
+                ReturnValue.Add(TempValue);
+            }
+        }
+
+        private static async Task GetResultsAsync(List<IList<dynamic>> ReturnValue, DbCommand ExecutableCommand, List<IParameter> FinalParameters, bool Finalizable, string FinalSQLCommand)
+        {
+            ExecutableCommand.CommandText = FinalSQLCommand;
+            FinalParameters.ForEach(x => x.AddParameter(ExecutableCommand));
+            if (Finalizable)
+            {
+                using (DbDataReader TempReader = await ExecutableCommand.ExecuteReaderAsync())
+                {
+                    ReturnValue.Add(GetValues(TempReader));
+                    while (TempReader.NextResult())
+                    {
+                        ReturnValue.Add(GetValues(TempReader));
+                    }
+                }
+            }
+            else
+            {
+                var TempValue = new List<dynamic>
+                                {
+                                    await ExecutableCommand.ExecuteNonQueryAsync()
+                                };
+                ReturnValue.Add(TempValue);
+            }
+        }
+
+        /// <summary>
+        /// Gets the values.
+        /// </summary>
+        /// <param name="tempReader">The temporary reader.</param>
+        /// <returns>The resulting values</returns>
         private static IList<dynamic> GetValues(DbDataReader tempReader)
         {
             if (tempReader == null)
@@ -199,6 +264,10 @@ private static IList<dynamic> GetValues(DbDataReader tempReader)
             return ReturnValue;
         }
 
+        /// <summary>
+        /// Executes the commands.
+        /// </summary>
+        /// <returns>The list of results</returns>
         private IList<IList<dynamic>> ExecuteCommands()
         {
             if (Source == null)
@@ -217,11 +286,7 @@ private IList<IList<dynamic>> ExecuteCommands()
                 Connection.ConnectionString = Source.Connection;
                 using (DbCommand ExecutableCommand = Factory.CreateCommand())
                 {
-                    ExecutableCommand.Connection = Connection;
-                    ExecutableCommand.CommandType = CommandType.Text;
-                    if (CheckTransaction())
-                        ExecutableCommand.BeginTransaction();
-                    ExecutableCommand.Open();
+                    SetupCommand(Connection, ExecutableCommand);
 
                     try
                     {
@@ -233,64 +298,57 @@ private IList<IList<dynamic>> ExecuteCommands()
                             string FinalSQLCommand = "";
                             int ParameterTotal = 0;
                             ExecutableCommand.Parameters.Clear();
-                            for (int y = Count; y < Commands.Count; ++y)
-                            {
-                                ICommand Command = Commands[y];
-                                if (ParameterTotal + Command.Parameters.Count > 2100)
-                                    break;
-                                ParameterTotal += Command.Parameters.Count;
-                                Finalizable |= Commands[y].Finalizable;
-                                if (Command.CommandType == CommandType.Text)
-                                {
-                                    var TempCommandText = Command.SQLCommand ?? "";
-                                    string Suffix = "Command" + Count.ToString(CultureInfo.InvariantCulture);
-                                    FinalSQLCommand += string.IsNullOrEmpty(Command.SQLCommand) ?
-                                                        "" :
-                                                        ParameterRegex.Replace(Command.SQLCommand, x =>
-                                                        {
-                                                            var Param = Command.Parameters.FirstOrDefault(z => z.ID == x.Groups["ParamName"].Value);
-                                                            if (Param != null)
-                                                                return x.Value + Suffix;
-                                                            return x.Value;
-                                                        }) + Environment.NewLine;
+                            SetupParameters(ref Count, FinalParameters, ref Finalizable, ref FinalSQLCommand, ref ParameterTotal);
+                            GetResults(ReturnValue, ExecutableCommand, FinalParameters, Finalizable, FinalSQLCommand);
+                            if (Count >= CommandCount)
+                                break;
+                        }
+                        ExecutableCommand.Commit();
+                    }
+                    catch { ExecutableCommand.Rollback(); throw; }
+                    finally { ExecutableCommand.Close(); }
+                }
+            }
+            FinalizeCommands(ReturnValue);
+            return ReturnValue;
+        }
 
-                                    foreach (IParameter TempParameter in Command.Parameters)
-                                    {
-                                        FinalParameters.Add(TempParameter.CreateCopy(Suffix));
-                                    }
-                                }
-                                else
-                                {
-                                    FinalSQLCommand += Command.SQLCommand + Environment.NewLine;
-                                    foreach (IParameter TempParameter in Command.Parameters)
-                                    {
-                                        FinalParameters.Add(TempParameter.CreateCopy(""));
-                                    }
-                                }
-                                ++Count;
-                            }
+        /// <summary>
+        /// Executes the commands asynchronously.
+        /// </summary>
+        /// <returns>The list of results</returns>
+        private async Task<IList<IList<dynamic>>> ExecuteCommandsAsync()
+        {
+            if (Source == null)
+                return new List<IList<dynamic>>();
+            if (Commands == null)
+                return new List<IList<dynamic>>();
+            var ReturnValue = new List<IList<dynamic>>();
+            if (Commands.Count == 0)
+            {
+                ReturnValue.Add(new List<dynamic>());
+                return ReturnValue;
+            }
+            var Factory = Source.Factory;
+            using (DbConnection Connection = Factory.CreateConnection())
+            {
+                Connection.ConnectionString = Source.Connection;
+                using (DbCommand ExecutableCommand = Factory.CreateCommand())
+                {
+                    SetupCommand(Connection, ExecutableCommand);
 
-                            ExecutableCommand.CommandText = FinalSQLCommand;
-                            FinalParameters.ForEach(x => x.AddParameter(ExecutableCommand));
-                            if (Finalizable)
-                            {
-                                using (DbDataReader TempReader = ExecutableCommand.ExecuteReader())
-                                {
-                                    ReturnValue.Add(GetValues(TempReader));
-                                    while (TempReader.NextResult())
-                                    {
-                                        ReturnValue.Add(GetValues(TempReader));
-                                    }
-                                }
-                            }
-                            else
-                            {
-                                var TempValue = new List<dynamic>
-                                {
-                                    ExecutableCommand.ExecuteNonQuery()
-                                };
-                                ReturnValue.Add(TempValue);
-                            }
+                    try
+                    {
+                        int Count = 0;
+                        while (true)
+                        {
+                            var FinalParameters = new List<IParameter>();
+                            bool Finalizable = false;
+                            string FinalSQLCommand = "";
+                            int ParameterTotal = 0;
+                            ExecutableCommand.Parameters.Clear();
+                            SetupParameters(ref Count, FinalParameters, ref Finalizable, ref FinalSQLCommand, ref ParameterTotal);
+                            await GetResultsAsync(ReturnValue, ExecutableCommand, FinalParameters, Finalizable, FinalSQLCommand);
                             if (Count >= CommandCount)
                                 break;
                         }
@@ -300,6 +358,12 @@ private IList<IList<dynamic>> ExecuteCommands()
                     finally { ExecutableCommand.Close(); }
                 }
             }
+            FinalizeCommands(ReturnValue);
+            return ReturnValue;
+        }
+
+        private void FinalizeCommands(List<IList<dynamic>> ReturnValue)
+        {
             for (int x = 0, y = 0; x < Commands.Count(); ++x)
             {
                 if (Commands[x].Finalizable)
@@ -310,7 +374,55 @@ private IList<IList<dynamic>> ExecuteCommands()
                 else
                     Commands[x].Finalize(new List<dynamic>());
             }
-            return ReturnValue;
+        }
+
+        private void SetupCommand(DbConnection Connection, DbCommand ExecutableCommand)
+        {
+            ExecutableCommand.Connection = Connection;
+            ExecutableCommand.CommandType = CommandType.Text;
+            if (CheckTransaction())
+                ExecutableCommand.BeginTransaction();
+            ExecutableCommand.Open();
+        }
+
+        private void SetupParameters(ref int Count, List<IParameter> FinalParameters, ref bool Finalizable, ref string FinalSQLCommand, ref int ParameterTotal)
+        {
+            for (int y = Count; y < Commands.Count; ++y)
+            {
+                ICommand Command = Commands[y];
+                if (ParameterTotal + Command.Parameters.Count > 2100)
+                    break;
+                ParameterTotal += Command.Parameters.Count;
+                Finalizable |= Commands[y].Finalizable;
+                if (Command.CommandType == CommandType.Text)
+                {
+                    var TempCommandText = Command.SQLCommand ?? "";
+                    string Suffix = "Command" + Count.ToString(CultureInfo.InvariantCulture);
+                    FinalSQLCommand += string.IsNullOrEmpty(Command.SQLCommand) ?
+                                        "" :
+                                        ParameterRegex.Replace(Command.SQLCommand, x =>
+                                        {
+                                            var Param = Command.Parameters.FirstOrDefault(z => z.ID == x.Groups["ParamName"].Value);
+                                            if (Param != null)
+                                                return x.Value + Suffix;
+                                            return x.Value;
+                                        }) + Environment.NewLine;
+
+                    foreach (IParameter TempParameter in Command.Parameters)
+                    {
+                        FinalParameters.Add(TempParameter.CreateCopy(Suffix));
+                    }
+                }
+                else
+                {
+                    FinalSQLCommand += Command.SQLCommand + Environment.NewLine;
+                    foreach (IParameter TempParameter in Command.Parameters)
+                    {
+                        FinalParameters.Add(TempParameter.CreateCopy(""));
+                    }
+                }
+                ++Count;
+            }
         }
     }
 }

src/SQLHelper.DB/HelperClasses/Interfaces/IBatch.cs

@@ -17,6 +17,7 @@ limitations under the License.
 using System;
 using System.Collections.Generic;
 using System.Data;
+using System.Threading.Tasks;
 
 namespace SQLHelper.HelperClasses.Interfaces
 {
@@ -78,6 +79,12 @@ public interface IBatch
         /// <returns>The results of the batched commands</returns>
         IList<IList<dynamic>> Execute();
 
+        /// <summary>
+        /// Executes the commands and returns the results (async)
+        /// </summary>
+        /// <returns>The results of the batched commands</returns>
+        Task<IList<IList<dynamic>>> ExecuteAsync();
+
         /// <summary>
         /// Removes duplicate commands from the batch
         /// </summary>

src/SQLHelper.DB/SQLHelper.cs

@@ -23,6 +23,7 @@ limitations under the License.
 using System.Data;
 using System.Data.Common;
 using System.Linq;
+using System.Threading.Tasks;
 
 namespace SQLHelper
 {
@@ -141,12 +142,21 @@ public SQLHelper CreateBatch()
         /// <summary>
         /// Executes this instance.
         /// </summary>
-        /// <returns></returns>
+        /// <returns>The results of the batched queries.</returns>
         public IList<IList<dynamic>> Execute()
         {
             return Batch.Execute();
         }
 
+        /// <summary>
+        /// Executes the queries asynchronously.
+        /// </summary>
+        /// <returns>The result of the queries</returns>
+        public async Task<IList<IList<dynamic>>> ExecuteAsync()
+        {
+            return await Batch.ExecuteAsync();
+        }
+
         /// <summary>
         /// Executes the batched commands and returns the first value, ignoring the rest.
         /// </summary>
@@ -161,6 +171,20 @@ public TData ExecuteScalar<TData>()
             return Value[Value.Keys.First()].To<object, TData>();
         }
 
+        /// <summary>
+        /// Executes the batched commands and returns the first value, ignoring the rest (async).
+        /// </summary>
+        /// <typeparam name="TData">The type of the data to return.</typeparam>
+        /// <returns>The first value of the batch</returns>
+        public async Task<TData> ExecuteScalarAsync<TData>()
+        {
+            var BatchResults = await Batch.ExecuteAsync();
+            IDictionary<string, object> Value = BatchResults[0][0] as IDictionary<string, object>;
+            if (Value == null)
+                return ((object)BatchResults[0][0]).To<object, TData>();
+            return Value[Value.Keys.First()].To<object, TData>();
+        }
+
         /// <summary>
         /// Removes duplicate queries from the batch.
         /// </summary>