/src/RaisingStudio.Data.Providers/Adapters/DataObjectAdapter.cs

Large files files are truncated, but you can click here to view the full file

using System;

using System.Collections.Generic;

using System.Text;



using RaisingStudio.Data.Common;

using RaisingStudio.Data.Common.Factories;

using RaisingStudio.Data.Expressions;

using RaisingStudio.Data.Common.Builders.Expressions;

using RaisingStudio.Data.Common.Managers;

using System.Data.Common;

using RaisingStudio.Data.Providers.Exceptions;

using System.Data;



namespace RaisingStudio.Data.Providers.Adapters

{

    public delegate object CreateDataObjectDelegate();

    public delegate System.Collections.IList CreateDataObjectListDelegate();



    /// <summary>

    /// data object DataAdapter.

    /// </summary>

    public partial class DataObjectAdapter : DataAdapterBase, RaisingStudio.Data.Common.IDataObjectAdapter

    {

        #region Common property

        protected System.Type dataObjectType;

        /// <summary>

        /// Type of data object.

        /// </summary>

        public System.Type DataObjectType

        {

            get

            {

                return this.dataObjectType;

            }

        }



        protected string definitionName;

        /// <summary>

        /// object definition name.

        /// </summary>

        public string DefinitionName

        {

            get

            {

                return this.definitionName;

            }

        }





        protected RaisingStudio.Data.Common.Builders.CommandBuilder commandBuilder;

        /// <summary>

        /// Command builder.

        /// </summary>

        public RaisingStudio.Data.Common.Builders.CommandBuilder CommandBuilder

        {

            get

            {

                if (this.commandBuilder == null)

                {

                    this.commandBuilder = CreateCommandBuilder();

                }

                return this.commandBuilder;

            }

        }



        protected System.Data.Common.DataTableMapping defaultDataTableMapping;

        /// <summary>

        /// default Data table mapping.

        /// </summary>

        public System.Data.Common.DataTableMapping DefaultDataTableMapping

        {

            get

            {

                if (this.defaultDataTableMapping == null)

                {

                    this.defaultDataTableMapping = this.CommandBuilder.CommonCommandBuilder.GetDataTableMapping();

                }

                return this.defaultDataTableMapping;

            }

        }

        #endregion

#if (PocketPC || Smartphone || WindowsCE)

        private bool _useDynamicProxy = false;

#else

        private bool _useDynamicProxy = true;

#endif

        public bool UseDynamicProxy

        {

            get { return _useDynamicProxy; }

            set { _useDynamicProxy = value; }

        }



        private bool _cacheDefalutCommand = true;



        public bool CacheDefalutCommand

        {

            get { return _cacheDefalutCommand; }

            set { _cacheDefalutCommand = value; }

        }



        #region Constructor

        /// <summary>

        /// Constructor

        /// </summary>

        /// <param name="dataObjectType">Type of data object.</param>

        public DataObjectAdapter(System.Type dataObjectType)

        {

            this.dataObjectType = dataObjectType;

            this.connection = ConnectionFactory.CreateConnection();

            DatabaseType databaseType;

            string providerName;

            ConnectionFactory.GetConnectionSetting(out databaseType, out providerName);

            this._databaseType = databaseType;

            this._providerName = providerName;

            this.transactionManager = TransactionManagerFactory.CreateTransactionManager(this.connection);

        }



        /// <summary>

        /// Constructor

        /// </summary>

        /// <param name="dataObjectType">Type of data object.</param>

        /// <param name="connection">database connection.</param>

        public DataObjectAdapter(System.Type dataObjectType, System.Data.IDbConnection connection)

        {

            this.dataObjectType = dataObjectType;

            this.connection = connection;

            this.transactionManager = TransactionManagerFactory.CreateTransactionManager(this.connection);

        }



        public DataObjectAdapter(System.Type dataObjectType, System.Data.IDbConnection connection, DatabaseType databaseType, string providerName)

            : this(dataObjectType, connection)

        {

            this._databaseType = databaseType;

            this._providerName = providerName;

        }



        /// <summary>

        /// Constructor

        /// </summary>

        /// <param name="dataObjectType">Type of data object.</param>

        /// <param name="transactionManager">database transaction manager.</param>

        public DataObjectAdapter(System.Type dataObjectType, TransactionManager transactionManager, ILogManager logManager)

        {

            this.dataObjectType = dataObjectType;

            this.transactionManager = transactionManager;

            this.connection = transactionManager.Connection;

            this._logManager = logManager;

        }



        public DataObjectAdapter(System.Type dataObjectType, TransactionManager transactionManager, DatabaseType databaseType, string providerName, ILogManager logManager)

            : this(dataObjectType, transactionManager, logManager)

        {

            this._databaseType = databaseType;

            this._providerName = providerName;

        }



        /// <summary>

        /// Constructor

        /// </summary>

        /// <param name="dataObjectType">Type of data object.</param>

        /// <param name="definitionName">object definition name.</param>

        public DataObjectAdapter(System.Type dataObjectType, string definitionName)

            : this(dataObjectType)

