EF-Code zuerst aus Datenbank 0..1 zu vielen Beziehung

Question

Ich versuche, ein Entity-Framework-Code-erstes Modell aus einer vorhandenen Datenbank zu generieren (ohne das Datenbankschema zu ändern). Diese Datenbank wurde in der Vergangenheit verwendet, um edmx-Modelle zu generieren, und ich versuche, das entsprechende Modell mit Fluent Api oder Datenanmerkungen zu erreichen.

Die Beziehung, die ich nicht reproduzieren konnte, ist 0..1 für viele, die eine Join-Tabelle verwenden (kein Nullable-Fremdschlüssel).

So wäre es etwa so aussehen:

TableA 
{ 
    ID (PrimaryKey) 
    TableB (0 or 1) 
} 

JoinTable 
{ 
    TableA_FK (PrimaryKey, ForeignKey), 
    TableB_FK (ForeignKey) 
} 

TableB 
{ 
    ID (PrimaryKey) 
    TableAs (Many) 
} 

Ist dies erreichbar im Code ersten Stil oder muß ich ein edmx Modell zu generieren, um diese Datenbank in EF zu verwenden, ohne das Schema zu ändern?

Vielen Dank, Phil

Answer 1

Wenn ich es richtig verstanden habe, der folgende Code nur Daten Annotationen verwenden, sollten Sie Ihr Modell erstellen.

public class TableA 
{ 
    public int ID { get; set; } 

    public JoinTable JoinTable { get; set; } 
} 

public class TableB 
{ 
    public int ID { get; set; } 

    public List<JoinTable> JoinTables{ get; set; } 
} 

public class JoinTable 
{ 
    [Key, ForeignKey("TableA")] 
    public int TableA_FK { get; set; } 

    [ForeignKey("TableB")] 
    public int TableB_FK { get; set; } 

    public TableA TableA { get; set; } 

    public TableB TableB { get; set; } 
}  

Interessanterweise hat EF nicht eine Rundfahrt zurück zum Original durchführt, wenn Sie den Code ersten Modelle aus dem Datenbank-Modell generieren, die dieser Code erstellt dann EF das Modell vereinfacht und entfernt den Tisch sitzen und eine schafft NULL-fähiger Fremdschlüssel

Lassen Sie mich wissen, ob das funktioniert.

Answer 2

Hier ist ein Beispiel ohne Verwendung einer JoinTable-Klasse. Die Join-Tabelle wird über die flüssige API konfiguriert.

class DataContext : DbContext 
    { 
     public DataContext(string connectionString) 
      : base(connectionString) 
     { } 

     public DbSet<TableA> TableA { get; set; } 
     public DbSet<TableB> TableB { get; set; } 

     protected override void OnModelCreating(DbModelBuilder modelBuilder) 
     { 
      base.OnModelCreating(modelBuilder); 

      modelBuilder.Entity<TableA>().ToTable("TableA"); 
      modelBuilder.Entity<TableB>().ToTable("TableB"); 

      modelBuilder.Entity<TableB>() 
       .HasMany(x => x.TableAs) 
       .WithMany() 
       .Map(m => 
       { 
        m.ToTable("JoinTable"); 
        m.MapLeftKey("TableA_FK"); 
        m.MapRightKey("TableB_FK"); 
       }); 
     } 
    } 

    class TableA 
    { 
     public int ID { get; set; } 
     public TableB TableB { get; set; } 
    } 

    class TableB 
    { 
     public int ID { get; set; } 
     public ICollection<TableA> TableAs { get; set; } 
    } 

Dies generiert das folgende Migrationsskript, das wie das Schema aussieht, das Sie haben.

public override void Up() 
{ 
    CreateTable(
     "dbo.TableA", 
     c => new 
      { 
       ID = c.Int(nullable: false, identity: true), 
       TableB_ID = c.Int(), 
      }) 
     .PrimaryKey(t => t.ID) 
     .ForeignKey("dbo.TableB", t => t.TableB_ID) 
     .Index(t => t.TableB_ID); 

    CreateTable(
     "dbo.TableB", 
     c => new 
      { 
       ID = c.Int(nullable: false, identity: true), 
      }) 
     .PrimaryKey(t => t.ID); 

    CreateTable(
     "dbo.JoinTable", 
     c => new 
      { 
       TableA_FK = c.Int(nullable: false), 
       TableB_FK = c.Int(nullable: false), 
      }) 
     .PrimaryKey(t => new { t.TableA_FK, t.TableB_FK }) 
     .ForeignKey("dbo.TableB", t => t.TableA_FK, cascadeDelete: true) 
     .ForeignKey("dbo.TableA", t => t.TableB_FK, cascadeDelete: true) 
     .Index(t => t.TableA_FK) 
     .Index(t => t.TableB_FK); 

} 

Answer 3

Ich kann mich irren, aber ich glaube, dass Sie einige Konzepte sind hier fehlt ...

Warum haben Sie eine JoinTable wenn es hat keine Spalte neben der Fremdschlüssel? Es macht keinen Sinn ... IHMO ein Nullable Fremdschlüssel in TableA wäre der richtige Weg.

Wenn Sie mit Code-First arbeiten, bedeutet dies, dass alles in Ihrer Datenbank durch CODE repräsentiert wird. Es gibt keinen Grund, eine Tabelle in der Datenbank zu haben, aber nicht in Ihrem Code ...

EDMX behandelt, die eine Beziehung, weil es „Verbände“ verwendet https://msdn.microsoft.com/en-us/data/jj713299#Overview

... Sicherung auf die Code-first, können Sie repräsentieren Ihre Datenbank wie folgt aus:

public class JoinTable 
{ 
     [Key] 
     [DatabaseGenerated(DatabaseGeneratedOption.None)] 
     public int TableA_FK { get; set; } 

     public int TableB_FK { get; set; } 

     //a future property here 

     public virtual TableA TableA { get; set; } 

     public virtual TableB TableB { get; set; } 
} 

public partial class TableA 
{ 
     [Key] 
     [DatabaseGenerated(DatabaseGeneratedOption.Identity)] 
     public int TableAId { get; set; } 

     [Required] 
     [StringLength(50)] 
     public string Name { get; set; } 

     public virtual JoinTable JoinTable { get; set; } 
} 


public partial class TableB 
{ 
     public TableB() 
     { 
      JoinTable = new HashSet<JoinTable>(); 
     } 

     [Key] 
     [DatabaseGenerated(DatabaseGeneratedOption.Identity)] 
     public int TableBId { get; set; } 

     [Required] 
     [StringLength(50)] 
     public string Name { get; set; } 

     public virtual ICollection<JoinTable> JoinTable { get; set; } 
    } 
} 

public partial class Model1 : DbContext 
{ 
    public Model1() 
     : base("name=Model1") 
    { 
    } 

    public virtual DbSet<JoinTable> JoinTable { get; set; } 
    public virtual DbSet<TableA> TableA { get; set; } 
    public virtual DbSet<TableB> TableB { get; set; } 

    protected override void OnModelCreating(DbModelBuilder modelBuilder) 
    { 

     modelBuilder.Entity<TableA>() 
      .HasOptional(e => e.JoinTable) 
      .WithRequired(e => e.TableA); 

     modelBuilder.Entity<TableB>() 
      .HasMany(e => e.JoinTable) 
      .WithRequired(e => e.TableB) 
      .HasForeignKey(e => e.TableB_FK) 
      .WillCascadeOnDelete(false); 
    } 
}