Code distributed in partial classes

Code distributed in partial classes

Author: afernandes

src/CfCommand.DataAdapter.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+
+namespace ConnectionFactory
+{
+    public partial class CfCommand : IDisposable
+    {
+        #region DataAdapter
+
+        /// <summary>
+        /// DataAdapter Performs and returns the DataSet
+        /// </summary>
+        /// <param name="cmdType">Command Type (text, procedure or table)</param>
+        /// <param name="cmdText">Command Text, procedure or table name</param>
+        /// <param name="cmdParms">Command Parameters (@parameter)</param>
+        /// <returns>DataSet</returns>
+        [System.Diagnostics.DebuggerStepThrough]
+        public DataSet DataAdapter(CfCommandType cmdType, string cmdText, IEnumerable<CfParameter> cmdParms = null)
+        {
+            // we use a try/catch here because if the method throws an exception we want to 
+            // close the connection throw code, because no datareader will exist, hence the 
+            // commandBehaviour.CloseConnection will not work
+            try
+            {
+                Logger.InfoFormat("DataAdapter: {0}", cmdText);
+                Logger.Info(cmdParms);
+
+                _conn.EstablishFactoryConnection();
+                var dda = _conn.CreateDataAdapter();
+                PrepareCommand(cmdType, cmdText, cmdParms);
+
+                dda.SelectCommand = _cmd;
+                var ds = new DataSet();
+                dda.Fill(ds);
+                return ds;
+            }
+            catch (Exception ex)
+            {
+                Logger.Error(ex);
+                throw new CfException("Unknown Error (Connection Factory: DataAdapter) " + ex.Message, ex);
+            }
+        }
+
+        #endregion
+    }
+}

src/CfCommand.ExecuteNonQuery.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Data.Common;
+
+namespace ConnectionFactory
+{
+    public partial class CfCommand : IDisposable
+    {
+        #region ExecuteNonQuery
+
+        //[System.Diagnostics.DebuggerStepThrough]
+        public int ExecuteNonQuery(CfCommandType cmdType, string cmdText, IEnumerable<CfParameter> cmdParms = null)
+        {
+            Logger.Debug("Begin Method");
+            try
+            {
+                Logger.InfoFormat("ExecuteNonQuery: {0}", cmdText);
+                Logger.Info(cmdParms);
+
+                _conn.EstablishFactoryConnection();
+                PrepareCommand(cmdType, cmdText, cmdParms);
+
+                Logger.Debug("End Method");
+                return _cmd.ExecuteNonQuery();
+            }
+            catch (DbException dbe)
+            {
+                Logger.Error(dbe);
+                throw new CfException("Unknown error in database: " + dbe.Message, dbe);
+
+            }
+            catch (Exception ex)
+            {
+                Logger.Error(ex);
+                throw new CfException("Error on Connection Factory Mechanism: " + ex.Message, ex);
+            }
+        }
+
+        #endregion
+    }
+}