        {

            this.definitionName = definitionName;

        }



        /// <summary>

        /// Constructor

        /// </summary>

        /// <param name="dataObjectType">Type of data object.</param>

        /// <param name="definitionName">object definition name.</param>

        /// <param name="connection">database connection.</param>

        public DataObjectAdapter(System.Type dataObjectType, string definitionName, System.Data.IDbConnection connection)

            : this(dataObjectType, connection)

        {

            this.definitionName = definitionName;

        }



        public DataObjectAdapter(System.Type dataObjectType, string definitionName, System.Data.IDbConnection connection, DatabaseType databaseType, string providerName)

            : this(dataObjectType, definitionName, connection)

        {

            this._databaseType = databaseType;

            this._providerName = providerName;

        }



        /// <summary>

        /// Constructor

        /// </summary>

        /// <param name="dataObjectType">Type of data object.</param>

        /// <param name="definitionName">object definition name.</param>

        /// <param name="transactionManager">database transaction manager.</param>

        public DataObjectAdapter(System.Type dataObjectType, string definitionName, TransactionManager transactionManager, ILogManager logManager)

            : this(dataObjectType, transactionManager, logManager)

        {

            this.definitionName = definitionName;

        }



        public DataObjectAdapter(System.Type dataObjectType, string definitionName, TransactionManager transactionManager, DatabaseType databaseType, string providerName, ILogManager logManager)

            : this(dataObjectType, definitionName, transactionManager, logManager)

        {

            this._databaseType = databaseType;

            this._providerName = providerName;

        }

        #endregion



        #region Create Command

        /// <summary>

        /// Create a command builder.

        /// </summary>

        /// <returns>Command builder.</returns>

        public virtual RaisingStudio.Data.Common.Builders.CommandBuilder CreateCommandBuilder()

        {

            DatabaseType databaseType = GetDatabaseType();

#if !(PocketPC || Smartphone || WindowsCE)

            if (databaseType == DatabaseType.SHAREPOINT)

            {

                if (this.definitionName != null)

                {

                    return new RaisingStudio.Data.Common.Builders.SharePointCommandBuilder(this.connection, databaseType, this._providerName, this.dataObjectType, this.definitionName);

                }

                else

                {

                    return new RaisingStudio.Data.Common.Builders.SharePointCommandBuilder(this.connection, databaseType, this._providerName, this.dataObjectType);

                }

            }

            else

            {

#endif

                if (this.definitionName != null)

                {

                    return new RaisingStudio.Data.Common.Builders.CommandBuilder(this.connection, databaseType, this._providerName, this.dataObjectType, this.definitionName);

                }

                else

                {

                    return new RaisingStudio.Data.Common.Builders.CommandBuilder(this.connection, databaseType, this._providerName, this.dataObjectType);

                }

#if !(PocketPC || Smartphone || WindowsCE)

            }

#endif

        }



        public virtual DatabaseType GetDatabaseType()

        {

            if ((this._databaseType == DatabaseType.OTHER) && (!ProviderManager.Instance.ProviderExists(this._providerName)))

            {

                DatabaseType databaseType = ConnectionFactory.GetDatabaseType(this.connection);

                return databaseType;

            }

            return this._databaseType;

        }

        #endregion

        #region Create data object

        protected CreateDataObjectDelegate createDataObjectMethod;

        /// <summary>

        /// Create data object delegate.

        /// </summary>

        public CreateDataObjectDelegate CreateDataObjectMethod

        {

            get

            {

                return this.createDataObjectMethod;

            }

            set

            {

                this.createDataObjectMethod = value;

            }

        }



        /// <summary>

        /// Create Data object.

        /// </summary>

        /// <returns>Data object.</returns>

        public virtual object CreateDataObject()

        {

            if (this.createDataObjectMethod != null)

            {

                return this.createDataObjectMethod();

            }

            else

            {

                if (UseDynamicProxy)

                {

                    #region UseDynamicProxy

                    IObjectCreater objectCreater = GetObjectCreater(dataObjectType, this.CommandBuilder.CommonCommandBuilder.DataTableDefinition.Columns);

                    if (objectCreater != null)

                    {

                        object dataObject = objectCreater.CreateObject();

                        return dataObject;

                    }

                    else

                    {

                        // TODO: exception.

                        #region Reflection

                        object dataObject = System.Activator.CreateInstance(this.dataObjectType);

                        return dataObject;

                        #endregion

                    }

                    #endregion

                }

                else

                {

                    #region Reflection

                    object dataObject = System.Activator.CreateInstance(this.dataObjectType);

                    return dataObject;

                    #endregion

                }

            }

        }



        protected CreateDataObjectListDelegate createDataObjectListMethod;

        /// <summary>

        /// Create data object column table delegate.

        /// </summary>

        public CreateDataObjectListDelegate CreateDataObjectListMethod

        {

            get

            {

                return this.createDataObjectListMethod;

            }

            set

            {

                this.createDataObjectListMethod = value;

            }

        }



        /// <summary>

        /// Create data object column table.

        /// </summary>

        /// <returns>data object column table.</returns>

