论怎样直接用EF Core实现创建更新时间、用户审计，自动化乐观并发、软删除 - ToB企服应用市场:ToB评测及商务社交产业平台

/// <summary>
/// 实体模型配置扩展
/// </summary>
public static class EntityModelBuilderExtensions
{
internal const string _logicallyDeleteableAnnotationName = "CoreDX.Entity.Property:LogicallyDeleteable";
internal const string _dependencyLogicallyDeleteableAnnotationName = "CoreDX.Entity.Property:DependencyLogicallyDeleteable";
internal const string _queryViewAnnotationName = "CoreDX.Relational:QueryView";
internal const string _queryViewNamePrefixes = "QueryView_";
internal const string _treeQueryViewNamePrefixes = $"{_queryViewNamePrefixes}Tree_";
/// <summary>
/// 使用<see langword="default" />（<see cref="DateTimeOffset.MinValue"/>）
/// </summary>
private static readonly DateTimeOffset _aliveEntityTime = default;
/// <summary>
/// 配置可逻辑删除实体的查询过滤器让EF Core自动添加查询条件过滤已被逻辑删除的记录。<br/>存活的记录使用<see cref="DateTimeOffset.MinValue"/>标记。
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="builder">实体类型构造器</param>
/// <returns>实体类型构造器</returns>
public static EntityTypeBuilder<TEntity> ConfigureQueryFilterForILogicallyDelete<TEntity>(this EntityTypeBuilder<TEntity> builder)
where TEntity : class, ILogicallyDeletable
{
ArgumentNullException.ThrowIfNull(builder);
// 配置数据库默认值和EF Core哨兵值
builder.Property(e => e.DeletedAt)
.HasDefaultValue(_aliveEntityTime)
.HasSentinel(_aliveEntityTime)
.HasAnnotation(_logicallyDeleteableAnnotationName, true);
ConfigQueryViewAnnotationForLogicallyDeletable(builder);
return builder.HasQueryFilter(e => e.DeletedAt == EF.Constant(_aliveEntityTime));
}
/// <summary>
/// 配置依赖项逻辑删除实体的查询过滤器让EF Core自动添加查询条件过滤已被逻辑删除的记录。
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="builder">实体类型构造器</param>
/// <param name="nullValueSql">依赖项逻辑删除在表中的计算列Null值生成Sql</param>
/// <returns>实体类型构造器</returns>
public static EntityTypeBuilder<TEntity> ConfigureQueryFilterForIDependencyLogicallyDelete<TEntity>(
this EntityTypeBuilder<TEntity> builder,
IDependencyLogicallyDeletableNullValueSql nullValueSql)
where TEntity : class, IDependencyLogicallyDeletable
{
ArgumentNullException.ThrowIfNull(builder);
ArgumentNullException.ThrowIfNull(nullValueSql);
// 配置表的依赖项逻辑删除标记列为值永远为NULL的计算列
builder.Property(e => e.DependencyDeletedAt)
.HasComputedColumnSql(nullValueSql.DependencyDeleteAtNullComputedValueSql)
.HasAnnotation(_dependencyLogicallyDeleteableAnnotationName, true);
ConfigQueryViewAnnotationForDependencyLogicallyDeletable(builder);
return builder.HasQueryFilter(e => e.DependencyDeletedAt == null || e.DependencyDeletedAt == EF.Constant(_aliveEntityTime));
}
/// <summary>
/// 配置可逻辑删除和依赖项逻辑删除实体的查询过滤器让EF Core自动添加查询条件过滤已被逻辑删除的记录。
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="builder">实体类型构造器</param>
/// <param name="nullValueSql">依赖项逻辑删除在表中的计算列Null值生成Sql</param>
/// <returns>实体类型构造器</returns>
public static EntityTypeBuilder<TEntity> ConfigureQueryFilterForILogicallyAndIDependencyLogicallyDelete<TEntity>(
this EntityTypeBuilder<TEntity> builder,
IDependencyLogicallyDeletableNullValueSql nullValueSql)
where TEntity : class, ILogicallyDeletable, IDependencyLogicallyDeletable
{
ArgumentNullException.ThrowIfNull(builder);
ArgumentNullException.ThrowIfNull(nullValueSql);
// 配置数据库默认值和EF Core哨兵值
builder.Property(e => e.DeletedAt)
.HasDefaultValue(_aliveEntityTime)
.HasSentinel(_aliveEntityTime)
.HasAnnotation(_logicallyDeleteableAnnotationName, true);
// 配置表的依赖项逻辑删除标记列为值永远为NULL的计算列
builder.Property(e => e.DependencyDeletedAt)
.HasComputedColumnSql(nullValueSql.DependencyDeleteAtNullComputedValueSql)
.HasAnnotation(_dependencyLogicallyDeleteableAnnotationName, true);
ConfigQueryViewAnnotationForLogicallyDeletable(builder);
ConfigQueryViewAnnotationForDependencyLogicallyDeletable(builder);
return builder.HasQueryFilter(e => e.DeletedAt == EF.Constant(_aliveEntityTime) && (e.DependencyDeletedAt == null || e.DependencyDeletedAt == EF.Constant(_aliveEntityTime)));
}
/// <summary>
/// 批量配置可逻辑删除和依赖项逻辑删除实体的查询过滤器让EF Core自动添加查询条件过滤已被逻辑删除或传递依赖删除的记录
/// </summary>
/// <param name="modelBuilder">模型构造器</param>
/// <param name="nullValueSql">依赖项逻辑删除在表中的计算列Null值生成Sql</param>
/// <returns>模型构造器</returns>
public static ModelBuilder ConfigureQueryFilterForILogicallyDeleteOrIDependencyLogicallyDeletable(
this ModelBuilder modelBuilder,
IDependencyLogicallyDeletableNullValueSql nullValueSql)
{
ArgumentNullException.ThrowIfNull(modelBuilder);
ArgumentNullException.ThrowIfNull(nullValueSql);
foreach (var entity
in modelBuilder.Model.GetEntityTypes()
.Where(e => e.ClrType.IsDerivedFrom<ILogicallyDeletable>() || e.ClrType.IsDerivedFrom<IDependencyLogicallyDeletable>()))
{
var entityTypeBuilderMethod = GetEntityTypeBuilderMethod(entity);
var isILogicallyDeletable = entity.ClrType.IsDerivedFrom<ILogicallyDeletable>();
var isIDependencyLogicallyDeletable = entity.ClrType.IsDerivedFrom<IDependencyLogicallyDeletable>();
var logicallyDeleteQueryFilterMethod = (isILogicallyDeletable, isIDependencyLogicallyDeletable) switch
{
(true, false) => GetEntityTypeConfigurationMethod(
nameof(ConfigureQueryFilterForILogicallyDelete),
1,
entity.ClrType),
(false, true) => GetEntityTypeConfigurationMethod(
nameof(ConfigureQueryFilterForIDependencyLogicallyDelete),
2,
entity.ClrType),
(true, true) => GetEntityTypeConfigurationMethod(
nameof(ConfigureQueryFilterForILogicallyAndIDependencyLogicallyDelete),
2,
entity.ClrType),
// 不可能进入此分支
(false, false) => throw new InvalidOperationException()
};
if (isIDependencyLogicallyDeletable) logicallyDeleteQueryFilterMethod.Invoke(null, [entityTypeBuilderMethod.Invoke(modelBuilder, null), nullValueSql]);
else logicallyDeleteQueryFilterMethod.Invoke(null, [entityTypeBuilderMethod.Invoke(modelBuilder, null)]);
}
return modelBuilder;
}
/// <summary>
/// 配置实体查询视图。
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="builder">实体类型构造器</param>
/// <returns>实体类型构造器</returns>
/// <remarks>
/// <para>如果实体类型实现<see cref="IDependencyLogicallyDeletable"/>，但不实现<see cref="ITreeEntity{TKey, TEntity}"/>，生成并映射查询到以<see cref="_queryViewNamePrefixes"/>开头的视图。</para>
/// <para>如果实体类型实现<see cref="ITreeEntity{TKey, TEntity}"/>，但不实现<see cref="IDependencyLogicallyDeletable"/>，生成并映射查询到以<see cref="_treeQueryViewNamePrefixes"/>开头的视图。</para>
/// <para>如果实体类型同时实现<see cref="IDependencyLogicallyDeletable"/>和<see cref="ITreeEntity{TKey, TEntity}"/>，同时生成以<see cref="_queryViewNamePrefixes"/>和<see cref="_treeQueryViewNamePrefixes"/>开头的视图。<br/>
/// 实体查询映射到以<see cref="_treeQueryViewNamePrefixes"/>开头的视图，并且<see cref="_treeQueryViewNamePrefixes"/>开头的视图以<see cref="_queryViewNamePrefixes"/>开头的视图为数据源。</para>
/// </remarks>
public static EntityTypeBuilder<TEntity> ConfigEntityQueryView<TEntity>(this EntityTypeBuilder<TEntity> builder)
where TEntity : class
{
ArgumentNullException.ThrowIfNull(builder);
if (builder.Metadata.FindAnnotation(_queryViewAnnotationName)?.Value is List<Type> annotationValue)
{
var isDependencyLogicallyDeletableEntity = annotationValue.Any(static x => x == typeof(IDependencyLogicallyDeletable));
var isTreeEntity = annotationValue.Any(static x => x == typeof(ITreeEntity<,>));
var tableName = builder.Metadata.GetTableName();
builder.ToTable(tableName);
if(isTreeEntity || isDependencyLogicallyDeletableEntity)
{
builder.ToView($"{(isTreeEntity ? _treeQueryViewNamePrefixes : _queryViewNamePrefixes)}{tableName}");
}
}
return builder;
}
/// <summary>
/// 批量配置实体查询视图
/// </summary>
/// <param name="modelBuilder">模型构造器</param>
/// <returns>模型构造器</returns>
/// <remarks>配置规则同<see cref="ConfigEntityQueryView{TEntity}"/></remarks>
public static ModelBuilder ConfigEntityQueryView(this ModelBuilder modelBuilder)
{
ArgumentNullException.ThrowIfNull(modelBuilder);
foreach (var entity
in modelBuilder.Model.GetEntityTypes()
.Where(static e => e.FindAnnotation(_queryViewAnnotationName) is not null))
{
var entityTypeBuilderMethod = GetEntityTypeBuilderMethod(entity);
var entityQueryViewMethod = GetEntityTypeConfigurationMethod(
nameof(ConfigEntityQueryView),
1,
entity.ClrType);
entityQueryViewMethod.Invoke(null, [entityTypeBuilderMethod.Invoke(modelBuilder, null)]);
}
return modelBuilder;
}
/// <summary>
/// 配置逻辑删除实体的查询视图注解
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="builder">实体类型构造器</param>
private static void ConfigQueryViewAnnotationForLogicallyDeletable<TEntity>(EntityTypeBuilder<TEntity> builder)
where TEntity : class, ILogicallyDeletable
{
var annotationValue = builder.Metadata.FindAnnotation(_queryViewAnnotationName)?.Value;
var typedAnnotationValue = annotationValue as List<Type>;
if (annotationValue is not null && typedAnnotationValue is null)
{
throw new InvalidOperationException($@"模型注解名称""{_queryViewAnnotationName}""已被占用，请把占用此名称的注解修改为其他名称。");
}
else if (typedAnnotationValue is null)
{
builder.HasAnnotation(_queryViewAnnotationName, new List<Type>() { typeof(ILogicallyDeletable) });
}
else if (typedAnnotationValue.Find(static x => x is ILogicallyDeletable) is null)
{
typedAnnotationValue.Add(typeof(ILogicallyDeletable));
}
}
/// <summary>
/// 配置依赖项逻辑删除实体的查询视图注解
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="builder">实体类型构造器</param>
private static void ConfigQueryViewAnnotationForDependencyLogicallyDeletable<TEntity>(EntityTypeBuilder<TEntity> builder)
where TEntity : class, IDependencyLogicallyDeletable
{
var annotationValue = builder.Metadata.FindAnnotation(_queryViewAnnotationName)?.Value;
var typedAnnotationValue = annotationValue as List<Type>;
if (annotationValue is not null && typedAnnotationValue is null)
{
throw new InvalidOperationException($@"模型注解名称""{_queryViewAnnotationName}""已被占用，请把占用此名称的注解修改为其他名称。");
}
else if (typedAnnotationValue is null)
{
builder.HasAnnotation(_queryViewAnnotationName, new List<Type>() { typeof(IDependencyLogicallyDeletable) });
}
else if (typedAnnotationValue.Find(static x => x is IDependencyLogicallyDeletable) is null)
{
typedAnnotationValue.Add(typeof(IDependencyLogicallyDeletable));
}
}
}