src/CfCommand.ExecuteReader.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Dynamic;
+using System.Linq;
+
+namespace ConnectionFactory
+{
+    public partial class CfCommand : IDisposable
+    {
+        #region ExecuteReader
+
+        /// <summary>
+        /// Performs datareader
+        /// </summary>
+        /// <param name="cmdType">Command Type (text, procedure or table)</param>
+        /// <param name="cmdText">Command Text, procedure or table name</param>
+        /// <param name="cmdParms">Command Parameters (@parameter)</param>
+        /// <returns>Data Reader</returns> 
+        [System.Diagnostics.DebuggerStepThrough]
+        public IDataReader ExecuteReader(CfCommandType cmdType, string cmdText, IEnumerable<CfParameter> cmdParms = null)
+        {
+            try
+            {
+                Logger.InfoFormat("ExecuteReader: {0}", cmdText);
+                Logger.Info(cmdParms);
+
+                _conn.EstablishFactoryConnection();
+                PrepareCommand(cmdType, cmdText, cmdParms);
+                return _cmd.ExecuteReader(CommandBehavior.CloseConnection);
+            }
+            catch (Exception ex)
+            {
+                Logger.Error(ex);
+                throw new CfException("Unknown Error (Connection Factory: ExecuteReader) " + ex.Message, ex);
+            }
+        }
+
+        public IDataReader ExecuteReader(CfCommandType cmdType, string cmdText, object cmdParms)
+        {
+            try
+            {
+                IList<CfParameter> cfParams = null;
+                if (cmdParms != null)
+                {
+                    if (!(cmdParms is IEnumerable<CfParameter>))
+                    {
+
+                        var props = cmdParms as ExpandoObject as IDictionary<string, object>;
+                        if (props != null)
+                        {
+                            cfParams = new List<CfParameter>(props.Count());
+                            foreach (var p in props)
+                            {
+                                cfParams.Add(new CfParameter(p.Key, p.Value));
+                            }
+                        }
+                        else
+                        {
+                            var properties = cmdParms.GetType().GetProperties();
+                            if (properties.Any())
+                            {
+                                cfParams = new List<CfParameter>(properties.Count());
+                                foreach (var property in properties)
+                                {
+                                    cfParams.Add(new CfParameter(property.Name, property.GetValue(cmdParms, null)));
+                                }
+                            }
+                        }
+                    }
+                }
+
+                _conn.EstablishFactoryConnection();
+                PrepareCommand(cmdType, cmdText, cfParams);
+                return _cmd.ExecuteReader(CommandBehavior.CloseConnection);
+            }
+            catch (Exception ex)
+            {
+                Logger.Error(ex);
+                throw new CfException("Unknown Error (Connection Factory: ExecuteReader) " + ex.Message, ex);
+            }
+        }
+
+        #endregion
+    }
+}

