MESProductionWeb/AntORM/Ant.ORM/Base/EnBaseObj.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Ant.Frame;
using Ant.Data;
using System.Data;
using System.Configuration;
using System.Reflection;
using Ant.Common;
using Newtonsoft.Json;
using Ant.Descriptors;
using Ant.Entity;

namespace Ant.ORM
{
    /// <summary>
    /// 实体基类
    /// </summary>
    [Serializable]
    public abstract class EnBaseObj<T> : EntityObject<T> where T : EntityObject<T>, new()
    {

        #region 获取单个实体
        /// <summary>
        /// 获取单个实体
        /// </summary>
        /// <param name="entity">查询条件</param>
        /// <returns>返回的是Object类型返回去要进行转换</returns>
        public override ResponseModel GetEntity(RequestModel request)
        {
            return GetEntityEnd(request);
        }


        #endregion

        #region 保存数据
        /// <summary>
        /// 保存数据
        /// </summary>
        /// <returns></returns>
        public override ResponseModel Save()
        {
            return SaveEnd(null);
        }
        /// <summary>
        /// 保存数据
        /// </summary>
        /// <param name="db">数据库对象参数</param>
        /// <returns></returns>
        public override ResponseModel Save(DataAccess db)
        {
            return SaveEnd(db);
        }

        #endregion

