using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using NewLife;
using NewLife.Data;
using NewLife.Log;
using NewLife.Threading;
using XCode.Cache;
using XCode.Configuration;
using XCode.DataAccessLayer;

/*
 * 检查表结构流程：
 * Create           创建实体会话，此时不能做任何操作，原则上各种操作要延迟到最后
 * Query/Execute    查询修改数据
 *      WaitForInitData     等待数据初始化
 *          Monitor.TryEnter    只会被调用一次，后续线程进入需要等待
 *          CheckModel          lock阻塞检查模型架构
 *              CheckTable      检查表
 *                  FixIndexName    修正索引名称
 *                  SetTables       设置表架构
 *              CheckTableAync  异步检查表
 *          InitData
 *          Monitor.Exit        初始化完成
 * Count            总记录数
 *      CheckModel
 *      WaitForInitData
 *
 * 缓存流程：
 * Insert/Update/Delete
 *      IEntityPersistence.Insert/Update/Delete
 *          Execute
 *              DataChange <= Tran!=null
 *                  ClearCache
 *                  OnDataChange
 *      更新缓存
 *      Tran.Completed
 *          Tran = null
 *          Success
 *              DataChange
 *          else
 *              回滚缓存
 * 
 * 缓存更新规则如下：
 * 1、直接执行SQL语句进行新增、编辑、删除操作，强制清空实体缓存、单对象缓存
 * 2、无论独占模式或非独占模式，使用实体对象或实体列表进行的对象操作，不再主动清空缓存。
 * 3、事务提交时对缓存的操作参考前两条
 * 4、事务回滚时一律强制清空缓存（因为无法判断什么异常触发回滚，回滚之前对缓存进行了哪些修改无法记录）
 * 5、强制清空缓存时传入执行更新操作记录数，如果存在更新操作清除实体缓存、单对象缓存。
 * 6、强制清空缓存时如果只有新增和删除操作，先判断当前实体类有无使用实体缓存，如果使用了实体缓存证明当前实体总记录数不大，
 *    清空实体缓存的同时清空单对象缓存，确保单对象缓存和实体缓存引用同一实体对象；没有实体缓存则不对单对象缓存进行清空操作。
 * */

namespace XCode
{
    /// <summary>实体会话。每个实体类、连接名和表名形成一个实体会话</summary>
    public class EntitySession<TEntity> : IEntitySession where TEntity : Entity<TEntity>, new()
    {
        #region 属性
        /// <summary>连接名</summary>
        public String ConnName { get; }

        /// <summary>表名</summary>
        public String TableName { get; }

        /// <summary>用于标识会话的键值</summary>
        public String Key { get; }
        #endregion

        #region 构造
        private EntitySession(String connName, String tableName)
        {
            ConnName = connName;
            TableName = tableName;
            Key = connName + "###" + tableName;

            TableItem = TableItem.Create(ThisType);
            Table = TableItem.DataTable.Clone() as IDataTable;
            Table.TableName = tableName;

            Queue = new EntityQueue(this)
            {
                InsertOnly = Table.InsertOnly
            };
        }

        private static readonly ConcurrentDictionary<String, EntitySession<TEntity>> _es = new(StringComparer.OrdinalIgnoreCase);
        /// <summary>创建指定表名连接名的会话</summary>
        /// <param name="connName"></param>
        /// <param name="tableName"></param>
        /// <returns></returns>
        public static EntitySession<TEntity> Create(String connName, String tableName)
        {
            if (connName.IsNullOrEmpty()) throw new ArgumentNullException(nameof(connName));
            if (tableName.IsNullOrEmpty()) throw new ArgumentNullException(nameof(tableName));

            // 字符串连接有较大性能损耗
            var key = connName + "###" + tableName;
            return _es.GetOrAdd(key, k => new EntitySession<TEntity>(connName, tableName));
        }
        #endregion

        #region 主要属性
        private Type ThisType => typeof(TEntity);

        /// <summary>表信息</summary>
        TableItem TableItem { get; }

        /// <summary>数据表</summary>
        public IDataTable Table { get; }

        IEntityFactory Factory { get; } = typeof(TEntity).AsFactory();

        private DAL _readDal;
        private DAL _Dal;
        /// <summary>数据操作层</summary>
        public DAL Dal => _Dal ??= DAL.Create(ConnName);

        private String _FormatedTableName;
        /// <summary>已格式化的表名，带有中括号等</summary>
        public virtual String FormatedTableName
        {
            get
            {
                if (_FormatedTableName.IsNullOrEmpty()) _FormatedTableName = Dal.Db.FormatName(Table);

                return _FormatedTableName;
            }
        }

        private EntitySession<TEntity> _Default;
        /// <summary>该实体类的默认会话。</summary>
        private EntitySession<TEntity> Default
        {
            get
            {
                if (_Default != null) return _Default;

                var cname = TableItem.ConnName;
                var tname = TableItem.TableName;

                if (ConnName == cname && TableName == tname)
                    _Default = this;
                else
                    _Default = Create(cname, tname);

                return _Default;
            }
        }

        /// <summary>用户数据</summary>
        public IDictionary<String, Object> Items { get; set; } = new Dictionary<String, Object>();
        #endregion

        #region 数据初始化
        /// <summary>记录已进行数据初始化</summary>
        Boolean hasCheckInitData = false;
        Int32 initThread = 0;
        readonly Object _wait_lock = new();

        /// <summary>检查并初始化数据。参数等待时间为0表示不等待</summary>
        /// <param name="ms">等待时间，-1表示不限，0表示不等待</param>
        /// <returns>如果等待，返回是否收到信号</returns>
        public Boolean WaitForInitData(Int32 ms = 3000)
        {
            // 已初始化
            if (hasCheckInitData || Table.IsView) return true;

            var tid = Thread.CurrentThread.ManagedThreadId;

            //!!! 一定一定小心堵塞的是自己
            if (initThread == tid) return true;

            if (!Monitor.TryEnter(_wait_lock, ms))
            {
                if (DAL.Debug) DAL.WriteLog("等待初始化{0}数据{1:n0}ms失败 initThread={2}", ThisType.Name, ms, initThread);
                return false;
            }
            try
            {
                // 已初始化
                if (hasCheckInitData) return true;
                hasCheckInitData = true;

                initThread = Thread.CurrentThread.ManagedThreadId;

                // 如果该实体类是首次使用检查模型，则在这个时候检查
                try
                {
                    CheckModel();
                }
                catch (Exception ex)
                {
                    XTrace.WriteException(ex);
                }

                try
                {
                    if (Factory.Default is EntityBase entity)
                    {
                        entity.InitData();
                    }
                }
                catch (Exception ex)
                {
                    if (XTrace.Debug) XTrace.WriteLine("初始化数据出错！" + ex.ToString());
                }

                return true;
            }
            finally
            {
                initThread = 0;
                Monitor.Exit(_wait_lock);
            }
        }
        #endregion

        #region 架构检查
        private void CheckTable()
        {
            var dal = Dal;

            // 检查新表名对应的数据表
            var table = TableItem.DataTable;
            // 克隆一份，防止修改
            table = table.Clone() as IDataTable;

            if (table != null && table.TableName != TableName)
            {
                // 表名去掉前缀
                var name = TableName;
                if (name.Contains(".")) name = name.Substring(".");

                table.TableName = name;
            }

            dal.SetTables(table);
        }