        public virtual System.Collections.IList CreateDataObjectList()

        {

            if (this.createDataObjectListMethod != null)

            {

                return this.createDataObjectListMethod();

            }

            else

            {

                if (UseDynamicProxy)

                {

                    #region UseDynamicProxy

                    IObjectCreater objectCreater = GetObjectCreater(dataObjectType, this.CommandBuilder.CommonCommandBuilder.DataTableDefinition.Columns);

                    if (objectCreater != null)

                    {

                        System.Collections.IList dataObjectList = objectCreater.CreateObjectList();

                        return dataObjectList;

                    }

                    else

                    {

                        // TODO: exception.

                        #region Reflection

                        System.Type listType = typeof(List<>);

                        System.Type dataObjectListType = listType.MakeGenericType(this.dataObjectType);

                        System.Collections.IList dataObjectList = System.Activator.CreateInstance(dataObjectListType) as System.Collections.IList;

                        return dataObjectList;

                        #endregion

                    }

                    #endregion

                }

                else

                {

                    #region Reflection

                    System.Type listType = typeof(List<>);

                    System.Type dataObjectListType = listType.MakeGenericType(this.dataObjectType);

                    System.Collections.IList dataObjectList = System.Activator.CreateInstance(dataObjectListType) as System.Collections.IList;

                    return dataObjectList;

                    #endregion

                }

            }

        }

        #endregion



        #region Transactions

        /// <summary>

        /// Begin Database transaction.

        /// </summary>

        /// <returns>The ID of transaction.</returns>

        public virtual string BeginTransaction()

        {

            return this.transactionManager.BeginTransaction();

        }



        /// <summary>

        /// Begin Database transaction.

        /// </summary>

        /// <param name="isolationLevel">Specifies the isolation level for the transaction.</param>

        /// <returns>The ID of transaction.</returns>

        public virtual string BeginTransaction(System.Data.IsolationLevel isolationLevel)

        {

            return this.transactionManager.BeginTransaction(isolationLevel);

        }



        /// <summary>

        /// Commit Database transaction.

        /// </summary>

        public virtual void CommitTransaction()

        {

            this.transactionManager.CommitTransaction();

        }



        /// <summary>

        /// Commit Database transaction.

        /// </summary>

        /// <param name="transactionID">The ID of transaction.</param>

        public virtual void CommitTransaction(string transactionID)

        {

            this.transactionManager.CommitTransaction(transactionID);

        }



        /// <summary>

        /// Rollback transaction.

        /// </summary>

        public virtual void RollbackTransaction()

        {

            this.transactionManager.RollbackTransaction();

        }



        /// <summary>

        /// Rollback transaction.

        /// </summary>

        /// <param name="transactionID">The ID of transaction.</param>

        public virtual void RollbackTransaction(string transactionID)

        {

            this.transactionManager.RollbackTransaction(transactionID);

        }

        #endregion



        #region Gets primary key value

        /// <summary>

        /// Gets data object The value of primary key.

        /// </summary>

        /// <param name="dataObject">Data object.</param>

        /// <returns>The value of primary key.</returns>

        public virtual object[] GetPrimaryKeys(object dataObject)

        {

            object[] primaryKeys = new object[this.CommandBuilder.CommonCommandBuilder.DataTableDefinition.PrimaryKeys.Count];

            if (UseDynamicProxy)

            {

                #region UseDynamicProxy

                System.Type dataObjectType = dataObject.GetType();

                IObjectAccessor objectAccessor = GetObjectAccessor(dataObjectType, this.CommandBuilder.CommonCommandBuilder.DataTableDefinition.Columns);

                if (objectAccessor != null)

                {

                    for (int i = 0; i < this.CommandBuilder.CommonCommandBuilder.DataTableDefinition.PrimaryKeys.Count; i++)

                    {

                        string columnName = this.CommandBuilder.CommonCommandBuilder.DataTableDefinition.PrimaryKeys[i];

                        primaryKeys[i] = objectAccessor.GetValue(dataObject, columnName);

                    }

                }

                else

                {

                    // TODO: exception.

                    throw new ObjectAccessorException(string.Format("Can't get ObjectAccessor for type [{0}].", dataObjectType));

                }

                #endregion

            }

            else

            {

                if (dataObject is IObjectAccessor)

                {

                    #region IObjectAccessor

                    IObjectAccessor objectAccessor = dataObject as IObjectAccessor;

                    if (objectAccessor != null)

                    {

                        for (int i = 0; i < this.CommandBuilder.CommonCommandBuilder.DataTableDefinition.PrimaryKeys.Count; i++)

                        {

                            string columnName = this.CommandBuilder.CommonCommandBuilder.DataTableDefinition.PrimaryKeys[i];

                            primaryKeys[i] = objectAccessor.GetValue(dataObject, columnName);

                        }

                    }

                    #endregion

                }

                else

                {

                    #region Reflection

                    System.Type dataObjectType = dataObject.GetType();

                    for (int i = 0; i < this.CommandBuilder.CommonCommandBuilder.DataTableDefinition.PrimaryKeys.Count; i++)

                    {

                        string columnName = this.CommandBuilder.CommonCommandBuilder.DataTableDefinition.PrimaryKeys[i];

                        System.Reflection.PropertyInfo propertyInfo = dataObjectType.GetProperty(columnName);

                        if (propertyInfo != null)

                        {

                            primaryKeys[i] = propertyInfo.GetValue(dataObject, null);

                        }

                        else

                        {

                            throw new System.MissingMemberException(string.Format("Can not find a property named {1} in type  {0}.", dataObjectType, columnName));

                        }

                    }

                    #endregion

                }

            }

            return primaryKeys;

        }



