- 合并 FreeSql.DbContext 项目至 FreeSql 维护；

FreeSql.DbContext/Repository/ContextSet/RepositoryDbContext.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Concurrent;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace FreeSql {
+	internal class RepositoryDbContext : DbContext {
+
+		protected IBaseRepository _repos;
+		public RepositoryDbContext(IFreeSql orm, IBaseRepository repos) : base() {
+			_orm = orm;
+			_repos = repos;
+			_isUseUnitOfWork = false;
+			_uowPriv = _repos.UnitOfWork;
+		}
+
+
+		static ConcurrentDictionary<Type, FieldInfo> _dicGetRepositoryDbField = new ConcurrentDictionary<Type, FieldInfo>();
+		static FieldInfo GetRepositoryDbField(Type type) => _dicGetRepositoryDbField.GetOrAdd(type, tp => typeof(BaseRepository<,>).MakeGenericType(tp, typeof(int)).GetField("_dbPriv", BindingFlags.Instance | BindingFlags.NonPublic));
+		public override IDbSet Set(Type entityType) {
+			if (_dicSet.ContainsKey(entityType)) return _dicSet[entityType];
+
+			var tb = _orm.CodeFirst.GetTableByEntity(entityType);
+			if (tb == null) return null;
+
+			object repos = _repos;
+			if (entityType != _repos.EntityType) {
+				repos = Activator.CreateInstance(typeof(DefaultRepository<,>).MakeGenericType(entityType, typeof(int)), _repos.Orm);
+				(repos as IBaseRepository).UnitOfWork = _repos.UnitOfWork;
+				GetRepositoryDbField(entityType).SetValue(repos, this);
+
+				typeof(RepositoryDbContext).GetMethod("SetRepositoryDataFilter").MakeGenericMethod(_repos.EntityType)
+					.Invoke(null, new object[] { repos, _repos });
+			}
+
+			var sd = Activator.CreateInstance(typeof(RepositoryDbSet<>).MakeGenericType(entityType), repos) as IDbSet;
+			if (entityType != typeof(object)) _dicSet.Add(entityType, sd);
+			return sd;
+		}
+
+		public static void SetRepositoryDataFilter<TEntity>(object repos, BaseRepository<TEntity> baseRepo) where TEntity : class {
+			var filter = baseRepo.DataFilter as DataFilter<TEntity>;
+			DataFilterUtil.SetRepositoryDataFilter(repos, fl => {
+				foreach (var f in filter._filters)
+					fl.Apply<TEntity>(f.Key, f.Value.Expression);
+			});
+		}
+
+		public override int SaveChanges() {
+			ExecCommand();
+			var ret = _affrows;
+			_affrows = 0;
+			return ret;
+		}
+		async public override Task<int> SaveChangesAsync() {
+			await ExecCommandAsync();
+			var ret = _affrows;
+			_affrows = 0;
+			return ret;
+		}
+	}
+}

FreeSql.DbContext/Repository/ContextSet/RepositoryDbSet.cs

