Question

我正在尝试为具有复杂值对象的实体建模。

数据库结构可能与此类似：

+-------------------------------------+
|                car                  |
+----------------------+--------------+
| id                   | CHAR(40)     |
+----------------------+--------------+
| model                | VARCHAR(255) |
+----------------------+--------------+
| specs_engine_version | VARCHAR(255) |
+----------------------+--------------+
| specs_lighting       | VARCHAR(255) |
+----------------------+--------------+


+------------------------------------+
|      specs_interior_equipment      |
+-----------------------+------------+
| car_id                | CHAR(40)   |
+-----------------------+------------+
| interior_equipment_id | INT(11)    |
+-----------------------+------------+

这是Car实体：

public class Car : IEntity<Guid>
{
    public Guid Id { get; private set; }
    public string Model { get; private set; }

    public Specs Specs { get; set; }

    public Car()
    { }
}

这是Specs值对象：

public class Specs : ValueObject<Specs>
{
    public string EngineVersion { get; private set; }
    public string Lighting { get; private set; }
    public List<int> InteriorEquipment { get; private set; }

    public Specs()
    {}
}

我正在或多或少地像这样配置映射：

class CarMap : IEntityTypeConfiguration<Car>
{
    public void Configure(EntityTypeBuilder<Car> builder)
    {
        builder.HasKey(t => t.Id);
        builder.ToTable("car");
        builder.Property(e => e.Id).HasColumnName("id");
        builder.Property(e => e.Name).HasColumnName("name");
        builder.OwnsOne(j => j.Specs, l =>
        {
            l.Property(t => t.EngineVersion).HasColumnName("specs_engine_version");
            l.Property(t => t.Lighting).HasColumnName("specs_lighting");
        });
    }
}

问题是：我应该如何配置映射以将内部设备保留在单独的表中？

我知道我可以将室内设备定义为对象，例如：

builder
    .HasMany(j => j.InteriorEquipment)
    .WithOne()
    .HasForeignKey(t => t.CarId)
    .OnDelete(DeleteBehavior.Cascade)
    .Metadata.PrincipalToDependent.SetPropertyAccessMode(PropertyAccessMode.Field);

但是我不知道如何加入所有片段...

你能帮我吗？

Answer 1

马克

我认为在您的情况下，您需要一个单独的类来构建表规格，这不应在car类中完成，例如：

class SpecMap : IEntityTypeConfiguration<Spec>

然后，您可以在存储库调用中添加一个函数以检索所有信息。

在这里，我向您发布我们如何在InfoJobs中解决此问题，希望对您有所帮助。

将候选类别指向CandidateResumeDeficiencies，因此候选可以具有CandidateResumeDeficiency列表。

-> CandidateResumeClass

公共类CandidateResume：BaseEntity，IAggregateRoot { #region。：属性：。

    public int IdCandidateResume { get; protected set; }
    public int IdCandidate { get; protected set; }
    ....
 }

->虚弱类

public class CandidateResumeDeficiency
{
    public int IdCandidateResumeDeficiency { get; private set; }
    public int IdCandidateResume { get; private set; }
    public int IdDeficiency1 { get; private set; }
    ...
}

->建设者

class CandidateEntityTypeConfiguration : IEntityTypeConfiguration<Candidate>
{
    public void Configure(EntityTypeBuilder<Candidate> builder)
    {
        builder.ToTable("candidates",    EFContext.DbSchema.candidate.ToString());

        builder.HasKey(b => b.IdCandidate);
        builder.HasAlternateKey(b => new { b.IdCompany, b.Email });

    }

}

class CandidateResumeDeficiencyEntityTypeConfiguration : IEntityTypeConfiguration<CandidateResumeDeficiency>
{
    public void Configure(EntityTypeBuilder<CandidateResumeDeficiency> builder)
    {
        builder.ToTable("candidateresumedeficiencies", EFContext.DbSchema.candidate.ToString());

        builder.HasKey(b => b.IdCandidateResumeDeficiency);
    }
}

->存储库

 public class CandidateResumeRepository : EFRepository<CandidateResume, int>, ICandidateResumeRepository
{
    public CandidateResumeRepository(EFContext dbContext) : base(dbContext)
    {
    }

    public async Task<CandidateResume> GetFullAsync(int idCandidateResume) =>
        await ((EFContext)_dbContext).CandidateResumes

                                              .Include(c => c.Deficiencies)

                                 .FirstOrDefaultAsync(c => c.IdCandidateResume == idCandidateResume);

}

Answer 2

我找到了一种解决方案，可以通过使用一个对象来代表设备来保持表分裂。

这是映射配置：

class CarMap : IEntityTypeConfiguration<Car>
{

    public void Configure(EntityTypeBuilder<Car> builder)
    {
        builder.HasKey(t => t.Id);

        builder.ToTable("car");

        builder.Property(e => e.Id).HasColumnName("id");
        builder.Property(e => e.Name).HasColumnName("name");

        builder.OwnsOne(j => j.Specs, l =>
        {
            l.Property(t => t.EngineVersion).HasColumnName("specs_engine_version");
            l.Property(t => t.Lighting).HasColumnName("specs_lighting");

            l.OwnsMany(x => x.InteriorEquipment, x =>
            {
                x.HasKey(t => t.Id);

                x.WithOwner().HasForeignKey("CarId");

                x.ToTable("specs_interior_equipment");

                x.Property(j => j.Id).HasColumnName("id");
                x.Property(j => j.CategoryId).HasColumnName("equipment_id");
                x.Property(j => j.CarId).HasColumnName("car_id");
            });
        });
    }
}

这是设备对象：

public class Equipment: TEntity<Guid>
{


    private Equipment() { }


    public Equipment(Guid carId, int equipmentId)
    {
        Id = Guid.NewGuid();
        CarId = carId;
        EquipomentId = equipmentId;
    }


    public Guid Id { get; internal set; }
    public Guid CarId { get; internal set; }
    public int EquipmentId { get; internal set; }
}

实体框架的核心和复杂的价值对象

2 个答案: