ow

CloudBuilder.Core/DatabaseAccessor/Repository.cs

@@ -0,0 +1,893 @@
+using CloudBuilder.Core.Application.Builders;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Data.SqlClient;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.ChangeTracking;
+using Microsoft.Extensions.DependencyInjection;
+using System.Data;
+using System.Data.Common;
+using System.Linq.Expressions;
+
+namespace CloudBuilder.Core.DatabaseAccessor.Entity
+{
+    public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
+    {
+        private readonly CloudBuilderBuilder builder;
+        private DbContext dbContext;
+        private readonly IHttpContextAccessor httpContext;
+
+        public Repository(IServiceProvider serviceProvider,
+            [FromKeyedServices(MasterDbContext.MASTER_DB_CONTEXT)] DbContext dbContext,
+            IUnitOfWork unitOfWork,
+            IHttpContextAccessor httpContext)
+        {
+            this.httpContext = httpContext;
+            this.dbContext = dbContext;
+            this.UnitOfWork = unitOfWork;
+            ServiceProvider = serviceProvider;
+            Entities = this.dbContext.Set<TEntity>()!;
+            DetachedEntities = Entities.AsNoTracking()!;
+        }
+
+        public IUnitOfWork UnitOfWork { get; set; }
+
+        public DbContext GetDbContext() { return dbContext; }
+
+        public DbSet<TEntity> Entities { get; set; } = null!;
+
+        public IQueryable<TEntity> DetachedEntities { get; set; } = null!;
+
+
+        public DbConnection DbConnection
+        {
+            get
+            {
+                return dbContext.Database.GetDbConnection();
+            }
+        }
+
+        public IServiceProvider ServiceProvider { get; set; } = null!;
+
+        public virtual TRepository GetRepository<TRepository>()
+        {
+            return ServiceProvider.GetRequiredService<TRepository>();
+        }
+
+        public void ChangeMasterDatabase()
+        {
+            this.dbContext = ServiceProvider.GetRequiredKeyedService<DbContext>(MasterDbContext.MASTER_DB_CONTEXT);
+            Entities = this.dbContext.Set<TEntity>()!;
+            DetachedEntities = Entities.AsNoTracking()!;
+        }
+
+        public void ChangeSecondaryDatabase()
+        {
+            this.dbContext = ServiceProvider.GetRequiredKeyedService<DbContext>(SecondaryDbContext.SECONDARY_DB_CONTEXT);
+            Entities = this.dbContext.Set<TEntity>()!;
+            DetachedEntities = Entities.AsNoTracking()!;
+        }
+
+        #region FromSqlRaw
+
+        public virtual IQueryable<TEntity> FromSql(string sql, params object[] parameters)
+        {
+            if (parameters == null)
+                return Entities.FromSqlRaw(sql);
+            else
+                return Entities.FromSqlRaw(sql, parameters);
+        }
+
+        public virtual IQueryable<TEntity> FromSqlWhere(TEntity t, string where, params object[] parameters)
+        {
+            string sql = $"{((IEntity<object>)t).GetSelectFrom()} {where} ";
+            if (parameters == null)
+                return Entities.FromSqlRaw(sql);
+            else
+                return Entities.FromSqlRaw(sql, parameters);
+        }
+
+        public virtual TEntity[] FindBySql(string sql, params object[] parameters)
+        {
+            if (parameters == null)
+                return Entities.FromSqlRaw(sql).ToArray();
+            else
+                return Entities.FromSqlRaw(sql, parameters).ToArray();
+        }
+
+        public virtual TEntity[] FindBySqlWhere(TEntity t, string where, params object[] parameters)
+        {
+            string sql = $"{((IGet)t).GetSelectFrom()} {where} ";
+            if (parameters == null)
+                return Entities.FromSqlRaw(sql).ToArray();
+            else
+                return Entities.FromSqlRaw(sql, parameters).ToArray();
+        }
+
+        public void PackSqlParameter(List<object> parameters, string parameterName, object value)
+        {
+            if (parameters == null) parameters = new List<object>();
+            else
+            {
+                string formatedValue;
+                if (value == null) formatedValue = $"null";
+                else
+                {
+                    formatedValue = $"'{value.ToString()}'";
+                    if (value is DateTime && !string.IsNullOrEmpty(formatedValue))
+                        formatedValue = $"'{Convert.ToDateTime(formatedValue).ToString("yyyy-MM-dd HH:mm:ss")}'";
+                }
+
+                parameters.Add(new SqlParameter(parameterName, value == null ? DBNull.Value : value));
+            }
+        }
+
+        public virtual void ExecuteNonQuery(string sql, params object[] parameters)
+        {
+            var conn = dbContext.Database.GetDbConnection(); ;
+
+            conn.Open();
+            var cmd = conn.CreateCommand();
+
+            cmd.CommandText = sql;
+            if (parameters != null && parameters.Length > 0)
+                cmd.Parameters.AddRange(parameters);
+
+
+            cmd.ExecuteNonQuery();
+        }
+
+        public virtual object ExecuteScalar(string sql, params object[] parameters)
+        {
+            var conn = dbContext.Database.GetDbConnection(); ;
+
+            conn.Open();
+            var cmd = conn.CreateCommand();
+
+            cmd.CommandText = sql;
+            if (parameters != null && parameters.Length > 0)
+                cmd.Parameters.AddRange(parameters);
+
+
+            return cmd.ExecuteScalar();
+        }
+
+        public virtual DataTable SelectDataTable(string sql, params object[] parameters)
+        {
+            var conn = dbContext.Database.GetDbConnection(); ;
+
+            conn.Open();
+            var cmd = conn.CreateCommand();
+
+            cmd.CommandText = sql;
+            if (parameters != null && parameters.Length > 0)
+                cmd.Parameters.AddRange(parameters);
+
+            SqlDataAdapter da = new SqlDataAdapter();
+            da.SelectCommand = cmd as SqlCommand;
+            DataTable dt = new DataTable();
+            da.Fill(dt);
+
+            dt.TableName = "TableName";
+
+            return dt;
+        }
+
+        #endregion
+
+        #region Insert
+
+        public virtual EntityEntry<TEntity> Insert(TEntity entity)
+        {
+            var entryEntity = Entities.Add(entity);
+
+            return entryEntity;
+        }
+
+        public virtual void Insert(params TEntity[] entities)
+        {
+            Entities.AddRange(entities);
+        }
+
+        public virtual void Insert(IEnumerable<TEntity> entities)
+        {
+            Entities.AddRange(entities);
+        }
+
+        public virtual async Task<EntityEntry<TEntity>> InsertAsync(TEntity entity, CancellationToken cancellationToken = default)
+        {
+            var entityEntry = await Entities.AddAsync(entity, cancellationToken);
+
+            return entityEntry;
+        }
+
+        public virtual Task InsertAsync(params TEntity[] entities)
+        {
+            return Entities.AddRangeAsync(entities);
+        }
+
+        public virtual Task InsertAsync(IEnumerable<TEntity> entities, CancellationToken cancellationToken = default)
+        {
+            return Entities.AddRangeAsync(entities, cancellationToken);
+        }
+
+        public virtual EntityEntry<TEntity> InsertNow(TEntity entity)
+        {
+            var entityEntry = Insert(entity);
+            SaveNow();
+            return entityEntry;
+        }
+
+        /// <summary>
+        /// 新增多条记录
+        /// </summary>
+        /// <param name="entities">多个实体</param>
+        public virtual void InsertNow(params TEntity[] entities)
+        {
+            Insert(entities);
+            SaveNow();
+        }
+
+        /// <summary>
+        /// 新增多条记录
+        /// </summary>
+        /// <param name="entities">多个实体</param>
+        public virtual void InsertNow(IEnumerable<TEntity> entities)
+        {
+            Insert(entities);
+            SaveNow();
+        }
+
+        /// <summary>
+        /// 新增一条记录并立即提交
+        /// </summary>
+        /// <param name="entity">实体</param>
+        /// <param name="ignoreNullValues"></param>
+        /// <param name="cancellationToken">取消异步令牌</param>
+        /// <returns>数据库中返回的实体</returns>
+        public virtual async Task<EntityEntry<TEntity>> InsertNowAsync(TEntity entity, CancellationToken cancellationToken = default)
+        {
+            var entityEntry = await InsertAsync(entity, cancellationToken);
+            await SaveNowAsync(cancellationToken);
+            return entityEntry;
+        }
+
+        /// <summary>
+        /// 新增多条记录并立即提交
+        /// </summary>
+        /// <param name="entities">多个实体</param>
+        /// <returns>Task</returns>
+        public virtual async Task InsertNowAsync(params TEntity[] entities)
+        {
+            await InsertAsync(entities);
+            await SaveNowAsync();
+        }
+
+        /// <summary>
+        /// 新增多条记录并立即提交
+        /// </summary>
+        /// <param name="entities">多个实体</param>
+        /// <param name="cancellationToken">取消异步令牌</param>
+        /// <returns>Task</returns>
+        public virtual async Task InsertNowAsync(TEntity[] entities, CancellationToken cancellationToken = default)
+        {
+            await InsertAsync(entities);
+            await SaveNowAsync(cancellationToken);
+        }
+
+        /// <summary>
+        /// 新增多条记录并立即提交
+        /// </summary>
+        /// <param name="entities">多个实体</param>
+        /// <param name="cancellationToken">取消异步令牌</param>
+        /// <returns>Task</returns>
+        public virtual async Task InsertNowAsync(IEnumerable<TEntity> entities, CancellationToken cancellationToken = default)
+        {
+            await InsertAsync(entities, cancellationToken);
+            await SaveNowAsync(cancellationToken);
+        }
+
+
+        /// <summary>
+        /// 提交更改操作
+        /// </summary>
+        /// <returns></returns>
+        public virtual int SaveNow()
+        {
+            return dbContext.SaveChanges();
+        }
+
+        /// <summary>
+        /// 提交更改操作（异步）
+        /// </summary>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public virtual Task<int> SaveNowAsync(CancellationToken cancellationToken = default)
+        {
+            return dbContext.SaveChangesAsync(cancellationToken);
+        }
+
+
+        #endregion
+
+        #region Update
+        public virtual EntityEntry<TEntity> Update(TEntity entity)
+        {
+            var entityEntry = Entities.Update(entity);
+
+            return entityEntry;
+        }
+
+        public virtual void Update(params TEntity[] entities)
+        {
+            Entities.UpdateRange(entities);
+        }
+
+        public virtual void Update(IEnumerable<TEntity> entities)
+        {
+            Entities.UpdateRange(entities);
+        }
+
+        public virtual Task<EntityEntry<TEntity>> UpdateAsync(TEntity entity)
+        {
+            return Task.FromResult(Update(entity));
+        }
+
+        public virtual Task UpdateAsync(params TEntity[] entities)
+        {
+            Update(entities);
+            return Task.CompletedTask;
+        }
+
+        public virtual Task UpdateAsync(IEnumerable<TEntity> entities)
+        {
+            Update(entities);
+            return Task.CompletedTask;
+        }
+
+        public virtual EntityEntry<TEntity> UpdateNow(TEntity entity)
+        {
+            var entityEntry = Update(entity);
+            SaveNow();
+            return entityEntry;
+        }
+
+        public virtual void UpdateNow(params TEntity[] entities)
+        {
+            Update(entities);
+            SaveNow();
+        }
+
+        public virtual void UpdateNow(IEnumerable<TEntity> entities)
+        {
+            Update(entities);
+            SaveNow();
+        }
+
+        public virtual async Task<EntityEntry<TEntity>> UpdateNowAsync(TEntity entity, CancellationToken cancellationToken = default)
+        {
+            var entityEntry = await UpdateAsync(entity);
+            await SaveNowAsync(cancellationToken);
+            return entityEntry;
+        }
+
+        public virtual async Task UpdateNowAsync(params TEntity[] entities)
+        {
+            await UpdateAsync(entities);
+            await SaveNowAsync();
+        }
+
+        public virtual async Task UpdateNowAsync(TEntity[] entities, CancellationToken cancellationToken = default)
+        {
+            await UpdateAsync(entities);
+            await SaveNowAsync(cancellationToken);
+        }
+
+        public virtual async Task UpdateNowAsync(IEnumerable<TEntity> entities, CancellationToken cancellationToken = default)
+        {
+            await UpdateAsync(entities);
+            await SaveNowAsync(cancellationToken);
+        }
+
+        public virtual EntityEntry<TEntity> UpdateInclude(TEntity entity, IEnumerable<string> propertyNames)
+        {
+            var entityEntry = ChangeEntityState(entity, EntityState.Detached);
+            foreach (var propertyName in propertyNames)
+            {
+                EntityPropertyEntry(entity, propertyName).IsModified = true;
+            }
+
+            return entityEntry;
+        }
+
+        public virtual EntityEntry<TEntity> UpdateInclude(TEntity entity, IEnumerable<Expression<Func<TEntity, object>>> propertyPredicates)
+        {
+            var entityEntry = ChangeEntityState(entity, EntityState.Detached);
+            foreach (var propertyPredicate in propertyPredicates)
+            {
+                EntityPropertyEntry(entity, propertyPredicate).IsModified = true;
+            }
+
+            return entityEntry;
+        }
+
+        public virtual Task<EntityEntry<TEntity>> UpdateIncludeAsync(TEntity entity, string[] propertyNames)
+        {
+            return Task.FromResult(UpdateInclude(entity, propertyNames));
+        }
+
+        public virtual Task<EntityEntry<TEntity>> UpdateIncludeAsync(TEntity entity, Expression<Func<TEntity, object>>[] propertyPredicates)
+        {
+            return Task.FromResult(UpdateInclude(entity, propertyPredicates));
+        }
+
+        public virtual Task<EntityEntry<TEntity>> UpdateIncludeAsync(TEntity entity, IEnumerable<string> propertyNames)
+        {
+            return Task.FromResult(UpdateInclude(entity, propertyNames));
+        }
+
+        public virtual Task<EntityEntry<TEntity>> UpdateIncludeAsync(TEntity entity, IEnumerable<Expression<Func<TEntity, object>>> propertyPredicates)
+        {
+            return Task.FromResult(UpdateInclude(entity, propertyPredicates));
+        }
+
+        public virtual EntityEntry<TEntity> UpdateIncludeNow(TEntity entity, string[] propertyNames)
+        {
+            var entityEntry = UpdateInclude(entity, propertyNames);
+            SaveNow();
+            return entityEntry;
+        }
+
+        public virtual EntityEntry<TEntity> UpdateIncludeNow(TEntity entity, Expression<Func<TEntity, object>>[] propertyPredicates)
+        {
+            var entityEntry = UpdateInclude(entity, propertyPredicates);
+            SaveNow();
+            return entityEntry;
+        }
+
+        public virtual EntityEntry<TEntity> UpdateIncludeNow(TEntity entity, IEnumerable<string> propertyNames)
+        {
+            var entityEntry = UpdateInclude(entity, propertyNames);
+            SaveNow();
+            return entityEntry;
+        }
+
+        public virtual EntityEntry<TEntity> UpdateIncludeNow(TEntity entity, IEnumerable<Expression<Func<TEntity, object>>> propertyPredicates)
+        {
+            var entityEntry = UpdateInclude(entity, propertyPredicates);
+            SaveNow();
+            return entityEntry;
+        }
+
+        public virtual async Task<EntityEntry<TEntity>> UpdateIncludeNowAsync(TEntity entity, string[] propertyNames, CancellationToken cancellationToken = default)
+        {
+            var entityEntry = await UpdateIncludeAsync(entity, propertyNames);
+            await SaveNowAsync(cancellationToken);
+            return entityEntry;
+        }
+
+        public virtual async Task<EntityEntry<TEntity>> UpdateIncludeNowAsync(TEntity entity, Expression<Func<TEntity, object>>[] propertyPredicates, CancellationToken cancellationToken = default)
+        {
+            var entityEntry = await UpdateIncludeAsync(entity, propertyPredicates);
+            await SaveNowAsync(cancellationToken);
+            return entityEntry;
+        }
+
+        public virtual async Task<EntityEntry<TEntity>> UpdateIncludeNowAsync(TEntity entity, IEnumerable<string> propertyNames, CancellationToken cancellationToken = default)
+        {
+            var entityEntry = await UpdateIncludeAsync(entity, propertyNames);
+            await SaveNowAsync(cancellationToken);
+            return entityEntry;
+        }
+
+        public virtual async Task<EntityEntry<TEntity>> UpdateIncludeNowAsync(TEntity entity, IEnumerable<Expression<Func<TEntity, object>>> propertyPredicates, CancellationToken cancellationToken = default)
+        {
+            var entityEntry = await UpdateIncludeAsync(entity, propertyPredicates);
+            await SaveNowAsync(cancellationToken);
+            return entityEntry;
+        }
+
+
+        public virtual EntityEntry<TEntity> UpdateExclude(TEntity entity, IEnumerable<string> propertyNames)
+        {
+            var entityEntry = ChangeEntityState(entity, EntityState.Modified);
+            foreach (var propertyName in propertyNames)
+            {
+                EntityPropertyEntry(entity, propertyName).IsModified = false;
+            }
+
+            return entityEntry;
+        }
+
+        public virtual EntityEntry<TEntity> UpdateExclude(TEntity entity, IEnumerable<Expression<Func<TEntity, object>>> propertyPredicates)
+        {
+            var entityEntry = ChangeEntityState(entity, EntityState.Modified);
+            foreach (var propertyPredicate in propertyPredicates)
+            {
+                EntityPropertyEntry(entity, propertyPredicate).IsModified = false;
+            }
+
+            return entityEntry;
+        }
+
+        public virtual Task<EntityEntry<TEntity>> UpdateExcludeAsync(TEntity entity, string[] propertyNames)
+        {
+            return Task.FromResult(UpdateExclude(entity, propertyNames));
+        }
+
+        public virtual Task<EntityEntry<TEntity>> UpdateExcludeAsync(TEntity entity, Expression<Func<TEntity, object>>[] propertyPredicates)
+        {
+            return Task.FromResult(UpdateExclude(entity, propertyPredicates));
+        }
+
+        public virtual Task<EntityEntry<TEntity>> UpdateExcludeAsync(TEntity entity, IEnumerable<string> propertyNames)
+        {
+            return Task.FromResult(UpdateExclude(entity, propertyNames));
+        }
+
+
+        public virtual Task<EntityEntry<TEntity>> UpdateExcludeAsync(TEntity entity, IEnumerable<Expression<Func<TEntity, object>>> propertyPredicates)
+        {
+            return Task.FromResult(UpdateExclude(entity, propertyPredicates));
+        }
+
+        public virtual EntityEntry<TEntity> UpdateExcludeNow(TEntity entity, string[] propertyNames)
+        {
+            var entityEntry = UpdateExclude(entity, propertyNames);
+            SaveNow();
+            return entityEntry;
+        }
+
+        public virtual EntityEntry<TEntity> UpdateExcludeNow(TEntity entity, Expression<Func<TEntity, object>>[] propertyPredicates)
+        {
+            var entityEntry = UpdateExclude(entity, propertyPredicates);
+            SaveNow();
+            return entityEntry;
+        }
+
+        public virtual EntityEntry<TEntity> UpdateExcludeNow(TEntity entity, IEnumerable<string> propertyNames)
+        {
+            var entityEntry = UpdateExclude(entity, propertyNames);
+            SaveNow();
+            return entityEntry;
+        }
+
+        public virtual EntityEntry<TEntity> UpdateExcludeNow(TEntity entity, IEnumerable<Expression<Func<TEntity, object>>> propertyPredicates)
+        {
+            var entityEntry = UpdateExclude(entity, propertyPredicates);
+            SaveNow();
+            return entityEntry;
+        }
+
+        public virtual async Task<EntityEntry<TEntity>> UpdateExcludeNowAsync(TEntity entity, string[] propertyNames, CancellationToken cancellationToken = default)
+        {
+            var entityEntry = await UpdateExcludeAsync(entity, propertyNames);
+            await SaveNowAsync(cancellationToken);
+            return entityEntry;
+        }
+
+        public virtual async Task<EntityEntry<TEntity>> UpdateExcludeNowAsync(TEntity entity, Expression<Func<TEntity, object>>[] propertyPredicates, CancellationToken cancellationToken = default)
+        {
+            var entityEntry = await UpdateExcludeAsync(entity, propertyPredicates);
+            await SaveNowAsync(cancellationToken);
+            return entityEntry;
+        }
+
+        public virtual async Task<EntityEntry<TEntity>> UpdateExcludeNowAsync(TEntity entity, IEnumerable<string> propertyNames, CancellationToken cancellationToken = default)
+        {
+            var entityEntry = await UpdateExcludeAsync(entity, propertyNames);
+            await SaveNowAsync(cancellationToken);
+            return entityEntry;
+        }
+
+        public virtual async Task<EntityEntry<TEntity>> UpdateExcludeNowAsync(TEntity entity, IEnumerable<Expression<Func<TEntity, object>>> propertyPredicates, CancellationToken cancellationToken = default)
+        {
+            var entityEntry = await UpdateExcludeAsync(entity, propertyPredicates);
+            await SaveNowAsync(cancellationToken);
+            return entityEntry;
+        }
+
+        #endregion
+
+        #region Delete
+        public virtual EntityEntry<TEntity> Delete(TEntity entity)
+        {
+            return Entities.Remove(entity);
+        }
+
+        public virtual void Delete(params TEntity[] entities)
+        {
+            Entities.RemoveRange(entities);
+        }
+
+        public virtual void Delete(IEnumerable<TEntity> entities)
+        {
+            Entities.RemoveRange(entities);
+        }
+
+        public virtual Task<EntityEntry<TEntity>> DeleteAsync(TEntity entity)
+        {
+            return Task.FromResult(Delete(entity));
+        }
+
+        public virtual Task DeleteAsync(params TEntity[] entities)
+        {
+            Delete(entities);
+            return Task.CompletedTask;
+        }
+
+        public virtual Task DeleteAsync(IEnumerable<TEntity> entities)
+        {
+            Delete(entities);
+            return Task.CompletedTask;
+        }
+
+        public virtual EntityEntry<TEntity> DeleteNow(TEntity entity)
+        {
+            var entityEntry = Delete(entity);
+            SaveNow();
+            return entityEntry;
+        }
+
+        public virtual void DeleteNow(params TEntity[] entities)
+        {
+            Delete(entities);
+            SaveNow();
+        }
+
+        public virtual void DeleteNow(IEnumerable<TEntity> entities)
+        {
+            Delete(entities);
+            SaveNow();
+        }
+
+        public virtual async Task<EntityEntry<TEntity>> DeleteNowAsync(TEntity entity, CancellationToken cancellationToken = default)
+        {
+            var entityEntry = await DeleteAsync(entity);
+            await SaveNowAsync(cancellationToken);
+            return entityEntry;
+        }
+
+        public virtual async Task DeleteNowAsync(params TEntity[] entities)
+        {
+            await DeleteAsync(entities);
+            await SaveNowAsync();
+        }
+
+        public virtual async Task DeleteNowAsync(TEntity[] entities, CancellationToken cancellationToken = default)
+        {
+            await DeleteAsync(entities);
+            await SaveNowAsync(cancellationToken);
+        }
+
+        public virtual async Task DeleteNowAsync(IEnumerable<TEntity> entities, CancellationToken cancellationToken = default)
+        {
+            await DeleteAsync(entities);
+            await SaveNowAsync(cancellationToken);
+        }
+
+        #endregion
+
+        #region EntityEntry
+
+        /// <summary>
+        /// 将实体加入数据上下文托管
+        /// </summary>
+        /// <param name="entity">实体</param>
+        /// <returns>EntityEntry</returns>
+        public virtual EntityEntry Entry(object entity)
+        {
+            return dbContext.Entry(entity);
+        }
+
+        /// <summary>
+        /// 将实体加入数据上下文托管
+        /// </summary>
+        /// <param name="entity">实体</param>
+        /// <returns></returns>
+        public virtual EntityEntry<TEntity> Entry(TEntity entity)
+        {
+            return dbContext.Entry(entity);
+        }
+
+        /// <summary>
+        /// 获取实体状态
+        /// </summary>
+        /// <param name="entity">实体</param>
+        /// <returns></returns>
+        public virtual EntityState EntityEntryState(object entity)
+        {
+            return Entry(entity).State;
+        }
+
+        /// <summary>
+        /// 获取实体状态
+        /// </summary>
+        /// <param name="entity">实体</param>
+        /// <returns>EntityState</returns>
+        public virtual EntityState EntityEntryState(TEntity entity)
+        {
+            return Entry(entity).State;
+        }
+
+        /// <summary>
+        /// 将实体属性加入托管
+        /// </summary>
+        /// <param name="entity">实体</param>
+        /// <param name="propertyName">属性名</param>
+        /// <returns>PropertyEntry</returns>
+        public virtual PropertyEntry EntityPropertyEntry(object entity, string propertyName)
+        {
+            return Entry(entity).Property(propertyName);
+        }
+
+        /// <summary>
+        /// 将实体属性加入托管
+        /// </summary>
+        /// <param name="entity">实体</param>
+        /// <param name="propertyName">属性名</param>
+        /// <returns>PropertyEntry</returns>
+        public virtual PropertyEntry EntityPropertyEntry(TEntity entity, string propertyName)
+        {
+            return Entry(entity).Property(propertyName);
+        }
+
+        /// <summary>
+        /// 将实体属性加入托管
+        /// </summary>
+        /// <typeparam name="TProperty">属性类型</typeparam>
+        /// <param name="entity">实体</param>
+        /// <param name="propertyPredicate">属性表达式</param>
+        /// <returns>PropertyEntry</returns>
+        public virtual PropertyEntry<TEntity, TProperty> EntityPropertyEntry<TProperty>(TEntity entity, Expression<Func<TEntity, TProperty>> propertyPredicate)
+        {
+            return Entry(entity).Property(propertyPredicate);
+        }
+
+        /// <summary>
+        /// 改变实体状态
+        /// </summary>
+        /// <param name="entity">实体</param>
+        /// <param name="entityState">实体状态</param>
+        /// <returns>EntityEntry</returns>
+        public virtual EntityEntry ChangeEntityState(object entity, EntityState entityState)
+        {
+            var entityEntry = Entry(entity);
+            entityEntry.State = entityState;
+            return entityEntry;
+        }
+
+        /// <summary>
+        /// 改变实体状态
+        /// </summary>
+        /// <param name="entity">实体</param>
+        /// <param name="entityState">实体状态</param>
+        /// <returns>EntityEntry{TEntity}</returns>
+        public virtual EntityEntry<TEntity> ChangeEntityState(TEntity entity, EntityState entityState)
+        {
+            var entityEntry = Entry(entity);
+            entityEntry.State = entityState;
+            return entityEntry;
+        }
+
+        /// <summary>
+        /// 改变实体状态
+        /// </summary>
+        /// <param name="entityEntry">实体条目</param>
+        /// <param name="entityState">实体状态</param>
+        /// <returns>EntityEntry</returns>
+        public virtual EntityEntry ChangeEntityState(EntityEntry entityEntry, EntityState entityState)
+        {
+            entityEntry.State = entityState;
+            return entityEntry;
+        }
+
+        /// <summary>
+        /// 改变实体状态
+        /// </summary>
+        /// <param name="entityEntry">实体条目</param>
+        /// <param name="entityState">实体状态</param>
+        /// <returns>EntityEntry{TEntity}</returns>
+        public virtual EntityEntry<TEntity> ChangeEntityState(EntityEntry<TEntity> entityEntry, EntityState entityState)
+        {
+            entityEntry.State = entityState;
+            return entityEntry;
+        }
+
+        /// <summary>
+        /// 判断是否被附加
+        /// </summary>
+        /// <param name="entity">实体</param>
+        /// <returns>bool</returns>
+        public virtual bool IsAttached(object entity)
+        {
+            return EntityEntryState(entity) != EntityState.Detached;
+        }
+
+        /// <summary>
+        /// 判断是否被附加
+        /// </summary>
+        /// <param name="entity">实体</param>
+        /// <returns>bool</returns>
+        public virtual bool IsAttached(TEntity entity)
+        {
+            return EntityEntryState(entity) != EntityState.Detached;
+        }
+
+        /// <summary>
+        /// 附加实体
+        /// </summary>
+        /// <param name="entity">实体</param>
+        /// <returns>EntityEntry</returns>
+        public virtual EntityEntry Attach(object entity)
+        {
+            return dbContext.Attach(entity);
+        }
+
+        /// <summary>
+        /// 附加实体
+        /// </summary>
+        /// <param name="entity">实体</param>
+        /// <returns>EntityEntry</returns>
+        public virtual EntityEntry<TEntity> Attach(TEntity entity)
+        {
+            return dbContext.Attach(entity);
+        }
+
+        /// <summary>
+        /// 附加多个实体
+        /// </summary>
+        /// <param name="entities">多个实体</param>
+        public virtual void AttachRange(params object[] entities)
+        {
+            dbContext.AttachRange(entities);
+        }
+
+        /// <summary>
+        /// 附加多个实体
+        /// </summary>
+        /// <param name="entities">多个实体</param>
+        public virtual void AttachRange(IEnumerable<TEntity> entities)
+        {
+            dbContext.AttachRange(entities);
+        }
+
+        /// <summary>
+        /// 取消附加实体
+        /// </summary>
+        /// <param name="entity">实体</param>
+        public virtual void Detach(object entity)
+        {
+            ChangeEntityState(entity, EntityState.Detached);
+        }
+
+        /// <summary>
+        /// 取消附加实体
+        /// </summary>
+        /// <param name="entity">实体</param>
+        public virtual void Detach(TEntity entity)
+        {
+            ChangeEntityState(entity, EntityState.Detached);
+        }
+
+        /// <summary>
+        /// 取消附加实体
+        /// </summary>
+        /// <param name="entityEntry">实体条目</param>
+        public virtual void Detach(EntityEntry entityEntry)
+        {
+            ChangeEntityState(entityEntry, EntityState.Detached);
+        }
+
+        /// <summary>
+        /// 取消附加实体
+        /// </summary>
+        /// <param name="entityEntry">实体条目</param>
+        public virtual void Detach(EntityEntry<TEntity> entityEntry)
+        {
+            ChangeEntityState(entityEntry, EntityState.Detached);
+        }
+
+
+        #endregion
+    }
+}