Codice EF dapprima dal database 0..1 a molte relazioni

Question

Sto provando a generare un primo modello di codice del framework di entità da un database esistente (senza modificare lo schema del database). Questo database è stato utilizzato in passato per generare modelli edmx e sto cercando di ottenere il modello equivalente usando Fluent Api o annotazioni di dati.

La relazione non riesco a riprodurre è 0..1 per molti utilizzando una tabella di join (non una chiave straniera nullable).

Quindi sarebbe simile a questa:

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

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

TableB 
{ 
    ID (PrimaryKey) 
    TableAs (Many) 
} 

È questo realizzabile in primo stile codice o dovrò generare un modello di edmx al fine di utilizzare questo database in EF senza cambiare lo schema?

Molte grazie, Phil

Answer 1

Se ho capito bene, il seguente codice usando solo le annotazioni di dati dovrebbe creare il proprio modello.

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; } 
}  

È interessante notare che, EF non esegue un giro indietro a quello originale, se generate i modelli in codice prima dal modello di database che questo codice crea quindi EF semplifica il modello e rimuove la tabella unirsi e crea una chiave straniera nullable.

Fammi sapere se funziona.

Answer 2

Ecco un esempio senza utilizzare una classe JoinTable. La tabella di join è configurata tramite l'API fluente.

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; } 
    } 

Questo genererà il seguente script di migrazione, che assomiglia allo schema che si ha.

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

Posso sbagliarmi, ma credo che ti manca alcuni concetti qui ...

Perché avere un JoinTable se è non ha colonna oltre alle chiavi esterne? Non ha senso ... IHMO una chiave straniera nullable in TableA sarebbe il modo corretto.

Quando si lavora con Code-First vuol dire che tutto nel database sarà rappresentato dal CODICE. Non c'è alcun motivo per avere una tabella nel database, ma non nel codice ...

EDMX gestisce quel rapporto perché utilizza "Associazioni" https://msdn.microsoft.com/en-us/data/jj713299#Overview

... appoggiano al codice-prima, è possibile rappresentare il database in questo modo:

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); 
    } 
}