EF core中缺少System.Data.Entity.ModelConfiguration

System.Data.Entity.ModelConfiguration missing in EF core

尝试在实体框架核心的 OnModelCreating 上动态加载所有配置。 如果缺少 ModelConfiguration，反之亦然。

答案1

现在在 Core 2.0 中更容易

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace MyApp.DAL.EntityConfigurations
{
    public class StudentConfiguration : IEntityTypeConfiguration<Student>
    {
        public void Configure(EntityTypeBuilder<Student> modelBuilder)
        {

            modelBuilder.Property(f => f.Name).IsRequired();

        }
    }
}

然后在您的数据库上下文中：

public DbSet<Student> Students{ get; set; }

public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options) { }

protected override void OnModelCreating(ModelBuilder builder)
{
    base.OnModelCreating(builder);

    // Customizations must go after base.OnModelCreating(builder)

    builder.ApplyConfiguration(new StudentConfig());
    builder.ApplyConfiguration(new SomeOtherConfig());

    // etc.
    // etc..
}

答案2

当我自己寻找答案时，我偶然发现了这个问题。 我发现它还没有（还？）在 EF Core 中实现，但可以很容易地自己实现。
您可以创建其中之一：

using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace Microsoft.EntityFrameworkCore
{
    public abstract class EntityTypeConfiguration<TEntity> where TEntity : class
    {
        public abstract void Map(EntityTypeBuilder<TEntity> modelBuilder);
    }

    public static class ModelBuilderExtensions
    {
        public static void AddConfiguration<TEntity>(this ModelBuilder modelBuilder, EntityTypeConfiguration<TEntity> configuration) where TEntity : class
        {
            configuration.Map(modelBuilder.Entity<TEntity>());
        }
    }
}

然后您可以为实体本身创建一个配置：

using Microsoft.EntityFrameworkCore;
using Project.Domain.Models;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace Project.Persistance.EntityConfigurations
{
    public class MyEntityConfiguration : EntityTypeConfiguration<MyEntity>
    {
        public override void Map(EntityTypeBuilder<MyEntity> modelBuilder)
        {
            modelBuilder
                .Property();//config etc
        }
    }
}

然后您可以将所有配置加载到某个地方（可能有更好的方法和更好的地方…但这就是我所做的：

using Microsoft.EntityFrameworkCore;
using Project.Domain.Models;
using Project.Persistance.EntityConfigurations;

namespace Project.Persistance
{
    public class MyDbContext : DbContext
    {
        // Normal DbContext stuff here

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.AddConfiguration(new MyEntityConfiguration());
        }
    }
}

---

Entity Framework core 配置

Entity Framework core configurations

在 EF 6 中，我们可以直接将 EntityTypeConfiguration 传递给模型构建器以构建映射并使我们的配置类与上下文分离，而不会在代码中过于冗长。

他们是否删除了 EF core 中的那些映射。 有没有一种方法可以在不为每个类的模型构建器中添加配置的情况下添加配置？

答案1

EntityFrameworkCore2.0 有一个 IEntityTypeConfiguration<TEntity> 可以用作：

class ApplicationUserMap : IEntityTypeConfiguration<ApplicationUser>
{
  public void Configure(EntityTypeBuilder<Customer> builder)
  {
    builder.ToTable("user", "identity");

    builder.Property(p => p.Id)
        .HasColumnName("id");
     ...
   }
}

...
// OnModelCreating
modelBuilder.ApplyConfiguration(new ApplicationUserMap());

答案2

最好的方法是让配置代码远离 OnModelCreating 方法。 所以你可以这样做：

创建一个类，您将在其中存储实际配置：

public class ApplicationUserConfiguration
{
    public ApplicationUserConfiguration(EntityTypeBuilder<ApplicationUser> entity)
    {
        // Here you have all the good stuff
        entity.ToTable("user", "identity");

        entity.Property(p => p.Id)
            .HasColumnName("id);

        // And so on ....
    }
}

并在您的 OnModelCreating 中实例化新创建的类并传递正确的实体：

protected override void OnModelCreating(ModelBuilder builder)
{
    base.OnModelCreating(builder);

    // Your custom configs here
    new ApplicationUserConfiguration(builder.Entity<ApplicationUser>());
}

是一种干净而简单的实现目标的方法

答案3

有没有一种方法可以在不为每个类的模型构建器中添加配置的情况下添加配置？

如果数据库中有数百个表，并且必须手动配置每个映射类，那肯定是很多额外的工作。

在这种扩展方法的帮助下，您可以像旧的 EF 6 一样，用几行代码就可以达到预期的效果。

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    Type[] types = typeof(EntityTypeConfiguration<>).GetTypeInfo().Assembly.GetTypes();
    IEnumerable<Type> typesToRegister = types
        .Where(type => !string.IsNullOrEmpty(type.Namespace) &&
                        type.GetTypeInfo().BaseType != null &&
                        type.GetTypeInfo().BaseType.GetTypeInfo().IsGenericType &&
                        type.GetTypeInfo().BaseType.GetGenericTypeDefinition() == typeof(EntityTypeConfiguration<>));

    foreach (var type in typesToRegister)
    {
        dynamic configurationInstance = Activator.CreateInstance(type);
        ModelBuilderExtensions.AddConfiguration(modelBuilder, configurationInstance);
    }

    base.OnModelCreating(modelBuilder);
}

扩展方法

public abstract class EntityTypeConfiguration<TEntity> where TEntity : class
{
    public abstract void Map(EntityTypeBuilder<TEntity> builder);
}

public static class ModelBuilderExtensions
{
    public static void AddConfiguration<TEntity>(ModelBuilder modelBuilder, EntityTypeConfiguration<TEntity> configuration)
        where TEntity : class
    {
        configuration.Map(modelBuilder.Entity<TEntity>());
    }
}

映射类

public class UserMap : EntityTypeConfiguration<User>
{
    public override void Map(EntityTypeBuilder<User> builder)
    {
        // Primary Key
        builder.HasKey(t => t.Id);
        ...
    } 
}