在EF6中创建两侧可选的一对一关系

时间:2015-05-22 16:14:57

标签: entity-framework entity-framework-6 ef-fluent-api

有没有办法在实体框架6中使用流畅的API映射两个实体以使两边都有一对一的关系?

代码示例

// Subscription (has FK OrderId)
this.HasOptional(t => t.Order)
    .WithOptionalDependent(t => t.Subscription)
    .HasForeignKey(d => d.OrderId); // does not compile

背景:我为什么要这样做?我在现有系统中工作,其中有支付订单以购买订阅。当订单获得付款时,会创建订阅并将其关联,这意味着订购是可选的。此外,还有其他方法可以创建订阅,这意味着订购是可选的。

2 个答案:

答案 0 :(得分:1)

通常在一对一(或零)关系中,两个实体共享相同的PK,并且在从属关系中,PK也被指定为FK。有关详细信息,请查看此introductory book。但是,如果实体不共享相同的PK,则无法在依赖实体中添加FK属性。如果你这样做,EF将抛出一个与多重性相关的异常,说它必须是*。

关于关系的配置,只有一种方法可以将双方的一对一关系配置为可选,这就是您目前使用Fluent Api所拥有的关系。这样,您还可以使用link方法按照您在数据库中Subscription表中已有的名称,在依赖表中按惯例重命名EF创建的FK列。

更新

如果您没有绑定现有数据库,可以执行以下操作:

public class Subscription
{
    public int SubscriptionId { get; set; }

    public int? OrderId { get; set; }
    public virtual Order Order { get; set; }
}

public class Order
{
    public int OrderId { get; set; }
    public int SubscriptionId { get; set; }

    public virtual Subscription Subscription { get; set; }
}

配置如下:

 modelBuilder.Entity<Subscription>()
            .HasOptional(s => s.Order)
            .WithMany()
            .HasForeignKey(s=>s.OrderId);

 modelBuilder.Entity<>(Order)
            .HasOptional(s => s.Subscription)
            .WithMany()
            .HasForeignKey(s=>s.SubscriptionId);

通过这种方式,您可以使用OrderId FK(以及SubscriptionId),就像它是一对一的关系一样。这里的问题是你必须分别设置和保存两个关联。

答案 1 :(得分:0)

请在数据库上下文类

中尝试此代码
    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Subscription>()
            .HasOptional(x => x.Order)
            .WithOptionalPrincipal()
            .Map(x => x.MapKey("SubscriptionId"));

        modelBuilder.Entity<Order>()
            .HasOptional(x => x.Subscription)
            .WithOptionalPrincipal()
            .Map(x => x.MapKey("OrderId"));

    }

我的测试模型如下

public class Order
{
    [Key]
    public int OrderId { get; set; }
    public string Description { get; set; }

    public virtual Subscription Subscription { get; set; }
}
public class Subscription
{
    [Key]
    public int SubscriptionId { get; set; }

    public virtual Order Order { get; set; }
}

修改 我对数据库进行了逆向工程,试图通过使用双重1对多关系来实现所需的代码结构。生成的代码如下所示。但是,这样做是不明智的。

public partial class Order
{
    public Order()
    {
        this.Subscriptions = new List<Subscription>();
    }

    public int OrderId { get; set; }
    public string Description { get; set; }
    public Nullable<int> SubscriptionId { get; set; }
    public virtual Subscription Subscription { get; set; }
    public virtual ICollection<Subscription> Subscriptions { get; set; }
}
public partial class Subscription
{
    public Subscription()
    {
        this.Orders = new List<Order>();
    }

    public int SubscriptionId { get; set; }
    public Nullable<int> OrderId { get; set; }
    public virtual ICollection<Order> Orders { get; set; }
    public virtual Order Order { get; set; }
}
public class OrderMap : EntityTypeConfiguration<Order>
{
    public OrderMap()
    {
        // Primary Key
        this.HasKey(t => t.OrderId);

        // Properties
        // Table & Column Mappings
        this.ToTable("Orders");
        this.Property(t => t.OrderId).HasColumnName("OrderId");
        this.Property(t => t.Description).HasColumnName("Description");
        this.Property(t => t.SubscriptionId).HasColumnName("SubscriptionId");

        // Relationships
        this.HasOptional(t => t.Subscription)
            .WithMany(t => t.Orders)
            .HasForeignKey(d => d.SubscriptionId);

    }
}
public class SubscriptionMap : EntityTypeConfiguration<Subscription>
{
    public SubscriptionMap()
    {
        // Primary Key
        this.HasKey(t => t.SubscriptionId);

        // Properties
        // Table & Column Mappings
        this.ToTable("Subscriptions");
        this.Property(t => t.SubscriptionId).HasColumnName("SubscriptionId");
        this.Property(t => t.OrderId).HasColumnName("OrderId");

        // Relationships
        this.HasOptional(t => t.Order)
            .WithMany(t => t.Subscriptions)
            .HasForeignKey(d => d.OrderId);

    }
}
public partial class EFOrdersContextContext : DbContext
{
    static EFOrdersContextContext()
    {
        Database.SetInitializer<EFOrdersContextContext>(null);
    }

    public EFOrdersContextContext()
        : base("Name=EFOrdersContextContext")
    {
    }

    public DbSet<Order> Orders { get; set; }
    public DbSet<Subscription> Subscriptions { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Configurations.Add(new OrderMap());
        modelBuilder.Configurations.Add(new SubscriptionMap());
    }
}