防止 EF Core 生成外鍵

Question

我想創建一個實體，它保留對自身克隆的引用，並且該克隆實際上會在保存到數據庫之前被序列化為 json。

public class Foo
{
    public string StringProperty { get; set; }
    public int IntProperty { get; set; }
    public Foo Snapshot { get; set; }
}

public class FooConfiguration : IEntityTypeConfiguration< Foo >
{
    public virtual void Configure( EntityTypeBuilder< Foo > builder )
    {
        builder.Property( e => e.StringProperty );
        builder.Property( e => e.IntProperty )
               .IsRequired();
        builder.Property( e => e.Snapshot )
               .HasConversion( new FooToJsonConverter() );
    }
}

問題在於，因為 EF 知道Foo （它在上下文中被引用並且有一個流暢的配置文件），所以它創建了一個外鍵。

即使我試圖忽略它

builder.Ignore( e => e.Snapshot )

我已經使用自定義轉換器成功序列化了另一種類型，但是 EF 不知道其他類型（上下文中沒有引用，也沒有流暢的配置文件）。

有沒有辦法做到這一點？

Answer 1

問題在於，因為 EF 知道 Foo（它在上下文中被引用並且有一個流暢的配置文件），所以它創建了一個外鍵。

您可以創建特殊類型 - 包裝器 - EF 不會知道。

public class SnapshotWrapper<T>
{
    public T? Snapshot { get; set; }

    public string Serialize() => JsonSerializer.Serialize(Snapshot);

    public static SnapshotWrapper<T> CreateFromJson(string json)
    {
        if (json == null)
            throw new ArgumentNullException(nameof(json));

        return new SnapshotWrapper<T>
        {
            Snapshot = JsonSerializer.Deserialize<T>(json)
        };
    }
}

然后定義接口來識別具有快照的實體：

public interface IHasSnapshot<T>
{
    SnapshotWrapper<T> Snapshot { get; }
}

Foo 的示例：

public class Foo : IHasSnapshot<Foo>
{
    public Foo(int id, string name, int age) : this()
    {
        FooId = id;
        FooName = name ?? throw new ArgumentNullException(nameof(name));
        FooAge = age;
    }

    //to follow DRY principle
    //you can specify some SnapshotBase base type for doing this
    public Foo()
    {
        Snapshot = new SnapshotWrapper<Foo>
        {
            Snapshot = this
        };
    }

    public int FooId { get; set; }

    public string? FooName { get; set; }

    public int FooAge { get; set; }

    [JsonIgnore]
    public SnapshotWrapper<Foo> Snapshot { get; set; }
}

此外，您還可以為此類實體指定一些基本的 EntityTypeConfiguration：

public abstract class WithSnapshotEntityTypeConfigurationBase<T> : IEntityTypeConfiguration<T>
            where T : class, IHasSnapshot<T>
    {
            public virtual void Configure(EntityTypeBuilder<T> builder)
        {
                builder.Property(x => x.Snapshot).HasConversion(
                    x => x.Serialize(),
                    str => SnapshotWrapper<T>.CreateFromJson(str));
        }
    }
    
    public class FooConfiguration : WithSnapshotEntityTypeConfigurationBase<Foo>
    {
        public override void Configure(EntityTypeBuilder<Foo> builder)
        {
            base.Configure(builder);
            builder.HasKey(x => x.FooId);
            builder.Property(x => x.FooName).IsRequired().HasMaxLength(200);
    
            builder.HasData(
                new Foo(1, "John Doe", 30),
                new Foo(2, "Jane Smith", 20),
                new Foo(3, "Billy The Drunken", 40),
                new Foo(4, "James Webb", 60),
                new Foo(5, "Old president", 40));
        }
    }

這行得通。 有幾個缺點：

1. 需要用[JsonIgnore]標記Snapshot屬性
2. IHasSnapshot<T>中的 T 沒有任何約束，因此您可以編寫除Foo以外的內容（ class Foo: IHasSnapshot<Bar> ），但這並不重要。