        private IObjectCreater GetObjectCreater(Type dataObjectType, Dictionary<string, DataColumnDefinition> columns)

        {

            return ObjectAccessorManager.Instance.GetObjectAccessor(dataObjectType, columns) as IObjectCreater;

        }



        private IObjectAccessor GetObjectAccessor(Type dataObjectType, Dictionary<string, DataColumnDefinition> columns)

        {

            return ObjectAccessorManager.Instance.GetObjectAccessor(dataObjectType, columns);

        }



        private IObjectAccessor GetObjectAccessor(Type dataObjectType, DataColumnMappingCollection columnMappings)

        {

            return ObjectAccessorManager.Instance.GetObjectAccessor(dataObjectType, columnMappings);

        }



        private Type GetDataObjectPropertyType(Type dataObjectType, string propertyName)

        {

            return ObjectAccessorManager.Instance.GetPropertyType(dataObjectType, propertyName);

        }

        #endregion



        public void SetParameterValue(object parameter, object value)

        {

            // TODO: convert.

            (parameter as System.Data.IDbDataParameter).Value = value;

        }



        #region protected methods

        /// <summary>

        /// FillData item.

        /// </summary>

        /// <param name="command">Command.</param>

        /// <param name="dataTableMapping">Data table mapping.</param>

        /// <param name="dataObject">Data object.</param>

        /// <param name="primaryKeys">The value of primary key.</param>

        /// <param name="transaction">Database transaction.</param>

        /// <returns>The result of execute command.</returns>

        protected int Fill(System.Data.IDbCommand command, System.Data.Common.DataTableMapping dataTableMapping, object dataObject, object[] primaryKeys, System.Data.IDbTransaction transaction)

        {

            for (int i = 0; i < command.Parameters.Count; i++)

            {

                SetParameterValue(command.Parameters[i], primaryKeys[i]);

            }

            if (transaction != null)

            {

                command.Transaction = transaction;

            }

            WriteLog(command);

            System.Data.IDataReader dataReader = RaisingStudio.Data.Common.Database.ExecuteReaderCommand(command);

            try

            {

                if (dataReader.Read())

                {

                    if (UseDynamicProxy)

                    {

                        #region UseDynamicProxy

                        System.Type dataObjectType = dataObject.GetType();

                        IObjectAccessor objectAccessor = GetObjectAccessor(dataObjectType, this.CommandBuilder.CommonCommandBuilder.DataTableDefinition.Columns);

                        SetDataObjectValues(dataReader, dataTableMapping, dataObjectType, objectAccessor, dataObject);

                        #endregion

                    }

                    else

                    {

                        if (dataObject is IDataObjectProxy)

                        {

                            #region IObjectAccessor

                            SetDataObjectValues(dataReader, dataTableMapping, dataObject as IDataObjectProxy, dataObject);

                            #endregion

                        }

                        else

                        {

                            #region Reflection

                            System.Type dataObjectType = dataObject.GetType();

                            SetDataObjectValues(dataReader, dataTableMapping, dataObjectType, dataObject);

                            #endregion

                        }

                    }

                }

            }

            finally

            {

                if (dataReader != null)

                {

                    dataReader.Close();

                }

            }



            return dataReader.RecordsAffected;

        }





        private void SetDataObjectValues(System.Data.IDataReader dataReader, System.Data.Common.DataTableMapping dataTableMapping, System.Type dataObjectType, IObjectAccessor objectAccessor, object dataObject)

        {

            if (objectAccessor != null)

            {

                foreach (System.Data.Common.DataColumnMapping dataColumnMapping in dataTableMapping.ColumnMappings)

                {

                    string columnName = dataColumnMapping.DataSetColumn;

                    string sourceName = dataColumnMapping.SourceColumn;

                    DataColumnDefinition dataColumnDefinition = this.CommandBuilder.CommonCommandBuilder.DataTableDefinition.Columns[columnName];

                    System.Data.DbType dbType = dataColumnDefinition.DbType;

                    object value = DataItemAdapter.GetDataReaderValue(dataReader, sourceName, dbType);

                    if (value == System.DBNull.Value)

                    {

                        objectAccessor.SetValue(dataObject, columnName, null);

                    }

                    else

                    {

                        Type propertyType = GetDataObjectPropertyType(dataObjectType, columnName);

                        value = ConvertDataValue(dbType, propertyType, value);

                        objectAccessor.SetValue(dataObject, columnName, value);

                    }

                }

            }

            else

            {

                // TODO: exception.

                throw new ObjectAccessorException(string.Format("Can't get ObjectAccessor for type [{0}].", dataObjectType));

            }

        }



        private void SetDataObjectValues(System.Data.IDataReader dataReader, System.Data.Common.DataTableMapping dataTableMapping, IDataObjectProxy proxy, object dataObject)

        {

            if (proxy != null)

            {

                foreach (System.Data.Common.DataColumnMapping dataColumnMapping in dataTableMapping.ColumnMappings)

                {

                    string columnName = dataColumnMapping.DataSetColumn;

                    string sourceName = dataColumnMapping.SourceColumn;

                    DataColumnDefinition dataColumnDefinition = this.CommandBuilder.CommonCommandBuilder.DataTableDefinition.Columns[columnName];

                    System.Data.DbType dbType = dataColumnDefinition.DbType;

                    object value = DataItemAdapter.GetDataReaderValue(dataReader, sourceName, dbType);

                    if (value == System.DBNull.Value)

                    {

                        proxy.SetValue(dataObject, columnName, null);

                    }

                    else

                    {

                        Type propertyType = proxy.GetPropertyType(columnName);

                        value = ConvertDataValue(dbType, propertyType, value);

                        proxy.SetValue(dataObject, columnName, value);

                    }

                }

            }

            else

            {

                // TODO: exception.

                throw new ObjectAccessorException(string.Format("Can't get ObjectAccessor for type [{0}].", dataObjectType));

            }

        }



        private void SetDataObjectValues(System.Data.IDataReader dataReader, System.Data.Common.DataTableMapping dataTableMapping, System.Type dataObjectType, object dataObject)

        {

            foreach (System.Data.Common.DataColumnMapping dataColumnMapping in dataTableMapping.ColumnMappings)

            {

                string columnName = dataColumnMapping.DataSetColumn;

                string sourceName = dataColumnMapping.SourceColumn;

                DataColumnDefinition dataColumnDefinition = this.CommandBuilder.CommonCommandBuilder.DataTableDefinition.Columns[columnName];

                System.Data.DbType dbType = dataColumnDefinition.DbType;

                System.Reflection.PropertyInfo propertyInfo = dataObjectType.GetProperty(columnName);

                if (propertyInfo != null)

                {

                    object value = DataItemAdapter.GetDataReaderValue(dataReader, sourceName, dbType);

                    if (value == System.DBNull.Value)

                    {

                        propertyInfo.SetValue(dataObject, null, null);

                    }

                    else

                    {

                        value = ConvertDataValue(dbType, propertyInfo.PropertyType, value);

                        propertyInfo.SetValue(dataObject, value, null);

                    }

                }

                else

                {

                    throw new System.MissingMemberException(string.Format("Can not find a property named {1} in type  {0}.", dataObjectType, columnName));

                }

            }

        }





        private object ConvertDataValue(System.Data.DbType dbType, Type propertyType, object value)

        {

            return ConverterManager.ConvertDataValue(dbType, propertyType, value);

        }



        private object ConvertDataValue(Type propertyType, System.Data.DbType dbType, object value)

        {

            return ConverterManager.ConvertDataValue(propertyType, dbType, value);

        }



        /// <summary>

        /// FillData item.

        /// </summary>

        /// <param name="command">Command.</param>

        /// <param name="dataTableMapping">Data table mapping.</param>

        /// <param name="dataObject">Data object.</param>

        /// <param name="primaryKeys">The value of primary key.</param>

        /// <param name="columnNames">An array of Columns.</param>

        /// <param name="transaction">Database transaction.</param>

        /// <returns>The result of execute command.</returns>

        protected int Fill(System.Data.IDbCommand command, System.Data.Common.DataTableMapping dataTableMapping, object dataObject, object[] primaryKeys, string[] columnNames, System.Data.IDbTransaction transaction)

        {

            for (int i = 0; i < command.Parameters.Count; i++)

            {

                SetParameterValue(command.Parameters[i], primaryKeys[i]);

            }

            if (transaction != null)

            {

                command.Transaction = transaction;

            }

            WriteLog(command);

            System.Data.IDataReader dataReader = RaisingStudio.Data.Common.Database.ExecuteReaderCommand(command);

            try

            {

                if (dataReader.Read())

                {

                    if (UseDynamicProxy)

                    {

                        #region UseDynamicProxy

                        System.Type dataObjectType = dataObject.GetType();

                        IObjectAccessor objectAccessor = GetObjectAccessor(dataObjectType, this.CommandBuilder.CommonCommandBuilder.DataTableDefinition.Columns);

                        SetDataObjectValues(dataTableMapping, dataObject, columnNames, dataReader, dataObjectType, objectAccessor);

                        #endregion

                    }

                    else

                    {

                        if (dataObject is IDataObjectProxy)

                        {

                            #region IObjectAccessor

                            IObjectAccessor objectAccessor = dataObject as IObjectAccessor;

                            SetDataObjectValues(dataTableMapping, dataObject, columnNames, dataReader, dataObject as IDataObjectProxy, objectAccessor);

                            #endregion

                        }

                        else

                        {

                            #region Reflection

                            System.Type dataObjectType = dataObject.GetType();

                            SetDataObjectValues(dataTableMapping, dataObject, columnNames, dataReader, dataObjectType);

                            #endregion

                        }

                    }

                }

            }

            finally

            {

                if (dataReader != null)

                {

                    dataReader.Close();

                }

            }



            return dataReader.RecordsAffected;

        }