复制代码

/// <summary>
/// 依赖项逻辑删除实体的视图列在表中的Null值计算列映射
/// </summary>
public interface IDependencyLogicallyDeletableNullValueSql
{
string DependencyDeleteAtNullComputedValueSql { get; }
}
public interface ITableOrColumnNameFormattable
{
/// <summary>
/// 格式化表或列名
/// <para>例如为SqlServer列名包裹方括号、MySql包裹反引号</para>
/// </summary>
/// <param name="name">表或列名</param>
/// <returns>格式化的表或列名</returns>
[return: NotNullIfNotNull(nameof(name))]
string? FormatTableOrColumnName(string? name);
}
/// <summary>
/// 依赖项逻辑删除实体的视图SQL模板
/// </summary>
public interface IDependencyLogicallyDeletableEntityDatabaseViewSqlTemplate : ITableOrColumnNameFormattable
{
/// <summary>
/// 创建视图的模板
/// </summary>
string CreateSqlTemplate { get; }
/// <summary>
/// 删除视图的模板
/// </summary>
string DropSqlTemplate { get; }
/// <summary>
/// 连接数据源模版
/// </summary>
/// <remarks>LEFT JOIN {principalDataSource} ON {tableName}.{foreignKey} = {principalDataSource}.{principalKey}</remarks>
string JoinTargetTemplate { get; }
string PrincipalLogicallyDeleteColumnTemplate { get; }
}