@@ -0,0 +1,60 @@
+using FreeSql.Extensions.EntityUtil;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace FreeSql {
+	internal class RepositoryDbSet<TEntity> : DbSet<TEntity> where TEntity : class {
+
+		protected BaseRepository<TEntity> _repos;
+		public RepositoryDbSet(BaseRepository<TEntity> repos) {
+			_ctx = repos._db;
+			_fsql = repos.Orm;
+			_uow = repos.UnitOfWork;
+			_repos = repos;
+		}
+
+		protected override ISelect<TEntity> OrmSelect(object dywhere) {
+			var select = base.OrmSelect(dywhere);
+
+			var filters = (_repos.DataFilter as DataFilter<TEntity>)._filters.Where(a => a.Value.IsEnabled == true);
+			foreach (var filter in filters) select.Where(filter.Value.Expression);
+			return select.AsTable(_repos.AsTableSelectInternal);
+		}
+		internal ISelect<TEntity> OrmSelectInternal(object dywhere) => OrmSelect(dywhere);
+		protected override IUpdate<TEntity> OrmUpdate(IEnumerable<TEntity> entitys) {
+			var update = base.OrmUpdate(entitys);
+			var filters = (_repos.DataFilter as DataFilter<TEntity>)._filters.Where(a => a.Value.IsEnabled == true);
+			foreach (var filter in filters) {
+				if (entitys != null)
+					foreach (var entity in entitys)
+						if (filter.Value.ExpressionDelegate?.Invoke(entity) == false)
+							throw new Exception($"FreeSql.Repository Update 失败，因为设置了过滤器 {filter.Key}: {filter.Value.Expression}，更新的数据不符合 {_fsql.GetEntityString(_entityType, entity)}");
+				update.Where(filter.Value.Expression);
+			}
+			return update.AsTable(_repos.AsTableInternal);
+		}
+		internal IUpdate<TEntity> OrmUpdateInternal(IEnumerable<TEntity> entitys) => OrmUpdate(entitys);
+		protected override IDelete<TEntity> OrmDelete(object dywhere) {
+			var delete = base.OrmDelete(dywhere);
+			var filters = (_repos.DataFilter as DataFilter<TEntity>)._filters.Where(a => a.Value.IsEnabled == true);
+			foreach (var filter in filters) delete.Where(filter.Value.Expression);
+			return delete.AsTable(_repos.AsTableInternal);
+		}
+		internal IDelete<TEntity> OrmDeleteInternal(object dywhere) => OrmDelete(dywhere);
+		protected override IInsert<TEntity> OrmInsert(TEntity entity) => OrmInsert(new[] { entity });
+		protected override IInsert<TEntity> OrmInsert(IEnumerable<TEntity> entitys) {
+			var insert = base.OrmInsert(entitys);
+			var filters = (_repos.DataFilter as DataFilter<TEntity>)._filters.Where(a => a.Value.IsEnabled == true);
+			foreach (var filter in filters) {
+				if (entitys != null)
+					foreach (var entity in entitys)
+						if (filter.Value.ExpressionDelegate?.Invoke(entity) == false)
+							throw new Exception($"FreeSql.Repository Insert 失败，因为设置了过滤器 {filter.Key}: {filter.Value.Expression}，插入的数据不符合 {_fsql.GetEntityString(_entityType, entity)}");
+			}
+			return insert.AsTable(_repos.AsTableInternal);
+		}
+		internal IInsert<TEntity> OrmInsertInternal(TEntity entity) => OrmInsert(entity);
+		internal IInsert<TEntity> OrmInsertInternal(IEnumerable<TEntity> entitys) => OrmInsert(entitys);
+	}
+}

FreeSql.DbContext/Repository/ContextSet/RepositoryUnitOfWork.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Linq.Expressions;
+
+namespace FreeSql {
+
+	public interface IRepositoryUnitOfWork : IUnitOfWork {
+		/// <summary>
+		/// 在工作单元内创建默认仓库类，工作单元下的仓储操作具有事务特点
+		/// </summary>
+		/// <typeparam name="TEntity"></typeparam>
+		/// <typeparam name="TKey"></typeparam>
+		/// <param name="filter">数据过滤 + 验证</param>
+		/// <returns></returns>
+		DefaultRepository<TEntity, TKey> GetRepository<TEntity, TKey>(Expression<Func<TEntity, bool>> filter = null) where TEntity : class;
+
+		/// <summary>
+		/// 在工作单元内创建联合主键的仓储类，工作单元下的仓储操作具有事务特点
+		/// </summary>
+		/// <typeparam name="TEntity"></typeparam>
+		/// <param name="filter">数据过滤 + 验证</param>
+		/// <returns></returns>
+		BaseRepository<TEntity> GetRepository<TEntity>(Expression<Func<TEntity, bool>> filter = null) where TEntity : class;
+
+		/// <summary>
+		/// 在工作单元内创建仓库类，工作单元下的仓储操作具有事务特点
+		/// </summary>
+		/// <typeparam name="TEntity"></typeparam>
+		/// <param name="filter">数据过滤 + 验证</param>
+		/// <param name="asTable">分表规则，参数：旧表名；返回：新表名 https://github.com/2881099/FreeSql/wiki/Repository</param>
+		/// <returns></returns>
+		GuidRepository<TEntity> GetGuidRepository<TEntity>(Expression<Func<TEntity, bool>> filter = null, Func<string, string> asTable = null) where TEntity : class;
+	}
+
+	class RepositoryUnitOfWork : UnitOfWork, IRepositoryUnitOfWork {
+
+		public RepositoryUnitOfWork(IFreeSql fsql) : base(fsql) {
+		}
+
+		public GuidRepository<TEntity> GetGuidRepository<TEntity>(Expression<Func<TEntity, bool>> filter = null, Func<string, string> asTable = null) where TEntity : class {
+			var repos = new GuidRepository<TEntity>(_fsql, filter, asTable);
+			repos.UnitOfWork = this;
+			return repos;
+		}
+
+		public DefaultRepository<TEntity, TKey> GetRepository<TEntity, TKey>(Expression<Func<TEntity, bool>> filter = null) where TEntity : class {
+			var repos = new DefaultRepository<TEntity, TKey>(_fsql, filter);
+			repos.UnitOfWork = this;
+			return repos;
+		}
+
+		public BaseRepository<TEntity> GetRepository<TEntity>(Expression<Func<TEntity, bool>> filter = null) where TEntity : class {
+			var repos = new DefaultRepository<TEntity, int>(_fsql, filter);
+			repos.UnitOfWork = this;
+			return repos;
+		}
+	}
+}

