外鍵的使用CTP4代碼優先

Question

要總結一下我的模型EF4 TPH鑑別：

• 許可和證書資格的兒童
• 資質有且只有一個職業
• 一個行業或者是有執照的種類（1型）或認證的種類（類型2）

要求：代表業務entiti之間的關係而不會在數據庫模式中引入冗餘。資格類型（許可證/證書）必須與專業類型相匹配。

這裏是我的簡化模型，因爲它目前爲 - 我解釋爲什麼不工作如下：

Public Class Profession 
    <Key()> 
    <DataMember(Order:=0)> 
    Public Property Type As Integer 
    <Key()> 
    <DataMember(Order:=1)> 
    Public Property Code As String 

    Public Property Title As String 
End Class 

Public Class Qualification 
    Public Property Id As Integer 
    Public Property PersonId As Integer 
    Public Property Type As Integer 
    Public Property ProfessionCode As String 
    Public Overridable Property Person As Person 
    Public Overridable Property Profession As Profession 
End Class 

Public Class License 
    Inherits Qualification 

    Public Property Number As String   
End Class 

Public Class Certificate 
    Inherits Qualification 

    Public Property IssuerName As String  
End Class 

這裏的簡化模型構建器：

modelBuilder.Entity(Of Qualification) _ 
    .Property(Function(q) q.ProfessionCode).IsRequired() 

modelBuilder.Entity(Of Qualification) _ 
    .HasRequired(Of Profession)(Function(q) q.Profession) _ 
    .HasConstraint(Function(q, p) p.Type = q.Type AndAlso p.Code = q.ProfessionCode) 

