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

- 增加 DbContext/Repository ManyToMany联级保存功能（之前已支持OneToMany）；

Browse Source
This commit is contained in:
28810
2019-09-29 15:02:08 +08:00
parent 7514000490
commit 33cb3e2dae
11 changed files with 435 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
FreeSql.DbContext/DbContext/DbContext.cs
View File

@ -148,14 +148,15 @@ namespace FreeSql
public ExecCommandInfoType actionType { get; set; }
public IDbSet dbSet { get; set; }
public Type stateType { get; set; }
public Type entityType { get; set; }
public object state { get; set; }
}
internal enum ExecCommandInfoType { Insert, Update, Delete }
Queue<ExecCommandInfo> _actions = new Queue<ExecCommandInfo>();
internal int _affrows = 0;
internal void EnqueueAction(ExecCommandInfoType actionType, IDbSet dbSet, Type stateType, object state) =>
_actions.Enqueue(new ExecCommandInfo { actionType = actionType, dbSet = dbSet, stateType = stateType, state = state });
internal void EnqueueAction(ExecCommandInfoType actionType, IDbSet dbSet, Type stateType, Type entityType, object state) =>
_actions.Enqueue(new ExecCommandInfo { actionType = actionType, dbSet = dbSet, stateType = stateType, entityType = entityType, state = state });
#endregion
~DbContext() => this.Dispose();

5
FreeSql.DbContext/DbContext/DbContextAsync.cs
View File