FreeSql.DbContext/Repository/DataFilter/DataFilter.cs

@@ -0,0 +1,152 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+using System.Linq.Expressions;
+using System.Linq;
+
+namespace FreeSql {
+	public interface IDataFilter<TEntity> : IDisposable where TEntity : class {
+
+		IDataFilter<TEntity> Apply(string filterName, Expression<Func<TEntity, bool>> filterAndValidateExp);
+
+		/// <summary>
+		/// 开启过滤器，若使用 using 则使用完后，恢复为原有状态
+		/// </summary>
+		/// <param name="filterName">过滤器名称</param>
+		/// <returns></returns>
+		IDisposable Enable(params string[] filterName);
+		/// <summary>
+		/// 开启所有过滤器，若使用 using 则使用完后，恢复为原有状态
+		/// </summary>
+		/// <returns></returns>
+		IDisposable EnableAll();
+
+		/// <summary>
+		/// 禁用过滤器，若使用 using 则使用完后，恢复为原有状态
+		/// </summary>
+		/// <param name="filterName"></param>
+		/// <returns></returns>
+		IDisposable Disable(params string[] filterName);
+		/// <summary>
+		/// 禁用所有过滤器，若使用 using 则使用完后，恢复为原有状态
+		/// </summary>
+		/// <returns></returns>
+		IDisposable DisableAll();
+
+		bool IsEnabled(string filterName);
+	}
+
+	internal class DataFilter<TEntity> : IDataFilter<TEntity> where TEntity : class {
+
+		internal class FilterItem {
+			public Expression<Func<TEntity, bool>> Expression { get; set; }
+			Func<TEntity, bool> _expressionDelegate;
+			public Func<TEntity, bool> ExpressionDelegate => _expressionDelegate ?? (_expressionDelegate = Expression?.Compile());
+			public bool IsEnabled { get; set; }
+		}
+
+		internal ConcurrentDictionary<string, FilterItem> _filters = new ConcurrentDictionary<string, FilterItem>(StringComparer.CurrentCultureIgnoreCase);
+		public IDataFilter<TEntity> Apply(string filterName, Expression<Func<TEntity, bool>> filterAndValidateExp) {
+
+			if (filterName == null)
+				throw new ArgumentNullException(nameof(filterName));
+			if (filterAndValidateExp == null) return this;
+
+			var filterItem = new FilterItem { Expression = filterAndValidateExp, IsEnabled = true };
+			_filters.AddOrUpdate(filterName, filterItem, (k, v) => filterItem);
+			return this;
+		}
+
+		public IDisposable Disable(params string[] filterName) {
+			if (filterName == null || filterName.Any() == false) return new UsingAny(() => { });
+
+			List<string> restore = new List<string>();
+			foreach (var name in filterName) {
+				if (_filters.TryGetValue(name, out var tryfi)) {
+					if (tryfi.IsEnabled) {
+						restore.Add(name);
+						tryfi.IsEnabled = false;
+					}
+				}
+			}
+			return new UsingAny(() => this.Enable(restore.ToArray()));
+		}
+		public IDisposable DisableAll() {
+			List<string> restore = new List<string>();
+			foreach (var val in _filters) {
+				if (val.Value.IsEnabled) {
+					restore.Add(val.Key);
+					val.Value.IsEnabled = false;
+				}
+			}
+			return new UsingAny(() => this.Enable(restore.ToArray()));
+		}
+		class UsingAny : IDisposable {
+			Action _ondis;
+			public UsingAny(Action ondis) {
+				_ondis = ondis;
+			}
+			public void Dispose() {
+				_ondis?.Invoke();
+			}
+		}
+
+		public IDisposable Enable(params string[] filterName) {
+			if (filterName == null || filterName.Any() == false) return new UsingAny(() => { });
+
+			List<string> restore = new List<string>();
+			foreach (var name in filterName) {
+				if (_filters.TryGetValue(name, out var tryfi)) {
+					if (tryfi.IsEnabled == false) {
+						restore.Add(name);
+						tryfi.IsEnabled = true;
+					}
+				}
+			}
+			return new UsingAny(() => this.Disable(restore.ToArray()));
+		}
+		public IDisposable EnableAll() {
+			List<string> restore = new List<string>();
+			foreach (var val in _filters) {
+				if (val.Value.IsEnabled == false) {
+					restore.Add(val.Key);
+					val.Value.IsEnabled = true;
+				}
+			}
+			return new UsingAny(() => this.Disable(restore.ToArray()));
+		}
+
+		public bool IsEnabled(string filterName) {
+			if (filterName == null) return false;
+			return _filters.TryGetValue(filterName, out var tryfi) ? tryfi.IsEnabled : false;
+		}
+
+		~DataFilter() {
+			this.Dispose();
+		}
+		public void Dispose() {
+			_filters.Clear();
+		}
+	}
+
+	public class FluentDataFilter : IDisposable {
+
+		internal List<(Type type, string name, LambdaExpression exp)> _filters = new List<(Type type, string name, LambdaExpression exp)>();
+
+		public FluentDataFilter Apply<TEntity>(string filterName, Expression<Func<TEntity, bool>> filterAndValidateExp) where TEntity : class {
+			if (filterName == null)
+				throw new ArgumentNullException(nameof(filterName));
+			if (filterAndValidateExp == null) return this;
+
+			_filters.Add((typeof(TEntity), filterName, filterAndValidateExp));
+			return this;
+		}
+
+		~FluentDataFilter() {
+			this.Dispose();
+		}
+		public void Dispose() {
+			_filters.Clear();
+		}
+	}
+}