复制代码

public class DefaultSqlServerDependencyLogicallyDeletableNullValueSql : IDependencyLogicallyDeletableNullValueSql
{
public static DefaultSqlServerDependencyLogicallyDeletableNullValueSql Instance => new();
private const string _dependencyDeleteAtNullComputedValueSql = "CAST(NULL AS datetimeoffset)";
public string DependencyDeleteAtNullComputedValueSql => _dependencyDeleteAtNullComputedValueSql;
private DefaultSqlServerDependencyLogicallyDeletableNullValueSql() { }
}
public class DefaultSqlServerDependencyLogicallyDeletableEntityViewSqlTemplate : IDependencyLogicallyDeletableEntityDatabaseViewSqlTemplate
{
public static DefaultSqlServerDependencyLogicallyDeletableEntityViewSqlTemplate Instance => new();
private const string _viewNameTemplate = $$"""{{EntityModelBuilderExtensions._queryViewNamePrefixes}}{tableName}""";
// SqlServer 2022起才支持GREATEST函数
private const string _createSqlTemplate =
$$"""
--创建或重建依赖项逻辑删除实体查询视图
{{_dropSqlTemplate}}
CREATE VIEW {{_viewNameTemplate}}
AS
SELECT {columns},
(SELECT MAX([DeleteTimeTable].[DeletedAt])
FROM (VALUES {principalLogicallyDeleteColumns}) AS DeleteTimeTable([DeletedAt])) AS {dependencyDeletedAtColumn}
FROM [{tableName}]
{joinTargets};
GO
""";
private const string _principalLogicallyDeleteColumnTemplate = "({principalLogicallyDeleteColumn})";
private const string _joinTargetTemplate =
$$"""
LEFT JOIN {principalDataSource}
ON {joinCondition}
""";
private const string _dropSqlTemplate =
$"""
--删除可能存在的过时依赖项逻辑删除实体查询视图
IF EXISTS(SELECT * FROM [sysobjects] WHERE [id] = OBJECT_ID(N'{_viewNameTemplate}') AND objectproperty(id, N'IsView') = 1)
BEGIN
DROP VIEW [{_viewNameTemplate}]
END
GO
""";
public string CreateSqlTemplate => _createSqlTemplate;
public string DropSqlTemplate => _dropSqlTemplate;
public string PrincipalLogicallyDeleteColumnTemplate => _principalLogicallyDeleteColumnTemplate;
public string JoinTargetTemplate => _joinTargetTemplate;
public string? FormatTableOrColumnName(string? name)
{
if (name is null) return null;
return $"[{name}]";
}
private DefaultSqlServerDependencyLogicallyDeletableEntityViewSqlTemplate() { }
}

复制代码