        private Boolean IsGenerated => ThisType.GetCustomAttribute<CompilerGeneratedAttribute>(true) != null;
        Boolean _hasCheckModel = false;
        readonly Object _checkLock = new();
        /// <summary>检查模型。依据反向工程设置、是否首次使用检查、是否已常规检查等</summary>
        private void CheckModel()
        {
            if (_hasCheckModel || Table.IsView) return;
            lock (_checkLock)
            {
                if (_hasCheckModel) return;
                _hasCheckModel = true;

                var cname = ConnName;
                var tname = TableName;
                if (Dal.Db.Migration == Migration.Off || IsGenerated)
                {
                    _hasCheckModel = true;
                    return;
                }

                // CheckTableWhenFirstUse的实体类，在这里检查，有点意思，记下来
                var mode = TableItem.ModelCheckMode;
                if (DAL.Debug && mode == ModelCheckModes.CheckTableWhenFirstUse)
                    DAL.WriteLog("检查实体{0}的数据表架构，模式：{1}", ThisType.FullName, mode);

                // 第一次使用才检查的，此时检查
                var ck = false;
                // 或者前面初始化的时候没有涉及的，也在这个时候检查
                var dal = DAL.Create(cname);
                if (!dal.CheckAndAdd(tname)) ck = true;

                if (ck)
                {
                    // 打开了开关，并且设置为true时，使用同步方式检查
                    // 设置为false时，使用异步方式检查，因为上级的意思是不大关心数据库架构
                    if (dal.Db.Migration > Migration.ReadOnly /*|| def != this*/)
                        CheckTable();
                    else
                        ThreadPoolX.QueueUserWorkItem(CheckTable);
                }
            }
        }
        #endregion

        #region 缓存
        private EntityCache<TEntity> _cache;
        /// <summary>实体缓存</summary>
        /// <returns></returns>
        public EntityCache<TEntity> Cache
        {
            get
            {
                // 以连接名和表名为key，因为不同的库不同的表，缓存也不一样
                if (_cache == null)
                {
                    var ec = new EntityCache<TEntity> { ConnName = ConnName, TableName = TableName };
                    // 从默认会话复制参数
                    if (Default != this) ec.CopySettingFrom(Default.Cache);
                    //_cache = ec;
                    Interlocked.CompareExchange(ref _cache, ec, null);
                }
                return _cache;
            }
        }

        private ISingleEntityCache<Object, TEntity> _singleCache;
        /// <summary>单对象实体缓存。</summary>
        public ISingleEntityCache<Object, TEntity> SingleCache
        {
            get
            {
                // 以连接名和表名为key，因为不同的库不同的表，缓存也不一样
                if (_singleCache == null)
                {
                    var sc = new SingleEntityCache<Object, TEntity>
                    {
                        ConnName = ConnName,
                        TableName = TableName
                    };

                    // 从默认会话复制参数
                    if (Default != this) sc.CopySettingFrom(Default.SingleCache);

                    Interlocked.CompareExchange(ref _singleCache, sc, null);
                }
                return _singleCache;
            }
        }

        IEntityCache IEntitySession.Cache => Cache;
        ISingleEntityCache IEntitySession.SingleCache => SingleCache;

        /// <summary>总记录数，小于1000时是精确的，大于1000时缓存10秒</summary>
        public Int32 Count
        {
            get
            {
                var v = LongCount;
                return v > Int32.MaxValue ? Int32.MaxValue : (Int32)v;
            }
        }

        private DateTime _NextCount;
        /// <summary>总记录数较小时，使用静态字段，较大时增加使用Cache</summary>
        private Int64 _Count = -2L;
        /// <summary>总记录数，小于100w时精确查询，否则取索引行数，缓存60秒</summary>
        public Int64 LongCount
        {
            get
            {
                // 当前缓存的值
                var n = _Count;

                // 如果有缓存，则考虑返回吧
                if (n >= 0)
                {
                    var now = TimerX.Now;
                    if (_NextCount < now)
                    {
                        _NextCount = now.AddSeconds(60);
                        // 异步更新
                        ThreadPoolX.QueueUserWorkItem(() => LongCount = GetCount(_Count));
                    }

                    return n;
                }

                // 来到这里，是第一次访问
                CheckModel();

                // 从配置读取
                if (n < 0)
                {
                    if (DataCache.Current.Counts.TryGetValue(CacheKey, out var c)) n = c;
                }

                if (DAL.Debug) DAL.WriteLog("{0}.Count 快速计算表记录数（非精确）[{1}/{2}] 参考值 {3:n0}", ThisType.Name, TableName, ConnName, n);

                LongCount = GetCount(n);

                // 先拿到记录数再初始化，因为初始化时会用到记录数，同时也避免了死循环
                //WaitForInitData();
                InitData();

                return _Count;
            }
            private set
            {
                _Count = value;
                _NextCount = TimerX.Now.AddSeconds(60);

                var dc = DataCache.Current;
                dc.Counts[CacheKey] = value;
                dc.SaveAsync();
            }
        }