FreeSql.DbContext/Repository/DataFilter/DataFilterUtil.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace FreeSql {
+
+	internal class DataFilterUtil {
+
+		internal static Action<FluentDataFilter> _globalDataFilter;
+
+		static ConcurrentDictionary<Type, Delegate> _dicSetRepositoryDataFilterApplyDataFilterFunc = new ConcurrentDictionary<Type, Delegate>();
+		static ConcurrentDictionary<Type, ConcurrentDictionary<string, bool>> _dicSetRepositoryDataFilterConvertFilterNotExists = new ConcurrentDictionary<Type, ConcurrentDictionary<string, bool>>();
+		internal static void SetRepositoryDataFilter(object repos, Action<FluentDataFilter> scopedDataFilter) {
+			if (scopedDataFilter != null) {
+				SetRepositoryDataFilter(repos, null);
+			}
+			if (scopedDataFilter == null) {
+				scopedDataFilter = _globalDataFilter;
+			}
+			if (scopedDataFilter == null) return;
+			using (var globalFilter = new FluentDataFilter()) {
+				scopedDataFilter(globalFilter);
+
+				var type = repos.GetType();
+				Type entityType = (repos as IBaseRepository).EntityType;
+				if (entityType == null) throw new Exception("FreeSql.Repository 设置过滤器失败，原因是对象不属于 IRepository");
+
+				var notExists = _dicSetRepositoryDataFilterConvertFilterNotExists.GetOrAdd(type, t => new ConcurrentDictionary<string, bool>());
+				var newFilter = new Dictionary<string, LambdaExpression>();
+				foreach (var gf in globalFilter._filters) {
+					if (notExists.ContainsKey(gf.name)) continue;
+
+					LambdaExpression newExp = null;
+					var filterParameter1 = Expression.Parameter(entityType, gf.exp.Parameters[0].Name);
+					try {
+						newExp = Expression.Lambda(
+							typeof(Func<,>).MakeGenericType(entityType, typeof(bool)),
+							new ReplaceVisitor().Modify(gf.exp.Body, filterParameter1),
+							filterParameter1
+						);
+					} catch {
+						notExists.TryAdd(gf.name, true); //防止第二次错误
+						continue;
+					}
+					newFilter.Add(gf.name, newExp);
+				}
+				if (newFilter.Any() == false) return;
+
+				var del = _dicSetRepositoryDataFilterApplyDataFilterFunc.GetOrAdd(type, t => {
+					var reposParameter = Expression.Parameter(type);
+					var nameParameter = Expression.Parameter(typeof(string));
+					var expressionParameter = Expression.Parameter(
+						typeof(Expression<>).MakeGenericType(typeof(Func<,>).MakeGenericType(entityType, typeof(bool)))
+					);
+					return Expression.Lambda(
+						Expression.Block(
+							Expression.Call(reposParameter, type.GetMethod("ApplyDataFilter", BindingFlags.Instance | BindingFlags.NonPublic), nameParameter, expressionParameter)
+						),
+						new[] {
+						reposParameter, nameParameter, expressionParameter
+						}
+					).Compile();
+				});
+				foreach (var nf in newFilter) {
+					del.DynamicInvoke(repos, nf.Key, nf.Value);
+				}
+				newFilter.Clear();
+			}
+		}
+	}
+
+	class ReplaceVisitor : ExpressionVisitor {
+		private ParameterExpression parameter;
+
+		public Expression Modify(Expression expression, ParameterExpression parameter) {
+			this.parameter = parameter;
+			return Visit(expression);
+		}
+
+		protected override Expression VisitMember(MemberExpression node) {
+			if (node.Expression?.NodeType == ExpressionType.Parameter)
+				return Expression.Property(parameter, node.Member.Name);
+			return base.VisitMember(node);
+		}
+	}
+}