/// <summary>
/// 依赖项逻辑删除实体视图迁移扩展
/// </summary>
public static class DependencyLogicallyDeletableEntityMigrationBuilderExtensions
{
/// <summary>
/// 自动扫描迁移模型并配置依赖项逻辑删除实体查询视图
/// </summary>
/// <param name="migrationBuilder">迁移构造器</param>
/// <param name="thisVersion">当前版本的迁移</param>
/// <param name="previousVersion">上一个版本的迁移</param>
/// <param name="isUp">是否为升级迁移</param>
/// <param name="sqlTemplate">Sql模板</param>
/// <returns>迁移构造器</returns>
public static MigrationBuilder ApplyDependencyLogicallyDeletableEntityQueryView(
this MigrationBuilder migrationBuilder,
Migration thisVersion,
Migration? previousVersion,
bool isUp,
IDependencyLogicallyDeletableEntityDatabaseViewSqlTemplate sqlTemplate)
{
ArgumentNullException.ThrowIfNull(migrationBuilder);
ArgumentNullException.ThrowIfNull(thisVersion);
ArgumentNullException.ThrowIfNull(sqlTemplate);
var thisVersionEntityTypes = thisVersion.TargetModel.GetEntityTypes()
.Where(static et =>
(et.FindAnnotation(EntityModelBuilderExtensions._queryViewAnnotationName)?.Value as List<Type>)
?.Any(x => x == typeof(IDependencyLogicallyDeletable)) is true
);
var previousVersionEntityTypes = previousVersion?.TargetModel.GetEntityTypes()
.Where(static et =>
(et.FindAnnotation(EntityModelBuilderExtensions._queryViewAnnotationName)?.Value as List<Type>)
?.Any(x => x == typeof(IDependencyLogicallyDeletable)) is true
);
var pendingViewOperations = new List<(IEntityType? entity, string? tableName, bool isCreate)>();
var tempViewOperationsDict = new Dictionary<string, List<(IEntityType? entity, string? tableName, bool isCreate)>>();
// 表操作
foreach (var tableOperation in
migrationBuilder.Operations.Where(static op =>
{
var opType = op.GetType();
return opType.IsDerivedFrom<TableOperation>() || opType.IsDerivedFrom<DropTableOperation>();
}))
{
if (tableOperation is CreateTableOperation createTable)
{
// 升级创建表，创建视图
if (isUp && thisVersionEntityTypes.Any(et => et.GetTableName() == createTable.Name))
{
var entity = thisVersionEntityTypes.Single(en => en.GetTableName() == createTable.Name);
AddEntityCreateEntityViewToTempDict(tempViewOperationsDict, entity);
}
// 回滚创建表，说明必然存在上一版迁移，以上一个版本的模型创建视图
if (!isUp)
{
EnsureMigrationOfPreviousVersion(previousVersion);
if (previousVersionEntityTypes?.Any(et => et.GetTableName() == createTable.Name) is true)
{
var entity = previousVersionEntityTypes.Single(en => en.GetTableName() == createTable.Name);
AddEntityCreateEntityViewToTempDict(tempViewOperationsDict, entity);
}
}
}
else if (tableOperation is AlterTableOperation alterTable)
{
// 升级修改表（仅当修改表名时），重建视图
// 因为修改表操作可能是修改表注释
if (isUp)
{
// 如果上一版本中这个实体是依赖项逻辑删除实体，删除旧视图
if (previousVersionEntityTypes?.Any(et => et.GetTableName() == alterTable.OldTable.Name) is true)
{
// 由于升级修改表名需要同时完成删除基于旧表名的视图和创建基于新表名的视图两个操作
// 删除旧视图的操作直接添加到挂起操作列表，修改表名的操作也不会在迁移中重复出现，没有重复添加相同操作的问题
pendingViewOperations.Add((null, alterTable.OldTable.Name, false));
}
if (thisVersionEntityTypes.Any(et => et.GetTableName() == alterTable.Name))
{
var entity = thisVersionEntityTypes.Single(en => en.GetTableName() == alterTable.Name);
AddEntityCreateEntityViewToTempDict(tempViewOperationsDict, entity);
}
}
// 回滚修改表（仅当修改表名时），说明必然存在上一版迁移，以上一个版本的模型重建视图
else
{
// 如果当前版本中这个实体也是依赖项逻辑删除实体，删除旧视图
if (thisVersionEntityTypes.Any(et => et.GetTableName() == alterTable.OldTable.Name))
{
// 由于回滚修改表名需要同时完成删除基于新表名的视图和创建基于旧表名的视图两个操作
// 删除旧视图的操作直接添加到挂起操作列表，修改表名的操作也不会在迁移中重复出现，没有重复添加相同操作的问题
pendingViewOperations.Add((null, alterTable.OldTable.Name, false));
}
EnsureMigrationOfPreviousVersion(previousVersion);
if (previousVersionEntityTypes!.Any(et => et.GetTableName() == alterTable.Name) && alterTable.OldTable.Name != alterTable.Name)
{
var entity = previousVersionEntityTypes!.Single(en => en.GetTableName() == alterTable.Name);
AddEntityCreateEntityViewToTempDict(tempViewOperationsDict, entity);
}
}
}
// 迁移操作需要删除表，则代表同样需要删除视图
else if (tableOperation is DropTableOperation dropTable)
{
if (isUp)
{
EnsureMigrationOfPreviousVersion(previousVersion);
if (previousVersionEntityTypes!.Any(en => en.GetTableName() == dropTable.Name))
{
AddTableDropTableViewToTempDict(tempViewOperationsDict, dropTable.Name);
}
}
else if (thisVersionEntityTypes.Any(en => en.GetTableName() == dropTable.Name))
{
AddTableDropTableViewToTempDict(tempViewOperationsDict, dropTable.Name);
}
}
}
// 列操作，每个表可能操作多个列，需要聚合处理
foreach (var tableColumnOperationsGrouping in
migrationBuilder.Operations
.Where(static op =>
{
var opType = op.GetType();
return opType.IsDerivedFrom<ColumnOperation>() || opType.IsDerivedFrom<DropColumnOperation>();
})
.GroupBy(static op => (op as ColumnOperation)?.Table ?? (op as DropColumnOperation)!.Table))
{
foreach (var columnOperation in tableColumnOperationsGrouping)
{
if (columnOperation is AddColumnOperation addColumn)
{
// 升级添加列，如果是依赖项逻辑删除，重建视图
if (isUp && thisVersionEntityTypes?.Any(et => et.GetTableName() == addColumn.Table) is true)
{
var entity = thisVersionEntityTypes.Single(en => en.GetTableName() == addColumn.Table);
AddEntityCreateEntityViewToTempDict(tempViewOperationsDict, entity);
}
// 回滚添加列，说明必然存在上一版迁移，如果上一版是依赖项逻辑删除实体，重建视图
if (!isUp)
{
EnsureMigrationOfPreviousVersion(previousVersion);
if (previousVersionEntityTypes?.Any(et => et.GetTableName() == addColumn.Table) is true)
{
var entity = previousVersionEntityTypes.Single(en => en.GetTableName() == addColumn.Table);
AddEntityCreateEntityViewToTempDict(tempViewOperationsDict, entity);
}
}
}
else if (columnOperation is AlterColumnOperation alterColumn)
{
// 升级修改列，重建视图
// 因为修改列操作可能是修改列注释
if (isUp)
{
if (thisVersionEntityTypes!.Any(et => et.GetTableName() == alterColumn.Table))
{
var entity = thisVersionEntityTypes!.Single(en => en.GetTableName() == alterColumn.Table);
AddEntityCreateEntityViewToTempDict(tempViewOperationsDict, entity);
}
else if (previousVersionEntityTypes?.Any(et => et.GetTableName() == alterColumn.Table) is true)
{
AddTableDropTableViewToTempDict(tempViewOperationsDict, alterColumn.Table);
}
}
// 回滚修改列（仅当修改列名时），说明必然存在上一版迁移，如果上一版是依赖项逻辑删除实体，重建视图
// 因为修改列操作可能是修改列注释
else
{
EnsureMigrationOfPreviousVersion(previousVersion);
if (previousVersionEntityTypes?.Any(et => et.GetTableName() == alterColumn.Table) is true)
{
var entity = previousVersionEntityTypes.Single(en => en.GetTableName() == alterColumn.Table);
AddEntityCreateEntityViewToTempDict(tempViewOperationsDict, entity);
}
else if (thisVersionEntityTypes!.Any(et => et.GetTableName() == alterColumn.Table))
{
AddTableDropTableViewToTempDict(tempViewOperationsDict, alterColumn.Table);
}
}
}
else if (columnOperation is DropColumnOperation dropColumn)
{
// 升级删除列
if (isUp)
{
// 当前版本仍然是依赖项逻辑删除实体，说明被删除的列和依赖项逻辑删除无关，重建视图
if (thisVersionEntityTypes!.Any(et => et.GetTableName() == dropColumn.Table))
{
var entity = thisVersionEntityTypes!.Single(en => en.GetTableName() == dropColumn.Table);
AddEntityCreateEntityViewToTempDict(tempViewOperationsDict, entity);
}
// 被删除的列是依赖项逻辑删除（上一版本的实体是依赖项逻辑删除，但当前版本不是），删除视图
else if (previousVersionEntityTypes?.Any(et => et.GetTableName() == dropColumn.Table) is true)
{
AddTableDropTableViewToTempDict(tempViewOperationsDict, dropColumn.Table);
}
}
// 回滚删除列
if (!isUp)
{
EnsureMigrationOfPreviousVersion(previousVersion);
// 上一版本是依赖项逻辑删除实体，说明被删除的列和依赖项逻辑删除无关，重建视图
if (previousVersionEntityTypes?.Any(et => et.GetTableName() == dropColumn.Table) is true)
{
var entity = previousVersionEntityTypes.Single(en => en.GetTableName() == dropColumn.Table);
AddEntityCreateEntityViewToTempDict(tempViewOperationsDict, entity);
}
// 被删除的列是依赖项逻辑删除（上一版本的实体不是依赖项逻辑删除，但当前版本是），删除视图
else if (thisVersionEntityTypes?.Any(et => et.GetTableName() == dropColumn.Table) is true)
{
AddTableDropTableViewToTempDict(tempViewOperationsDict, dropColumn.Table);
}
}
}
}
}
// 聚合所有操作，然后选择其中合理的一个作为最终操作
foreach (var entityViewOperations in tempViewOperationsDict)
{
// 理论上来说如果上面的代码没有问题，针对同一张表的操作应该不会出现矛盾
Debug.Assert(entityViewOperations.Value.All(x => x.isCreate == entityViewOperations.Value.First().isCreate));
pendingViewOperations.Add(entityViewOperations.Value.First());
}
// 检查是依赖项逻辑删除但没有出现在操作列表中的实体
// 这种实体可能由于依赖的主实体存在迁移操作，导致现有视图过时，需要追加到重建视图的操作列表中
// 这种情况只会出现在所依赖的主实体从同时是逻辑删除和依赖项逻辑删除实体变成只是其中一种或者从原来是其中一种变成另外一种
// 或者逻辑删除和依赖项逻辑删除列被改名
// 主实体的其他列改动与当前实体无关，当前实体的视图对主实体的依赖仅限于主实体的逻辑删除（来自表或视图）和依赖项逻辑删除（一定是视图）（如果主实体也依赖于它的主实体）
// 主实体从都不是变成至少是其中一种需要在从实体上添加依赖项逻辑删除接口以实现功能，会导致迁移至少会增加一列，因此从实体自身必然会出现在添加列操作中
// 主实体从至少是其中一种变成都不是，模型构建阶段从实体上的依赖项逻辑删除接口就会抛出异常提示取消对接口的实现，会导致迁移至少会删除一列，因此从实体自身必然会出现在删除列操作中
// 收集所有添加、删除和改名列操作并按照表分组备用
var tableColumnOperationsGroupingforTransitiveDependencyCheck = migrationBuilder.Operations
.Where(static op =>
{
var opType = op.GetType();
return opType.IsDerivedFrom<AddColumnOperation>()
// 如果是修改列名，也可能需要重建视图
// 在模型上单独配置接口属性的列名映射时需要重建视图
// 其他无关列的改名无关紧要，但是因为在这里没有对应的实体属性信息，改名后无法确定哪个是逻辑删除属性对应的列名，只能全部收集后在之后匹配
|| opType.IsDerivedFrom<AlterColumnOperation>()
|| opType.IsDerivedFrom<DropColumnOperation>();
});
// 收集存在视图操作的实体
var pendingViewOperationEntities = pendingViewOperations
.Select(pop =>
pop.entity ?? (isUp ? thisVersion.TargetModel : previousVersion?.TargetModel)
?.GetEntityTypes()
.SingleOrDefault(et => et.GetTableName()! == (pop.tableName ?? pop.entity!.GetTableName())))
.Where(static pop => pop is not null)
.ToList();
// 收集自身不在操作列表中，但依赖的主实体在操作列表中的实体
// 升级迁移收集当前版本的迁移实体，回滚迁移收集上一版本的迁移实体
var principalInPendingViewOperationEntities = (isUp ? thisVersionEntityTypes : previousVersionEntityTypes)
?.Where(et => !pendingViewOperationEntities.Contains(et))
.Where(et =>
et.GetForeignKeys()
.Select(static fk => fk.PrincipalEntityType)
.Any(pet => pendingViewOperationEntities.Contains(pet))
)
.ToList() ?? [];
// 把这些实体加入视图重建列表
pendingViewOperations.AddRange(principalInPendingViewOperationEntities?.Select(et => ((IEntityType?)et, (string?)null, true)) ?? []);
foreach (var (entity, tableName, _) in pendingViewOperations.Where(op => !op.isCreate))
{
if (entity is not null) migrationBuilder.DropDependencyLogicallyDeletableEntityQueryView(entity, sqlTemplate);
else if (tableName is not null) migrationBuilder.DropDependencyLogicallyDeletableEntityQueryView(tableName, sqlTemplate);
else throw new InvalidOperationException("迁移实体类型和迁移表名不能同时为 null。");
}
migrationBuilder.CreateDependencyLogicallyDeletableEntityQueryViewsByDataSourceDependency(
pendingViewOperations.Where(op => op.isCreate).Select(op => op.entity!),
sqlTemplate);
return migrationBuilder;
/// <summary>
/// 确保提供了上一版本的迁移
/// </summary>
static void EnsureMigrationOfPreviousVersion(Migration? previousVersion)
{
if (previousVersion is null) throw new InvalidOperationException($"回滚操作指出存在更早版本的迁移，但未提供上一版本的迁移。");
}
/// <summary>
/// 向按表分组的临时操作存放字典添加创建实体视图命令
/// </summary>
static void AddEntityCreateEntityViewToTempDict(Dictionary<string, List<(IEntityType? entity, string? tableName, bool isCreate)>> tempViewOperationsDict, IEntityType entity)
{
if (!tempViewOperationsDict.TryGetValue(entity.GetTableName()!, out var result))
{
result ??= [];
tempViewOperationsDict.Add(entity.GetTableName()!, result);
}
result.Add((entity, null, true));
}
/// <summary>
/// 向按表分组的临时操作存放字典添加删除表视图命令
/// </summary>
static void AddTableDropTableViewToTempDict(Dictionary<string, List<(IEntityType? entity, string? tableName, bool isCreate)>> tempViewOperationsDict, string tableName)
{
if (!tempViewOperationsDict.TryGetValue(tableName, out var result))
{
result ??= [];
tempViewOperationsDict.Add(tableName, result);
}
result.Add((null, tableName, false));
}
}
/// <summary>
/// 创建依赖项逻辑删除实体查询视图
/// </summary>
/// <param name="migrationBuilder">迁移构造器</param>
/// <param name="entityType">实体类型</param>
/// <param name="sqlTemplate">Sql模板</param>
/// <returns>迁移构造器</returns>
public static MigrationBuilder CreateDependencyLogicallyDeletableEntityQueryView(
this MigrationBuilder migrationBuilder,
IEntityType entityType,
IDependencyLogicallyDeletableEntityDatabaseViewSqlTemplate sqlTemplate)
{
ArgumentNullException.ThrowIfNull(migrationBuilder);
ArgumentNullException.ThrowIfNull(entityType);
ArgumentNullException.ThrowIfNull(sqlTemplate);
var (sql, _, _) = CreateDependencyLogicallyDeletableEntityQueryViewSql(entityType, sqlTemplate);
migrationBuilder.Sql(sql);
return migrationBuilder;
}
/// <summary>
/// 创建依赖项逻辑删除视图并对视图创建进行排序，确保被依赖的主实体视图优先创建
/// </summary>
/// <param name="migrationBuilder">迁移构造器</param>
/// <param name="entityTypes">实体类型集合</param>
/// <param name="sqlTemplate">Sql模板</param>
/// <returns>迁移构造器</returns>
public static MigrationBuilder CreateDependencyLogicallyDeletableEntityQueryViewsByDataSourceDependency(
this MigrationBuilder migrationBuilder,
IEnumerable<IEntityType> entityTypes,
IDependencyLogicallyDeletableEntityDatabaseViewSqlTemplate sqlTemplate)
{
var viewSqls = entityTypes
.Select(e => CreateDependencyLogicallyDeletableEntityQueryViewSql(e, sqlTemplate))
.ToImmutableList();
var viewNames = viewSqls
.Select(vs => vs.viewName)
.ToImmutableList();
var rootViewSqls = viewSqls.Where(x =>
x.principalDataSourceNames
.All(ds => !ds.isViewDependency || !viewNames.Contains(ds.principalDataSourceName)));
var viewSqlTrees = rootViewSqls.Select(rv =>
rv.AsHierarchical(v =>
viewSqls.Where(vs =>
vs.principalDataSourceNames
.Select(static dsn => dsn.principalDataSourceName)
.Contains(v.viewName))));
var orderedViewSqls = viewSqlTrees
.SelectMany(tr => tr.AsEnumerable())
.GroupBy(h => h.Current.viewName)
.Select(hg => hg.OrderByDescending(h => h.Level).First())
.OrderBy(h => h.Level)
.Select(h => h.Current);
foreach (var (sql, _, _) in orderedViewSqls) migrationBuilder.Sql(sql);
return migrationBuilder;
}
/// <summary>
/// 删除依赖项逻辑删除实体查询视图
/// </summary>
/// <param name="migrationBuilder">迁移构造器</param>
/// <param name="entityType">实体类型</param>
/// <param name="sqlTemplate">Sql模板</param>
/// <returns>迁移构造器</returns>
public static MigrationBuilder DropDependencyLogicallyDeletableEntityQueryView(
this MigrationBuilder migrationBuilder,
IEntityType entityType,
IDependencyLogicallyDeletableEntityDatabaseViewSqlTemplate sqlTemplate)
{
ArgumentNullException.ThrowIfNull(migrationBuilder);
ArgumentNullException.ThrowIfNull(entityType);
ArgumentNullException.ThrowIfNull(sqlTemplate);
return migrationBuilder.DropDependencyLogicallyDeletableEntityQueryView(entityType.GetTableName()!, sqlTemplate);
}
/// <summary>
/// 删除依赖项逻辑删除实体查询视图
/// </summary>
/// <param name="migrationBuilder">迁移构造器</param>
/// <param name="tableName">视图对应的表名</param>
/// <param name="sqlTemplate">Sql模板</param>
/// <returns>迁移构造器</returns>
public static MigrationBuilder DropDependencyLogicallyDeletableEntityQueryView(
this MigrationBuilder migrationBuilder,
string tableName,
IDependencyLogicallyDeletableEntityDatabaseViewSqlTemplate sqlTemplate)
{
ArgumentNullException.ThrowIfNull(migrationBuilder);
ArgumentNullException.ThrowIfNull(sqlTemplate);
if (string.IsNullOrEmpty(tableName))
{
throw new ArgumentException($"“{nameof(tableName)}”不能为 null 或空。", nameof(tableName));
}
migrationBuilder.Sql(sqlTemplate.DropSqlTemplate.Replace("{tableName}", tableName));
return migrationBuilder;
}
/// <summary>
/// 创建依赖项逻辑删除视图
/// </summary>
/// <param name="entityType">实体类型</param>
/// <param name="sqlTemplate">Sql模板</param>
/// <returns>视图创建Sql、视图名称、依赖数据源名称以及依赖类型的集合，为视图创建排序提供线索</returns>
private static (string sql, string viewName, IReadOnlyList<(string principalDataSourceName, bool isViewDependency)> principalDataSourceNames) CreateDependencyLogicallyDeletableEntityQueryViewSql(
IEntityType entityType,
IDependencyLogicallyDeletableEntityDatabaseViewSqlTemplate sqlTemplate)
{
ArgumentNullException.ThrowIfNull(entityType);
ArgumentNullException.ThrowIfNull(sqlTemplate);
var isDependencyLogicallyDeletableEntity = (entityType
.FindAnnotation(EntityModelBuilderExtensions._queryViewAnnotationName)?.Value as List<Type>)
?.Any(static x => x == typeof(IDependencyLogicallyDeletable)) is true;
if (!isDependencyLogicallyDeletableEntity) throw new InvalidOperationException($"{entityType.Name}不是依赖项逻辑删除实体或未配置视图生成。");
var tableName = entityType.GetTableName()!;
var formatTableName = sqlTemplate.FormatTableOrColumnName(tableName)!;
var tableIdentifier = StoreObjectIdentifier.Table(tableName)!;
var columnEnumerable = entityType.GetProperties()
.Where(static prop => prop.FindAnnotation(EntityModelBuilderExtensions._dependencyLogicallyDeleteableAnnotationName)?.Value is not true)
.Select(prop => $"{formatTableName}.{sqlTemplate.FormatTableOrColumnName(prop.GetColumnName(tableIdentifier))}");
var columns = string.Join(", ", columnEnumerable);
var foreignKeys = entityType.GetForeignKeys()
.Where(static fk => fk.DeleteBehavior is DeleteBehavior.Cascade or DeleteBehavior.SetNull)
.Where(static fk =>
{
var annotationValue = fk.PrincipalEntityType
.FindAnnotation(EntityModelBuilderExtensions._queryViewAnnotationName)?.Value as List<Type>;
return annotationValue
?.Any(static t =>
t == typeof(ILogicallyDeletable) || t == typeof(IDependencyLogicallyDeletable)) is true;
})
.Select(fk => BuildJoinInfo(entityType, fk))
.ToList();
if (foreignKeys.Count == 0) throw new InvalidOperationException($"实体{entityType.Name}没有支持逻辑删除或依赖项逻辑删除的级联外键，无需实现{nameof(IDependencyLogicallyDeletable)}接口。");
var principalLogicallyDeleteColumns = string.Join(
", ",
foreignKeys
.SelectMany(p => BuildPrincipalDataSources(p.Key))
.Select(x => sqlTemplate.PrincipalLogicallyDeleteColumnTemplate.Replace("{principalLogicallyDeleteColumn}", x))
);
var joinTargetEnumerable = foreignKeys.Select(p =>
{
var formatPrincipalDataSourceName = sqlTemplate.FormatTableOrColumnName(p.Key.principalDataSourceName)!;
var conditions = p.Value.Select(x => $"{formatTableName}.{sqlTemplate.FormatTableOrColumnName(x.foreignKeyName)} = {formatPrincipalDataSourceName}.{sqlTemplate.FormatTableOrColumnName(x.principalKeyName)}");
return sqlTemplate.JoinTargetTemplate
.Replace("{principalDataSource}", formatPrincipalDataSourceName)
.Replace("{joinCondition}", string.Join(" AND ", conditions));
});
var joinTargets = string.Join("\r\n", joinTargetEnumerable);
var dependencyDeletedAtProperty = entityType.GetProperties()
.Single(static prop => prop.FindAnnotation(EntityModelBuilderExtensions._dependencyLogicallyDeleteableAnnotationName)?.Value is true);
var sql = sqlTemplate.CreateSqlTemplate
.Replace("{tableName}", tableName)
.Replace("{columns}", columns)
.Replace("{dependencyDeletedAtColumn}", sqlTemplate.FormatTableOrColumnName(dependencyDeletedAtProperty.GetColumnName(tableIdentifier)))
.Replace("{principalLogicallyDeleteColumns}", principalLogicallyDeleteColumns)
.Replace("{joinTargets}", joinTargets);
return (sql, entityType.GetViewName()!, foreignKeys.Select(x => (x.Key.principalDataSourceName, x.Key.isViewDependency)).ToImmutableList());
static KeyValuePair<(string principalDataSourceName, string? principalLogicallyDeletableColumnName, string? principalDependencyLogicallyDeletableColumnName, bool isViewDependency), IReadOnlyList<(string foreignKeyName, string principalKeyName)>> BuildJoinInfo(IEntityType entityType, IForeignKey foreignKey)
{
if (foreignKey.Properties.Count != foreignKey.PrincipalKey.Properties.Count) throw new InvalidOperationException($"外键和主键字段数量不一致。外键实体：{entityType.Name}；主实体：{foreignKey.PrincipalEntityType.Name}");
var principalEntityType = foreignKey.PrincipalEntityType;
var principalIsDependencyLogicallyDeletableEntity = (principalEntityType
.FindAnnotation(EntityModelBuilderExtensions._queryViewAnnotationName)?.Value as List<Type>)
?.Any(static t => t == typeof(IDependencyLogicallyDeletable)) is true;
var principalDataSourceName = principalIsDependencyLogicallyDeletableEntity
? principalEntityType.GetViewName()!
: principalEntityType.GetTableName()!;
var principalDataSourceIdentifier = principalIsDependencyLogicallyDeletableEntity
? StoreObjectIdentifier.View(principalDataSourceName)
: StoreObjectIdentifier.Table(principalDataSourceName);
var foreignTableName = entityType.GetTableName()!;
var foreignTableIdentifier = StoreObjectIdentifier.Table(foreignTableName);
var foreignKeyNames = foreignKey.Properties.Select(prop => prop.GetColumnName(foreignTableIdentifier)!);
var principalKeyNames = foreignKey.PrincipalKey.Properties.Select(prop => prop.GetColumnName(principalDataSourceIdentifier)!);
var joinConditionPairs = foreignKeyNames.Zip(principalKeyNames, (fk, pk) => (foreignKeyName: fk, principalKeyName: pk));
return KeyValuePair.Create(
(
principalDataSourceName,
principalEntityType.GetProperties()
.SingleOrDefault(prop => prop.FindAnnotation(EntityModelBuilderExtensions._logicallyDeleteableAnnotationName)?.Value is true)
?.GetColumnName(principalDataSourceIdentifier),
principalEntityType.GetProperties()
.SingleOrDefault(prop => prop.FindAnnotation(EntityModelBuilderExtensions._dependencyLogicallyDeleteableAnnotationName)?.Value is true)
?.GetColumnName(principalDataSourceIdentifier),
principalIsDependencyLogicallyDeletableEntity
),
joinConditionPairs.ToImmutableList() as IReadOnlyList<(string, string)>
);
}
IEnumerable<string> BuildPrincipalDataSources((string principalDataSourceName, string? principalLogicallyDeletableColumnName, string? principalDependencyLogicallyDeletableColumnName, bool _) val)
{
if (val.principalLogicallyDeletableColumnName is not null)
yield return $"{sqlTemplate.FormatTableOrColumnName(val.principalDataSourceName)}.{sqlTemplate.FormatTableOrColumnName(val.principalLogicallyDeletableColumnName)}";
if (val.principalDependencyLogicallyDeletableColumnName is not null)
yield return $"{sqlTemplate.FormatTableOrColumnName(val.principalDataSourceName)}.{sqlTemplate.FormatTableOrColumnName(val.principalDependencyLogicallyDeletableColumnName)}";
}
}
}