        #region 删除数据
        /// <summary>
        /// 删除
        /// </summary>
        /// <returns></returns>
        public override ResponseModel Delete()
        {
            return DeleteEnd("", null);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="db"></param>
        /// <returns></returns>
        public override ResponseModel Delete(DataAccess db)
        {
            return DeleteEnd("", db);
        }
        /// <summary>
        /// 通过oid删除记录
        /// </summary>
        /// <param name="oid"></param>
        /// <returns></returns>
        public override ResponseModel Delete(string oid)
        {
            return DeleteEnd(oid, null);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="oid"></param>
        /// <param name="db"></param>
        /// <returns></returns>
        public override ResponseModel Delete(string oid, DataAccess db)
        {
            return DeleteEnd(oid, db);
        }

        #endregion


        #region 更新数据集


        /// <summary>
        /// 更新自带Where条件的数据
        /// </summary>
        /// <param name="entity">更新的数据</param>
        /// <param name="filter">更新的条件</param>
        /// <param name="db">连接数据库对象</param>
        /// <returns></returns>
        public override ResponseModel UpdateEntity(ResquestUpdateModel enty)
        {
            return UpdateEntityEnd(enty);
        }



        #endregion

        #region 获取数据集
        /// <summary>
        /// 获取DataTable
        /// </summary>
        /// <param name="showfield"></param>
        /// <param name="db"></param>
        /// <returns></returns>
        public override ResponseModel GetDtList(RequestModel enty)
        {
            return GetDtListEnd(enty);
        }

        /// <summary>
        ///  由DataReader转DataTable
        /// </summary>
        /// <param name="enty"></param>
        /// <returns></returns>
        public override ResponseModel GetDr2DtList(RequestModel enty)
        {
            return GetDr2DtListEnd(enty);
        }


        /// <summary>
        /// 通过DataReader返回List集合这种效率高
        /// </summary>
        /// <param name="showfield">显示字段</param>
        /// <param name="db">数据对象</param>
        /// <returns>返回Object类型的数据</returns>
        public override ResponseModel GetDr2EnList(RequestModel enty)
        {
            return GetDr2EnListEnd(enty);
        }


        /// <summary>
        /// 查询DataTable转换成实体效率不高（要求性不高的情况下使用）
        /// </summary>
        /// <param name="db"></param>
        /// <returns></returns>
        public override ResponseModel GetDt2EnList(RequestModel enty)
        {
            return GetDt2EnListEnd(enty);
        }

        /// <summary>
        /// 获取分页方法
        /// </summary>
        /// <param name="enty"></param>
        /// <returns></returns>
        public override ResponseModel GetPageRecordList(RequestModel enty)
        {
            return GetPageRecordListEnd(enty);
        }
        /// <summary>
        /// 获取分页数据返回DataTable
        /// </summary>
        /// <param name="startNum"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public override ResponseModel GetPageRecordDt(RequestModel enty)
        {
            return GetPageRecordDtEnd(enty);
        }
        /// <summary>
        /// 数据的总记录
        /// </summary>
        /// <returns></returns>
        public override ResponseModel Sum()
        {
            return SumEnd();
        }

        #endregion



        #region 最终调用方法

        #region 获取分页数据最终方法
        /// <summary>
        /// 获取分页数据返回实体集合
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private ResponseModel GetPageRecordListEnd(RequestModel request)
        {
            var result = new ResponseModel(); QueryCommand cmd = new QueryCommand();
            var db = request.db;
            try
            {
                System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
                sw.Start();
                //QueryCommandBuilders querycommd = new QueryCommandBuilders();
                MetaData md = MetaDataManager.GetMetaData(this);//获取实体的元数据
                //if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接

                if (db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                if (request.newSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }
                else
                {
                    if (request.newSt.NewSt.IsNull())
                    {
                        result.IsSuccess = false;
                        result.Message = "备注信息不能为空";
                        return result;
                    }
                }
                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.Md = md;//实体属性
                qcBuilder.PersistType = EntityPersistType.QueryPage;//操作方式
                qcBuilder.PageNo = request.StartNum;
                qcBuilder.PageSize = request.PageSize;
                //qcBuilder.SelectField = enty.SelectField;
                qcBuilder.ShowField = request.ShowField;
                qcBuilder.Predicate = request.Predicate;
                cmd = qcBuilder.GetQueryCommand();

                System.Diagnostics.StackFrame[] sfs = request.newSt.NewSt.GetFrames();
                string sqlWithComment = string.Empty;
                if (sfs.Count() > 0)
                {
                    System.Diagnostics.StackFrame infos = sfs[0];
                    System.Reflection.MethodBase mb = infos.GetMethod();
                    var filename = infos.GetFileName();
                    sqlWithComment = string.Format(ConstSql.SQL_WITH_COMMENT, "ORM框架", request.newSt.Author, request.newSt.SqlDesc, filename, mb.Name, mb.DeclaringType.FullName);
                }

                var dt = db.ExecuteDataReader(string.Format(@"{0}{1}", cmd.CommandText, sqlWithComment), cmd.Parameters);
                var objlist = DataToModel.Dr2EnList<T>(dt);
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.IsSuccess = true;
                result.ResultModel = objlist;
                result.RecordNum = PageSumEnd(md).RecordNum;
                result.Message = "查询成功，用时：" + str;
                return result;
            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                result.IsSuccess = false;
                result.Message = ex.ToString();
                cmd = new QueryCommand();
                return result;
            }
            finally
            {
                result.StrSql = cmd.SqlString;
                result.DBConfig = db.ConnectionString;
                if (!db.IsNull()) db.Close();
            }
        }


        /// <summary>
        /// 获取分页数据
        /// </summary>
        /// <param name="startNum"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        //private ResponseTable GetPageRecordDtEnd(string showfield, int startNum, int pageSize)
        private ResponseModel GetPageRecordDtEnd(RequestModel enty)
        {
            DataAccess db = enty.db; QueryCommand cmd = new QueryCommand();
            ResponseModel result = new ResponseModel();
            try
            {
                System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
                sw.Start();
                MetaData md = MetaDataManager.GetMetaData(this);//获取实体的元数据
                if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName, DataConfigEnum.WriteData);//创建数据库连接

                if (db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                if (enty.newSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }
                else
                {
                    if (enty.newSt.NewSt.IsNull())
                    {
                        result.IsSuccess = false;
                        result.Message = "备注信息不能为空";
                        return result;
                    }
                }

                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.Md = md;//实体属性
                qcBuilder.PersistType = EntityPersistType.QueryPage;//操作方式
                qcBuilder.PageNo = enty.StartNum;
                qcBuilder.PageSize = enty.PageSize;
                //qcBuilder.SelectField = enty.SelectField;
                qcBuilder.ShowField = enty.ShowField;
                cmd = qcBuilder.GetQueryCommand();

                System.Diagnostics.StackFrame[] sfs = enty.newSt.NewSt.GetFrames();
                string sqlWithComment = string.Empty;
                if (sfs.Count() > 0)
                {
                    System.Diagnostics.StackFrame infos = sfs[0];
                    System.Reflection.MethodBase mb = infos.GetMethod();
                    var filename = infos.GetFileName();
                    sqlWithComment = string.Format(ConstSql.SQL_WITH_COMMENT, "ORM框架", enty.newSt.Author, enty.newSt.SqlDesc, filename, mb.Name, mb.DeclaringType.FullName);
                }

                DataTable dt = db.ExecuteDataTable(string.Format(@"{0}{1}", cmd.CommandText, sqlWithComment), cmd.Parameters);
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.IsSuccess = dt.Rows.Count > 0;
                result.RecordNum = PageSumEnd(md).RecordNum;
                result.DataTable = dt;
                result.Message = "查询返回成功,用时：" + str;

                return result;
            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                result.IsSuccess = false;
                result.Message = ex.ToString();
                return result;
            }
            finally
            {
                result.StrSql = cmd.SqlString;
                result.DBConfig = db.ConnectionString;
                if (!db.IsNull()) db.Close();
            }
        }

        /// <summary>
        /// 带分页的统计记录
        /// </summary>
        /// <param name="md"></param>
        /// <returns></returns>
        private ResponseModel PageSumEnd(MetaData md)
        {
            DataAccess db = null; ResponseModel result = new ResponseModel(); QueryCommand cmd = new QueryCommand();
            try
            {
                if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
                if (db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.Md = md;
                qcBuilder.PersistType = EntityPersistType.Sum;
                cmd = qcBuilder.GetQueryCommand();
                var num = db.ExecuteScalar(cmd.CommandText, cmd.Parameters).ToInt32();
                result.RecordNum = num;
                result.IsSuccess = true;
                result.Message = "返回成功";
            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                result.IsSuccess = false;
                result.Message = ex.ToString();
            }
            finally
            {
                result.StrSql = cmd.SqlString;
                result.DBConfig = db.ConnectionString;
                if (!db.IsNull()) db.Close();
            }
            return result;
        }

        /// <summary>
        /// 数据的总记录
        /// </summary>
        /// <returns></returns>
        private ResponseModel SumEnd()
        {
            DataAccess db = null; ResponseModel result = new ResponseModel(); QueryCommand cmd = new QueryCommand();
            try
            {
                //QueryCommandBuilders querycommd = new QueryCommandBuilders();
                MetaData md = MetaDataManager.GetMetaData(this);//获取实体的元数据
                if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
                if (db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.Md = md;
                qcBuilder.PersistType = EntityPersistType.Sum;
                cmd = qcBuilder.GetQueryCommand();
                var num = db.ExecuteScalar(cmd.CommandText, cmd.Parameters).ToInt32();
                result.RecordNum = num;
                result.IsSuccess = true;
                result.Message = "返回成功";
            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                result.IsSuccess = false;
                result.Message = ex.ToString();
            }
            finally
            {
                result.StrSql = cmd.SqlString;
                result.DBConfig = db.ConnectionString;
                if (!db.IsNull()) db.Close();
            }
            return result;
        }
        #endregion

        /// <summary>
        /// 获取单个实体最终方法
        /// </summary>
        /// <param name="oid"></param>
        /// <param name="showfield"></param>
        /// <param name="db"></param>
        /// <returns></returns>
        private ResponseModel GetEntityEnd(RequestModel enty)
        {
            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            sw.Start();
            T obj = Activator.CreateInstance<T>(); DataAccess db = enty.db;
            var result = new ResponseModel(); TypeDescriptor md = null;
            QueryCommand cmd = new QueryCommand(); string sqlWithComment = string.Empty;
            try
            {
                md = TypeDescriptor.ParserMeta(this); //获取实体的元数据
                if (md.Fields.Count == 0 && enty.Predicate.IsNull())//主键和查询类都没有赋值这样就不能做这种查询
                {
                    result.Message = "所有查询条件都没有，不能查询";
                    result.IsSuccess = false;
                    return result;
                }
                if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName, DataConfigEnum.WriteData);//创建数据库连接 
                if (db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }

                if (enty.newSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }
                else
                {
                    if (enty.newSt.NewSt.IsNull())
                    {
                        result.IsSuccess = false;
                        result.Message = "备注信息不能为空";
                        return result;
                    }
                }

                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType); //构建生成哪种SQL语句
                qcBuilder.Md = md;
                qcBuilder.PersistType = EntityPersistType.Query;
                qcBuilder.Predicate = enty.Predicate;
                qcBuilder.Top = "1";
                qcBuilder.SqlType = SqlEnum.MainSql;
                qcBuilder.Sort = enty.Sort;
                cmd = qcBuilder.GetQueryCommand(); //生成SQL语句和参数
                System.Diagnostics.StackFrame[] sfs = enty.newSt.NewSt.GetFrames();
                if (sfs.Count() > 0)
                {
                    System.Diagnostics.StackFrame infos = sfs[0];
                    System.Reflection.MethodBase mb = infos.GetMethod();
                    var filename = infos.GetFileName();
                    sqlWithComment = string.Format(ConstSql.SQL_WITH_COMMENT, "ORM框架", enty.newSt.Author, enty.newSt.SqlDesc, filename, mb.Name, mb.DeclaringType.FullName);
                }

                using (IDataReader rdr = db.ExecuteDataReader(string.Format(@"{0}{1}", cmd.CommandText, sqlWithComment), cmd.Parameters))
                {
                    obj = DataToModel.Dr2En<T>(rdr);
                }
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.IsSuccess = obj.IfNotNull();
                result.ResultModel = obj;
                result.Message = "获取实体成功，用时：" + str;
                return result;
            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                result.IsSuccess = false;
                result.Message = ex.ToString();
                return result;
            }
            finally
            {
                string showsqlstr = string.Format(@"{0}{1}", cmd.SqlString, sqlWithComment);
                result.StrSql = showsqlstr;
                result.DBConfig = db.ConnectionString;
                if (!db.IsNull()) db.Close();
            }
        }

        /// <summary>
        /// 判断数据库中是否有值
        /// </summary>
        /// <param name="comText">执行的sql查询</param>
        /// <returns></returns>
        public bool GetDataHasRows(string comText)
        {

            return true;
        }

        /// <summary>
        /// 保存数据
        /// </summary>
        /// <param name="db"></param>
        /// <returns></returns>
        private ResponseModel SaveEnd(DataAccess db)
        {
            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            sw.Start();
            ResponseModel result = new ResponseModel(); QueryCommand cmd = new QueryCommand(); string sqlWithComment = string.Empty;
            try
            {

                TypeDescriptor md = TypeDescriptor.ParserMeta(this);//获取实体的元数据
                if (db.IsNull())
                    db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
                if (db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);//构建生成哪种SQL语句
                qcBuilder.TypeDes = md;//所有实体属性
                qcBuilder.PersistType = PersistType;
                cmd = qcBuilder.GetQueryCommand();//解析SQL语句
                result.DBConfig = db.ConnectionString;
                int num = 0; var location = cmd.CommandText.EndsWith(ConstSql.SQL_SCOPE_IDENTITY, StringComparison.CurrentCultureIgnoreCase);
                if (location)
                {
                    num = (!cmd.CommandText.IsEmpty()) ? db.ExecuteScalar(cmd.CommandText, cmd.Parameters).ToInt32() : 0;//执行SQL语句
                    result.RecordNum = num;
                }
                else
                {
                    num = (!cmd.CommandText.IsEmpty()) ? db.ExecuteNonQuery(cmd.CommandText, cmd.Parameters).ToInt32() : 0;
                }
                result.IsSuccess = num > 0;
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.Message = "保存成功,用时：" + str;
                sw = null;
            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                result.IsSuccess = false;
                result.Message = ex.ToString();
            }
            finally
            {
                string showsqlstr = string.Format(@"{0}{1}", cmd.SqlString, sqlWithComment);
                result.StrSql = showsqlstr;
                if (db.IfNotNull()) db.Close();
            }
            return result;
        }

        /// <summary>
        /// 删除最终方法
        /// </summary>
        /// <param name="oid"></param>
        /// <param name="db"></param>
        /// <returns></returns>
        private ResponseModel DeleteEnd(string oid, DataAccess db)
        {
            ResponseModel result = new ResponseModel(); QueryCommand cmd = new QueryCommand();
            try
            {
                System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
                sw.Start();
                TypeDescriptor md = null;
                if (oid.IsEmpty())
                {
                    md = TypeDescriptor.ParserMeta(this); //获取实体的元数据
                }
                else
                {
                    md = TypeDescriptor.GetDescriptor(typeof(T)); //获取实体的元数据
                    md.ModuleName = Activator.CreateInstance<T>().ModuleName;
                    md.WhereSql = ModPerkey(md.PrimaryKey.Column.Name, oid); //自定义查询条件
                }

                if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
                if (db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }

                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.TypeDes = md;
                qcBuilder.PersistType = EntityPersistType.Delete;
                cmd = qcBuilder.GetQueryCommand();
                int num = db.ExecuteNonQuery(cmd.CommandText, cmd.Parameters);//执行SQL语句
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.IsSuccess = num > 0;
                result.Message = "删除成功,用时：" + str;
                sw = null;
            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                //
                result.IsSuccess = false;
                result.Message = ex.ToString();
            }
            finally
            {
                result.StrSql = cmd.SqlString;
                result.DBConfig = db.ConnectionString;
                if (!db.IsNull()) db.Close();
            }
            return result;

        }


        /// <summary>
        /// 获取DataTable转List的方法
        /// </summary>
        /// <param name="showfield"></param>
        /// <param name="db"></param>
        /// <returns></returns>
        private ResponseModel GetDtListEnd(RequestModel enty)
        {
            var result = new ResponseModel(); DataAccess db = enty.db; QueryCommand cmd = new QueryCommand();
            try
            {
                System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
                sw.Start();
                TypeDescriptor md = TypeDescriptor.ParserMeta(this);//获取实体的元数据
                if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
                if (db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                if (enty.newSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }
                else
                {
                    if (enty.newSt.NewSt.IsNull())
                    {
                        result.IsSuccess = false;
                        result.Message = "备注信息不能为空";
                        return result;
                    }
                }
                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.TypeDes = md;
                //qcBuilder.SelectField = enty.SelectField;
                qcBuilder.ShowField = enty.ShowField;
                if (enty.TopNum > 0)
                    qcBuilder.Top = enty.TopNum.ToString();
                qcBuilder.PersistType = EntityPersistType.Query;//操作方式
                cmd = qcBuilder.GetQueryCommand();
                DataTable dt = new DataTable();
                System.Diagnostics.StackFrame[] sfs = enty.newSt.NewSt.GetFrames();
                string sqlWithComment = string.Empty;
                if (sfs.Count() > 0)
                {
                    System.Diagnostics.StackFrame infos = sfs[0];
                    System.Reflection.MethodBase mb = infos.GetMethod();
                    var filename = infos.GetFileName();
                    sqlWithComment = string.Format(ConstSql.SQL_WITH_COMMENT, "ORM框架", enty.newSt.Author, enty.newSt.SqlDesc, filename, mb.Name, mb.DeclaringType.FullName);
                }
                dt = db.ExecuteDataTable(string.Format(@"{0}{1}", cmd.CommandText, sqlWithComment), cmd.Parameters);
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.IsSuccess = dt.IsHaveRows();
                result.DataTable = dt;
                result.Message = string.Format("返回数据成功记录数：{0}耗时：{1}", dt.Rows.Count, str);
                sw = null;
                return result;

            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                result.IsSuccess = false;
                result.Message = ex.ToString();
                return result;
            }
            finally
            {
                result.StrSql = cmd.SqlString;
                result.DBConfig = db.ConnectionString;
                if (!db.IsNull()) db.Close();
            }
            return result;
        }

        /// <summary>
        /// 由DataReader转DataTable
        /// </summary>
        /// <param name="enty"></param>
        /// <returns></returns>
        private ResponseModel GetDr2DtListEnd(RequestModel enty)
        {
            var result = new ResponseModel(); DataAccess db = enty.db; QueryCommand cmd = new QueryCommand(); string sqlWithComment = string.Empty;
            try
            {
                System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
                sw.Start();
                TypeDescriptor md = TypeDescriptor.ParserMeta(this);//获取实体的元数据
                if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
                if (db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                if (enty.newSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }
                else
                {
                    if (enty.newSt.NewSt.IsNull())
                    {
                        result.IsSuccess = false;
                        result.Message = "备注信息不能为空";
                        return result;
                    }
                }

                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.TypeDes = md;
                //qcBuilder.SelectField = enty.SelectField;
                qcBuilder.ShowField = enty.ShowField;
                if (enty.TopNum > 0)
                    qcBuilder.Top = enty.TopNum.ToString();
                qcBuilder.PersistType = EntityPersistType.Query;//操作方式
                cmd = qcBuilder.GetQueryCommand();
                DataTable dt = new DataTable();

                //dt = db.ExecuteDataTable(cmd.CommandText, cmd.Parameters);
                //sw.Stop();
                //string str = sw.Elapsed.ToString();

                System.Diagnostics.StackFrame[] sfs = enty.newSt.NewSt.GetFrames();

                if (sfs.Count() > 0)
                {
                    System.Diagnostics.StackFrame infos = sfs[0];
                    System.Reflection.MethodBase mb = infos.GetMethod();
                    var filename = infos.GetFileName();
                    sqlWithComment = string.Format(ConstSql.SQL_WITH_COMMENT, "ORM框架", enty.newSt.Author, enty.newSt.SqlDesc, filename, mb.Name, mb.DeclaringType.FullName);
                }

                using (IDataReader rdr = db.ExecuteDataReader(string.Format(@"{0}{1}", cmd.CommandText, sqlWithComment), cmd.Parameters))
                {
                    dt = DataToModel.Dr2Dt(rdr);
                }
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.IsSuccess = dt.IsHaveRows();
                result.DataTable = dt;
                result.Message = string.Format("返回数据成功记录数：{0}耗时：{1}", dt.Rows.Count, str);
                return result;

            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                result.IsSuccess = false;
                result.Message = ex.ToString();
                return result;
            }
            finally
            {
                string showsqlstr = string.Format(@"{0}{1}", cmd.SqlString, sqlWithComment);
                result.StrSql = showsqlstr;
                result.DBConfig = db.ConnectionString;
                if (!db.IsNull()) db.Close();
            }
            return result;
        }


        /// <summary>
        /// 通过DataReader返回List集合这种效率高
        /// </summary>
        /// <param name="showfield">显示字段</param>
        /// <param name="db">数据对象</param>
        /// <returns>返回Object类型的数据</returns>
        private ResponseModel GetDr2EnListEnd(RequestModel enty)
        {
            var result = new ResponseModel(); DataAccess db = enty.db; QueryCommand cmd = new QueryCommand();
            try
            {
                System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
                sw.Start();
                TypeDescriptor md = TypeDescriptor.ParserMeta(this);//获取实体的元数据
                if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
                if (db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                if (enty.newSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }
                else
                {
                    if (enty.newSt.NewSt.IsNull())
                    {
                        result.IsSuccess = false;
                        result.Message = "备注信息不能为空";
                        return result;
                    }
                }
                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.TypeDes = md;
                //qcBuilder.SelectField = enty.SelectField;
                qcBuilder.ShowField = enty.ShowField;
                if (enty.TopNum > 0)
                    qcBuilder.Top = enty.TopNum.ToString();
                qcBuilder.PersistType = EntityPersistType.Query;//操作方式
                cmd = qcBuilder.GetQueryCommand();
                List<T> objlist = new List<T>();

                System.Diagnostics.StackFrame[] sfs = enty.newSt.NewSt.GetFrames();
                string sqlWithComment = string.Empty;
                if (sfs.Count() > 0)
                {
                    System.Diagnostics.StackFrame infos = sfs[0];
                    System.Reflection.MethodBase mb = infos.GetMethod();
                    var filename = infos.GetFileName();
                    sqlWithComment = string.Format(ConstSql.SQL_WITH_COMMENT, "ORM框架", enty.newSt.Author, enty.newSt.SqlDesc, filename, mb.Name, mb.DeclaringType.FullName);
                }

                using (IDataReader rdr = db.ExecuteDataReader(string.Format(@"{0}{1}", cmd.CommandText, sqlWithComment), cmd.Parameters))
                {
                    objlist = DataToModel.Dr2EnList<T>(rdr);
                }
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.IsSuccess = objlist.Count > 0;
                if (result.IsSuccess)
                {
                    result.ResultModel = objlist;
                    result.Message = string.Format("返回数据成功记录数：{0}耗时：{1}", objlist.Count, str);
                }
                else
                {
                    result.Message = "返回失败";
                    result.StrSql = cmd.SqlString;
                }

                return result;

            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                result.IsSuccess = false;
                result.Message = ex.ToString();
                return result;
            }
            finally
            {

                result.DBConfig = db.ConnectionString;
                if (!db.IsNull()) db.Close();
            }
        }

        /// <summary>
        /// 查询DataTable转换成实体效率不高（要求性不高的情况下使用）
        /// </summary>
        /// <param name="db"></param>
        /// <param name="showfield"></param>
        /// <returns></returns>
        private ResponseModel GetDt2EnListEnd(RequestModel enty)
        {
            var result = new ResponseModel(); DataAccess db = enty.db; QueryCommand cmd = new QueryCommand(); string sqlWithComment = string.Empty;
            try
            {
                System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
                sw.Start();
                //QueryCommandBuilders querycommdlist = new QueryCommandBuilders();
                TypeDescriptor md = TypeDescriptor.ParserMeta(this);//获取实体的元数据
                if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
                if (db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }
                if (enty.newSt.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "备注信息不能为空";
                    return result;
                }
                else
                {
                    if (enty.newSt.NewSt.IsNull())
                    {
                        result.IsSuccess = false;
                        result.Message = "备注信息不能为空";
                        return result;
                    }
                }
                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.TypeDes = md;
                //qcBuilder.SelectField = enty.SelectField;
                qcBuilder.ShowField = enty.ShowField;
                if (enty.TopNum > 0)
                    qcBuilder.Top = enty.TopNum.ToString();
                qcBuilder.PersistType = EntityPersistType.Query;
                cmd = qcBuilder.GetQueryCommand();
                // querycommdlist.Add(qcBuilder);
                System.Diagnostics.StackFrame[] sfs = enty.newSt.NewSt.GetFrames();

                if (sfs.Count() > 0)
                {
                    System.Diagnostics.StackFrame infos = sfs[0];
                    System.Reflection.MethodBase mb = infos.GetMethod();
                    var filename = infos.GetFileName();
                    sqlWithComment = string.Format(ConstSql.SQL_WITH_COMMENT, "ORM框架", enty.newSt.Author, enty.newSt.SqlDesc, filename, mb.Name, mb.DeclaringType.FullName);
                }


                DataTable dt = db.ExecuteDataTable(string.Format(@"{0}{1}", cmd.CommandText, sqlWithComment), cmd.Parameters);
                var objlist = DataToModel.Dt2EnList<T>(dt);

                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.ResultModel = objlist;
                result.IsSuccess = objlist.Count > 0;
                result.Message = string.Format("返回数据成功记录数：{0}耗时：{1}", objlist.Count, str);
                return result;
            }
            catch (Exception ex)
            {
                //LogHelper.WriteExLog(ex);
                result.IsSuccess = false;
                result.Message = ex.ToString();
                return result;
            }
            finally
            {
                string showsqlstr = string.Format(@"{0}{1}", cmd.SqlString, sqlWithComment);
                result.StrSql = showsqlstr;
                result.DBConfig = db.ConnectionString;
                if (!db.IsNull()) db.Close();
            }
        }


        /// <summary>
        /// 批量更新操作
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        //private ResponseModel UpdateEntityEnd(object entyvalue, DataAccess db)
        private ResponseModel UpdateEntityEnd(ResquestUpdateModel request)
        {
            ResponseModel result = new ResponseModel(); QueryCommand cmd = new QueryCommand();
            try
            {
                System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
                sw.Start();
                MetaData md = (request.QueryModel.IfNotNull()) ? MetaDataManager.GetMetaData(this, request.QueryModel) : MetaDataManager.GetMetaData(this);//获取实体的元数据
                if (request.db.IsNull()) request.db = DataAccessFactory.CreateDataConnection(md.ModuleName, DataConfigEnum.WriteData);//创建数据库连接
                if (request.db.IsNull())
                {
                    result.IsSuccess = false;
                    result.Message = "数据库配置不正确";
                    return result;
                }

                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(request.db.DatabaseType);////构建生成哪种SQL语句
                qcBuilder.Md = md;
                qcBuilder.PersistType = EntityPersistType.Update;
                qcBuilder.Predicate = request.Predicate;
                cmd = qcBuilder.GetQueryCommand();//解析SQL语句
                int num = request.db.ExecuteNonQuery(cmd.CommandText, cmd.Parameters);//执行SQL语句
                sw.Stop();
                string str = sw.Elapsed.ToString();
                result.IsSuccess = num > 0;
                result.Message = "数据更新成功，用时：" + str;
            }
            catch (Exception ex)
            {
                //
                result.IsSuccess = false;
                result.Message = ex.ToString();
            }
            finally
            {
                result.StrSql = cmd.SqlString;
                result.DBConfig = request.db.ConnectionString;
                if (!request.db.IsNull()) request.db.Close();
            }
            return result;
        }


        #region Old分页GetPageRecordDt代码
        ///// <summary>
        ///// 获取分页数据
        ///// </summary>
        ///// <param name="startNum"></param>
        ///// <param name="pageSize"></param>
        ///// <returns></returns>
        //public override ResponseTable GetPageRecordDt(string showfield, int startNum, int pageSize)
        //{
        //    SqlCmd = new Dictionary<string, QueryParameterCollection>(); db = null;
        //    try
        //    {
        //        QueryCommandBuilders querycommd = new QueryCommandBuilders();
        //        MetaData md = MetaDataManager.GetMetaData(this);//获取实体的元数据
        //        if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
        //        QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
        //        qcBuilder.Md = md;//实体属性
        //        qcBuilder.PersistType = EntityPersistType.QueryPage;//操作方式
        //        qcBuilder.PageNo = startNum;
        //        qcBuilder.PageSize = pageSize;
        //        qcBuilder.ShowField = showfield;


        //        QueryCommand cmd = qcBuilder.GetQueryCommand();
        //        querycommd.Add(qcBuilder);
        //        if (md.ReferenceObjects.Count > 0)
        //        {
        //            md = MetaDataManager.GetMetaData(this);//获取实体的元数据
        //            if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
        //            qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
        //            qcBuilder.Md = md;//实体属性
        //            qcBuilder.PersistType = EntityPersistType.QueryPage;//操作方式
        //            qcBuilder.PageNo = startNum;
        //            qcBuilder.PageSize = pageSize;
        //            cmd = qcBuilder.GetQueryCommand();
        //            querycommd.Add(qcBuilder);
        //        }
        //        SqlCmd.Add(cmd.CommandText, cmd.Parameters);
        //        DataTable dt = db.ExecuteDataTable(cmd.CommandText, cmd.Parameters);
        //        return dt;
        //    }
        //    catch (Exception ex)
        //    {
        //        LogHelper.WriteExLog(ex);
        //        //
        //        return new DataTable();
        //    }
        //    finally
        //    {
        //        if (!db.IsNull()) db.Close();
        //    }
        //}
        #endregion

        #region OldGetEntity
        ///// <summary>
        ///// 获取单个实体
        ///// </summary>
        ///// <param name="oid"></param>
        ///// <returns></returns>
        //public override ResponseModel GetEntity(string oid, string showfield, DataAccess db)
        //{
        //    lock (this) //处理并发情况(分布式情况) 
        //    {
        //        T obj = Activator.CreateInstance<T>(); var result = new ResponseModel();
        //        try
        //        {
        //            if (!string.IsNullOrEmpty(oid))
        //            {
        //                SqlCmd = new Dictionary<string, QueryParameterCollection>();

        //                #region 获取主对象
        //                MetaData md = MetaDataManager.GetMetaData(typeof(T));//获取实体的元数据
        //                md.ModuleName = Activator.CreateInstance<T>().ModuleName;
        //                md.WhereSql = ModPerkey(md.PrimaryKey, oid);//自定义查询条件
        //                if (db.IsNull())
        //                {
        //                    db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
        //                }
        //                QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);//构建生成哪种SQL语句

        //                qcBuilder.Md = md;
        //                qcBuilder.PersistType = EntityPersistType.Query;
        //                qcBuilder.ShowField = showfield;
        //                qcBuilder.Top = "1";
        //                qcBuilder.SqlType = SqlEnum.MainSql;
        //                QueryCommand cmd = qcBuilder.GetQueryCommand();//生成SQL语句和参数
        //                SqlCmd.Add(cmd.CommandText, cmd.Parameters);
        //                using (IDataReader rdr = db.ExecuteDataReader(cmd.CommandText, cmd.Parameters))
        //                {
        //                    obj = DataToModel.Dr2En<T>(rdr);
        //                }
        //                #endregion

        //                #region 获取扩展对象
        //                if (md.ReferenceObjects.Count > 0)
        //                {
        //                    qcBuilder.Fields = MetaDataManager.GetEntityFields(obj);
        //                    qcBuilder.SqlType = SqlEnum.ReferenceSql;
        //                    if (qcBuilder.Fields.Count > 0)
        //                    {
        //                        cmd = qcBuilder.GetQueryCommand();//生成SQL语句和参数
        //                        if (cmd.Parameters.Count > 0)
        //                        {
        //                            using (IDataReader rdr2 = db.ExecuteDataReader(cmd.CommandText, cmd.Parameters))
        //                            {
        //                                obj = DataToModel.Dr2En<T>(rdr2, obj);
        //                            }
        //                        }
        //                    }

        //                }
        //                #endregion

        //                result.IsSuccess = true;
        //                result.Mod = obj;
        //                return result;
        //            }
        //            else
        //            {
        //                result.IsSuccess = false;
        //                result.Message = "没有查询找到数据";
        //                result.Mod = obj;
        //                return result;
        //            }
        //        }
        //        catch (Exception ex)
        //        {
        //            LogHelper.WriteExLog(ex);
        //            result.Message = ex.ToString();
        //            return result;
        //        }
        //        finally
        //        {
        //            if (!db.IsNull()) db.Close();
        //        }
        //    }
        //}

        #endregion
        #endregion



        #region 获取带扩展属性的实体集合
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        //public override ResponseModelList GetReferenceList(int startNum, int pageSize)
        //{
        //    db = null;
        //    return GetReferenceList(db, startNum, pageSize);
        //}

        /// <summary>
        /// 获取带扩展属性的实体集合用关联SQL语句来实现
        /// </summary>
        /// <param name="db"></param>
        /// <returns></returns>
        //public override ResponseModelList GetReferenceList(DataAccess db, int startNum, int pageSize)
        //{
        //    SqlCmd = new Dictionary<string, QueryParameterCollection>(); db = null;
        //    var result = new ResponseModelList();
        //    try
        //    {
        //        MetaData md = MetaDataManager.GetMetaData(this);//获取实体的元数据
        //        if (db.IsNull()) db = DataAccessFactory.CreateDataConnection(md.ModuleName);//创建数据库连接
        //        QueryCommandBuilder qcBuilder = QueryCommandBuilder.Instance(db.DatabaseType);////构建生成哪种SQL语句
        //        qcBuilder.Md = md;
        //        qcBuilder.PageNo = startNum;
        //        qcBuilder.PageSize = pageSize;
        //        qcBuilder.PersistType = EntityPersistType.LeftJoin;
        //        QueryCommand cmd = qcBuilder.GetQueryCommand();
        //        DataTable dt = new DataTable();
        //        SqlCmd.Add(cmd.CommandText, cmd.Parameters);
        //        dt = db.ExecuteDataTable(cmd.CommandText, cmd.Parameters);
        //        var objlist = DataToModel.Dt2EnList<T>(dt);
        //        result.IsSuccess = true;
        //        result.ModList = objlist;
        //        return  result;
        //    }
        //    catch (Exception ex)
        //    {
        //        LogHelper.WriteExLog(ex);
        //        result.Message = ex.ToString();
        //        return result;
        //    }
        //    finally
        //    {
        //        if (!db.IsNull()) db.Close();
        //    }
        //}
        #endregion

        /// <summary>
        /// 查询条件表达式
        /// </summary>
        /// <param name="type"></param>
        /// <param name="oid">主键值</param>
        /// <returns></returns>
        private string ModPerkey(string oid, string value)
        {
            string tmpFilter = value;
            if (!string.IsNullOrEmpty(tmpFilter))
                tmpFilter = oid + "='" + tmpFilter + "'";
            return tmpFilter;
        }

        public override void GetDetail(int level)
        {
            throw new NotImplementedException();
        }



        /// <summary>
        /// 给实体赋值
        /// </summary>
        /// <param name="FieldName">字段名称</param>
        /// <param name="defaultValue">默认值</param>
        protected void SetChanaged(string FieldName, object defaultValue)
        {
            if (!Values.ContainsKey(FieldName))
            {
                EntityValue val = new EntityValue();
                val.OriginalValue = defaultValue;
                val.FieldName = FieldName;
                val.IsChanage = false;
                Values.Add(FieldName, val);
            }
            else
            {
                EntityValue val = base.Values[FieldName];
                if (object.Equals(val.OriginalValue, defaultValue))
                {
                    val.CurrentValue = null;
                    val.IsChanage = false;
                }
                else
                {
                    val.CurrentValue = defaultValue;
                    val.IsChanage = true;
                }
            }
        }
        /// <summary>
        /// 获得对象的值
        /// </summary>
        /// <param name="FieldName">字段名称</param>
        /// <returns></returns>
        protected object ToValue(string FieldName)
        {
            if (base.Values.ContainsKey(FieldName))
            {
                EntityValue val = base.Values[FieldName];
                if (val.CurrentValue != null)
                {
                    return val.CurrentValue;
                }
                if (val.OriginalValue != null)
                {
                    return val.OriginalValue;
                }
                return null;
            }
            return null;
        }
        /// <summary>
        /// 属性值修改情况
        /// </summary>
        /// <param name="FieldName">字段名称</param>
        /// <param name="currentValue">当前值</param>
        protected void ToChanaged(string FieldName, object currentValue)
        {
            if (base.Values.ContainsKey(FieldName))
            {
                EntityValue val = base.Values[FieldName];
                if (object.Equals(val.OriginalValue, currentValue))
                {
                    val.CurrentValue = null;
                    val.IsChanage = false;
                }
                else
                {
                    val.CurrentValue = currentValue;
                    val.IsChanage = true;
                }
            }
        }
        [JsonIgnore, NotMapped]
        public override string ModuleName
        {
            get;
            set;
        }



    }
}