2015-07-16

- Implementing IDataRecordExtensions...
- Implementing DataReader...
- Removing obsolete methods
- Implementing IDbTransactionScope...
- ConnectionDefinition
- Implementing DataReader...
- How to log CallerInformation
- Implementing PostgreSQL provider...

Author: csbernath

DataCommander.Foundation/Collections/IndexableCollection/NonUniqueIndex.cs

@@ -13,11 +13,15 @@
     /// <typeparam name="T"></typeparam>
     public class NonUniqueIndex<TKey, T> : ICollectionIndex<T>, IDictionary<TKey, ICollection<T>>
     {
+        #region Private Fields
+
         private string name;
         private IDictionary<TKey, ICollection<T>> dictionary;
         private Func<T, GetKeyResponse<TKey>> getKey;
         private Func<ICollection<T>> createCollection;
 
+        #endregion
+
         /// <summary>
         /// 
         /// </summary>

DataCommander.Foundation/Data/CommandDefinition.cs

@@ -0,0 +1,31 @@
+namespace DataCommander.Foundation.Data
+{
+    using System.Collections.Generic;
+    using System.Data;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public sealed class CommandDefinition
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        public string CommandText;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public List<object> Parameters;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public CommandType CommandType = CommandType.Text;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public int CommandTimeout;
+    }
+}

DataCommander.Foundation/Data/DataReader.cs