复制代码

public class ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
: ApplicationIdentityDbContext<
ApplicationUser,
ApplicationRole,
IdentityKey,
ApplicationUserClaim,
ApplicationUserRole,
ApplicationUserLogin,
ApplicationRoleClaim,
ApplicationUserToken>(options)
{
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
// 其他无关代码
// 自动根据数据库类型进行数据库相关的模型配置
switch (Database.ProviderName)
{
case _msSqlServerProvider:
modelBuilder.ApplyConfigurationsFromAssembly(
typeof(LogRecordEntityTypeConfiguration).Assembly,
type => type.GetCustomAttributes<DatabaseProviderAttribute>().Any(a => a.ProviderName is _msSqlServerProvider));
modelBuilder.ConfigureQueryFilterForILogicallyDeleteOrIDependencyLogicallyDeletable(DefaultSqlServerDependencyLogicallyDeletableNullValueSql.Instance);
break;
case _pomeloMySqlProvider:
modelBuilder.ApplyConfigurationsFromAssembly(
typeof(LogRecordEntityTypeConfiguration).Assembly,
type => type.GetCustomAttributes<DatabaseProviderAttribute>().Any(a => a.ProviderName is _pomeloMySqlProvider));
modelBuilder.ConfigureForTimeAuditable(DefaultMySqlTimeAuditableDefaultValueSql.Instance);
modelBuilder.ConfigureQueryFilterForILogicallyDeleteOrIDependencyLogicallyDeletable(DefaultMySqlDependencyLogicallyDeletableNullValueSql.Instance);
break;
case _msSqliteProvider:
goto default;
default:
throw new NotSupportedException(Database.ProviderName);
}
modelBuilder.ConfigEntityQueryView();
}
}

