AutoMapper.Collections，EFCore-使用短期DbContext

Question

我尝试使用AutoMapper.Collection.EntityFrameworkCore映射我的对象。如果我一直使用相同的DbContext，则一切正常。

问题是无法拒绝DbContext中的所有缓存对象。是的，我进行了搜索并找到了this帖子，但是它不起作用。我不太了解这个问题，但我敢打赌，这是因为我仅分离了容器对象。没有复杂的算法就无法遍历所有对象以分离它们。

这是当前正在运行的代码（非常简单）：

using var ctx = this.DbContextFactory.CreateDbContext();
var dtoProject = await ctx.Set<DtoProject>().Include(item => item.Jobs).FirstAsync();

var p = this.Mapper.Map<Project>(dtoProject);
var j = new Job(Guid.NewGuid().ToString("B").ToUpperInvariant(), $"Job {p.Jobs.Count + 1}");

p.Jobs.Add(j);

await ctx.Set<DtoProject>().Persist(this.Mapper).InsertOrUpdateAsync(p);
await ctx.SaveChangesAsync();

此代码在按预期工作的ctx处重用了SaveChangesAsync()。

但是这导致DbContext实例的寿命很长，因为只要使用业务对象，它就必须处于活动状态。这听起来不像是一个真正的问题，但是如果需要，我无法使DbContext中的对象无效以强制重新加载。

它似乎要走一个短暂的DbContext实例。听起来不错。我更改了上面的代码，以便使用单独的方法加载业务对象，并使用新的上下文来保存更改。

此简单代码显示更改：

using var ctx = this.DbContextFactory.CreateDbContext();
var dtoProject = await ctx.Set<DtoProject>().Include(item => item.Jobs).FirstAsync();

var p = this.Mapper.Map<Project>(dtoProject);
var j = new Job(Guid.NewGuid().ToString("B").ToUpperInvariant(), $"Job {p.Jobs.Count + 1}");

p.Jobs.Add(j);

using var tmpCtx = this.DbContextFactory.CreateDbContext();
await tmpCtx.Set<DtoProject>().Persist(this.Mapper).InsertOrUpdateAsync(p);
await tmpCtx.SaveChangesAsync();

唯一的更改是一个新的DbContext，称为tmpCtx，用于存储更改后的值。

但是此代码抛出DbUpdateException，告诉我jobs.id的唯一约束违规。 [container]实例p接缝被接受，但是包含的作业实例接缝失败。

如何解决？

以下代码显示了自动映射器的配置和对象声明：

private IMapper CreateMapper()
{
    var mapperCfg = new MapperConfiguration(cfg =>
    {
        cfg.AddExpressionMapping();
        cfg.AddCollectionMappers();

        cfg.CreateMap<Job, DtoJob>()
            .EqualityComparison((blo, dto) => blo.Id == dto.Id)
            .ForMember(dst => dst.ParentId, opt => opt.Ignore())
            .ForMember(dst => dst.Parent, opt => opt.Ignore())
            .ForMember(dst => dst.Id, opt => opt.MapFrom(src => src.Id))
            .ForMember(dst => dst.Name, opt => opt.MapFrom(src => src.Name));
        cfg.CreateMap<DtoJob, Job>()
            .EqualityComparison((dto, blo) => dto.Id == blo.Id)
            .ForCtorParam("id", opt => opt.MapFrom(src => src.Id))
            .ForCtorParam("name", opt => opt.MapFrom(src => src.Name))
            .ForMember(dst => dst.Id, opt => opt.MapFrom(src => src.Id))
            .ForMember(dst => dst.Name, opt => opt.MapFrom(src => src.Name))
            .ForSourceMember(src => src.ParentId, opt => opt.DoNotValidate())
            .ForSourceMember(src => src.Parent, opt => opt.DoNotValidate());

        cfg.CreateMap<Project, DtoProject>()
            .EqualityComparison((blo, dto) => blo.Id == dto.Id)
            .ForMember(dst => dst.Id, opt => opt.MapFrom(src => src.Id))
            .ForMember(dst => dst.Name, opt => opt.MapFrom(src => src.Name))
            .ForMember(dst => dst.Jobs, opt => opt.MapFrom(src => src.Jobs));
        cfg.CreateMap<DtoProject, Project>()
            .EqualityComparison((dto, blo) => dto.Id == blo.Id)
            .ForCtorParam("id", opt => opt.MapFrom(src => src.Id))
            .ForCtorParam("name", opt => opt.MapFrom(src => src.Name))
            .ForMember(dst => dst.Id, opt => opt.MapFrom(src => src.Id))
            .ForMember(dst => dst.Name, opt => opt.MapFrom(src => src.Name))
            .ForMember(dst => dst.Jobs, opt => opt.MapFrom(src => src.Jobs));
    });
    mapperCfg.AssertConfigurationIsValid();

    return mapperCfg.CreateMapper();
}

