Added generic DbConnectionFactory that takes a factory function.

Author: electricessence

DbConnectionFactory.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Data;
+using System.Data.Common;
+
+namespace Open.Database.Extensions
+{
+    /// <summary>
+    /// Generic connection factory implementation that accepts a factory function.
+    /// </summary>
+    /// <typeparam name="TConnection"></typeparam>
+    public class DbConnectionFactory<TConnection> : IDbConnectionFactory<TConnection>
+        where TConnection:DbConnection
+    {
+        readonly Func<TConnection> _factory;
+
+        /// <summary>
+        /// Constructs a DbConnectionFactory.
+        /// </summary>
+        /// <param name="factory"></param>
+        public DbConnectionFactory(Func<TConnection> factory)
+        {
+            _factory = factory ?? throw new ArgumentNullException(nameof(factory));
+        }
+
+        /// <summary>
+        /// Creates a connection of from the underlying factory function. 
+        /// </summary>
+        public virtual TConnection Create() => _factory();
+
+        IDbConnection IDbConnectionFactory.Create() => Create();
+    }
+}

Documentation.xml

@@ -1,9 +1,7 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Data;
 using System.Data.Common;
 using System.Linq;
-using System.Threading.Tasks;
 
 namespace Open.Database.Extensions
 {

ExpressiveDbCommand.cs

@@ -111,23 +111,31 @@ public Task<int> ExecuteNonQueryAsync()
         /// <summary>
         /// Calls ExecuteScalarAsync on the underlying command.
         /// </summary>
-        /// <returns>The varlue returned from the method.</returns>
+        /// <returns>The value returned from the method.</returns>
         public Task<object> ExecuteScalarAsync()
             => ExecuteAsync(command => command.ExecuteScalarAsync());
 
         /// <summary>
         /// Asynchronously executes scalar on the underlying command.
         /// </summary>
         /// <typeparam name="T">The type expected.</typeparam>
-        /// <returns>The varlue returned from the method.</returns>
+        /// <returns>The value returned from the method.</returns>
         public async Task<T> ExecuteScalarAsync<T>(Func<object, T> transform)
             => transform(await ExecuteScalarAsync());
 
+        /// <summary>
+        /// Asynchronously executes scalar on the underlying command and casts to the expected type.
+        /// </summary>
+        /// <typeparam name="T">The type expected.</typeparam>
+        /// <returns>The value returned from the method.</returns>
+        public async Task<T> ExecuteScalarAsync<T>()
+            => (T)(await ExecuteScalarAsync());
+
         /// <summary>
         /// Asynchronously executes scalar on the underlying command.
         /// </summary>
         /// <typeparam name="T">The type expected.</typeparam>
-        /// <returns>The varlue returned from the method.</returns>
+        /// <returns>The value returned from the method.</returns>
         public async Task<T> ExecuteScalarAsync<T>(Func<object, Task<T>> transform)
             => await transform(await ExecuteScalarAsync());
 

ExpressiveDbCommandBase.cs

@@ -2,27 +2,32 @@
 
 namespace Open.Database.Extensions
 {
-	/// <summary>
-	/// Base interface for creating connections.
-	/// Useful for dependency injection.
-	/// </summary>
-	/// <typeparam name="TConnection">The actual connection type.</typeparam>
-    public interface IDbConnectionFactory<out TConnection>
+    /// <summary>
+    /// Simplified interface with IDbConnection as the generic type.
+    /// </summary>
+    public interface IDbConnectionFactory
+    {
+        /// <summary>
+        /// Generates a new connection of declared generic type.
+        /// </summary>
+        /// <returns></returns>
+        IDbConnection Create();
+    }
+
+    /// <summary>
+    /// Base interface for creating connections.
+    /// Useful for dependency injection.
+    /// </summary>
+    /// <typeparam name="TConnection">The actual connection type.</typeparam>
+    public interface IDbConnectionFactory<out TConnection> : IDbConnectionFactory
         where TConnection : IDbConnection
     {
 		/// <summary>
 		/// Generates a new connection of declared generic type.
 		/// </summary>
 		/// <returns></returns>
-		TConnection Create();
+		new TConnection Create();
     }
 
-	/// <summary>
-	/// Simplified interface with IDbConnection as the generic type.
-	/// </summary>
-    public interface IDbConnectionFactory
-		: IDbConnectionFactory<IDbConnection>
-	{
-		
-    }
+
 }

IDbConnectionFactory.cs

@@ -11,11 +11,10 @@
     <Description>Useful set of utilities and abstractions for simplifying modern database operations and ensuring DI compatibility.</Description>
     <RepositoryUrl>https://github.com/electricessence/Open.Database.Extensions</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
-    <Version>5.4.0</Version>
-    <AssemblyVersion>5.4.0.0</AssemblyVersion>
-    <FileVersion>5.4.0.0</FileVersion>
-    <PackageReleaseNotes>Refactored code that was exclusive to SqlClient to be part of broarder Db classes and extensions.
-Provides 'async' functionality for all DbDataReader and DbCommand classes.</PackageReleaseNotes>
+    <Version>5.4.1</Version>
+    <AssemblyVersion>5.4.1.0</AssemblyVersion>
+    <FileVersion>5.4.1.0</FileVersion>
+    <PackageReleaseNotes>Tweaks to interfaces and restored ExecuteScalarAsync&lt;T&gt;().</PackageReleaseNotes>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">

Open.Database.Extensions.csproj

@@ -1,4 +1,5 @@
-using System.Data;
+using System;
+using System.Data;
 using System.Data.SqlClient;
 
 namespace Open.Database.Extensions.SqlClient
@@ -7,31 +8,22 @@ namespace Open.Database.Extensions.SqlClient
 	/// <summary>
 	/// Default SqlConnectionFactory for generating SqlConnections.
 	/// </summary>
-    public class SqlConnectionFactory : IDbConnectionFactory, IDbConnectionFactory<SqlConnection>
+    public class SqlConnectionFactory : DbConnectionFactory<SqlConnection>
     {
-        string _connectionString;
-
-		/// <summary>
-		/// Default injectable connection factory constructor.
-		/// </summary>
-		/// <param name="connectionString">Required connection string value.</param>
-        public SqlConnectionFactory(string connectionString)
+        /// <summary>
+        /// Default injectable connection factory constructor.
+        /// </summary>
+        /// <param name="factory">The factory that generates the connections.</param>
+        public SqlConnectionFactory(Func<SqlConnection> factory) : base(factory)
         {
-            _connectionString = connectionString;
         }
 
-		/// <summary>
-		/// Method for generating SqlConnections.
-		/// </summary>
-		/// <returns></returns>
-        public SqlConnection Create()
+        /// <summary>
+        /// Default injectable connection factory constructor that accepts a connection string.
+        /// </summary>
+        /// <param name="connectionString">Required connection string value.</param>
+        public SqlConnectionFactory(string connectionString) : base (()=>new SqlConnection(connectionString))
         {
-            return new SqlConnection(_connectionString);
         }
-
-		IDbConnection IDbConnectionFactory<IDbConnection>.Create()
-		{
-			return Create();
-		}
 	}
 }