        private void SetDataObjectValues(System.Data.Common.DataTableMapping dataTableMapping, object dataObject, string[] columnNames, System.Data.IDataReader dataReader, System.Type dataObjectType, IObjectAccessor objectAccessor)

        {

            if (objectAccessor != null)

            {

                foreach (string columnName in columnNames)

                {

                    DataColumnDefinition dataColumnDefinition = this.CommandBuilder.CommonCommandBuilder.DataTableDefinition.Columns[columnName];

                    string sourceName = RaisingStudio.Data.Common.Builders.CommonCommandBuilder.GetDataColumnSourceColumn(dataTableMapping, columnName);

                    System.Data.DbType dbType = dataColumnDefinition.DbType;

                    object value = DataItemAdapter.GetDataReaderValue(dataReader, sourceName, dbType);

                    if (value == System.DBNull.Value)

                    {

                        objectAccessor.SetValue(dataObject, columnName, null);

                    }

                    else

                    {

                        Type propertyType = GetDataObjectPropertyType(dataObjectType, columnName);

                        value = ConvertDataValue(dbType, propertyType, value);

                        objectAccessor.SetValue(dataObject, columnName, value);

                    }

                }

            }

            else

            {

                // TODO: exception.

                throw new ObjectAccessorException(string.Format("Can't get ObjectAccessor for type [{0}].", dataObjectType));

            }

        }

        

        private void SetDataObjectValues(System.Data.Common.DataTableMapping dataTableMapping, object dataObject, string[] columnNames, System.Data.IDataReader dataReader, IDataObjectProxy proxy, IObjectAccessor objectAccessor)

        {

            if (objectAccessor != null)

            {

                foreach (string columnName in columnNames)

                {

                    DataColumnDefinition dataColumnDefinition = this.CommandBuilder.CommonCommandBuilder.DataTableDefinition.Columns[columnName];

                    string sourceName = RaisingStudio.Data.Common.Builders.CommonCommandBuilder.GetDataColumnSourceColumn(dataTableMapping, columnName);

                    System.Data.DbType dbType = dataColumnDefinition.DbType;

                    object value = DataItemAdapter.GetDataReaderValue(dataReader, sourceName, dbType);

                    if (value == System.DBNull.Value)

                    {

                        objectAccessor.SetValue(dataObject, columnName, null);

                    }

                    else

                    {

                        Type propertyType = proxy.GetPropertyType(columnName);

                        value = ConvertDataValue(dbType, propertyType, value);

                        objectAccessor.SetValue(dataObject, columnName, value);

                    }

                }

            }

            else

            {

                // TODO: exception.

                throw new ObjectAccessorException(string.Format("Can't get ObjectAccessor for type [{0}].", dataObjectType));

            }

        }



        private void SetDataObjectValues(System.Data.Common.DataTableMapping dataTableMapping, object dataObject, string[] columnNames, System.Data.IDataReader dataReader, System.Type dataObjectType)

        {

            foreach (string columnName in columnNames)

            {

                DataColumnDefinition dataColumnDefinition = this.CommandBuilder.CommonCommandBuilder.DataTableDefinition.Columns[columnName];

                string sourceName = RaisingStudio.Data.Common.Builders.CommonCommandBuilder.GetDataColumnSourceColumn(dataTableMapping, columnName);

                System.Data.DbType dbType = dataColumnDefinition.DbType;



                System.Reflection.PropertyInfo propertyInfo = dataObjectType.GetProperty(columnName);

                if (propertyInfo != null)

                {

                    object value = DataItemAdapter.GetDataReaderValue(dataReader, sourceName, dbType);

                    if (value == System.DBNull.Value)

                    {

                        propertyInfo.SetValue(dataObject, null, null);

                    }

                    else

                    {

                        value = ConvertDataValue(dbType, propertyInfo.PropertyType, value);

                        propertyInfo.SetValue(dataObject, value, null);

                    }

                }

                else

                {

                    throw new System.MissingMemberException(string.Format("Can not find a property named {1} in type  {0}.", dataObjectType, columnName));

                }

            }

        }



        private System.Data.Common.DataTableMapping _defaultDataTableMapping;

        private System.Data.IDbCommand _defalutConditionSelectCommand;

        /// <summary>

        /// Fill Data object.

        /// </summary>

        /// <param name="dataObject">Data object.</param>

        /// <param name="primaryKeys">The value of primary key.</param>

        /// <param name="transaction">Database transaction.</param>

        /// <returns>The result of execute command.</returns>

        protected virtual int Fill(object dataObject, object[] primaryKeys, System.Data.IDbTransaction transaction)