@ -97,10 +97,11 @@ namespace FreeSql
if (_actions.Any() == false && states.Any() ||
info != null && oldinfo.actionType != info.actionType ||
info != null && oldinfo.stateType != info.stateType)
info != null && oldinfo.stateType != info.stateType ||
info != null && oldinfo.entityType != info.entityType)
{
if (info != null && oldinfo.actionType == info.actionType && oldinfo.stateType == info.stateType)
if (info != null && oldinfo.actionType == info.actionType && oldinfo.stateType == info.stateType && oldinfo.entityType == info.entityType)
{
//最后一个，合起来发送
states.Add(info.state);

11
FreeSql.DbContext/DbContext/DbContextOptions.cs
View File

@ -5,7 +5,16 @@ namespace FreeSql
{
/// <summary>
/// 是否开启一对多，联级保存功能
/// 是否开启一对多，多对多联级保存功能<para></para>
/// <para></para>
/// 【一对多】模型下， 保存时可联级保存实体的属性集合。出于使用安全考虑我们没做完整对比，只实现实体属性集合的添加或更新操作，所以不会删除实体属性集合的数据。<para></para>
/// 完整对比的功能使用起来太危险，试想下面的场景：<para></para>
/// - 保存的时候，实体的属性集合是空的，如何操作？记录全部删除？<para></para>
/// - 保存的时候，由于数据库中记录非常之多，那么只想保存子表的部分数据，或者只需要添加，如何操作？<para></para>
/// <para></para>
/// 【多对多】模型下，我们对中间表的保存是完整对比操作，对外部实体的操作只作新增（注意不会更新）
/// - 属性集合为空时，删除他们的所有关联数据（中间表）
/// - 属性集合不为空时，与数据库存在的关联数据（中间表）完全对比，计算出应该删除和添加的记录
/// </summary>
public bool EnableAddOrUpdateNavigateList { get; set; } = true;
}

5
FreeSql.DbContext/DbContext/DbContextSync.cs
View File

@ -97,10 +97,11 @@ namespace FreeSql
if (_actions.Any() == false && states.Any() ||
info != null && oldinfo.actionType != info.actionType ||
info != null && oldinfo.stateType != info.stateType)
info != null && oldinfo.stateType != info.stateType ||
info != null && oldinfo.entityType != info.entityType)
{
if (info != null && oldinfo.actionType == info.actionType && oldinfo.stateType == info.stateType)
if (info != null && oldinfo.actionType == info.actionType && oldinfo.stateType == info.stateType && oldinfo.entityType == info.entityType)
{
//最后一个，合起来发送
states.Add(info.state);

7
FreeSql.DbContext/DbSet/DbSet.cs
View File

@ -60,7 +60,7 @@ namespace FreeSql
protected virtual IDelete<TEntity> OrmDelete(object dywhere) => _db.Orm.Delete<TEntity>().AsType(_entityType).WithTransaction(_uow?.GetOrBeginTransaction()).WhereDynamic(dywhere);
internal void EnqueueToDbContext(DbContext.ExecCommandInfoType actionType, EntityState state) =>
_db.EnqueueAction(actionType, this, typeof(EntityState), state);
_db.EnqueueAction(actionType, this, typeof(EntityState), _entityType, state);
internal void IncrAffrows(int affrows) =>
_db._affrows += affrows;
@ -117,14 +117,15 @@ namespace FreeSql
/// </summary>
/// <param name="entityType"></param>
/// <returns></returns>
public void AsType(Type entityType)
public DbSet<TEntity> AsType(Type entityType)
{
if (entityType == typeof(object)) throw new Exception("ISelect.AsType 参数不支持指定为 object");
if (entityType == _entityType) return;
if (entityType == _entityType) return this;
var newtb = _db.Orm.CodeFirst.GetTableByEntity(entityType);
_entityType = entityType;
_tablePriv = newtb ?? throw new Exception("DbSet.AsType 参数错误，请传入正确的实体类型");
_tableIdentitysPriv = null;
return this;
}
public class EntityState

140
FreeSql.DbContext/DbSet/DbSetAsync.cs
View File

@ -4,6 +4,8 @@ using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Threading.Tasks;
namespace FreeSql
@ -131,46 +133,132 @@ namespace FreeSql
{
if (_table.ColumnsByCsIgnore.ContainsKey(prop.Key)) continue;
if (_table.ColumnsByCs.ContainsKey(prop.Key)) continue;
var tref = _table.GetTableRef(prop.Key, true);
if (tref == null) continue;
switch (tref.RefType)
{
case Internal.Model.TableRefType.OneToOne:
case Internal.Model.TableRefType.ManyToOne:
case Internal.Model.TableRefType.ManyToMany:
continue;
case Internal.Model.TableRefType.OneToMany:
if (itemType == null) itemType = item.GetType();
if (_table.TypeLazy != null && itemType == _table.TypeLazy)
{
var lazyField = _dicLazyIsSetField.GetOrAdd(_table.TypeLazy, tl => new ConcurrentDictionary<string, System.Reflection.FieldInfo>()).GetOrAdd(prop.Key, propName =>
_table.TypeLazy.GetField($"__lazy__{propName}", System.Reflection.BindingFlags.GetField | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance));
if (lazyField != null)
{
var lazyFieldValue = (bool)lazyField.GetValue(item);
if (lazyFieldValue == false) continue;
}
}
var propVal = prop.Value.GetValue(item);
var propValEach = propVal as IEnumerable;
if (propValEach == null) continue;
object dbset = null;
System.Reflection.MethodInfo dbsetAddOrUpdate = null;
}
object propVal = null;
if (itemType == null) itemType = item.GetType();
if (_table.TypeLazy != null && itemType == _table.TypeLazy)
{
var lazyField = _dicLazyIsSetField.GetOrAdd(_table.TypeLazy, tl => new ConcurrentDictionary<string, FieldInfo>()).GetOrAdd(prop.Key, propName =>
_table.TypeLazy.GetField($"__lazy__{propName}", BindingFlags.GetField | BindingFlags.NonPublic | BindingFlags.Instance));
if (lazyField != null)
{
var lazyFieldValue = (bool)lazyField.GetValue(item);
if (lazyFieldValue == false) continue;
}
propVal = prop.Value.GetValue(item);
}
else
{
propVal = prop.Value.GetValue(item);
if (propVal == null) continue;
}
var propValEach = propVal as IEnumerable;
if (propValEach == null) continue;
DbSet<object> refSet = _db.Set<object>().AsType(tref.RefEntityType);
switch (tref.RefType)
{
case Internal.Model.TableRefType.ManyToMany:
var curList = new List<object>();
foreach (var propValItem in propValEach)
{
if (dbset == null)
curList.Add(propValItem);
var flagExists = refSet.ExistsInStates(propValItem);
if (flagExists == false)
flagExists = await refSet.Select.WhereDynamic(propValItem).AnyAsync();
if (refSet.CanAdd(propValItem, false) && flagExists != true)
await refSet.AddAsync(propValItem);
}
var midSelectParam = Expression.Parameter(typeof(object), "a");
var midWheres = new List<Expression<Func<object, bool>>>();
for (var colidx = 0; colidx < tref.Columns.Count; colidx++)
midWheres.Add(Expression.Lambda<Func<object, bool>>(Expression.Equal(
Expression.MakeMemberAccess(Expression.Convert(midSelectParam, tref.RefMiddleEntityType), tref.MiddleColumns[colidx].Table.Properties[tref.MiddleColumns[colidx].CsName]),
Expression.Constant(
FreeSql.Internal.Utils.GetDataReaderValue(
tref.MiddleColumns[colidx].CsType,
_db.Orm.GetEntityValueWithPropertyName(_table.Type, item, tref.Columns[colidx].CsName)), tref.MiddleColumns[colidx].CsType)
), midSelectParam));
if (curList.Any() == false) //全部删除
{
var delall = _db.Orm.Delete<object>().AsType(tref.RefMiddleEntityType);
foreach (var midWhere in midWheres) delall.Where(midWhere);
await delall.ExecuteAffrowsAsync();
}
else //保存
{
var midSet = _db.Set<object>().AsType(tref.RefMiddleEntityType);
var midSelect = midSet.Select;
foreach (var midWhere in midWheres) midSelect.Where(midWhere);
var midList = await midSelect.ToListAsync();
var midListDel = new List<object>();
var midListAdd = new List<object>();
foreach (var midItem in midList)
{
dbset = _db.Set(tref.RefEntityType);
dbsetAddOrUpdate = dbset.GetType().GetMethod("AddOrUpdateAsync", new Type[] { tref.RefEntityType });
var curContains = new List<int>();
for (var curIdx = 0; curIdx < curList.Count; curIdx++)
{
var isEquals = true;
for (var midcolidx = tref.Columns.Count; midcolidx < tref.MiddleColumns.Count; midcolidx++)
{
var refcol = tref.Columns[midcolidx - tref.Columns.Count];
var midval = FreeSql.Internal.Utils.GetDataReaderValue(refcol.CsType, _db.Orm.GetEntityValueWithPropertyName(tref.RefMiddleEntityType, midItem, tref.MiddleColumns[midcolidx].CsName));
var refval = FreeSql.Internal.Utils.GetDataReaderValue(refcol.CsType, _db.Orm.GetEntityValueWithPropertyName(tref.RefEntityType, curList[curIdx], tref.Columns[midcolidx - tref.Columns.Count].CsName));
if (object.Equals(midval, refval) == false)
{
isEquals = false;
break;
}
}
if (isEquals)
curContains.Add(curIdx);
}
if (curContains.Any())
foreach (var curIdx in curContains)
curList.RemoveAt(curIdx);
else
midListDel.Add(midItem);
}
midSet.RemoveRange(midListDel); //删除未保存的项
foreach (var curItem in curList)
{
var newItem = Activator.CreateInstance(tref.RefMiddleEntityType);
for (var colidx = 0; colidx < tref.Columns.Count; colidx++)
{
var val = FreeSql.Internal.Utils.GetDataReaderValue(tref.MiddleColumns[colidx].CsType, _db.Orm.GetEntityValueWithPropertyName(_table.Type, item, tref.Columns[colidx].CsName));
_db.Orm.SetEntityValueWithPropertyName(tref.RefMiddleEntityType, newItem, tref.MiddleColumns[colidx].CsName, val);
}
for (var midcolidx = tref.Columns.Count; midcolidx < tref.MiddleColumns.Count; midcolidx++)
{
var refcol = tref.Columns[midcolidx - tref.Columns.Count];
var refval = FreeSql.Internal.Utils.GetDataReaderValue(tref.MiddleColumns[midcolidx].CsType, _db.Orm.GetEntityValueWithPropertyName(tref.RefEntityType, curItem, refcol.CsName));
_db.Orm.SetEntityValueWithPropertyName(tref.RefMiddleEntityType, newItem, tref.MiddleColumns[midcolidx].CsName, refval);
}
midListAdd.Add(newItem);
}
await midSet.AddRangeAsync(midListAdd);
}
break;
case Internal.Model.TableRefType.OneToMany:
foreach (var propValItem in propValEach)
{
for (var colidx = 0; colidx < tref.Columns.Count; colidx++)
{
tref.RefColumns[colidx].Table.Properties[tref.RefColumns[colidx].CsName]
.SetValue(propValItem, tref.Columns[colidx].Table.Properties[tref.Columns[colidx].CsName].GetValue(item));
var val = FreeSql.Internal.Utils.GetDataReaderValue(tref.RefColumns[colidx].CsType, _db.Orm.GetEntityValueWithPropertyName(_table.Type, item, tref.Columns[colidx].CsName));
_db.Orm.SetEntityValueWithPropertyName(tref.RefEntityType, propValItem, tref.RefColumns[colidx].CsName, val);
}
Task task = dbsetAddOrUpdate.Invoke(dbset, new object[] { propValItem }) as Task;
await task;
await refSet.AddOrUpdateAsync(propValItem);
}
break;
}

116
FreeSql.DbContext/DbSet/DbSetSync.cs
View File

@ -5,6 +5,8 @@ using System.Collections.Generic;
using System.Collections.Concurrent;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Linq.Expressions;
namespace FreeSql
{
@ -137,8 +139,16 @@ namespace FreeSql
if (_table.ColumnsByCsIgnore.ContainsKey(prop.Key)) continue;
if (_table.ColumnsByCs.ContainsKey(prop.Key)) continue;
object propVal = null;
var tref = _table.GetTableRef(prop.Key, true);
if (tref == null) continue;
switch (tref.RefType)
{
case Internal.Model.TableRefType.OneToOne:
case Internal.Model.TableRefType.ManyToOne:
continue;
}
object propVal = null;
if (itemType == null) itemType = item.GetType();
if (_table.TypeLazy != null && itemType == _table.TypeLazy)
{
@ -157,33 +167,103 @@ namespace FreeSql
if (propVal == null) continue;
}
var tref = _table.GetTableRef(prop.Key, true);
if (tref == null) continue;
var propValEach = propVal as IEnumerable;
if (propValEach == null) continue;
DbSet<object> refSet = _db.Set<object>().AsType(tref.RefEntityType);
switch (tref.RefType)
{
case Internal.Model.TableRefType.OneToOne:
case Internal.Model.TableRefType.ManyToOne:
case Internal.Model.TableRefType.ManyToMany:
continue;
case Internal.Model.TableRefType.OneToMany:
var propValEach = propVal as IEnumerable;
if (propValEach == null) continue;
object dbset = null;
MethodInfo dbsetAddOrUpdate = null;
var curList = new List<object>();
foreach (var propValItem in propValEach)
{
if (dbset == null)
curList.Add(propValItem);
var flagExists = refSet.ExistsInStates(propValItem);
if (flagExists == false)
flagExists = refSet.Select.WhereDynamic(propValItem).Any();
if (refSet.CanAdd(propValItem, false) && flagExists != true)
refSet.Add(propValItem);
}
var midSelectParam = Expression.Parameter(typeof(object), "a");
var midWheres = new List<Expression<Func<object, bool>>>();
for (var colidx = 0; colidx < tref.Columns.Count; colidx++)
midWheres.Add(Expression.Lambda<Func<object, bool>>(Expression.Equal(
Expression.MakeMemberAccess(Expression.Convert(midSelectParam, tref.RefMiddleEntityType), tref.MiddleColumns[colidx].Table.Properties[tref.MiddleColumns[colidx].CsName]),
Expression.Constant(
FreeSql.Internal.Utils.GetDataReaderValue(
tref.MiddleColumns[colidx].CsType,
_db.Orm.GetEntityValueWithPropertyName(_table.Type, item, tref.Columns[colidx].CsName)), tref.MiddleColumns[colidx].CsType)
), midSelectParam));
if (curList.Any() == false) //全部删除
{
var delall = _db.Orm.Delete<object>().AsType(tref.RefMiddleEntityType);
foreach (var midWhere in midWheres) delall.Where(midWhere);
delall.ExecuteAffrows();
}
else //保存
{
var midSet = _db.Set<object>().AsType(tref.RefMiddleEntityType);
var midSelect = midSet.Select;
foreach (var midWhere in midWheres) midSelect.Where(midWhere);
var midList = midSelect.ToList();
var midListDel = new List<object>();
var midListAdd = new List<object>();
foreach (var midItem in midList)
{
dbset = _db.Set(tref.RefEntityType);
dbsetAddOrUpdate = dbset.GetType().GetMethod("AddOrUpdate", new Type[] { tref.RefEntityType });
var curContains = new List<int>();
for(var curIdx = 0; curIdx < curList.Count; curIdx ++)
{
var isEquals = true;
for (var midcolidx = tref.Columns.Count; midcolidx < tref.MiddleColumns.Count; midcolidx++)
{
var refcol = tref.Columns[midcolidx - tref.Columns.Count];
var midval = FreeSql.Internal.Utils.GetDataReaderValue(refcol.CsType, _db.Orm.GetEntityValueWithPropertyName(tref.RefMiddleEntityType, midItem, tref.MiddleColumns[midcolidx].CsName));
var refval = FreeSql.Internal.Utils.GetDataReaderValue(refcol.CsType, _db.Orm.GetEntityValueWithPropertyName(tref.RefEntityType, curList[curIdx], tref.Columns[midcolidx - tref.Columns.Count].CsName));
if (object.Equals(midval, refval) == false)
{
isEquals = false;
break;
}
}
if (isEquals)
curContains.Add(curIdx);
}
if (curContains.Any())
foreach (var curIdx in curContains)
curList.RemoveAt(curIdx);
else
midListDel.Add(midItem);
}
midSet.RemoveRange(midListDel); //删除未保存的项
foreach (var curItem in curList)
{
var newItem = Activator.CreateInstance(tref.RefMiddleEntityType);
for (var colidx = 0; colidx < tref.Columns.Count; colidx++)
{
var val = FreeSql.Internal.Utils.GetDataReaderValue(tref.MiddleColumns[colidx].CsType, _db.Orm.GetEntityValueWithPropertyName(_table.Type, item, tref.Columns[colidx].CsName));
_db.Orm.SetEntityValueWithPropertyName(tref.RefMiddleEntityType, newItem, tref.MiddleColumns[colidx].CsName, val);
}
for (var midcolidx = tref.Columns.Count; midcolidx < tref.MiddleColumns.Count; midcolidx++)
{
var refcol = tref.Columns[midcolidx - tref.Columns.Count];
var refval = FreeSql.Internal.Utils.GetDataReaderValue(tref.MiddleColumns[midcolidx].CsType, _db.Orm.GetEntityValueWithPropertyName(tref.RefEntityType, curItem, refcol.CsName));
_db.Orm.SetEntityValueWithPropertyName(tref.RefMiddleEntityType, newItem, tref.MiddleColumns[midcolidx].CsName, refval);
}
midListAdd.Add(newItem);
}
midSet.AddRange(midListAdd);
}
break;
case Internal.Model.TableRefType.OneToMany:
foreach (var propValItem in propValEach)
{
for (var colidx = 0; colidx < tref.Columns.Count; colidx++)
{
tref.RefColumns[colidx].Table.Properties[tref.RefColumns[colidx].CsName]
.SetValue(propValItem, tref.Columns[colidx].Table.Properties[tref.Columns[colidx].CsName].GetValue(item));
var val = FreeSql.Internal.Utils.GetDataReaderValue(tref.RefColumns[colidx].CsType, _db.Orm.GetEntityValueWithPropertyName(_table.Type, item, tref.Columns[colidx].CsName));
_db.Orm.SetEntityValueWithPropertyName(tref.RefEntityType, propValItem, tref.RefColumns[colidx].CsName, val);
}
dbsetAddOrUpdate.Invoke(dbset, new object[] { propValItem });
refSet.AddOrUpdate(propValItem);
}
break;
}

22
FreeSql.DbContext/FreeSql.DbContext.xml
View File

@ -48,7 +48,16 @@
</member>
<member name="P:FreeSql.DbContextOptions.EnableAddOrUpdateNavigateList">
<summary>
是否开启一对多，联级保存功能
是否开启一对多，多对多联级保存功能<para></para>
<para></para>
【一对多】模型下， 保存时可联级保存实体的属性集合。出于使用安全考虑我们没做完整对比，只实现实体属性集合的添加或更新操作，所以不会删除实体属性集合的数据。<para></para>
完整对比的功能使用起来太危险，试想下面的场景：<para></para>
- 保存的时候，实体的属性集合是空的，如何操作？记录全部删除？<para></para>
- 保存的时候，由于数据库中记录非常之多，那么只想保存子表的部分数据，或者只需要添加，如何操作？<para></para>
<para></para>
【多对多】模型下，我们对中间表的保存是完整对比操作，对外部实体的操作只作新增（注意不会更新）
- 属性集合为空时，删除他们的所有关联数据（中间表）
- 属性集合不为空时，与数据库存在的关联数据（中间表）完全对比，计算出应该删除和添加的记录
</summary>
</member>
<member name="M:FreeSql.DbSet`1.AsType(System.Type)">
@ -158,6 +167,11 @@
<param name="entityType"></param>
<returns></returns>
</member>
<member name="P:FreeSql.IBaseRepository.DbContextOptions">
<summary>
设置 DbContext 选项
</summary>
</member>
<member name="M:FreeSql.IBasicRepository`1.FlushState">
<summary>
清空状态数据
@ -193,14 +207,14 @@
开启工作单元
</summary>
</member>
<member name="M:FreeSqlDbContextExtenssions.CreateDbContext(IFreeSql)">
<member name="M:FreeSqlDbContextExtensions.CreateDbContext(IFreeSql)">
<summary>
创建普通数据上下文档对象
</summary>
<param name="that"></param>
<returns></returns>
</member>
<member name="M:FreeSqlDbContextExtenssions.NoTracking``1(FreeSql.ISelect{``0})">
<member name="M:FreeSqlDbContextExtensions.NoTracking``1(FreeSql.ISelect{``0})">
<summary>
不跟踪查询的实体数据（在不需要更新其数据时使用），可提长查询性能
</summary>
@ -208,7 +222,7 @@
<param name="select"></param>
<returns></returns>
</member>
<member name="M:FreeSqlDbContextExtenssions.SetDbContextOptions(IFreeSql,System.Action{FreeSql.DbContextOptions})">
<member name="M:FreeSqlDbContextExtensions.SetDbContextOptions(IFreeSql,System.Action{FreeSql.DbContextOptions})">
<summary>
设置 DbContext 选项设置
</summary>

1
FreeSql.DbContext/Repository/Repository/BaseRepository.cs
View File

@ -59,6 +59,7 @@ namespace FreeSql
}
public Type EntityType => _dbsetPriv?.EntityType ?? typeof(TEntity);
public void AsType(Type entityType) => _dbset.AsType(entityType);
public DbContextOptions DbContextOptions { get => _db.Options; set => _db.Options = value; }
public IFreeSql Orm { get; private set; }
public IUnitOfWork UnitOfWork { get; set; }

5
FreeSql.DbContext/Repository/Repository/IBaseRepository.cs
View File

@ -17,6 +17,11 @@ namespace FreeSql
/// <param name="entityType"></param>
/// <returns></returns>
void AsType(Type entityType);
/// <summary>
/// 设置 DbContext 选项
/// </summary>
DbContextOptions DbContextOptions { get; set; }
}
public interface IBaseRepository<TEntity> : IReadOnlyRepository<TEntity>, IBasicRepository<TEntity>