FreeSql.DbContext/Repository/Extenssions/DependencyInjection.cs

@@ -0,0 +1,39 @@
+#if ns20
+
+using System;
+using System.Reflection;
+using System.Linq;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace FreeSql {
+	public static class FreeSqlRepositoryDependencyInjection {
+
+		public static IServiceCollection AddFreeRepository(this IServiceCollection services, Action<FluentDataFilter> globalDataFilter = null, params Assembly[] assemblies) {
+
+			DataFilterUtil._globalDataFilter = globalDataFilter;
+
+			services.AddScoped(typeof(IReadOnlyRepository<>), typeof(GuidRepository<>));
+			services.AddScoped(typeof(IBasicRepository<>), typeof(GuidRepository<>));
+			services.AddScoped(typeof(BaseRepository<>), typeof(GuidRepository<>));
+			services.AddScoped(typeof(GuidRepository<>));
+
+			services.AddScoped(typeof(IReadOnlyRepository<,>), typeof(DefaultRepository<,>));
+			services.AddScoped(typeof(IBasicRepository<,>), typeof(DefaultRepository<,>));
+			services.AddScoped(typeof(BaseRepository<,>), typeof(DefaultRepository<,>));
+			services.AddScoped(typeof(DefaultRepository<,>));
+
+			if (assemblies?.Any() == true) {
+				foreach(var asse in assemblies) {
+					foreach (var repos in asse.GetTypes().Where(a => a.IsAbstract == false && typeof(IBaseRepository).IsAssignableFrom(a))) {
+
+						services.AddScoped(repos);
+					}
+				}
+			}
+
+			return services;
+		}
+	}
+}
+
+#endif

FreeSql.DbContext/Repository/Extenssions/FreeSqlRepositoryExtenssions.cs

@@ -0,0 +1,65 @@
+using FreeSql;
+using System;
+using System.Linq.Expressions;
+using System.Linq;
+
+public static class FreeSqlRepositoryExtenssions {
+
+	/// <summary>
+	/// 返回默认仓库类
+	/// </summary>
+	/// <typeparam name="TEntity"></typeparam>
+	/// <typeparam name="TKey"></typeparam>
+	/// <param name="that"></param>
+	/// <param name="filter">数据过滤 + 验证</param>
+	/// <returns></returns>
+	public static DefaultRepository<TEntity, TKey> GetRepository<TEntity, TKey>(this IFreeSql that, Expression<Func<TEntity, bool>> filter = null) where TEntity : class {
+		return new DefaultRepository<TEntity, TKey>(that, filter);
+	}
+
+	/// <summary>
+	/// 返回默认仓库类，适用联合主键的仓储类
+	/// </summary>
+	/// <typeparam name="TEntity"></typeparam>
+	/// <param name="that"></param>
+	/// <param name="filter">数据过滤 + 验证</param>
+	/// <returns></returns>
+	public static BaseRepository<TEntity> GetRepository<TEntity>(this IFreeSql that, Expression<Func<TEntity, bool>> filter = null) where TEntity : class {
+		return new DefaultRepository<TEntity, int>(that, filter);
+	}
+
+	/// <summary>
+	/// 返回仓库类
+	/// </summary>
+	/// <typeparam name="TEntity"></typeparam>
+	/// <param name="that"></param>
+	/// <param name="filter">数据过滤 + 验证</param>
+	/// <param name="asTable">分表规则，参数：旧表名；返回：新表名 https://github.com/2881099/FreeSql/wiki/Repository</param>
+	/// <returns></returns>
+	public static GuidRepository<TEntity> GetGuidRepository<TEntity>(this IFreeSql that, Expression<Func<TEntity, bool>> filter = null, Func<string, string> asTable = null) where TEntity : class {
+		return new GuidRepository<TEntity>(that, filter, asTable);
+	}
+
+	/// <summary>
+	/// 合并两个仓储的设置（过滤+分表），以便查询
+	/// </summary>
+	/// <typeparam name="TEntity"></typeparam>
+	/// <typeparam name="T2"></typeparam>
+	/// <param name="that"></param>
+	/// <param name="repos"></param>
+	/// <returns></returns>
+	public static ISelect<TEntity> FromRepository<TEntity, T2>(this ISelect<TEntity> that, BaseRepository<T2> repos) where TEntity : class where T2 : class {
+		var filters = (repos.DataFilter as DataFilter<T2>)._filters.Where(a => a.Value.IsEnabled == true);
+		foreach (var filter in filters) that.Where<T2>(filter.Value.Expression);
+		return that.AsTable(repos.AsTableSelectInternal);
+	}
+
+	/// <summary>
+	/// 创建基于仓储功能的工作单元，务必使用 using 包含使用
+	/// </summary>
+	/// <param name="that"></param>
+	/// <returns></returns>
+	public static IRepositoryUnitOfWork CreateUnitOfWork(this IFreeSql that) {
+		return new RepositoryUnitOfWork(that);
+	}
+}