        {

            if (CacheDefalutCommand)

            {

                if (_defalutConditionSelectCommand == null)

                {

                    _defalutConditionSelectCommand = this.CommandBuilder.GetConditionSelectCommand(out _defaultDataTableMapping);

                }

                System.Data.Common.DataTableMapping dataTableMapping = _defaultDataTableMapping;

                System.Data.IDbCommand command = _defalutConditionSelectCommand;

                return Fill(command, dataTableMapping, dataObject, primaryKeys, transaction);

            }

            else

            {

                System.Data.Common.DataTableMapping dataTableMapping;

                System.Data.IDbCommand command = this.CommandBuilder.GetConditionSelectCommand(out dataTableMapping);

                return Fill(command, dataTableMapping, dataObject, primaryKeys, transaction);

            }

        }



        /// <summary>

        /// Fill Data object.

        /// </summary>

        /// <param name="dataObject">has primary key value Data object.</param>

        /// <param name="transaction">Database transaction.</param>

        /// <returns>The result of execute command.</returns>

        protected virtual int Fill(object dataObject, System.Data.IDbTransaction transaction)

        {

            return Fill(dataObject, GetPrimaryKeys(dataObject), transaction);

        }



        /// <summary>

        /// Fill Data object.

        /// </summary>

        /// <param name="dataObject">Data object.</param>

        /// <param name="primaryKeys">The value of primary key.</param>

        /// <param name="columnNames">An array of Columns.</param>

        /// <param name="transaction">Database transaction.</param>

        /// <returns>The result of execute command.</returns>

        protected virtual int Fill(object dataObject, object[] primaryKeys, string[] columnNames, System.Data.IDbTransaction transaction)

        {

            System.Data.Common.DataTableMapping dataTableMapping;

            System.Data.IDbCommand command = this.CommandBuilder.GetConditionSelectCommand(columnNames, out dataTableMapping);

            return Fill(command, dataTableMapping, dataObject, primaryKeys, columnNames, transaction);

        }



        /// <summary>

        /// Fill Data object.

        /// </summary>

        /// <param name="dataObject">has primary key value Data object.</param>

        /// <param name="columnNames">An array of Columns.</param>

        /// <param name="transaction">Database transaction.</param>

        /// <returns>The result of execute command.</returns>

        protected virtual int Fill(object dataObject, string[] columnNames, System.Data.IDbTransaction transaction)

        {

            return Fill(dataObject, GetPrimaryKeys(dataObject), columnNames, transaction);

        }



        /// <summary>

        /// Gets Data object.

        /// </summary>

        /// <param name="primaryKeys">The value of primary key.</param>

        /// <param name="transaction">Database transaction.</param>

        /// <returns>Data object.</returns>

        protected virtual object GetData(object[] primaryKeys, System.Data.IDbTransaction transaction)

        {

            object dataObject = CreateDataObject();

            Fill(dataObject, primaryKeys, transaction);

            return dataObject;

        }



        /// <summary>

        /// Gets Data object.

        /// </summary>

        /// <param name="dataObject">has primary key value Data object.</param>

        /// <param name="transaction">Database transaction.</param>

        /// <returns>Data object.</returns>

        protected virtual object GetData(object dataObject, System.Data.IDbTransaction transaction)

        {

            Fill(dataObject, transaction);

            return dataObject;

        }



        /// <summary>

        /// Gets Data object.

        /// </summary>

        /// <param name="primaryKeys">The value of primary key.</param>

        /// <param name="columnNames">An array of Columns.</param>

        /// <param name="transaction">Database transaction.</param>

        /// <returns>Data object.</returns>

        protected virtual object GetData(object[] primaryKeys, string[] columnNames, System.Data.IDbTransaction transaction)

        {

            object dataObject = CreateDataObject();

            Fill(dataObject, primaryKeys, columnNames, transaction);

            return dataObject;

        }



        /// <summary>

        /// Gets Data object.

        /// </summary>

        /// <param name="dataObject">has primary key value Data object.</param>

        /// <param name="columnNames">An array of Columns.</param>

        /// <param name="transaction">Database transaction.</param>

        /// <returns>Data object.</returns>

        protected virtual object GetData(object dataObject, string[] columnNames, System.Data.IDbTransaction transaction)

        {

            Fill(dataObject, columnNames, transaction);

            return dataObject;

        }



        public static bool GetSourceColumnNullMapping(System.Data.IDbDataParameter parameter)

        {

            return DataParameterManager.GetSourceColumnNullMapping(parameter);

        }



        private System.Data.IDbCommand _defalutInsertCommand;

        /// <summary>

        /// Insert Data object.

        /// </summary>

        /// <param name="dataObject">Data object.</param>

        /// <param name="transaction">Database transaction.</param>

        /// <returns>The count of rows that updated.</returns>

        protected virtual int Insert(object dataObject, System.Data.IDbTransaction transaction)

