FreeSql.DbContext 内部仓储融合

FreeSql.DbContext/Repository/DataFilter/DataFilter.cs

@@ -0,0 +1,153 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+using System.Linq.Expressions;
+using System.Text;
+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,90 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Text;
+
+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 IRepository).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 @@
+using FreeSql;
+using System;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+using System.Linq.Expressions;
+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(IRepository).IsAssignableFrom(a))) {
+
+						services.AddScoped(repos);
+					}
+				}
+			}
+
+			return services;
+		}
+	}
+}

FreeSql.DbContext/Repository/Extenssions/FreeSqlRepositoryExtenssions.cs

@@ -0,0 +1,58 @@
+using FreeSql;
+using System;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+using System.Text;
+using System.Linq.Expressions;
+using System.Linq;
+using System.Data;
+
+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>
+	/// 返回仓库类，适用 Insert 方法无须返回插入的数据
+	/// </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,99 @@
+using FreeSql.Extensions.EntityUtil;
+using FreeSql.Internal.Model;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace FreeSql {
+	public abstract class BaseRepository<TEntity> : IRepository<TEntity>
+		where TEntity : class {
+
+		internal IFreeSql _fsql;
+		internal UnitOfWork _uow;
+		RepositoryDbSet<TEntity> _setPriv;
+		internal RepositoryDbSet<TEntity> _set => _setPriv ?? (_setPriv = new RepositoryDbSet<TEntity>(this));
+		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 BaseRepository(IFreeSql fsql, Expression<Func<TEntity, bool>> filter, Func<string, string> asTable = null) {
+			_fsql = fsql;
+			DataFilterUtil.SetRepositoryDataFilter(this, null);
+			DataFilter.Apply("", filter);
+			AsTable = asTable;
+		}
+
+		public Type EntityType => _set._entityTypeInternal;
+		public IUpdate<TEntity> UpdateDiy => _set.OrmUpdateInternal(null);
+
+
+		public ISelect<TEntity> Select => _set.OrmSelectInternal(null);
+		public ISelect<TEntity> Where(Expression<Func<TEntity, bool>> exp) => _set.OrmSelectInternal(null).Where(exp);
+		public ISelect<TEntity> WhereIf(bool condition, Expression<Func<TEntity, bool>> exp) => _set.OrmSelectInternal(null).WhereIf(condition, exp);
+
+		public int Delete(Expression<Func<TEntity, bool>> predicate) => _set.OrmDeleteInternal(null).Where(predicate).ExecuteAffrows();
+		public Task<int> DeleteAsync(Expression<Func<TEntity, bool>> predicate) => _set.OrmDeleteInternal(null).Where(predicate).ExecuteAffrowsAsync();
+
+		public int Delete(TEntity entity) => _set.RemoveAffrows(entity);
+		public Task<int> DeleteAsync(TEntity entity) => _set.RemoveAffrowsAsync(entity);
+		public int Delete(IEnumerable<TEntity> entitys) => _set.RemoveRangeAffrows(entitys);
+		public Task<int> DeleteAsync(IEnumerable<TEntity> entitys) => _set.RemoveRangeAffrowsAsync(entitys);
+
+		public virtual TEntity Insert(TEntity entity) {
+			_set.Add(entity);
+			return entity;
+		}
+		public virtual List<TEntity> Insert(IEnumerable<TEntity> entitys) {
+			_set.AddRange(entitys);
+			return entitys.ToList();
+		}
+		async public virtual Task<TEntity> InsertAsync(TEntity entity) {
+			await _set.AddAsync(entity);
+			return entity;
+		}
+		async public virtual Task<List<TEntity>> InsertAsync(IEnumerable<TEntity> entitys) {
+			await _set.AddRangeAsync(entitys);
+			return entitys.ToList();
+		}
+
+		public int Update(TEntity entity) => _set.UpdateAffrows(entity);
+		public Task<int> UpdateAsync(TEntity entity) => _set.UpdateAffrowsAsync(entity);
+		public int Update(IEnumerable<TEntity> entitys) => _set.UpdateRangeAffrows(entitys);
+		public Task<int> UpdateAsync(IEnumerable<TEntity> entitys) => _set.UpdateRangeAffrowsAsync(entitys);
+	}
+
+	public abstract class BaseRepository<TEntity, TKey> : BaseRepository<TEntity>, IRepository<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);
+			if (_set._statesInternal.ContainsKey(stateKey)) _set._statesInternal.Remove(stateKey);
+			return _set.OrmDeleteInternal(id).ExecuteAffrows();
+		}
+		public Task<int> DeleteAsync(TKey id) {
+			var stateKey = string.Concat(id);
+			if (_set._statesInternal.ContainsKey(stateKey)) _set._statesInternal.Remove(stateKey);
+			return _set.OrmDeleteInternal(id).ExecuteAffrowsAsync();
+		}
+
+		public TEntity Find(TKey id) => _set.OrmSelectInternal(id).ToOne();
+		public Task<TEntity> FindAsync(TKey id) => _set.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,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Text;
+using System.Threading.Tasks;
+
+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,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+using System.Threading.Tasks;
+
+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/IBasicRepository.cs

@@ -0,0 +1,32 @@
+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);
+
+		int Update(TEntity entity);
+		int Update(IEnumerable<TEntity> entitys);
+		Task<int> UpdateAsync(TEntity entity);
+		Task<int> UpdateAsync(IEnumerable<TEntity> entitys);
+
+		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> : IRepository
+		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);
+	}
+}

FreeSql.DbContext/Repository/Repository/IRepository.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+
+namespace FreeSql {
+
+	public interface IRepository {
+		Type EntityType { get; }
+	}
+
+	public interface IRepository<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 IRepository<TEntity, TKey> : IRepository<TEntity>, IReadOnlyRepository<TEntity, TKey>, IBasicRepository<TEntity, TKey>
+		where TEntity : class {
+	}
+}

FreeSql.DbContext/Repository/Repository/RepositoryDbSet.cs

@@ -0,0 +1,59 @@
+using FreeSql.Extensions.EntityUtil;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace FreeSql {
+	internal class RepositoryDbSet<TEntity> : DbSet<TEntity> where TEntity : class {
+
+		protected BaseRepository<TEntity> _repos;
+		public RepositoryDbSet(BaseRepository<TEntity> repos) {
+			_fsql = repos._fsql;
+			_uow = repos._uow;
+			_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(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(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/Repository/RepositoryUnitOfWork.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Text;
+
+namespace FreeSql {
+	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._uow = 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._uow = this;
+			return repos;
+		}
+	}
+}