public class Job
{
    public Job(string id, string name)
    {
        this.Id = id;
        this.Name = name;
    }

    public string Id { get; }

    public string Name { get; }
}

public class Project
{
    public Project(string id, string name)
    {
        this.Id = id;
        this.Name = name;
    }

    public string Id { get; }

    public string Name { get; }

    public List<Job> Jobs { get; set; }
}

[Table("jobs")]
public class DtoJob
{
    [Key]
    [Column("id")]
    public string Id { get; set; }

    [Column("parent_id")]
    [ForeignKey(nameof(Parent))]
    [Required]
    public string ParentId { get; set; }

    public DtoProject Parent { get; set; }

    [Column("name")]
    [Required]
    public string Name { get; set; }
}

[Table("projects")]
public class DtoProject
{
    [Key]
    [Column("id")]
    [Required]
    public string Id { get; set; }

    [Column("name")]
    [Required]
    public string Name { get; set; }

    public List<DtoJob> Jobs { get; set; }
}

这是一个非常简单的测试代码，用于隔离问题。

Answer 1

我找到了一个似乎可行的解决方案。步骤如下：

• 加载：
  • 创建DbContext实例
  • 加载DTO并将其映射到业务逻辑实例
  • 拒绝DbContext实例
• 修改业务逻辑实例（添加/修改/删除子级）
• 保存：
  • 创建DbContext实例
  • 加载DTO并将其映射到业务逻辑实例仅供内部使用
  • 将现有业务逻辑实例映射到已加载实例（将值映射（复制到现有实例）。
  • 保存此映射实例。已加载该实例的上下文跟踪该实例。这就是为什么此操作有效的原因。

这将执行不需要的加载操作，但我没有找到其他解决方案。

简单代码为：

var p = (await this.LoadAsync()).FirstOrDefault();
// null handling omitted
var j = new Job(Guid.NewGuid().ToString("B").ToUpperInvariant(), $"Job {p.Jobs.Count + 1}");

p.Jobs.Add(j);
p.Jobs.RemoveAt(0);

await this.SaveAsync(p);

这使用以下方法：

private async Task<IList<Project>> LoadAsync(Expression<Func<Project, bool>> filter = null)
{
    using var ctx = this.DbContextFactory.CreateDbContext();
    IQueryable<DtoProject> query = ctx.Set<DtoProject>().Include(item => item.Jobs);
    if (!(filter is null))
    {
        query = query.Where(this.Mapper.MapExpression<Expression<Func<DtoProject, bool>>>(filter));
    }

    var resultDtos = await query.ToListAsync();
    var result = resultDtos.Select(this.Mapper.Map<Project>).ToList();
    return result;
}

private async Task SaveAsync(Project project)
{
    Project MapToStored(DtoProject dtoProject)
    {
        var result = this.Mapper.Map<Project>(dtoProject);
        this.Mapper.Map(project, result);
        return result;
    }

    Expression<Func<Project, bool>> filter = p => p.Id == project.Id;

    using var ctx = this.DbContextFactory.CreateDbContext();
    var storedDtoProject = await ctx.Set<DtoProject>().Include(p => p.Jobs).FirstOrDefaultAsync(this.Mapper.MapExpression<Expression<Func<DtoProject, bool>>>(filter));
    var projectToStore =
        !(storedDtoProject is null) ?
            MapToStored(storedDtoProject) :
            project;

    await ctx.Set<DtoProject>().Persist(this.Mapper).InsertOrUpdateAsync(projectToStore);
    await ctx.SaveChangesAsync();
}

此解决方案的主要优点是DbContext实例的寿命很短。它们仅用于加载和保存对象。业务逻辑对象的生存期对DbContext实例没有任何影响。

上面的代码将Project的实例映射到Project的实例（与Job相同）。这需要将以下映射添加到现有的映射中，该现有映射是从DTO映射到DTO的：

cfg.CreateMap<Job, Job>()
    .EqualityComparison((left, right) => left.Id == right.Id)
    .ForCtorParam("id", opt => opt.MapFrom(src => src.Id))
    .ForCtorParam("name", opt => opt.MapFrom(src => src.Name))
    .ForMember(dst => dst.Id, opt => opt.MapFrom(src => src.Id))
    .ForMember(dst => dst.Name, opt => opt.MapFrom(src => src.Name));
cfg.CreateMap<Project, Project>()
    .EqualityComparison((left, right) => left.Id == right.Id)
    .ForCtorParam("id", opt => opt.MapFrom(src => src.Id))
    .ForCtorParam("name", opt => opt.MapFrom(src => src.Name))
    .ForMember(dst => dst.Id, opt => opt.MapFrom(src => src.Id))
    .ForMember(dst => dst.Name, opt => opt.MapFrom(src => src.Name))
    .ForMember(dst => dst.Jobs, opt => opt.MapFrom(src => src.Jobs));

这就是我现在将尝试的方法，希望它能够解决所有问题。