        /// <summary>获取总行数，基于参考值采取不同策略</summary>
        /// <param name="count"></param>
        /// <returns></returns>
        private Int64 GetCount(Int64 count)
        {
            var dal = GetDAL(false);

            // 第一次访问，SQLite的Select Count非常慢，数据大于阀值时，使用最大ID作为表记录数
            if (count < 0 && dal.DbType == DatabaseType.SQLite && TableItem.Identity != null)
            {
                var builder = new SelectBuilder
                {
                    Table = FormatedTableName,
                    OrderBy = TableItem.Identity.Desc()
                };
                FixBuilder(builder);
                var ds = dal.Query(builder, 0, 1);
                if (ds.Columns.Length > 0 && ds.Rows.Count > 0)
                    count = Convert.ToInt64(ds.Rows[0][0]);
            }

            // 100w数据时，没有预热Select Count需要3000ms，预热后需要500ms
            if ((count <= 0 || count >= 1_000_000) && !Table.IsView) count = dal.Session.QueryCountFast(FormatedTableName);

            // 查真实记录数，修正FastCount不够准确的情况
            if (/*count >= 0 &&*/ count < 10_000_000)
            {
                var builder = new SelectBuilder
                {
                    Table = FormatedTableName
                };
                FixBuilder(builder);
                count = dal.SelectCount(builder);
            }

            return count;
        }

        /// <summary>清除缓存</summary>
        /// <param name="reason">清除原因</param>
        [Obsolete]
        public void ClearCache(String reason) => ClearCache(reason, false);

        /// <summary>清除缓存</summary>
        /// <param name="reason">清除原因</param>
        /// <param name="force">强制清除，下次访问阻塞等待。默认false仅置为过期，下次访问异步更新</param>
        public void ClearCache(String reason, Boolean force)
        {
            _cache?.Clear(reason, force);

            _singleCache?.Clear(reason);

            // Count提供的是非精确数据，避免频繁更新
            //_Count = -1L;
            //_NextCount = DateTime.MinValue;
        }

        String CacheKey => $"{ConnName}_{TableName}_{ThisType.Name}";
        #endregion

        #region 数据库操作
        private String _readonlyConnName;
        /// <summary>获取数据操作对象，根据是否查询以及事务来进行读写分离</summary>
        /// <param name="read"></param>
        /// <returns></returns>
        public DAL GetDAL(Boolean read)
        {
            // 如果主连接已打开事务，则直接使用
            var dal = Dal;
            if (dal.Session is DbSession ds && ds.Transaction != null) return dal;

            // 读写分离
            if (read)
            {
                if (_readDal != null) return _readDal;

                // 根据后缀查找只读连接名
                var name = ConnName + ".readonly";
                if (DAL.ConnStrs.ContainsKey(name))
                {
                    if (_readonlyConnName.IsNullOrEmpty())
                    {
                        XTrace.WriteLine("[{0}]读写分离到[{1}]", ConnName, name);
                        _readonlyConnName = name;
                    }
                    return _readDal = DAL.Create(name);
                }
            }

            return dal;
        }

        /// <summary>初始化数据，执行反向工程检查，建库建表</summary>
        public void InitData() => WaitForInitData();

