modelBuilder.Les Configurations.Ajouter et modelBuilder.Entité sur OnModelCreating

Vous avez plusieurs façons de configurer votre entités. Ci-dessous je vais vous montrer trois manières,l'une utilisant DataAnnotations et deux à l'aide Api Fluent.

La première variante est à l'aide de DataAnnotations. Vous pouvez utiliser des attributs(DataAnnotations) pour configurer vos classes d'entités et les propriétés.DataAnnotations attributs remplace le Code par défaut Premières conventions:

[Table(“BLOGS”)]
public class Blog
{
    [Key]
    [Column(“BLOGID”)]
    public int BlogId { get; set; }
    [Column(“NAME”)]
    public string Name { get; set; }
    [Column(“URL”)]
    public string Url { get; set; }

    public virtual List<Post> Posts { get; set; }
}
[Table(“POSTS”)]
public class Post
{
    [Key]
    [Column(“POSTID”)]
    public int PostId { get; set; }
    [Column(“TEXT”)]
    public string Text { get; set; }

    public int BlogId { get; set; }

    [ForeignKey("BlogId")]
    public virtual BaseCard Blog { get; set; }
}

Puis, dans votre contexte de la classe, vous n'avez pas besoin de remplacer le OnModelCreating méthode, EF utiliser l'attribut de mapper les entités et les relations (il va créer un 1 à plusieurs relations entre le blog et le post):

public class BlogContext : DbContext
{
    public BlogContext(string name)
        : base(name)
    {
    }

    public IDbSet<Blog> Blogs { get; set; }
    public IDbSet<Post> Posts { get; set; }
}  

Configuration avec Annotations de Données est assez simple et il peut être juste ce que vous cherchez. Mais les Données les Annotations seulement vous permettre d'accéder à un sous-ensemble des configurations possibles (bien que beaucoup plus que vous avez vu jusqu'à présent). Le API Fluent , cependant, vous donne accès à encore plus, alors vous préférerez peut-être pour cette raison.
Avec Api Fluent vous n'avez pas besoin d'utiliser les attributs de mapper les champs et les relations de vos classes d'entités. Il y a deux façons d'utiliser les Api Fluent:

1-Cartographie des entités (des champs et des relations) dans le OnModelCreating méthode dans votre contexte (Votre deuxième Approche):

public class BloggingContext : DbContext
{     

    public DbSet<Blog> Blogs { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Blog>().ToTable("BLOGS");

        modelBuilder.Entity<Blog>().HasKey(t => t.BlogId);
        modelBuilder.Entity<Blog>().Property(t => t.BlogId).HasColumnName("BLOGID");
        modelBuilder.Entity<Blog>().Property(t => t.Name).HasColumnName("NAME");
        modelBuilder.Entity<Blog>().Property(t => t.Url).HasColumnName("URL");
       //The same with post

        //mapping one-to-many relationship
        modelBuilder.Entity<Post>().HasRequired(c => c.Blog)
       .WithMany(s => s.Posts)
       .HasForeignKey(c => c.BlogId);

}

2-La deuxième variante à l'aide Api Fluent est la création de la cartographie des classes (Premier). De cette façon, vous pouvez configurer vos Entités dans les classes qui héritent de EntityTypeConfiguration<TEntity>:

public class BlogMap : EntityTypeConfiguration<Blog>
{
    public BlogMap()
    {
        ToTable("BLOGS");
        HasKey(t => t.BlogId);
        Property(t => t.BlogId).HasColumnName("BLOGID");
        Property(t => t.Name).HasColumnName("NAME");
        Property(t => t.Url).HasColumnName("URL");
    }

}

public class PostMap : EntityTypeConfiguration<Post>
{
    public PostMap()
    {
        ToTable("POSTS");
        HasKey(t => t.PostId);
        Property(t => t.Text).HasColumnName("TEXT");

      //mapping the relationship
        HasRequired(c => c.Blog)
        .WithMany(s => s.Posts)
        .HasForeignKey(c => c.BlogId);

    }
}

Alors, pour inclure les mappages dans votre contexte, vous devez les ajouter dans la OnModelCreating méthode:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
  modelBuilder.Configurations.Add(new BlogMap());
  modelBuilder.Configurations.Add(new PostMap());
}

La meilleure façon d'ajouter de la configuration est à cette façon:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
     var typesToRegister = Assembly.GetExecutingAssembly().GetTypes()
      .Where(type => !String.IsNullOrEmpty(type.Namespace))
      .Where(type => type.BaseType != null && type.BaseType.IsGenericType
           && type.BaseType.GetGenericTypeDefinition() == typeof(EntityTypeConfiguration<>));
       foreach (var type in typesToRegister)
       {
           dynamic configurationInstance = Activator.CreateInstance(type);
           modelBuilder.Configurations.Add(configurationInstance);
       }
       base.OnModelCreating(modelBuilder);  
}

Cette dernière variante, la première approche) pour moi, c'est la meilleure raison pour que vous ne touchez pas à votre modèle de classes (ajout d'attributs) pour spécifier ce que vous voulez et est plus souple si vous voulez ajouter une nouvelle entité ou de changer quelque chose.