@@ -0,0 +1,153 @@
+namespace DataCommander.Foundation.Data
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Data;
+    using System.Diagnostics.Contracts;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public sealed class DataReader : IDisposable
+    {
+        #region Private Fields
+        private readonly IDbCommand command;
+        private readonly IDataReader dataReader;
+        private bool nextResultCalled = true;
+        #endregion
+
+        private DataReader(IDbCommand command, IDataReader dataReader)
+        {
+            Contract.Requires<ArgumentNullException>(command != null);
+            Contract.Requires<ArgumentNullException>(dataReader != null);
+
+            this.command = command;
+            this.dataReader = dataReader;
+        }
+
+        internal static DataReader Create(
+            IDbTransactionScope transactionScope,
+            CommandDefinition commandDefinition,
+            CommandBehavior commandBehavior)
+        {
+            Contract.Requires<ArgumentNullException>(transactionScope != null);
+            Contract.Requires<ArgumentNullException>(commandDefinition != null);
+
+            IDbCommand command = null;
+            IDataReader dataReader = null;
+
+            try
+            {
+                command = transactionScope.CreateCommand(commandDefinition);
+                dataReader = command.ExecuteReader(commandBehavior);
+                return new DataReader(command, dataReader);
+            }
+            catch
+            {
+                if (dataReader != null)
+                {
+                    dataReader.Dispose();
+                }
+
+                if (command != null)
+                {
+                    command.Dispose();
+                }
+
+                throw;
+            }
+        }
+
+        #region Public Methods
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="read"></param>
+        /// <returns></returns>
+        public IEnumerable<T> Read<T>(Func<IDataRecord, T> read)
+        {
+            Contract.Requires<ArgumentNullException>(read != null);
+            this.PrivateNextResult();
+
+            while (this.dataReader.Read())
+            {
+                yield return read(this.dataReader);
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="read"></param>
+        public void Read(Action<IDataRecord> read)
+        {
+            Contract.Requires<ArgumentNullException>(read != null);
+            this.PrivateNextResult();
+
+            while (this.dataReader.Read())
+            {
+                read(this.dataReader);
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="read"></param>
+        public void Read(Func<IDataRecord, bool> read)
+        {
+            Contract.Requires<ArgumentNullException>(read != null);
+            this.PrivateNextResult();
+
+            while (this.dataReader.Read())
+            {
+                bool succeeded = read(this.dataReader);
+                if (!succeeded)
+                {
+                    break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns></returns>
+        public bool NextResult()
+        {
+            Contract.Assert(this.dataReader != null);
+            Contract.Assert(!this.nextResultCalled);
+            bool nextResult = this.dataReader.NextResult();
+            this.nextResultCalled = true;
+            return nextResult;
+        }
+
+        #endregion
+
+        void IDisposable.Dispose()
+        {
+            this.dataReader.Dispose();
+            this.command.Dispose();
+        }
+
+        private void PrivateNextResult()
+        {
+            if (this.nextResultCalled)
+            {
+                this.nextResultCalled = false;
+            }
+            else
+            {
+                bool nextResult = this.dataReader.NextResult();
+                this.nextResultCalled = true;
+
+                if (!nextResult)
+                {
+                    throw new InvalidOperationException();
+                }
+            }
+        }
+    }
+}

DataCommander.Foundation/Data/DataReaderContext.cs

@@ -1,10 +1,12 @@
 namespace DataCommander.Foundation.Data
 {
     using System;
+    using System.Collections.Generic;
     using System.Data;
     using System.Data.Common;
     using System.Diagnostics.Contracts;
     using System.Globalization;
+    using System.Linq;
 
     /// <summary>
     /// 
@@ -37,5 +39,53 @@ public static DataTable ExecuteDataTable(
             adapter.Fill(table);
             return table;
         }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="dbProviderFactory"></param>
+        /// <param name="connectionString"></param>
+        /// <param name="commandDefinition"></param>
+        /// <param name="commandBehavior"></param>
+        /// <param name="read"></param>
+        public static IEnumerable<T> ExecuteReader<T>(
+            this DbProviderFactory dbProviderFactory,
+            string connectionString,
+            CommandDefinition commandDefinition,
+            CommandBehavior commandBehavior,
+            Func<IDataRecord, T> read)
+        {
+            Contract.Requires<ArgumentNullException>(dbProviderFactory != null);
+            Contract.Requires<ArgumentNullException>(commandDefinition != null);
+            Contract.Requires<ArgumentNullException>(read != null);
+
+            using (var connection = dbProviderFactory.CreateConnection())
+            {
+                connection.ConnectionString = connectionString;
+                connection.Open();
+                var transactionScope = new DbTransactionScope(connection, null);
+
+                using (var dataReader = transactionScope.ExecuteReader(commandDefinition, commandBehavior))
+                {
+                    return dataReader.Read(read);
+                }
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="dbProviderFactory"></param>
+        /// <param name="connnectionString"></param>
+        /// <param name="commandText"></param>
+        /// <param name="read"></param>
+        public static IEnumerable<T> ExecuteReader<T>(
+            this DbProviderFactory dbProviderFactory,
+            string connnectionString,
+            string commandText,
+            Func<IDataRecord, T> read)
+        {
+            return dbProviderFactory.ExecuteReader(connnectionString, new CommandDefinition {CommandText = commandText}, CommandBehavior.Default, read);
+        }
     }
 }

DataCommander.Foundation/Data/DbProviderFactoryExtensions.cs

@@ -1,4 +1,4 @@
-namespace DataCommander.Foundation.Data
+namespace DataCommander.Foundation.Data
 {
     using System;
     using System.Data;
@@ -7,57 +7,37 @@
     /// <summary>
     /// 
     /// </summary>
-    public sealed class DbConnectionContext : IDbConnectionContext
+    public sealed class DbTransactionScope : IDbTransactionScope
     {
-        #region Private Fields
-
         private readonly IDbConnection connection;
         private readonly IDbTransaction transaction;
-        private readonly int? commandTimeout;
-
-        #endregion
 
         /// <summary>
         /// 
         /// </summary>
         /// <param name="connection"></param>
         /// <param name="transaction"></param>
-        /// <param name="commandTimeout"></param>
-        public DbConnectionContext(IDbConnection connection, IDbTransaction transaction, int? commandTimeout)
+        public DbTransactionScope(IDbConnection connection, IDbTransaction transaction)
         {
             Contract.Requires<ArgumentNullException>(connection != null);
-
             this.connection = connection;
             this.transaction = transaction;
-            this.commandTimeout = commandTimeout;
         }
 
-        #region IDbConnectionContext Members
-
-        IDbConnection IDbConnectionContext.Connection
+        IDbConnection IDbTransactionScope.Connection
         {
             get
             {
                 return this.connection;
             }
         }
 
-        IDbTransaction IDbConnectionContext.Transaction
+        IDbTransaction IDbTransactionScope.Transaction
         {
             get
             {
                 return this.transaction;
             }
         }
-
-        int? IDbConnectionContext.CommandTimeout
-        {
-            get
-            {
-                return this.commandTimeout;
-            }
-        }
-
-        #endregion
     }
 }