        /// <summary>执行SQL查询，返回记录集</summary>
        /// <param name="builder">SQL语句</param>
        /// <param name="startRowIndex">开始行，0表示第一行</param>
        /// <param name="maximumRows">最大返回行数，0表示所有行</param>
        /// <returns></returns>
        public virtual DbTable Query(SelectBuilder builder, Int64 startRowIndex, Int64 maximumRows)
        {
            InitData();

            FixBuilder(builder);

            return GetDAL(true).Query(builder, startRowIndex, maximumRows);
        }

        /// <summary>执行SQL查询，返回记录集</summary>
        /// <param name="sql">SQL语句</param>
        /// <returns></returns>
        public virtual DbTable Query(String sql)
        {
            InitData();

            return GetDAL(true).Query(sql);
        }

        /// <summary>查询记录数</summary>
        /// <param name="builder">查询生成器</param>
        /// <returns>记录数</returns>
        public virtual Int32 QueryCount(SelectBuilder builder)
        {
            InitData();

            FixBuilder(builder);

            return GetDAL(true).SelectCount(builder);
        }

        /// <summary>查询记录数</summary>
        /// <param name="sql">SQL语句</param>
        /// <returns></returns>
        public virtual Int32 QueryCount(String sql)
        {
            InitData();

            return GetDAL(true).SelectCount(sql, CommandType.Text, null);
        }

        private void FixBuilder(SelectBuilder builder)
        {
            if (Table.IsView && builder.Table == FormatedTableName)
            {
                builder.Table = $"({Factory.Template.GetSql(Dal.DbType)}) SourceTable";
            }
        }

        /// <summary>执行</summary>
        /// <param name="sql">SQL语句</param>
        /// <param name="type">命令类型，默认SQL文本</param>
        /// <param name="ps">命令参数</param>
        /// <returns>影响的结果</returns>
        public Int32 Execute(String sql, CommandType type = CommandType.Text, params IDataParameter[] ps)
        {
            InitData();

            var rs = GetDAL(false).Execute(sql, type, ps);
            DataChange("Execute " + type);
            return rs;
        }

        /// <summary>执行插入语句并返回新增行的自动编号</summary>
        /// <param name="sql">SQL语句</param>
        /// <param name="type">命令类型，默认SQL文本</param>
        /// <param name="ps">命令参数</param>
        /// <returns>新增行的自动编号</returns>
        public Int64 InsertAndGetIdentity(String sql, CommandType type = CommandType.Text, params IDataParameter[] ps)
        {
            InitData();

            var rs = GetDAL(false).InsertAndGetIdentity(sql, type, ps);
            DataChange("InsertAndGetIdentity " + type);
            return rs;
        }

#if !NET40
        /// <summary>执行SQL查询，返回记录集</summary>
        /// <param name="builder">SQL语句</param>
        /// <param name="startRowIndex">开始行，0表示第一行</param>
        /// <param name="maximumRows">最大返回行数，0表示所有行</param>
        /// <returns></returns>
        public virtual Task<DbTable> QueryAsync(SelectBuilder builder, Int64 startRowIndex, Int64 maximumRows)
        {
            InitData();

            return GetDAL(true).QueryAsync(builder, startRowIndex, maximumRows);
        }

        /// <summary>查询记录数</summary>
        /// <param name="builder">查询生成器</param>
        /// <returns>记录数</returns>
        public virtual Task<Int64> QueryCountAsync(SelectBuilder builder)
        {
            InitData();

            return GetDAL(true).SelectCountAsync(builder);
        }

        /// <summary>执行</summary>
        /// <param name="sql">SQL语句</param>
        /// <param name="type">命令类型，默认SQL文本</param>
        /// <param name="ps">命令参数</param>
        /// <returns>影响的结果</returns>
        public Task<Int32> ExecuteAsync(String sql, CommandType type = CommandType.Text, params IDataParameter[] ps)
        {
            InitData();

            var rs = GetDAL(false).ExecuteAsync(sql, type, ps);
            DataChange("Execute " + type);
            return rs;
        }