modelBuilder.Entity(Of Qualification) _ 
    .MapHierarchy() _ 
    .Case(Of Qualification)(Function(q) New With { 
     q.Id, 
     q.PersonId, 
     q.ProfessionCode, 
     .Type = 0) _ 
    .Case(Of License)(Function(q) New With { 
     q.Number, 
     .Type = 1}) _ 
    .Case(Of Certificate)(Function(q) New With { 
     q.IssuerName, 
     .Type = 2}) _ 
    .ToTable("dbo.Qualifications") 

的原因，這不工作是EF4 does not allow FK屬性作爲TPH鑑別器加倍。這意味着Type不能既是鑑別器又是外鍵字段。嘗試在每個實體的HasConstraint方法中硬編碼Profession類型也不起作用 - 這會生成一個異常。

一個可能的解決方案是將代理鍵添加到職業，擺脫資格中的類型屬性，並用ProfessionId FK替換它。這會消除冗餘問題，但也會破壞TPH。實際上，鑑別者從資格轉移到職業。這裏的問題是，我還沒有想出映射許可證和證書對象的方法。也許我可以映射到視圖呢？但我如何在Code First中做到這一點？

所以，現在我面臨着一些不愉快的選擇。有什麼建議麼？

Answer 1

我設法使它的工作原理是將其更改爲這種模式：

public class Profession {  
    [Key][DataMember(Order = 0)]  
    public int Type { get; set; } 
    [Key][DataMember(Order = 1)] 
    public string Code { get; set; } 
    public string Title { get; set; } 
} 

public class Qualification { 
    public int Id { get; set; }    
    [Required] 
    public int ProfessionType { get; set; } 
    [Required] 
    public string ProfessionCode { get; set; }     
    [Required] 
    public virtual Profession Profession { get; set; } 
} 

public class License : Qualification { 
    public string Number { get; set; } 
} 

public class Certificate : Qualification { 
    public string IssuerName { get; set; } 
} 

class Context : DbContext { 
    public DbSet<Qualification> Qualifications { get; set; } 
    public DbSet<Profession> Professions { get; set; } 

    protected override void OnModelCreating(ModelBuilder modelBuilder) { 
     modelBuilder.Entity<Qualification>() 
      .HasRequired<Profession>(q => q.Profession) 
      .HasConstraint((q, p) => q.ProfessionCode == p.Code 
            && q.ProfessionType == p.Type); 

     modelBuilder.Entity<Qualification>().MapHierarchy() 
      .Case<Qualification>(q => new { 
       q.ProfessionCode, 
       q.ProfessionType, 
       q.Id,      
       Type = 0 
      }).Case<License>(q => new { 
       q.Number, 
       Type = 1 
      }).Case<Certificate>(q => new { 
       q.IssuerName, 
       Type = 2 
      }).ToTable("Qualifications"); 
    } 
} 

然而，正如你所知道的，ProfessionType是資格多餘的，沒有辦法要解決它，因爲像你說的， EF不會讓你重用鑑別爲FK其意義，因爲這條規則：

一個行業或者是有執照的種類（1型）或認證的種類（類型2）

是EF不知道的，因此它必須防止它爲了保護層次結構。

個人而言，如下是我認爲更清晰和更少的冗餘我將設計對象模型：

public class Profession { 
    public int ProfessionId { get; set; }   
    public int Type { get; set; } 
    public string Code { get; set; } 
    public string Title { get; set; } 
} 

public class Qualification { 
    public int Id { get; set; } 
    public int ProfessionId { get; set; }     
    [Required] 
    public virtual Profession Profession { get; set; } 
} 

public class License : Qualification { 
    public string Number { get; set; } 
} 

public class Certificate : Qualification { 
    public string IssuerName { get; set; } 
} 

class Context : DbContext { 
    public DbSet<Qualification> Qualifications { get; set; } 
    public DbSet<Profession> Professions { get; set; } 

    protected override void OnModelCreating(ModelBuilder modelBuilder) { 
     modelBuilder.Entity<Qualification>() 
      .HasRequired<Profession>(q => q.Profession) 
      .HasConstraint((q, p) => q.ProfessionId == p.ProfessionId); 

     modelBuilder.Entity<Qualification>().MapHierarchy() 
      .Case<Qualification>(q => new { 
       q.ProfessionId,     
       q.Id,      
       Type = 0 
      }) 
      .Case<License>(q => new { 
       q.Number, 
       Type = 1 
      }) 
      .Case<Certificate>(q => new { 
       q.IssuerName, 
       Type = 2 
      }) 
      .ToTable("Qualifications"); 
    } 
} 

導致在DB以下模式：

的又一種方式避免DRY會將等級變爲TPT而不是TPH：

public class Profession { 
    [Key] 
    [DataMember(Order = 0)] 
    public int Type { get; set; } 
    [Key] 
    [DataMember(Order = 1)] 
    public string Code { get; set; } 
    public string Title { get; set; } 
} 

public class Qualification { 
    public int Id { get; set; } 
    [Required] 
    public int ProfessionType { get; set; } 
    [Required] 
    public string ProfessionCode { get; set; } 
    [Required] 
    public virtual Profession Profession { get; set; } 
} 

public class License : Qualification { 
    public string Number { get; set; } 
} 

public class Certificate : Qualification { 
    public string IssuerName { get; set; } 
} 

class Context : DbContext 
{ 
    public DbSet<Qualification> Qualifications { get; set; } 
    public DbSet<Profession> Professions { get; set; } 

    protected override void OnModelCreating(ModelBuilder modelBuilder) { 
     modelBuilder.Entity<Qualification>() 
      .HasRequired<Profession>(q => q.Profession) 
      .HasConstraint((q, p) => q.ProfessionCode == p.Code 
            && q.ProfessionType == p.Type); 

     modelBuilder.Entity<Qualification>().MapHierarchy(q => new 
     { 
      q.Id, 
      q.ProfessionCode, 
      q.ProfessionType, 
     }) 
     .ToTable("Qualifications"); 

     modelBuilder.Entity<License>().MapHierarchy(l => new 
     { 
      l.Id, 
      l.Number 
     }) 
     .ToTable("Licenses"); 

     modelBuilder.Entity<Certificate>().MapHierarchy(c => new 
     { 
      c.Id, 
      c.IssuerName 
     }) 
     .ToTable("Certificates"); 
    } 
} 

導致以下模式在DB：