tk/FreeSql
1
0
Fork 0
mirror of https://github.com/nsnail/FreeSql.git synced 2025-06-18 20:08:15 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
- 增加 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) 附加新的过滤器
```
This commit is contained in:
28810
2019-03-12 16:33:10 +08:00
parent dae8eb7a67
commit acf6fa0391
12 changed files with 221 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

147
FreeSql.Repository/Extenssions/AutofacExtenssions.cs
View File

@ -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) {