        /// <summary>执行插入语句并返回新增行的自动编号</summary>
        /// <param name="sql">SQL语句</param>
        /// <param name="type">命令类型，默认SQL文本</param>
        /// <param name="ps">命令参数</param>
        /// <returns>新增行的自动编号</returns>
        public Task<Int64> InsertAndGetIdentityAsync(String sql, CommandType type = CommandType.Text, params IDataParameter[] ps)
        {
            InitData();

            var rs = GetDAL(false).InsertAndGetIdentityAsync(sql, type, ps);
            DataChange("InsertAndGetIdentity " + type);
            return rs;
        }
#endif

        private void DataChange(String reason)
        {
            ClearCache(reason, true);

            _OnDataChange?.Invoke(ThisType);
        }

        private Action<Type> _OnDataChange;
        /// <summary>数据改变后触发。参数指定触发该事件的实体类</summary>
        public event Action<Type> OnDataChange
        {
            add
            {
                if (value != null)
                {
                    // 这里不能对委托进行弱引用，因为GC会回收委托，应该改为对对象进行弱引用
                    //WeakReference<Action<Type>> w = value;

                    // 弱引用事件，只会执行一次，一次以后自动取消注册
                    _OnDataChange += new WeakAction<Type>(value, handler => { _OnDataChange -= handler; }, true);
                }
            }
            remove { }
        }
        #endregion

        #region 数据库高级操作
        /// <summary>清空数据表，标识归零</summary>
        /// <returns></returns>
        public Int32 Truncate()
        {
            var rs = GetDAL(false).Session.Truncate(FormatedTableName);

            // 干掉所有缓存
            _cache?.Clear("Truncate", true);
            _singleCache?.Clear("Truncate");
            LongCount = 0;

            //// 重新初始化
            //hasCheckInitData = false;

            return rs;
        }
        #endregion

        #region 事务保护
        //private ITransaction GetTran() => (Dal.Session as DbSession).Transaction;

        /// <summary>开始事务</summary>
        /// <returns>剩下的事务计数</returns>
        public virtual Int32 BeginTrans()
        {
            /* 这里也需要执行初始化检查架构，因为无法确定在调用此方法前是否已使用实体类进行架构检查，如下调用会造成事务不平衡而上抛异常：
             * Exception：执行SqlServer的Dispose时出错：System.InvalidOperationException: 此 SqlTransaction 已完成；它再也无法使用。
             * 
             * 如果实体的模型检查模式为CheckTableWhenFirstUse，直接执行静态操作
             * using (var trans = new EntityTransaction<TEntity>())
             * {
             *   TEntity.Delete(whereExp);
             *   TEntity.Update(new String[] { 字段1,字段2 }, new Object[] { 值1,值1 }, whereExp);
             *   trans.Commit();
             * }
             */
            InitData();

            var count = Dal.BeginTransaction();

            return count;
        }

        /// <summary>提交事务</summary>
        /// <returns>剩下的事务计数</returns>
        public virtual Int32 Commit()
        {
            var rs = Dal.Commit();

            if (rs == 0) DataChange("Commit");

            return rs;
        }

        /// <summary>回滚事务，忽略异常</summary>
        /// <returns>剩下的事务计数</returns>
        public virtual Int32 Rollback()
        {
            var rs = Dal.Rollback();

            if (rs == 0) DataChange($"Rollback");

            return rs;
        }

        /// <summary>创建事务</summary>
        public virtual EntityTransaction CreateTrans() => new(Dal);
        #endregion

        #region 参数化
        ///// <summary>格式化参数名</summary>
        ///// <param name="name">名称</param>
        ///// <returns></returns>
        //public virtual String FormatParameterName(String name) => Dal.Db.FormatParameterName(name);
        #endregion

