- 修改 FreeSql.Repository Autofac 注入方式，真正的实现全局过滤功能；

- 增加 FreeSql.Repository DataFilter 属性；
```csharp
repos.DataFilter.Disable("test") 临时禁用，不影响全部；
repos.DataFilter.DisableAll()
repos.DataFilter.Enable("test")
repos.DataFilter.EnableAll()
repos.DataFilter.Apply("name", a => a.Id > 1) 附加新的过滤器
```

Examples/repository_01/Startup.cs

@@ -67,8 +67,9 @@ namespace repository_01 {
 
 			var builder = new ContainerBuilder();
 
-			builder.RegisterFreeRepositoryAndFilter<Song>(() => a => a.Title == DateTime.Now.ToString() + System.Threading.Thread.CurrentThread.ManagedThreadId);
-			//builder.RegisterFreeGuidRepository<Song>(a => a.Id == 1, oldname => $"{oldname}_{DateTime.Now.Year}");
+			builder.RegisterFreeRepository(filter => 
+				filter.Apply<Song>("test", a => a.Title == DateTime.Now.ToString() + System.Threading.Thread.CurrentThread.ManagedThreadId)
+			);
 
 			builder.Populate(services);
 			var container = builder.Build();

FreeSql.Repository/BaseRepository.cs

@@ -9,18 +9,7 @@ namespace FreeSql {
 		where TEntity : class {
 
 		protected IFreeSql _fsql;
-
-		Expression<Func<TEntity, bool>> _filterVal;
-		protected Expression<Func<TEntity, bool>> Filter {
-			get => _filterVal;
-			set {
-				_filterVal = value;
-				FilterCompile = value?.Compile();
-			}
-		}
-		internal Expression<Func<TEntity, bool>> FilterInternal => Filter;
-		protected Func<TEntity, bool> FilterCompile { get; private set; }
-		internal Func<TEntity, bool> FilterCompileInternal => FilterCompile;
+		public IDataFilter<TEntity> DataFilter { get; } = new DataFilter<TEntity>();
 
 		Func<string, string> _asTableVal;
 		protected Func<string, string> AsTable {
@@ -36,35 +25,24 @@ namespace FreeSql {
 		protected Type EntityType { get; } = typeof(TEntity);
 
 		protected BaseRepository(IFreeSql fsql, Expression<Func<TEntity, bool>> filter, Func<string, string> asTable = null) : base() {
-			_fsql = fsql ?? throw new NullReferenceException("fsql 参数不可为空");
-			Filter = filter;
+			_fsql = fsql ?? throw new NullReferenceException(nameof(fsql));
+			DataFilter.Apply("", filter);
 			AsTable = asTable;
 		}
 
-		public ISelect<TEntity> Select => _fsql.Select<TEntity>().Where(Filter).AsTable(AsTableSelect);
+		public ISelect<TEntity> Select => OrmSelect(null);
+		public IUpdate<TEntity> UpdateDiy => OrmUpdate(null);
 
-		public IUpdate<TEntity> UpdateDiy => _fsql.Update<TEntity>().Where(Filter).AsTable(AsTable);
-
-		public int Delete(Expression<Func<TEntity, bool>> predicate) => _fsql.Delete<TEntity>().Where(Filter).Where(predicate).AsTable(AsTable).ExecuteAffrows();
-
-		public int Delete(TEntity entity) {
-			ValidatorEntityAndThrow(entity);
-			return _fsql.Delete<TEntity>(entity).Where(Filter).AsTable(AsTable).ExecuteAffrows();
-		}
-
-		public Task<int> DeleteAsync(Expression<Func<TEntity, bool>> predicate) => _fsql.Delete<TEntity>().Where(Filter).Where(predicate).AsTable(AsTable).ExecuteAffrowsAsync();
-
-		public Task<int> DeleteAsync(TEntity entity) {
-			ValidatorEntityAndThrow(entity);
-			return _fsql.Delete<TEntity>(entity).Where(Filter).AsTable(AsTable).ExecuteAffrowsAsync();
-		}
+		public int Delete(Expression<Func<TEntity, bool>> predicate) => OrmDelete(null).Where(predicate).ExecuteAffrows();
+		public int Delete(TEntity entity) => OrmDelete(entity).ExecuteAffrows();
+		public Task<int> DeleteAsync(Expression<Func<TEntity, bool>> predicate) => OrmDelete(null).Where(predicate).ExecuteAffrowsAsync();
+		public Task<int> DeleteAsync(TEntity entity) => OrmDelete(entity).ExecuteAffrowsAsync();
 
 		public virtual TEntity Insert(TEntity entity) {
-			ValidatorEntityAndThrow(entity);
 			switch (_fsql.Ado.DataType) {
 				case DataType.SqlServer:
 				case DataType.PostgreSQL:
-					return _fsql.Insert<TEntity>().AppendData(entity).AsTable(AsTable).ExecuteInserted().FirstOrDefault();
+					return OrmInsert(entity).ExecuteInserted().FirstOrDefault();
 				case DataType.MySql:
 				case DataType.Oracle:
 				case DataType.Sqlite:
@@ -72,13 +50,11 @@ namespace FreeSql {
 					throw new NotImplementedException($"{_fsql.Ado.DataType}不支持类似returning或output类型的特性，请参考FreeSql插入数据的方法重新实现。");
 			}
 		}
-
 		public virtual List<TEntity> Insert(IEnumerable<TEntity> entitys) {
-			ValidatorEntityAndThrow(entitys);
 			switch (_fsql.Ado.DataType) {
 				case DataType.SqlServer:
 				case DataType.PostgreSQL:
-					return _fsql.Insert<TEntity>().AppendData(entitys).AsTable(AsTable).ExecuteInserted();
+					return OrmInsert(entitys).ExecuteInserted();
 				case DataType.MySql:
 				case DataType.Oracle:
 				case DataType.Sqlite:
@@ -86,13 +62,11 @@ namespace FreeSql {
 					throw new NotImplementedException($"{_fsql.Ado.DataType}不支持类似returning或output类型的特性，请参考FreeSql插入数据的方法重新实现。");
 			}
 		}
-
 		async public virtual Task<TEntity> InsertAsync(TEntity entity) {
-			ValidatorEntityAndThrow(entity);
 			switch (_fsql.Ado.DataType) {
 				case DataType.SqlServer:
 				case DataType.PostgreSQL:
-					return (await _fsql.Insert<TEntity>().AppendData(entity).AsTable(AsTable).ExecuteInsertedAsync()).FirstOrDefault();
+					return (await OrmInsert(entity).ExecuteInsertedAsync()).FirstOrDefault();
 				case DataType.MySql:
 				case DataType.Oracle:
 				case DataType.Sqlite:
@@ -100,13 +74,11 @@ namespace FreeSql {
 					throw new NotImplementedException($"{_fsql.Ado.DataType}不支持类似returning或output类型的特性，请参考FreeSql插入数据的方法重新实现。");
 			}
 		}
-
 		public virtual Task<List<TEntity>> InsertAsync(IEnumerable<TEntity> entitys) {
-			ValidatorEntityAndThrow(entitys);
 			switch (_fsql.Ado.DataType) {
 				case DataType.SqlServer:
 				case DataType.PostgreSQL:
-					return _fsql.Insert<TEntity>().AppendData(entitys).AsTable(AsTable).ExecuteInsertedAsync();
+					return OrmInsert(entitys).ExecuteInsertedAsync();
 				case DataType.MySql:
 				case DataType.Oracle:
 				case DataType.Sqlite:
@@ -115,22 +87,45 @@ namespace FreeSql {
 			}
 		}
 
-		public int Update(TEntity entity) {
-			ValidatorEntityAndThrow(entity);
-			return _fsql.Update<TEntity>().SetSource(entity).Where(Filter).AsTable(AsTable).ExecuteAffrows();
-		}
+		public int Update(TEntity entity) => OrmUpdate(entity).ExecuteAffrows();
+		public Task<int> UpdateAsync(TEntity entity) => OrmUpdate(entity).ExecuteAffrowsAsync();
 
-		public Task<int> UpdateAsync(TEntity entity) {
-			ValidatorEntityAndThrow(entity);
-			return _fsql.Update<TEntity>().SetSource(entity).Where(Filter).AsTable(AsTable).ExecuteAffrowsAsync();
+		protected ISelect<TEntity> OrmSelect(object dywhere) {
+			var select = _fsql.Select<TEntity>(dywhere);
+			var filters = (DataFilter as DataFilter<TEntity>)._filters.Where(a => a.Value.IsEnabled == true);
+			foreach (var filter in filters) select.Where(filter.Value.Expression);
+			return select.AsTable(AsTableSelect);
 		}
-
-		protected void ValidatorEntityAndThrow(TEntity entity) => ValidatorEntityAndThrow(new[] { entity });
-		protected virtual void ValidatorEntityAndThrow(IEnumerable<TEntity> entitys) {
-			foreach (var entity in entitys) {
-				if (FilterCompile?.Invoke(entity) == false) throw new Exception($"FreeSql.Repository Insert 失败，因为设置了 {Filter}，插入的数据不符合");
+		protected IUpdate<TEntity> OrmUpdate(object dywhere) {
+			var entityObj = dywhere as TEntity;
+			var update = _fsql.Update<TEntity>(dywhere);
+			var filters = (DataFilter as DataFilter<TEntity>)._filters.Where(a => a.Value.IsEnabled == true);
+			foreach (var filter in filters) {
+				if (entityObj != null && filter.Value.ExpressionDelegate?.Invoke(entityObj) == false)
+					throw new Exception($"FreeSql.Repository Update 失败，因为设置了 {filter.Key}: {filter.Value.Expression}，更新的数据不符合");
+				update.Where(filter.Value.Expression);
 			}
+			return update.AsTable(AsTable);
 		}
+		protected IDelete<TEntity> OrmDelete(object dywhere) {
+			var delete = _fsql.Delete<TEntity>(dywhere);
+			var filters = (DataFilter as DataFilter<TEntity>)._filters.Where(a => a.Value.IsEnabled == true);
+			foreach (var filter in filters) delete.Where(filter.Value.Expression);
+			return delete.AsTable(AsTable);
+		}
+		protected IInsert<TEntity> OrmInsert(TEntity entity) => OrmInsert(new[] { entity });
+		protected IInsert<TEntity> OrmInsert(IEnumerable<TEntity> entitys) {
+			var insert = _fsql.Insert<TEntity>(entitys);
+			var filters = (DataFilter as DataFilter<TEntity>)._filters.Where(a => a.Value.IsEnabled == true);
+			foreach (var filter in filters) {
+				foreach (var entity in entitys)
+					if (entity != null && filter.Value.ExpressionDelegate?.Invoke(entity) == false)
+						throw new Exception($"FreeSql.Repository Insert 失败，因为设置了 {filter.Key}: {filter.Value.Expression}，插入的数据不符合");
+			}
+			return insert.AsTable(AsTable);
+		}
+
+		protected void ApplyDataFilter(string name, Expression<Func<TEntity, bool>> exp) => DataFilter.Apply(name, exp);
 	}
 
 	public abstract class BaseRepository<TEntity, TKey> : BaseRepository<TEntity>, IRepository<TEntity, TKey>
@@ -139,16 +134,13 @@ namespace FreeSql {
 		public BaseRepository(IFreeSql fsql, Expression<Func<TEntity, bool>> filter, Func<string, string> asTable = null) : base(fsql, filter, asTable) {
 		}
 
-		public int Delete(TKey id) => _fsql.Delete<TEntity>(id).Where(Filter).AsTable(AsTable).ExecuteAffrows();
+		public int Delete(TKey id) => OrmDelete(id).ExecuteAffrows();
+		public Task<int> DeleteAsync(TKey id) => OrmDelete(id).ExecuteAffrowsAsync();
 
-		public Task<int> DeleteAsync(TKey id) => _fsql.Delete<TEntity>(id).Where(Filter).AsTable(AsTable).ExecuteAffrowsAsync();
-
-		public TEntity Find(TKey id) => _fsql.Select<TEntity>(id).Where(Filter).AsTable(AsTableSelect).ToOne();
-
-		public Task<TEntity> FindAsync(TKey id) => _fsql.Select<TEntity>(id).Where(Filter).AsTable(AsTableSelect).ToOneAsync();
+		public TEntity Find(TKey id) => OrmSelect(id).ToOne();
+		public Task<TEntity> FindAsync(TKey id) => OrmSelect(id).ToOneAsync();
 
 		public TEntity Get(TKey id) => Find(id);
-
 		public Task<TEntity> GetAsync(TKey id) => FindAsync(id);
 	}
 }

FreeSql.Repository/DataFilter.cs

@@ -0,0 +1,92 @@
+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> where TEntity : class {
+
+		IDataFilter<TEntity> Apply(string filterName, Expression<Func<TEntity, bool>> filterAndValidateExp);
+
+		IDataFilter<TEntity> Enable(params string[] filterName);
+		IDataFilter<TEntity> EnableAll();
+
+		IDataFilter<TEntity> Disable(params string[] filterName);
+		IDataFilter<TEntity> 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 IDataFilter<TEntity> Disable(params string[] filterName) {
+			if (filterName == null || filterName.Any() == false) return this;
+
+			foreach (var name in filterName) {
+				if (_filters.TryGetValue(name, out var tryfi))
+					tryfi.IsEnabled = false;
+			}
+			return this;
+		}
+		public IDataFilter<TEntity> DisableAll() {
+			foreach (var val in _filters.Values.ToArray())
+				val.IsEnabled = false;
+			return this;
+		}
+
+		public IDataFilter<TEntity> Enable(params string[] filterName) {
+			if (filterName == null || filterName.Any() == false) return this;
+
+			foreach (var name in filterName) {
+				if (_filters.TryGetValue(name, out var tryfi))
+					tryfi.IsEnabled = true;
+			}
+			return this;
+		}
+		public IDataFilter<TEntity> EnableAll() {
+			foreach (var val in _filters.Values.ToArray())
+				val.IsEnabled = true;
+			return this;
+		}
+
+		public bool IsEnabled(string filterName) {
+			if (filterName == null) return false;
+			return _filters.TryGetValue(filterName, out var tryfi) ? tryfi.IsEnabled : false;
+		}
+	}
+
+	public class GlobalDataFilter {
+
+		internal List<(Type type, string name, LambdaExpression exp)> _filters = new List<(Type type, string name, LambdaExpression exp)>();
+
+		public GlobalDataFilter 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;
+		}
+	}
+}

FreeSql.Repository/Extenssions/AutofacExtenssions.cs

@@ -5,41 +5,62 @@ using System.Collections.Generic;
 using System.Collections.Concurrent;
 using System.Linq.Expressions;
 using System.Reflection;
+using System.Linq;
 
 public static class FreeSqlRepositoryAutofacExtenssions {
 
-	public static void RegisterFreeRepository(this ContainerBuilder builder) => RegisterFreeRepositoryPrivate<bool>(builder, null, null);
-	public static void RegisterFreeRepositoryAndFilter<TEntity>(this ContainerBuilder builder, Func<Expression<Func<TEntity, bool>>> filterHandler) => RegisterFreeRepositoryPrivate<TEntity>(builder, filterHandler, null);
+	public static void RegisterFreeRepository(this ContainerBuilder builder, Action<GlobalDataFilter> globalDataFilter) => RegisterFreeRepositoryPrivate(builder, globalDataFilter);
 
-	static ConcurrentDictionary<Type, Delegate> _dicRegisterFreeRepositorySetFilterFunc = new ConcurrentDictionary<Type, Delegate>();
-	static ConcurrentDictionary<Type, Delegate> _dicRegisterFreeRepositorySetAsTableFunc = new ConcurrentDictionary<Type, Delegate>();
-	static void RegisterFreeRepositoryPrivate<TEntity>(ContainerBuilder builder, Func<Expression<Func<TEntity, bool>>> filterHandler, Func<string, string> asTableHandler) {
+	static ConcurrentDictionary<Type, Delegate> _dicRegisterFreeRepositoryPrivateSetFilterFunc = new ConcurrentDictionary<Type, Delegate>();
+	static ConcurrentDictionary<Type, ConcurrentDictionary<string, bool>> _dicRegisterFreeRepositoryPrivateConvertFilterNotExists = new ConcurrentDictionary<Type, ConcurrentDictionary<string, bool>>();
+	static void RegisterFreeRepositoryPrivate(ContainerBuilder builder, Action<GlobalDataFilter> globalDataFilter) {
 
-		Func<Type, Delegate> setFilterFunc = reposType => _dicRegisterFreeRepositorySetFilterFunc.GetOrAdd(reposType, type => { 
-			var reposParameter = Expression.Parameter(type);
-			var fitlerParameter = Expression.Parameter(typeof(Expression<>).MakeGenericType(typeof(Func<,>).MakeGenericType(type.GenericTypeArguments[0], typeof(bool))));
-			return Expression.Lambda(
-				Expression.Block(
-					Expression.Call(reposParameter, type.GetMethod("set_Filter", BindingFlags.Instance | BindingFlags.NonPublic), fitlerParameter)
-				),
-				new[] {
-					reposParameter, fitlerParameter
-				}
-			).Compile();
-		});
-		Func<Type, LambdaExpression> convertFilter = type => {
-			var filter = filterHandler?.Invoke();
-			if (filter == null) return null;
+		Action<object> funcSetDataFilter = instance => {
+			if (globalDataFilter == null) return;
+			var globalFilter = new GlobalDataFilter();
+			globalDataFilter(globalFilter);
+
+			var type = instance.GetType();
 			var entityType = type.GenericTypeArguments[0];
-			var filterParameter1 = Expression.Parameter(entityType, filter.Parameters[0].Name);
-			try {
-				return Expression.Lambda(
-					typeof(Func<,>).MakeGenericType(entityType, typeof(bool)),
-					new ReplaceVisitor<TEntity>().Modify(filter.Body, filterParameter1),
-					filterParameter1
+
+			var notExists = _dicRegisterFreeRepositoryPrivateConvertFilterNotExists.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, gf.exp);
+			}
+			if (newFilter.Any() == false) return;
+
+			var del = _dicRegisterFreeRepositoryPrivateSetFilterFunc.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)))
 				);
-			} catch {
-				return null;
+				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(instance, nf.Key, nf.Value);
 			}
 		};
 
@@ -49,10 +70,7 @@ public static class FreeSqlRepositoryAutofacExtenssions {
 			typeof(IBasicRepository<>),
 			typeof(IReadOnlyRepository<>)
 		).OnActivating(a => {
-			if (filterHandler != null) {
-				var type = a.Instance.GetType();
-				setFilterFunc(type)?.DynamicInvoke(a.Instance, convertFilter(type));
-			}
+			funcSetDataFilter(a.Instance);
 		}).InstancePerDependency();
 
 		builder.RegisterGeneric(typeof(DefaultRepository<,>)).As(
@@ -61,72 +79,11 @@ public static class FreeSqlRepositoryAutofacExtenssions {
 			typeof(IBasicRepository<,>),
 			typeof(IReadOnlyRepository<,>)
 		).OnActivating(a => {
-			if (filterHandler != null) {
-				var type = a.Instance.GetType();
-				setFilterFunc(type)?.DynamicInvoke(a.Instance, convertFilter(type));
-			}
+			funcSetDataFilter(a.Instance);
 		}).InstancePerDependency();
 	}
 
-	//static void RegisterRepository<TEntity>(this ContainerBuilder builder, Expression<Func<TEntity, bool>> filter, Func<string, string> asTable, int regType) {
-
-	//	Func<Type, LambdaExpression> reposFunc = type => {
-	//		var entityType = type.GenericTypeArguments[0];
-	//		var filterParameter1 = Expression.Parameter(entityType, filter.Parameters[0].Name);
-	//		var convertFilter = Expression.Lambda(
-	//			typeof(Func<,>).MakeGenericType(entityType, typeof(bool)),
-	//			new ReplaceVisitor<TEntity>().Modify(filter.Body, filterParameter1),
-	//			filterParameter1
-	//		);
-	//		var repos = Expression.Parameter(type);
-	//		var blocks = new List<Expression>();
-	//		if (filter != null) blocks.Add(Expression.Call(repos, type.GetMethod("set_Filter", BindingFlags.Instance | BindingFlags.NonPublic), Expression.Constant(convertFilter)));
-	//		if (asTable != null) blocks.Add(Expression.Call(repos, type.GetMethod("set_AsTable", BindingFlags.Instance | BindingFlags.NonPublic), Expression.Constant(asTable)));
-	//		return Expression.Lambda(
-	//			//Expression.New(
-	//			//	typeof(GuidRepository<>).MakeGenericType(type.GenericTypeArguments).GetConstructors()[1],
-	//			//	Expression.Constant(a.Context.Resolve<IFreeSql>()),
-	//			//	Expression.Constant(convertFilter),
-	//			//	Expression.Constant(asTable)
-	//			//)
-	//			Expression.Block(blocks),
-	//			repos
-	//		);
-	//	};
-
-	//	if (regType == 1)
-	//		builder.RegisterGeneric(typeof(GuidRepository<>)).As(
-	//			typeof(GuidRepository<>),
-	//			typeof(BaseRepository<>), typeof(BaseRepository<,>),
-	//			typeof(IBasicRepository<>), typeof(IBasicRepository<,>),
-	//			typeof(IReadOnlyRepository<>), typeof(IReadOnlyRepository<,>)
-	//		).OnActivating(a => {
-	//			if (filter != null)
-	//				_dicAddGuidRepositoryFunc.GetOrAdd(a.Instance.GetType(), t => {
-	//					try { reposFunc(t).Compile(); } catch { }
-	//					return null;
-	//				})?.DynamicInvoke(a.Instance);
-	//		}).InstancePerDependency();
-
-
-	//	if (regType == 2)
-	//		builder.RegisterGeneric(typeof(DefaultRepository<,>)).As(
-	//			typeof(DefaultRepository<,>),
-	//			typeof(BaseRepository<,>),
-	//			typeof(IBasicRepository<,>),
-	//			typeof(IReadOnlyRepository<,>)
-	//		).OnActivating(a => {
-	//			if (filter != null)
-	//				_dicAddGuidRepositoryFunc.GetOrAdd(a.Instance.GetType(), t => {
-	//					try { reposFunc(t).Compile(); } catch { }
-	//					return null;
-	//				})?.DynamicInvoke(a.Instance);
-	//		}).InstancePerDependency();
-	//}
-
-	//static ConcurrentDictionary<Type, Delegate> _dicAddGuidRepositoryFunc = new ConcurrentDictionary<Type, Delegate>();
-
-	class ReplaceVisitor<TEntity1> : ExpressionVisitor {
+	class ReplaceVisitor : ExpressionVisitor {
 		private ParameterExpression parameter;
 
 		public Expression Modify(Expression expression, ParameterExpression parameter) {

FreeSql.Repository/Extenssions/IFreeSqlExtenssions.cs

@@ -4,6 +4,7 @@ using System.Collections.Generic;
 using System.Collections.Concurrent;
 using System.Text;
 using System.Linq.Expressions;
+using System.Linq;
 
 public static class FreeSqlRepositoryIFreeSqlExtenssions {
 
@@ -44,7 +45,7 @@ public static class FreeSqlRepositoryIFreeSqlExtenssions {
 	static ConcurrentDictionary<Type, IRepository> dicGetGuidRepository = new ConcurrentDictionary<Type, IRepository>();
 
 	/// <summary>
-	/// 合并两个仓储的设置，以便查询
+	/// 合并两个仓储的设置（过滤+分表），以便查询
 	/// </summary>
 	/// <typeparam name="TEntity"></typeparam>
 	/// <typeparam name="T2"></typeparam>
@@ -52,6 +53,8 @@ public static class FreeSqlRepositoryIFreeSqlExtenssions {
 	/// <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 {
-		return that.AsTable(repos.AsTableSelectInternal).Where<T2>(repos.FilterInternal);
+		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);
 	}
 }

FreeSql.Repository/FreeSql.Repository.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
-    <Version>0.3.12</Version>
+    <Version>0.3.13</Version>
     <Authors>YeXiangQin</Authors>
     <Description>FreeSql 通用仓库层实现，支持 MySql/SqlServer/PostgreSQL/Oracle/Sqlite，读写分离、分表分库。</Description>
     <PackageProjectUrl>https://github.com/2881099/FreeSql</PackageProjectUrl>

FreeSql.Repository/GuidRepository.cs

@@ -17,26 +17,20 @@ namespace FreeSql {
 		}
 
 		public override List<TEntity> Insert(IEnumerable<TEntity> entity) {
-			base.ValidatorEntityAndThrow(entity);
-			_fsql.Insert<TEntity>().AppendData(entity).AsTable(AsTable).ExecuteAffrows();
+			OrmInsert(entity).ExecuteAffrows();
 			return entity.ToList();
 		}
-
 		async public override Task<List<TEntity>> InsertAsync(IEnumerable<TEntity> entity) {
-			base.ValidatorEntityAndThrow(entity);
-			await _fsql.Insert<TEntity>().AppendData(entity).AsTable(AsTable).ExecuteAffrowsAsync();
+			await OrmInsert(entity).ExecuteAffrowsAsync();
 			return entity.ToList();
 		}
 
 		public override TEntity Insert(TEntity entity) {
-			base.ValidatorEntityAndThrow(entity);
-			_fsql.Insert<TEntity>().AppendData(entity).AsTable(AsTable).ExecuteAffrows();
+			OrmInsert(entity).ExecuteAffrows();
 			return entity;
 		}
-
 		async public override Task<TEntity> InsertAsync(TEntity entity) {
-			base.ValidatorEntityAndThrow(entity);
-			await _fsql.Insert<TEntity>().AppendData(entity).AsTable(AsTable).ExecuteAffrowsAsync();
+			await OrmInsert(entity).ExecuteAffrowsAsync();
 			return entity;
 		}
 	}

FreeSql.Repository/IReadOnlyRepository.cs

@@ -4,6 +4,8 @@ namespace FreeSql {
 	public interface IReadOnlyRepository<TEntity> : IRepository
 		where TEntity : class {
 
+		IDataFilter<TEntity> DataFilter { get; }
+
 		ISelect<TEntity> Select { get; }
 	}
 

FreeSql/FreeSql.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
-    <Version>0.3.12</Version>
+    <Version>0.3.13</Version>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <Authors>YeXiangQin</Authors>
     <Description>打造 .NETCore 最方便的 ORM，DbFirst 与 CodeFirst 混合使用，提供从实体同步数据库，或者从数据库生成实体代码，支持 MySql/SqlServer/PostgreSQL/Oracle/Sqlite，读写分离、分表分库。</Description>

FreeSql/Internal/CommonProvider/AdoProvider/AdoProvider.cs

@@ -78,6 +78,7 @@ namespace FreeSql.Internal.CommonProvider {
 		public List<T> Query<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => Query<T>(null, cmdType, cmdText, cmdParms);
 		public List<T> Query<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
 			var ret = new List<T>();
+			if (string.IsNullOrEmpty(cmdText)) return ret;
 			var type = typeof(T);
 			int[] indexes = null;
 			var props = dicQueryTypeGetProperties.GetOrAdd(type, k => type.GetProperties());
@@ -96,6 +97,7 @@ namespace FreeSql.Internal.CommonProvider {
 		public void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, string cmdText, object parms = null) => ExecuteReader(transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
 		public void ExecuteReader(Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReader(null, readerHander, cmdType, cmdText, cmdParms);
 		public void ExecuteReader(DbTransaction transaction, Action<DbDataReader> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
+			if (string.IsNullOrEmpty(cmdText)) return;
 			var dt = DateTime.Now;
 			var logtxt = new StringBuilder();
 			var logtxt_dt = DateTime.Now;
@@ -218,6 +220,7 @@ namespace FreeSql.Internal.CommonProvider {
 		public int ExecuteNonQuery(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQuery(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
 		public int ExecuteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQuery(null, cmdType, cmdText, cmdParms);
 		public int ExecuteNonQuery(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
+			if (string.IsNullOrEmpty(cmdText)) return 0;
 			var dt = DateTime.Now;
 			var logtxt = new StringBuilder();
 			var logtxt_dt = DateTime.Now;
@@ -245,6 +248,7 @@ namespace FreeSql.Internal.CommonProvider {
 		public object ExecuteScalar(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalar(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
 		public object ExecuteScalar(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalar(null, cmdType, cmdText, cmdParms);
 		public object ExecuteScalar(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
+			if (string.IsNullOrEmpty(cmdText)) return null;
 			var dt = DateTime.Now;
 			var logtxt = new StringBuilder();
 			var logtxt_dt = DateTime.Now;

FreeSql/Internal/CommonProvider/AdoProvider/AdoProviderAsync.cs

@@ -14,6 +14,7 @@ namespace FreeSql.Internal.CommonProvider {
 		public Task<List<T>> QueryAsync<T>(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => QueryAsync<T>(null, cmdType, cmdText, cmdParms);
 		async public Task<List<T>> QueryAsync<T>(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
 			var ret = new List<T>();
+			if (string.IsNullOrEmpty(cmdText)) return ret;
 			var type = typeof(T);
 			int[] indexes = null;
 			var props = dicQueryTypeGetProperties.GetOrAdd(type, k => type.GetProperties());
@@ -33,6 +34,7 @@ namespace FreeSql.Internal.CommonProvider {
 		public Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, string cmdText, object parms = null) => ExecuteReaderAsync(transaction, readerHander, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
 		public Task ExecuteReaderAsync(Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteReaderAsync(null, readerHander, cmdType, cmdText, cmdParms);
 		async public Task ExecuteReaderAsync(DbTransaction transaction, Func<DbDataReader, Task> readerHander, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
+			if (string.IsNullOrEmpty(cmdText)) return;
 			var dt = DateTime.Now;
 			var logtxt = new StringBuilder();
 			var logtxt_dt = DateTime.Now;
@@ -155,6 +157,7 @@ namespace FreeSql.Internal.CommonProvider {
 		public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteNonQueryAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
 		public Task<int> ExecuteNonQueryAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteNonQueryAsync(null, cmdType, cmdText, cmdParms);
 		async public Task<int> ExecuteNonQueryAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
+			if (string.IsNullOrEmpty(cmdText)) return 0;
 			var dt = DateTime.Now;
 			var logtxt = new StringBuilder();
 			var logtxt_dt = DateTime.Now;
@@ -182,6 +185,7 @@ namespace FreeSql.Internal.CommonProvider {
 		public Task<object> ExecuteScalarAsync(DbTransaction transaction, string cmdText, object parms = null) => ExecuteScalarAsync(transaction, CommandType.Text, cmdText, GetDbParamtersByObject(cmdText, parms));
 		public Task<object> ExecuteScalarAsync(CommandType cmdType, string cmdText, params DbParameter[] cmdParms) => ExecuteScalarAsync(null, cmdType, cmdText, cmdParms);
 		async public Task<object> ExecuteScalarAsync(DbTransaction transaction, CommandType cmdType, string cmdText, params DbParameter[] cmdParms) {
+			if (string.IsNullOrEmpty(cmdText)) return null;
 			var dt = DateTime.Now;
 			var logtxt = new StringBuilder();
 			var logtxt_dt = DateTime.Now;

FreeSql/Internal/CommonProvider/CacheProvider.cs

@@ -25,7 +25,7 @@ namespace FreeSql.Internal.CommonProvider {
 			try { Cache.Remove($"{key1}|{key2}"); } catch { } // redis-cluster 不允许执行 multi keys 命令
 			CacheSupportMultiRemove = Cache.Get(key1) == null && cache.Get(key2) == null;
 			if (CacheSupportMultiRemove == false) {
-				log.LogWarning("FreeSql Warning: 低性能, IDistributedCache 没实现批量删除缓存 Cache.Remove(\"key1|key2\").");
+				//log.LogWarning("FreeSql Warning: 低性能, IDistributedCache 没实现批量删除缓存 Cache.Remove(\"key1|key2\").");
 				Remove(key1, key2);
 			}
 		}