src/CfCommand.ExecuteScalar.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+
+namespace ConnectionFactory
+{
+    public partial class CfCommand : IDisposable
+    {
+        #region ExecuteScalar
+
+        [System.Diagnostics.DebuggerStepThrough]
+        public T ExecuteScalar<T>(CfCommandType cmdType, string cmdText, IEnumerable<CfParameter> cmdParms = null)
+        {
+            try
+            {
+                Logger.InfoFormat("ExecuteScalar: {0}", cmdText);
+                Logger.Info(cmdParms);
+
+                _conn.EstablishFactoryConnection();
+                PrepareCommand(cmdType, cmdText, cmdParms);
+                var returnValue = _cmd.ExecuteScalar();
+                _cmd.Dispose();
+                if (returnValue is DBNull || returnValue == null)
+                {
+                    return default(T);
+                }
+                try
+                {
+                    return (T)returnValue;
+                }
+                catch (Exception ex)
+                {
+                    Logger.Error(ex);
+                    throw new CfException(String.Format("Conversion error in ({0})\"{1}\" - (Connection Factory: ExecuteScalar) > {2}", typeof(T).Name, returnValue, ex.Message), ex);
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.Error(ex);
+                throw new CfException("Unknown Error (Connection Factory: ExecuteScalar) " + ex.Message, ex);
+            }
+        }
+
+        public dynamic ExecuteScalar(CfCommandType cmdType, string cmdText, IEnumerable<CfParameter> cmdParms = null)
+        {
+            _conn.EstablishFactoryConnection();
+            PrepareCommand(cmdType, cmdText, cmdParms);
+            dynamic returnValue = _cmd.ExecuteScalar();
+            _cmd.Dispose();
+
+            if (returnValue is DBNull || returnValue == null)
+            {
+                return default(dynamic);
+            }
+
+            return returnValue;
+        }
+
+        #endregion
+    }
+}

src/CfCommand.LazyLoad.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+
+namespace ConnectionFactory
+{
+    public partial class CfCommand : IDisposable
+    {
+        #region LazyLoad
+
+        /// <summary>
+        /// Performs LazyLoad
+        /// </summary>
+        /// <param name="cmdType">Command Type (text, procedure or table)</param>
+        /// <param name="cmdText">Command Text, procedure or table name</param>
+        /// <param name="cmdParms">Command Parameters (@parameter)</param>
+        /// <returns>IEnumerable IDataRecord</returns> 
+        [System.Diagnostics.DebuggerStepThrough]
+        public IEnumerable<IDataReader> LazyLoad(CfCommandType cmdType, string cmdText, IEnumerable<CfParameter> cmdParms = null)
+        {
+            Logger.InfoFormat("LazyLoad: {0}", cmdText);
+            Logger.Info(cmdParms);
+
+            _conn.EstablishFactoryConnection();
+            PrepareCommand(cmdType, cmdText, cmdParms);
+
+            using (var reader = _cmd.ExecuteReader(CommandBehavior.CloseConnection))
+            {
+                while (reader.Read())
+                {
+                    yield return reader;
+                }
+            }
+        }
+
+        #endregion
+    }
+}

src/CfCommand.LazyLoadForObjects.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+
+namespace ConnectionFactory
+{
+    public partial class CfCommand : IDisposable
+    {
+        #region LazyLoadForObjects
+
+        /// <summary>
+        /// Datareader Performs and returns the list loaded entities
+        /// </summary>
+        /// <typeparam name="T">type of entity returned</typeparam>
+        /// <param name="cmdType">Command Type (text, procedure or table)</param>
+        /// <param name="cmdText">Command Text, procedure or table name</param>
+        /// <param name="cmdParms">Command Parameters (@parameter)</param>
+        /// <returns>list of entities</returns>
+        [System.Diagnostics.DebuggerStepThrough]
+        public IEnumerable<T> LazyLoadForObjects<T>(
+            CfCommandType cmdType, string cmdText, IEnumerable<CfParameter> cmdParms = null) where T : new()
+        {
+            return LazyLoadForObjects<T>(LazyLoad(cmdType, cmdText, cmdParms));
+        }
+
+        /// <summary>
+        /// LazyLoadForObjects Performs and returns the list loaded entities
+        /// </summary>
+        /// <typeparam name="T">type of entity returned</typeparam>
+        /// <param name="dr">datareader loaded</param>
+        /// <returns>list of entities</returns>
+        [System.Diagnostics.DebuggerStepThrough]
+        public static IEnumerable<T> LazyLoadForObjects<T>(IEnumerable<IDataReader> dr) where T : new()
+        {
+            Logger.Debug("Begin method");
+
+            Type entityType = typeof(T);
+            var properties = CfMapCache.GetInstance(entityType);
+
+            using (var enumerator = dr.GetEnumerator())
+            {
+                while (enumerator.MoveNext())
+                {
+                    var reader = enumerator.Current;
+
+                    if (reader != null)
+                    {
+                        var newObject = new T();
+                        for (var index = 0; index < reader.FieldCount; index++)
+                        {
+                            if (properties.ContainsKey(reader.GetName(index).ToUpper()))
+                            {
+                                var info = properties[reader.GetName(index).ToUpper()];
+                                if ((info != null) && info.CanWrite && !reader.IsDBNull(index))
+                                {
+                                    try
+                                    {
+                                        info.SetValue(newObject, reader.GetValue(index), null);
+                                    }
+                                    catch (Exception ex)
+                                    {
+                                        Logger.Error(ex);
+                                        throw new CfException(String.Format("Conversion error in {0}.{1} - (Connection Factory: LazyLoadForObjects) > {2}", entityType.Name, reader.GetName(index), ex.Message), ex);
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                Logger.Debug("Property not exist: " + entityType.FullName + reader.GetName(index));
+                            }
+                        }
+                        yield return newObject;
+                    }
+                }
+            }
+            Logger.Debug("End method");
+        }
+
+        public IEnumerable<dynamic> LazyLoadForObjects(
+            CfCommandType cmdType, string cmdText, IEnumerable<CfParameter> cmdParms = null)
+        {
+            return LazyLoadForObjects(LazyLoad(cmdType, cmdText, cmdParms));
+        }
+
+        public static IEnumerable<dynamic> LazyLoadForObjects(IEnumerable<IDataReader> dr)
+        {
+            using (var enumerator = dr.GetEnumerator())
+            {
+                while (enumerator.MoveNext())
+                {
+                    var reader = enumerator.Current;
+
+                    if (reader != null)
+                    {
+                        yield return reader.ToExpando();
+                    }
+                }
+            }
+        }
+
+        #endregion
+    }
+}