        #region 实体操作
        /// <summary>把该对象持久化到数据库，添加/更新实体缓存和单对象缓存，增加总计数</summary>
        /// <param name="entity">实体对象</param>
        /// <returns></returns>
        public virtual Int32 Insert(IEntity entity)
        {
            if (Table.IsView) throw new NotSupportedException("视图无法添删改！");

            var rs = Factory.Persistence.Insert(this, entity);

            var e = entity as TEntity;

            // 加入实体缓存
            _cache?.Add(e);

            // 增加计数
            if (_Count >= 0) Interlocked.Increment(ref _Count);

            // 清空扩展属性
            //(entity as EntityBase)._Extends?.Clear();
            (entity as EntityBase)._Extends = null;

            return rs;
        }

        /// <summary>更新数据库，同时更新实体缓存</summary>
        /// <param name="entity">实体对象</param>
        /// <returns></returns>
        public virtual Int32 Update(IEntity entity)
        {
            if (Table.IsView) throw new NotSupportedException("视图无法添删改！");

            var rs = Factory.Persistence.Update(this, entity);

            var e = entity as TEntity;

            // 更新缓存
            _cache?.Update(e);

            // 干掉缓存项，让它重新获取
            _singleCache?.Remove(e);

            // 清空扩展属性
            (entity as EntityBase)._Extends = null;

            return rs;
        }

        /// <summary>从数据库中删除该对象，同时从实体缓存和单对象缓存中删除，扣减总数量</summary>
        /// <param name="entity">实体对象</param>
        /// <returns></returns>
        public virtual Int32 Delete(IEntity entity)
        {
            if (Table.IsView) throw new NotSupportedException("视图无法添删改！");

            var rs = Factory.Persistence.Delete(this, entity);

            var e = entity as TEntity;

            // 从实体缓存删除
            _cache?.Remove(e);

            // 从单对象缓存删除
            _singleCache?.Remove(e);

            // 减少计数
            if (_Count > 0) Interlocked.Decrement(ref _Count);

            // 清空扩展属性
            (entity as EntityBase)._Extends = null;

            return rs;
        }

#if !NET40
        /// <summary>把该对象持久化到数据库，添加/更新实体缓存和单对象缓存，增加总计数</summary>
        /// <param name="entity">实体对象</param>
        /// <returns></returns>
        public virtual async Task<Int32> InsertAsync(IEntity entity)
        {
            if (Table.IsView) throw new NotSupportedException("视图无法添删改！");

            var rs = await Factory.Persistence.InsertAsync(this, entity);

            var e = entity as TEntity;

            // 加入实体缓存
            _cache?.Add(e);

            // 增加计数
            if (_Count >= 0) Interlocked.Increment(ref _Count);

            return rs;
        }

        /// <summary>更新数据库，同时更新实体缓存</summary>
        /// <param name="entity">实体对象</param>
        /// <returns></returns>
        public virtual Task<Int32> UpdateAsync(IEntity entity)
        {
            if (Table.IsView) throw new NotSupportedException("视图无法添删改！");

            var rs = Factory.Persistence.UpdateAsync(this, entity);

            var e = entity as TEntity;

            // 更新缓存
            _cache?.Update(e);

            // 干掉缓存项，让它重新获取
            _singleCache?.Remove(e);

            return rs;
        }

        /// <summary>从数据库中删除该对象，同时从实体缓存和单对象缓存中删除，扣减总数量</summary>
        /// <param name="entity">实体对象</param>
        /// <returns></returns>
        public virtual Task<Int32> DeleteAsync(IEntity entity)
        {
            if (Table.IsView) throw new NotSupportedException("视图无法添删改！");

            var rs = Factory.Persistence.DeleteAsync(this, entity);

            var e = entity as TEntity;

            // 从实体缓存删除
            _cache?.Remove(e);

            // 从单对象缓存删除
            _singleCache?.Remove(e);

            // 减少计数
            if (_Count > 0) Interlocked.Decrement(ref _Count);

            return rs;
        }
#endif
        #endregion

        #region 队列
        /// <summary>实体队列</summary>
        public EntityQueue Queue { get; private set; }
        #endregion
    }
}