FreeSql.DbContext/Repository/Repository/BaseRepository.cs

@@ -0,0 +1,160 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace FreeSql {
+	public abstract class BaseRepository<TEntity> : IBaseRepository<TEntity>
+		where TEntity : class {
+
+		internal RepositoryDbContext _dbPriv;
+		internal RepositoryDbContext _db => _dbPriv ?? (_dbPriv = new RepositoryDbContext(Orm, this));
+		internal RepositoryDbSet<TEntity> _dbsetPriv;
+		internal RepositoryDbSet<TEntity> _dbset => _dbsetPriv ?? (_dbsetPriv = _db.Set<TEntity>() as RepositoryDbSet<TEntity>);
+		public IDataFilter<TEntity> DataFilter { get; } = new DataFilter<TEntity>();
+		Func<string, string> _asTableVal;
+		protected Func<string, string> AsTable {
+			get => _asTableVal;
+			set {
+				_asTableVal = value;
+				AsTableSelect = value == null ? null : new Func<Type, string, string>((a, b) => a == EntityType ? value(b) : null);
+			}
+		}
+		internal Func<string, string> AsTableInternal => AsTable;
+		protected Func<Type, string, string> AsTableSelect { get; private set; }
+		internal Func<Type, string, string> AsTableSelectInternal => AsTableSelect;
+
+		protected void ApplyDataFilter(string name, Expression<Func<TEntity, bool>> exp) => DataFilter.Apply(name, exp);
+
+		protected BaseRepository(IFreeSql fsql, Expression<Func<TEntity, bool>> filter, Func<string, string> asTable = null) {
+			Orm = fsql;
+			DataFilterUtil.SetRepositoryDataFilter(this, null);
+			DataFilter.Apply("", filter);
+			AsTable = asTable;
+		}
+
+		~BaseRepository() {
+			this.Dispose();
+		}
+		bool _isdisposed = false;
+		public void Dispose() {
+			if (_isdisposed) return;
+			try {
+				_dbsetPriv?.Dispose();
+				_dbPriv?.Dispose();
+				this.DataFilter.Dispose();
+			} finally {
+				_isdisposed = true;
+				GC.SuppressFinalize(this);
+			}
+		}
+		public Type EntityType => _dbsetPriv?.EntityType ?? typeof(TEntity);
+		public void AsType(Type entityType) => _dbset.AsType(entityType);
+
+		public IFreeSql Orm { get; private set; }
+		public IUnitOfWork UnitOfWork { get; set; }
+		public IUpdate<TEntity> UpdateDiy => _dbset.OrmUpdateInternal(null);
+
+		public ISelect<TEntity> Select => _dbset.OrmSelectInternal(null);
+		public ISelect<TEntity> Where(Expression<Func<TEntity, bool>> exp) => _dbset.OrmSelectInternal(null).Where(exp);
+		public ISelect<TEntity> WhereIf(bool condition, Expression<Func<TEntity, bool>> exp) => _dbset.OrmSelectInternal(null).WhereIf(condition, exp);
+
+		public int Delete(Expression<Func<TEntity, bool>> predicate) => _dbset.OrmDeleteInternal(null).Where(predicate).ExecuteAffrows();
+		public Task<int> DeleteAsync(Expression<Func<TEntity, bool>> predicate) => _dbset.OrmDeleteInternal(null).Where(predicate).ExecuteAffrowsAsync();
+
+		public int Delete(TEntity entity) {
+			_dbset.Remove(entity);
+			return _db.SaveChanges();
+		}
+		public Task<int> DeleteAsync(TEntity entity) {
+			_dbset.Remove(entity);
+			return _db.SaveChangesAsync();
+		}
+		public int Delete(IEnumerable<TEntity> entitys) {
+			_dbset.RemoveRange(entitys);
+			return _db.SaveChanges();
+		}
+		public Task<int> DeleteAsync(IEnumerable<TEntity> entitys) {
+			_dbset.RemoveRange(entitys);
+			return _db.SaveChangesAsync();
+		}
+
+		public virtual TEntity Insert(TEntity entity) {
+			_dbset.Add(entity);
+			_db.SaveChanges();
+			return entity;
+		}
+		async public virtual Task<TEntity> InsertAsync(TEntity entity) {
+			await _dbset.AddAsync(entity);
+			_db.SaveChanges();
+			return entity;
+		}
+		public virtual List<TEntity> Insert(IEnumerable<TEntity> entitys) {
+			_dbset.AddRange(entitys);
+			_db.SaveChanges();
+			return entitys.ToList();
+		}
+		async public virtual Task<List<TEntity>> InsertAsync(IEnumerable<TEntity> entitys) {
+			await _dbset.AddRangeAsync(entitys);
+			await _db.SaveChangesAsync();
+			return entitys.ToList();
+		}
+
+		public int Update(TEntity entity) {
+			_dbset.Update(entity);
+			return _db.SaveChanges();
+		}
+		public Task<int> UpdateAsync(TEntity entity) {
+			_dbset.Update(entity);
+			return _db.SaveChangesAsync();
+		}
+		public int Update(IEnumerable<TEntity> entitys) {
+			_dbset.UpdateRange(entitys);
+			return _db.SaveChanges();
+		}
+		public Task<int> UpdateAsync(IEnumerable<TEntity> entitys) {
+			_dbset.UpdateRange(entitys);
+			return _db.SaveChangesAsync();
+		}
+
+		public void Attach(TEntity data) => _db.Attach(data);
+		public void Attach(IEnumerable<TEntity> data) => _db.AttachRange(data);
+		public void FlushState() => _dbset.FlushState();
+
+		public TEntity InsertOrUpdate(TEntity entity) {
+			_dbset.AddOrUpdate(entity);
+			_db.SaveChanges();
+			return entity;
+		}
+		async public Task<TEntity> InsertOrUpdateAsync(TEntity entity) {
+			await _dbset.AddOrUpdateAsync(entity);
+			_db.SaveChanges();
+			return entity;
+		}
+	}
+
+	public abstract class BaseRepository<TEntity, TKey> : BaseRepository<TEntity>, IBaseRepository<TEntity, TKey>
+		where TEntity : class {
+
+		public BaseRepository(IFreeSql fsql, Expression<Func<TEntity, bool>> filter, Func<string, string> asTable = null) : base(fsql, filter, asTable) {
+		}
+
+		public int Delete(TKey id) {
+			var stateKey = string.Concat(id);
+			_dbset._statesInternal.TryRemove(stateKey, out var trystate);
+			return _dbset.OrmDeleteInternal(id).ExecuteAffrows();
+		}
+		public Task<int> DeleteAsync(TKey id) {
+			var stateKey = string.Concat(id);
+			_dbset._statesInternal.TryRemove(stateKey, out var trystate);
+			return _dbset.OrmDeleteInternal(id).ExecuteAffrowsAsync();
+		}
+
+		public TEntity Find(TKey id) => _dbset.OrmSelectInternal(id).ToOne();
+		public Task<TEntity> FindAsync(TKey id) => _dbset.OrmSelectInternal(id).ToOneAsync();
+
+		public TEntity Get(TKey id) => Find(id);
+		public Task<TEntity> GetAsync(TKey id) => FindAsync(id);
+	}
+}