        {

            System.Data.IDbCommand command = null;

            if (CacheDefalutCommand)

            {

                if (_defalutInsertCommand == null)

                {

                    _defalutInsertCommand = this.CommandBuilder.GetInsertCommand(this.DefaultDataTableMapping, false);

                }

                command = _defalutInsertCommand;

            }

            else

            {

                command = this.CommandBuilder.GetInsertCommand(this.DefaultDataTableMapping, false);

            }

            SetInsertCommandParameterValues(dataObject, command);

            if (transaction != null)

            {

                command.Transaction = transaction;

            }

            WriteLog(command);

            return RaisingStudio.Data.Common.Database.ExecuteNonQueryCommand(command);

        }



        private void SetInsertCommandParameterValues(object dataObject, System.Data.IDbCommand command)

        {

            if (UseDynamicProxy)

            {

                #region UseDynamicProxy

                System.Type dataObjectType = dataObject.GetType();

                IObjectAccessor objectAccessor = GetObjectAccessor(dataObjectType, this.DefaultDataTableMapping.ColumnMappings);

                SetParameterValues(dataObject, command, dataObjectType, objectAccessor, true);

                #endregion

            }

            else

            {

                if (dataObject is IDataObjectProxy)

                {

                    #region IObjectAccessor

                    IObjectAccessor objectAccessor = dataObject as IObjectAccessor;

                    SetParameterValues(dataObject, command, dataObject as IDataObjectProxy, objectAccessor, true);

                    #endregion

                }

                else

                {

                    #region Reflection

                    System.Type dataObjectType = dataObject.GetType();

                    SetParameterValues(dataObject, command, dataObjectType, true);

                    #endregion

                }

            }

        }





        private void SetParameterValues(object dataObject, System.Data.IDbCommand command, System.Type dataObjectType, IObjectAccessor objectAccessor, bool currentVersion)

        {

            if (objectAccessor != null)

            {

                foreach (System.Data.IDbDataParameter parameter in command.Parameters)

                {

                    if ((!GetSourceColumnNullMapping(parameter)) && (( currentVersion && (parameter.SourceVersion == System.Data.DataRowVersion.Current)) || (!currentVersion)))

                    {

                        string columnName = parameter.SourceColumn;

                        object value = objectAccessor.GetValue(dataObject, columnName);

                        if (value == null)

                        {

                            parameter.Value = System.DBNull.Value;

                        }

                        else

                        {

                            Type propertyType = GetDataObjectPropertyType(dataObjectType, columnName);

                            value = ConvertDataValue(propertyType, parameter.DbType, value);

                            parameter.Value = value;

                        }

                    }

                }

            }

            else

            {

                // TODO: exception.

                throw new ObjectAccessorException(string.Format("Can't get ObjectAccessor for type [{0}].", dataObjectType));

            }

        }



        private void SetParameterValues(object dataObject, System.Data.IDbCommand command, IDataObjectProxy proxy, IObjectAccessor objectAccessor, bool currentVersion)

        {

            if (objectAccessor != null)

            {

                foreach (System.Data.IDbDataParameter parameter in command.Parameters)

                {

                    if ((!GetSourceColumnNullMapping(parameter)) && ((currentVersion && (parameter.SourceVersion == System.Data.DataRowVersion.Current)) || (!currentVersion)))

                    {

                        string columnName = parameter.SourceColumn;

                        object value = objectAccessor.GetValue(dataObject, columnName);

                        if (value == null)

                        {

                            parameter.Value = System.DBNull.Value;

                        }

                        else

                        {

                            Type propertyType = proxy.GetPropertyType(columnName);

                            value = ConvertDataValue(propertyType, parameter.DbType, value);

                            parameter.Value = value;

                        }

                    }

                }

            }

            else

            {

                // TODO: exception.

                throw new ObjectAccessorException(string.Format("Can't get ObjectAccessor for type [{0}].", dataObjectType));

            }

        }



        private void SetParameterValues(object dataObject, System.Data.IDbCommand command, System.Type dataObjectType, bool currentVersion)

        {

            foreach (System.Data.IDbDataParameter parameter in command.Parameters)

            {

                if ((!GetSourceColumnNullMapping(parameter)) && ((currentVersion && (parameter.SourceVersion == System.Data.DataRowVersion.Current)) || (!currentVersion)))

                {

                    string columnName = parameter.SourceColumn;

                    System.Reflection.PropertyInfo propertyInfo = dataObjectType.GetProperty(columnName);

                    if (propertyInfo != null)

                    {

                        object value = propertyInfo.GetValue(dataObject, null);

                        if (value == null)

                        {

                            parameter.Value = System.DBNull.Value;

                        }

                        else

                        {

                            value = ConvertDataValue(propertyInfo.PropertyType, parameter.DbType, value);

                            parameter.Value = value;

                        }

                    }

                    else

                    {

                        throw new System.MissingMemberException(string.Format("Can not find a property named {1} in type  {0}.", dataObjectType, columnName));

                    }

                }

            }

        }





        /// <summary>

        /// Insert Data object.

        /// </summary>

        /// <param name="dataObject">Data object.</param>

        /// <param name="columnNames">An array of Columns.</param>

        /// <param name="transaction">Database transaction.</param>

        /// <returns>The count of rows that updated.</r…

Large files files are truncated, but you can click here to view the full file