复制代码

/// <summary>
/// 把逻辑删除实体的删除变更为编辑，设置删除时间，然后使用<see cref="LogicallyDeletedRuntimeAnnotation"/>标记运行时注释便于区分普通的已编辑实体
/// </summary>
public class LogicallyDeletableSaveChangesInterceptor : SaveChangesInterceptor
{
/// <summary>
/// 逻辑删除实体的运行时注释名，注释的值为<see langword="true"/>
/// </summary>
public const string LogicallyDeletedRuntimeAnnotation = "Runtime:LogicallyDeleted";
protected IServiceScopeFactory ScopeFactory { get; }
public LogicallyDeletableSaveChangesInterceptor(IServiceScopeFactory scopeFactory)
{
ArgumentNullException.ThrowIfNull(scopeFactory);
ScopeFactory = scopeFactory;
}
public override InterceptionResult<int> SavingChanges(
DbContextEventData eventData,
InterceptionResult<int> result)
{
OnSavingChanges(eventData);
return base.SavingChanges(eventData, result);
}
public override ValueTask<InterceptionResult<int>> SavingChangesAsync(
DbContextEventData eventData,
InterceptionResult<int> result,
CancellationToken cancellationToken = default)
{
OnSavingChanges(eventData);
return base.SavingChangesAsync(eventData, result, cancellationToken);
}
public override int SavedChanges(SaveChangesCompletedEventData eventData, int result)
{
OnSavedChanges(eventData);
return base.SavedChanges(eventData, result);
}
public override ValueTask<int> SavedChangesAsync(
SaveChangesCompletedEventData eventData,
int result,
CancellationToken cancellationToken = default)
{
OnSavedChanges(eventData);
return base.SavedChangesAsync(eventData, result, cancellationToken);
}
public override void SaveChangesCanceled(DbContextEventData eventData)
{
OnSaveChangesCanceled(eventData);
base.SaveChangesCanceled(eventData);
}
public override Task SaveChangesCanceledAsync(
DbContextEventData eventData,
CancellationToken cancellationToken = default)
{
OnSaveChangesCanceled(eventData);
return base.SaveChangesCanceledAsync(eventData, cancellationToken);
}
public override void SaveChangesFailed(DbContextErrorEventData eventData)
{
OnSaveChangesFailed(eventData);
base.SaveChangesFailed(eventData);
}
public override Task SaveChangesFailedAsync(
DbContextErrorEventData eventData,
CancellationToken cancellationToken = default)
{
OnSaveChangesFailed(eventData);
return base.SaveChangesFailedAsync(eventData, cancellationToken);
}
protected virtual void OnSavingChanges(DbContextEventData eventData)
{
ArgumentNullException.ThrowIfNull(eventData.Context);
using var scope = ScopeFactory.CreateScope();
var timeProvider = scope.ServiceProvider.GetRequiredService<TimeProvider>();
eventData.Context.ChangeTracker.DetectChanges();
// 按实体元数据分组
var typedEntries = eventData.Context.ChangeTracker.Entries()
.Where(static entry => entry.State is EntityState.Deleted)
.GroupBy(static entry => entry.Metadata);
foreach (var entries in typedEntries)
{
// 相同元数据的不同上下文对象使用不同的逻辑删除缓存
// 实体模型的运行时元数据会通过逻辑删除缓存持有上下文对象的引用，需要在所有保存拦截方法中处理缓存并删除引用
var logicalDeletedCacheDictionary = entries.Key
.GetOrAddRuntimeAnnotationValue<ConcurrentDictionary<DbContext, HashSet<EntityEntry>>, object?>(
LogicallyDeletedRuntimeAnnotation,
static dbContext => [],
null);
var logicalDeletedCache = logicalDeletedCacheDictionary.GetOrAdd(eventData.Context, []);
foreach (var entry in entries)
{
if (entry.Entity is ILogicallyDeletable logicallyDeletable)
{
entry.State = EntityState.Modified;
logicallyDeletable.DeletedAt = timeProvider.GetLocalNow();
// 使用运行时注释缓存逻辑删除的实体
logicalDeletedCache.Add(entry);
}
}
}
}
protected virtual void OnSavedChanges(SaveChangesCompletedEventData eventData)
{
// 保存成功时需要解除对实体的跟踪，其他情况无需处理
PostProcessEntriesAndCleanLogicalDeletedCache(eventData, static entry => entry.State = EntityState.Detached);
}
protected virtual void OnSaveChangesCanceled(DbContextEventData eventData)
{
PostProcessEntriesAndCleanLogicalDeletedCache(eventData);
}
protected virtual void OnSaveChangesFailed(DbContextEventData eventData)
{
PostProcessEntriesAndCleanLogicalDeletedCache(eventData);
}
/// <summary>
/// 获取已逻辑删除的实体
/// </summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="eventData"></param>
/// <returns>已逻辑删除的实体集合</returns>
protected static IReadOnlyList<EntityEntry> GetLogicallyDeletedEntries<TEntity>(DbContextEventData eventData)
where TEntity : class
{
var dict = eventData.Context?.Model
.FindEntityType(typeof(TEntity))
?.FindRuntimeAnnotationValue(LogicallyDeletedRuntimeAnnotation) as ConcurrentDictionary<DbContext, HashSet<EntityEntry>>;
var entities = dict
?.GetValueOrDefault(eventData.Context!)
?.Where(static e => e.Entity is TEntity)
?.ToImmutableArray() ?? [];
return entities;
}
/// <summary>
/// 获取已逻辑删除的实体
/// </summary>
/// <param name="eventData"></param>
/// <returns>已逻辑删除的实体集合</returns>
protected static IReadOnlyList<EntityEntry> GetLogicallyDeletedEntries(DbContextEventData eventData)
{
var entities = eventData.Context?.Model
.GetEntityTypes()
.Select(static et => et.FindRuntimeAnnotationValue(LogicallyDeletedRuntimeAnnotation) as ConcurrentDictionary<DbContext, HashSet<EntityEntry>>)
.Where(static dict => dict is not null)
.Select(dict => dict!.GetValueOrDefault(eventData.Context!))
.Where(static hs => hs is { Count: > 0 })
.SelectMany(static hs => hs!)
.ToImmutableArray() ?? [];
return entities;
}
/// <summary>
/// 在保存后事件调用，执行自定义实体处理，然后清除运行时元数据注释的缓存，避免内存泄漏
/// </summary>
/// <param name="eventData">事件数据</param>
/// <param name="action">自定义处理委托</param>
protected static void PostProcessEntriesAndCleanLogicalDeletedCache(DbContextEventData eventData, Action<EntityEntry>? action = null)
{
ArgumentNullException.ThrowIfNull(eventData.Context);
var entrySetDict = eventData.Context.ChangeTracker.Entries()
.GroupBy(static e => e.Metadata)
.Select(static group => group.Key.FindRuntimeAnnotationValue(LogicallyDeletedRuntimeAnnotation) as ConcurrentDictionary<DbContext, HashSet<EntityEntry>>)
.Where(static dict => dict is not null)
.ToList();
var entrySets = entrySetDict
.Select(dict => dict!.GetValueOrDefault(eventData.Context))
.Where(static set => set is not null);
foreach (var set in entrySets)
{
foreach (var entry in set!)
{
action?.Invoke(entry);
}
set.Clear();
}
// 清空当前上下文的逻辑删除缓存避免内存泄漏
foreach (var dict in entrySetDict)
{
dict!.TryRemove(eventData.Context, out var _);
}
}
}
/// <summary><inheritdoc cref="LogicallyDeletableSaveChangesInterceptor"/></summary>
/// <typeparam name="TUser">用户实体类型</typeparam>
/// <typeparam name="TKey">用户实体主键类型</typeparam>
/// <param name="scopeFactory"></param>
/// <remarks>为 Identity 实体的唯一索引属性设置特别删除标记</remarks>
public class IdentityLogicallyDeletableSaveChangesInterceptor<TUser, TKey>(IServiceScopeFactory scopeFactory)
: LogicallyDeletableSaveChangesInterceptor(scopeFactory)
where TUser : IdentityUser<TKey>, ILogicallyDeletable
where TKey : IEquatable<TKey>
{
private const string _delMark = "!del";
/// <summary>
/// 把已删除的用户的特殊属性增加标记，避免无法创建同名用户和查询出已删除的同名用户
/// </summary>
/// <param name="eventData"></param>
protected override void OnSavingChanges(DbContextEventData eventData)
{
// 此处会把应该逻辑删除的已删除实体调整为已修改，不能通过ChangeTracker找到已逻辑删除的实体
base.OnSavingChanges(eventData);
var entityEntries = GetLogicallyDeletedEntries<TUser>(eventData);
foreach (var entry in entityEntries)
{
var entity = entry.Entity as TUser;
entity!.Email += _delMark + entity.DeletedAt.Ticks;
entity.NormalizedEmail += _delMark.ToUpperInvariant() + entity.DeletedAt.Ticks;
entity.UserName += _delMark + entity.DeletedAt.Ticks;
entity.NormalizedUserName += _delMark.ToUpperInvariant() + entity.DeletedAt.Ticks;
}
}
}

复制代码