FreeSql.DbContext/Repository/Repository/DefaultRepository.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Linq.Expressions;
+
+namespace FreeSql {
+	public class DefaultRepository<TEntity, TKey> :
+		BaseRepository<TEntity, TKey>
+		where TEntity : class {
+
+		public DefaultRepository(IFreeSql fsql) : base(fsql, null, null) {
+
+		}
+
+		public DefaultRepository(IFreeSql fsql, Expression<Func<TEntity, bool>> filter) : base(fsql, filter, null) {
+		}
+	}
+}

FreeSql.DbContext/Repository/Repository/GuidRepository.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Linq.Expressions;
+
+namespace FreeSql {
+	public class GuidRepository<TEntity> :
+		BaseRepository<TEntity, Guid>
+		where TEntity : class {
+
+		public GuidRepository(IFreeSql fsql) : this(fsql, null, null) {
+
+		}
+		public GuidRepository(IFreeSql fsql, Expression<Func<TEntity, bool>> filter, Func<string, string> asTable) : base(fsql, filter, asTable) {
+		}
+	}
+}

FreeSql.DbContext/Repository/Repository/IBaseRepository.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace FreeSql {
+
+	public interface IBaseRepository : IDisposable {
+		Type EntityType { get; }
+		IUnitOfWork UnitOfWork { get; set; }
+		IFreeSql Orm { get; }
+
+		/// <summary>
+		/// 动态Type，在使用 Repository&lt;object&gt; 后使用本方法，指定实体类型
+		/// </summary>
+		/// <param name="entityType"></param>
+		/// <returns></returns>
+		void AsType(Type entityType);
+	}
+
+	public interface IBaseRepository<TEntity> : IReadOnlyRepository<TEntity>, IBasicRepository<TEntity>
+		where TEntity : class {
+		int Delete(Expression<Func<TEntity, bool>> predicate);
+
+		Task<int> DeleteAsync(Expression<Func<TEntity, bool>> predicate);
+	}
+
+	public interface IBaseRepository<TEntity, TKey> : IBaseRepository<TEntity>, IReadOnlyRepository<TEntity, TKey>, IBasicRepository<TEntity, TKey>
+		where TEntity : class {
+	}
+}

FreeSql.DbContext/Repository/Repository/IBasicRepository.cs

@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace FreeSql {
+	public interface IBasicRepository<TEntity> : IReadOnlyRepository<TEntity>
+		where TEntity : class {
+		TEntity Insert(TEntity entity);
+		List<TEntity> Insert(IEnumerable<TEntity> entitys);
+		Task<TEntity> InsertAsync(TEntity entity);
+		Task<List<TEntity>> InsertAsync(IEnumerable<TEntity> entitys);
+
+		/// <summary>
+		/// 清空状态数据
+		/// </summary>
+		void FlushState();
+		/// <summary>
+		/// 附加实体，可用于不查询就更新或删除
+		/// </summary>
+		/// <param name="entity"></param>
+		void Attach(TEntity entity);
+		void Attach(IEnumerable<TEntity> entity);
+		int Update(TEntity entity);
+		int Update(IEnumerable<TEntity> entitys);
+		Task<int> UpdateAsync(TEntity entity);
+		Task<int> UpdateAsync(IEnumerable<TEntity> entitys);
+
+		TEntity InsertOrUpdate(TEntity entity);
+		Task<TEntity> InsertOrUpdateAsync(TEntity entity);
+
+		IUpdate<TEntity> UpdateDiy { get; }
+
+		int Delete(TEntity entity);
+		int Delete(IEnumerable<TEntity> entitys);
+		Task<int> DeleteAsync(TEntity entity);
+		Task<int> DeleteAsync(IEnumerable<TEntity> entitys);
+	}
+
+	public interface IBasicRepository<TEntity, TKey> : IBasicRepository<TEntity>, IReadOnlyRepository<TEntity, TKey>
+		where TEntity : class {
+		int Delete(TKey id);
+
+		Task<int> DeleteAsync(TKey id);
+	}
+}
+

FreeSql.DbContext/Repository/Repository/IReadOnlyRepository.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace FreeSql {
+	public interface IReadOnlyRepository<TEntity> : IBaseRepository
+		where TEntity : class {
+
+		IDataFilter<TEntity> DataFilter { get; }
+
+		ISelect<TEntity> Select { get; }
+
+		ISelect<TEntity> Where(Expression<Func<TEntity, bool>> exp);
+		ISelect<TEntity> WhereIf(bool condition, Expression<Func<TEntity, bool>> exp);
+	}
+
+	public interface IReadOnlyRepository<TEntity, TKey> : IReadOnlyRepository<TEntity>
+		where TEntity : class {
+		TEntity Get(TKey id);
+
+		Task<TEntity> GetAsync(TKey id);
+
+		TEntity Find(TKey id);
+
+		Task<TEntity> FindAsync(TKey id);
+	}
+}