EF Core Mapping EntityTypeConfiguration

129

In EF6 können wir normalerweise die Entität auf diese Weise konfigurieren.

public class AccountMap : EntityTypeConfiguration<Account>
{
    public AccountMap()
    {
        ToTable("Account");
        HasKey(a => a.Id);

        Property(a => a.Username).HasMaxLength(50);
        Property(a => a.Email).HasMaxLength(255);
        Property(a => a.Name).HasMaxLength(255);
    }
}

Wie wir es in EF Core machen können, seitdem die Klasse I EntityTypeConfiguration erbt, die die Klasse nicht finden kann.

Ich lade den EF Core-Rohquellcode vom GitHub herunter und kann ihn nicht finden. Kann jemand dabei helfen?

Ihr Mann
quelle
8
Warum nicht diese Antwort akzeptieren?
Den
da es jetzt in Beta5 ist, wenn wir maxLength (50) setzen. in der Datenbank generiert es nvarchar (max)
Herman
6
Für alle anderen daran interessiert, gibt es jetzt eine IEntityTypeConfiguration<T>mit einer void Configure()Methode , die Sie umsetzen können. Details hier: github.com/aspnet/EntityFramework/pull/6989
Galilyou

Antworten:

183

Seit EF Core 2.0 gibt es IEntityTypeConfiguration<TEntity>. Sie können es so verwenden:

class CustomerConfiguration : IEntityTypeConfiguration<Customer>
{
  public void Configure(EntityTypeBuilder<Customer> builder)
  {
     builder.HasKey(c => c.AlternateKey);
     builder.Property(c => c.Name).HasMaxLength(200);
   }
}

...
// OnModelCreating
builder.ApplyConfiguration(new CustomerConfiguration());

Weitere Informationen zu dieser und anderen in 2.0 eingeführten neuen Funktionen finden Sie hier .

Krzysztof Branicki
quelle
8
Dies ist die beste Antwort für EF Core 2.0. Vielen Dank!
Collin M. Barrett
2
Das ist ausgezeichnet. Ich suchte nach einer Möglichkeit, fließende API-Definitionen zu trennen. Danke
Blaze
Siehe auch diese Antwort für "ToTable" und "HasColumnName" usw. ::: stackoverflow.com/questions/43200184/…
granadaCoder
Wenn Sie eine benutzerdefinierte Konfiguration haben, builder.ApplyConfigurationsFromAssembly(typeof(ApplicationDbContext).Assembly);werden alle benutzerdefinierten Konfigurationen angewendet
alim91
52

Sie können dies durch einige einfache zusätzliche Typen erreichen:

internal static class ModelBuilderExtensions
{
   public static void AddConfiguration<TEntity>(
     this ModelBuilder modelBuilder, 
     DbEntityConfiguration<TEntity> entityConfiguration) where TEntity : class
   {     
       modelBuilder.Entity<TEntity>(entityConfiguration.Configure);
   }
}

internal abstract class DbEntityConfiguration<TEntity> where TEntity : class
{     
    public abstract void Configure(EntityTypeBuilder<TEntity> entity);
}

Verwendung:

internal class UserConfiguration : DbEntityConfiguration<UserDto>
{
    public override void Configure(EntityTypeBuilder<UserDto> entity)
    {
        entity.ToTable("User");
        entity.HasKey(c => c.Id);
        entity.Property(c => c.Username).HasMaxLength(255).IsRequired();
        // etc.
    }
}

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

    modelBuilder.AddConfiguration(new UserConfiguration());
}
devdigital
quelle
1
Wo liegt ForSqlServerToTable()?
im1dermike
1
Dies ist jetzt ToTable, siehe docs.microsoft.com/en-us/ef/core/modeling/relational/tables
devdigital
1
Wie verwende ich HasColumnType damit? . Zum Beispiel. entity.Property(c => c.JoinDate).HasColumnType("date");
Biju Soman
OnModelCreatingwurde aktualisiert, um a zu erfordern DbModelBuilder. Der Weg, um Konfigurationen hinzuzufügen, ist jetztmodelBuilder.Configurations.Add(new UserConfiguration());
Izzy
2
@Izzy - DbModelBuilder ist Entity Framework 6.0, ModelBuilder ist EF Core. Es handelt sich um verschiedene Baugruppen, und in diesem Fall war die Frage spezifisch für EF Core.
Jason
29

In EF7 überschreiben Sie OnModelCreating für die von Ihnen implementierte DbContext-Klasse.

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

        modelBuilder.Entity<Account>()
            .ForRelational(builder => builder.Table("Account"))
            .Property(value => value.Username).MaxLength(50)
            .Property(value => value.Email).MaxLength(255)
            .Property(value => value.Name).MaxLength(255);
    }
Avi Cherry
quelle
23
Wenn ich also 20 Entitätstypkonfigurationen habe, habe ich sie in eine große Methode eingefügt?
Den
6
Standardmäßig scheint es so. Sie können Ihre eigenen FooMapper / FooModelBuilder-Klassen erstellen, die eine Basisklasse erweitern und über eine Methode verfügen, mit der Sie einen typisierten EntityBuilder <Foo> übergeben. Sie können sogar die neue Schnittstelle für Abhängigkeitsinjektion und IConfiguration verwenden, um sie automatisch für Sie erkennen / aufrufen zu lassen, wenn Sie Lust haben!
Avi Cherry
1
Bitte. Eine Antwort zu verbessern (und den Fragesteller zu ermutigen, sie zu akzeptieren) ist noch besser!
Avi Cherry
Normalerweise mache ich das :)
Den
4
Probieren Sie die neuen Tools zur Abhängigkeitsinjektion aus? Erstellen Sie eine IEntityMapperStrategySchnittstelle mit einer void MapEntity(ModelBuilder, Type)Signatur und bool IsFor(Type). Implementieren Sie die Schnittstelle so oft oder so oft Sie möchten (damit Sie Klassen erstellen können, die mehr als eine Entität zuordnen können, wenn Sie möchten), und erstellen Sie dann eine andere Klasse (einen Strategieanbieter), die eine IEnumerableder gesamten Klassen einfügt IEntityMapperStrategies. Siehe hier unter "Spezielle Typen". Fügen Sie das in Ihren Kontext ein.
Avi Cherry
22

Dies verwendet die neueste Version, Beta 8. Versuchen Sie Folgendes:

public class AccountMap
{
    public AccountMap(EntityTypeBuilder<Account> entityBuilder)
    {
        entityBuilder.HasKey(x => x.AccountId);

        entityBuilder.Property(x => x.AccountId).IsRequired();
        entityBuilder.Property(x => x.Username).IsRequired().HasMaxLength(50);
    }
}

Dann in Ihrem DbContext:

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

        new AccountMap(modelBuilder.Entity<Account>());
    }
John
quelle
3
Ich habe es ähnlich gemacht. Ich entschied mich jedoch für eine statische Methode anstelle eines Konstruktors.
Matt Sanders
Ich verwende diese Methode und bis zu diesem Punkt hatte ich keine Probleme außer mit der Vererbung. Wenn ich die AccountMap in Ihrem Beispiel in eine neue erben und einen alternativen Schlüssel hinzufügen möchte, was wäre der beste Ansatz?
Chris
14

Sie können Reflection verwenden, um Dinge sehr ähnlich wie in EF6 zu tun, mit einer separaten Zuordnungsklasse für jede Entität. Dies funktioniert in RC1 final:

Erstellen Sie zunächst eine Schnittstelle für Ihre Zuordnungstypen:

public interface IEntityTypeConfiguration<TEntityType> where TEntityType : class
{
    void Map(EntityTypeBuilder<TEntityType> builder);
}

Erstellen Sie dann eine Zuordnungsklasse für jede Ihrer Entitäten, z. B. für eine PersonKlasse:

public class PersonMap : IEntityTypeConfiguration<Person>
{
    public void Map(EntityTypeBuilder<Person> builder)
    {
        builder.HasKey(x => x.Id);
        builder.Property(x => x.Name).IsRequired().HasMaxLength(100);
    }
}

Nun ist die Reflexionsmagie OnModelCreatingin Ihrer DbContextImplementierung:

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

    // Interface that all of our Entity maps implement
    var mappingInterface = typeof(IEntityTypeConfiguration<>);

    // Types that do entity mapping
    var mappingTypes = typeof(DataContext).GetTypeInfo().Assembly.GetTypes()
        .Where(x => x.GetInterfaces().Any(y => y.GetTypeInfo().IsGenericType && y.GetGenericTypeDefinition() == mappingInterface));

    // Get the generic Entity method of the ModelBuilder type
    var entityMethod = typeof(ModelBuilder).GetMethods()
        .Single(x => x.Name == "Entity" && 
                x.IsGenericMethod && 
                x.ReturnType.Name == "EntityTypeBuilder`1");

    foreach (var mappingType in mappingTypes)
    {
        // Get the type of entity to be mapped
        var genericTypeArg = mappingType.GetInterfaces().Single().GenericTypeArguments.Single();

        // Get the method builder.Entity<TEntity>
        var genericEntityMethod = entityMethod.MakeGenericMethod(genericTypeArg);

        // Invoke builder.Entity<TEntity> to get a builder for the entity to be mapped
        var entityBuilder = genericEntityMethod.Invoke(builder, null);

        // Create the mapping type and do the mapping
        var mapper = Activator.CreateInstance(mappingType);
        mapper.GetType().GetMethod("Map").Invoke(mapper, new[] { entityBuilder });
    }
}
Cocowalla
quelle
Welche Referenz verwendet das DataContextund .Where? Ich habe dafür ein separates Projekt gemacht und scheine die Referenz nicht zu finden.
Ruchan
.Whereist System.Linq, DataContextist die Klasse, in der der Code hinzugefügt wird (mein EF DbContextimpl)
Cocowalla
12

Seit EF Core 2.2 können Sie alle Konfigurationen (Klassen, die die IEntityTypeConfiguration-Schnittstelle implementiert haben) in einer Zeile in der Methode OnModelCreating in class hinzufügen, die von der DbContext-Klasse geerbt wird

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    //this will apply configs from separate classes which implemented IEntityTypeConfiguration<T>
    modelBuilder.ApplyConfigurationsFromAssembly(Assembly.GetExecutingAssembly());
}

Und wie in der vorherigen Antwort erwähnt, können Sie seit EF Core 2.0 die Schnittstelle IEntityTypeConfiguration implementieren und die Zuordnungskonfiguration mithilfe der FluentAPI in Configure-Methode einrichten.

public class QuestionAnswerConfig : IEntityTypeConfiguration<QuestionAnswer>
{
    public void Configure(EntityTypeBuilder<QuestionAnswer> builder)
    {
      builder
        .HasKey(bc => new { bc.QuestionId, bc.AnswerId });
      builder
        .HasOne(bc => bc.Question)
        .WithMany(b => b.QuestionAnswers)
        .HasForeignKey(bc => bc.QuestionId);
      builder
        .HasOne(bc => bc.Answer)
        .WithMany(c => c.QuestionAnswers)
        .HasForeignKey(bc => bc.AnswerId);
    }
}
Julia Trikoz
quelle
6

Dies ist, was ich in einem Projekt mache, an dem ich gerade arbeite.

public interface IEntityMappingConfiguration<T> where T : class
{
    void Map(EntityTypeBuilder<T> builder);
}

public static class EntityMappingExtensions
{
     public static ModelBuilder RegisterEntityMapping<TEntity, TMapping>(this ModelBuilder builder) 
        where TMapping : IEntityMappingConfiguration<TEntity> 
        where TEntity : class
    {
        var mapper = (IEntityMappingConfiguration<TEntity>)Activator.CreateInstance(typeof (TMapping));
        mapper.Map(builder.Entity<TEntity>());
        return builder;
    }
}

Verwendung:

In der OnModelCreating-Methode Ihres Kontexts:

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

        builder
            .RegisterEntityMapping<Card, CardMapping>()
            .RegisterEntityMapping<User, UserMapping>();
    }

Beispiel für eine Zuordnungsklasse:

public class UserMapping : IEntityMappingConfiguration<User>
{
    public void Map(EntityTypeBuilder<User> builder)
    {
        builder.ToTable("User");
        builder.HasKey(m => m.Id);
        builder.Property(m => m.Id).HasColumnName("UserId");
        builder.Property(m => m.FirstName).IsRequired().HasMaxLength(64);
        builder.Property(m => m.LastName).IsRequired().HasMaxLength(64);
        builder.Property(m => m.DateOfBirth);
        builder.Property(m => m.MobileNumber).IsRequired(false);
    }
}

Eine andere Sache, die ich gerne mache, um das Faltverhalten von Visual Studio 2015 zu nutzen, ist für eine Entität namens "Benutzer". Sie nennen Ihre Zuordnungsdatei "User.Mapping.cs". Visual Studio faltet die Datei im Lösungs-Explorer so dass es unter der Entitätsklassendatei enthalten ist.

Jamie Gould
quelle
Vielen Dank für Ihre Lösung. Ich werde meinen Lösungscode am Ende meines Projekts optimieren ... Ich überprüfe ihn in Zukunft sicher.
Miroslav Siska
Ich kann nur 'IEntityTypeConfiguration <T>' annehmen und war Configure(builder)2016 nicht vorhanden? Bei einer geringfügigen Änderung der Verkabelung, um auf TypeConfiguration zu verweisen, ist die zusätzliche Schnittstelle nicht erforderlich.
WernerCD
3

Ich endete mit dieser Lösung:

public interface IEntityMappingConfiguration
{
    void Map(ModelBuilder b);
}

public interface IEntityMappingConfiguration<T> : IEntityMappingConfiguration where T : class
{
    void Map(EntityTypeBuilder<T> builder);
}

public abstract class EntityMappingConfiguration<T> : IEntityMappingConfiguration<T> where T : class
{
    public abstract void Map(EntityTypeBuilder<T> b);

    public void Map(ModelBuilder b)
    {
        Map(b.Entity<T>());
    }
}

public static class ModelBuilderExtenions
{
    private static IEnumerable<Type> GetMappingTypes(this Assembly assembly, Type mappingInterface)
    {
        return assembly.GetTypes().Where(x => !x.IsAbstract && x.GetInterfaces().Any(y => y.GetTypeInfo().IsGenericType && y.GetGenericTypeDefinition() == mappingInterface));
    }

    public static void AddEntityConfigurationsFromAssembly(this ModelBuilder modelBuilder, Assembly assembly)
    {
        var mappingTypes = assembly.GetMappingTypes(typeof (IEntityMappingConfiguration<>));
        foreach (var config in mappingTypes.Select(Activator.CreateInstance).Cast<IEntityMappingConfiguration>())
        {
            config.Map(modelBuilder);
        }
    }
}

Beispielverwendung:

public abstract class PersonConfiguration : EntityMappingConfiguration<Person>
{
    public override void Map(EntityTypeBuilder<Person> b)
    {
        b.ToTable("Person", "HumanResources")
            .HasKey(p => p.PersonID);

        b.Property(p => p.FirstName).HasMaxLength(50).IsRequired();
        b.Property(p => p.MiddleName).HasMaxLength(50);
        b.Property(p => p.LastName).HasMaxLength(50).IsRequired();
    }
}

und

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.AddEntityConfigurationsFromAssembly(GetType().Assembly);
}
Domen Kogler
quelle
Beim Kompilieren wird ein Fehler angezeigt : " Operator '! X.Istract' kann nicht auf Operanden vom Typ 'Methodengruppe' " auf '! X.IsAbstract' (System.Type.IsAbstract) in ModelBuilderExtenions.GetMappingTypes () angewendet werden. . Muss ich einen Verweis auf mscorlib hinzufügen? Wie mache ich das mit einem .NET Core 1.0-Projekt?
RandyDaddis
Für .net-Kernprojekte (unter Verwendung von netstandard) müssen Sie die Erweiterung GetTypeInfo () im System.Reflection-Namespace verwenden. Verwendung als x.GetTypeInfo (). IsAbstract oder x.GetTypeInfo (). GetInterfaces ()
animalito maquina
Ich habe einen Teil Ihrer Lösung für meine verwendet und es hat gut funktioniert. Vielen Dank!
Diego Cotini
2

Implementieren Sie einfach die IEntityTypeConfiguration

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

und fügen Sie es dann Ihrem Entitätskontext hinzu

public class ProductContext : DbContext, IDbContext
{
    public ProductContext(DbContextOptions<ProductContext> options)
        : base((DbContextOptions)options)
    {
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        modelBuilder.ApplyConfiguration(new ProductMap());
    }

    public DbSet<Entities.Product> Products { get; set; }
}
Meister Zi
quelle
1

In ef core müssen wir IEntityTypeConfiguration anstelle von EntityTypeConfiguration impelementieren. In diesem Fall haben wir vollen Zugriff auf DbContext modelBuilder und können eine fließende API verwenden. In ef core unterscheidet sich diese API jedoch geringfügig von früheren Versionen. Weitere Informationen zur Konfiguration des ef-Kernmodells finden Sie unter

https://www.learnentityframeworkcore.com/configuration/fluent-api

mohammadali ghanbari
quelle
1

In Entity Framework Core 2.0:

Ich nahm Cocowallas Antwort und passte sie für v2.0 an:

    public static class ModelBuilderExtenions
    {
        private static IEnumerable<Type> GetMappingTypes(this Assembly assembly, Type mappingInterface)
        {
            return assembly.GetTypes().Where(x => !x.IsAbstract && x.GetInterfaces().Any(y => y.GetTypeInfo().IsGenericType && y.GetGenericTypeDefinition() == mappingInterface));
        }

        public static void AddEntityConfigurationsFromAssembly(this ModelBuilder modelBuilder, Assembly assembly)
        {
            // Types that do entity mapping
            var mappingTypes = assembly.GetMappingTypes(typeof(IEntityTypeConfiguration<>));

            // Get the generic Entity method of the ModelBuilder type
            var entityMethod = typeof(ModelBuilder).GetMethods()
                .Single(x => x.Name == "Entity" &&
                        x.IsGenericMethod &&
                        x.ReturnType.Name == "EntityTypeBuilder`1");

            foreach (var mappingType in mappingTypes)
            {
                // Get the type of entity to be mapped
                var genericTypeArg = mappingType.GetInterfaces().Single().GenericTypeArguments.Single();

                // Get the method builder.Entity<TEntity>
                var genericEntityMethod = entityMethod.MakeGenericMethod(genericTypeArg);

                // Invoke builder.Entity<TEntity> to get a builder for the entity to be mapped
                var entityBuilder = genericEntityMethod.Invoke(modelBuilder, null);

                // Create the mapping type and do the mapping
                var mapper = Activator.CreateInstance(mappingType);
                mapper.GetType().GetMethod("Configure").Invoke(mapper, new[] { entityBuilder });
            }
        }


    }

Und es wird im DbContext folgendermaßen verwendet:

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.AddEntityConfigurationsFromAssembly(GetType().Assembly);
    }

Und so erstellen Sie eine Entitätstypkonfiguration für eine Entität:

    public class UserUserRoleEntityTypeConfiguration : IEntityTypeConfiguration<UserUserRole>
    {
        public void Configure(EntityTypeBuilder<UserUserRole> builder)
        {
            builder.ToTable("UserUserRole");
            // compound PK
            builder.HasKey(p => new { p.UserId, p.UserRoleId });
        }
    }
Francisco Goldenstein
quelle
Hat bei mir nicht funktioniert. Ausnahme:Late bound operations cannot be performed on types or methods for which ContainsGenericParameters is true.
Tohid
PS: Die Lösung gefunden: &&! T.IsGenericType. Weil ich eine Basisklasse hatte, die generisch ist ( class EntityTypeConfigurationBase<TEntity> : IEntityTypeConfiguration<TEntity>). Sie können keine Instanz dieser Basisklasse erstellen.
Tohid
0

Habe ich recht?

public class SmartModelBuilder<T> where T : class         {

    private ModelBuilder _builder { get; set; }
    private Action<EntityTypeBuilder<T>> _entityAction { get; set; }

    public SmartModelBuilder(ModelBuilder builder, Action<EntityTypeBuilder<T>> entityAction)
    {
        this._builder = builder;
        this._entityAction = entityAction;

        this._builder.Entity<T>(_entityAction);
    }
}   

Ich kann config übergeben:

 protected override void OnModelCreating(ModelBuilder builder)
    {
        base.OnModelCreating(builder);
        // Customize the ASP.NET Identity model and override the defaults if needed.
        // For example, you can rename the ASP.NET Identity table names and more.
        // Add your customizations after calling base.OnModelCreating(builder);



        new SmartModelBuilder<Blog>(builder, entity => entity.Property(b => b.Url).Required());

    } 
Miroslav Siska
quelle
Die akzeptierte Antwort scheint besser zu sein. Beide haben den gleichen negativen Nebeneffekt wie ein massiv überfülltes OnModelCreating (), aber für die akzeptierte Antwort sind keine Hilfsklassen erforderlich. Fehlt mir etwas, das Ihre Antwort verbessert?
Segeln Judo
0

Ich verfolgte einen ähnlichen Ansatz wie Microsoft ForSqlServerToTable implementiert hat

mit Erweiterungsmethode ...

der Teil- Flag ist erforderlich , wenn Sie die gleichen Klassennamen in mehreren Dateien verwenden mögen

public class ConsignorUser
{
    public int ConsignorId { get; set; }

    public string UserId { get; set; }

    public virtual Consignor Consignor { get; set; }
    public virtual User User { get; set; }

}

public static partial class Entity_FluentMappings
{
    public static EntityTypeBuilder<ConsignorUser> AddFluentMapping<TEntity> (
        this EntityTypeBuilder<ConsignorUser> entityTypeBuilder) 
        where TEntity : ConsignorUser
    {
       entityTypeBuilder.HasKey(x => new { x.ConsignorId, x.UserId });
       return entityTypeBuilder;
    }      
}

Dann rufen Sie im DataContext OnModelCreating für jede Nebenstelle an ...

 public class DataContext : IdentityDbContext<User>
{

    protected override void OnModelCreating(ModelBuilder builder)
    {
        base.OnModelCreating(builder);
        // Customize the ASP.NET Identity model and override the defaults if needed.
        // For example, you can rename the ASP.NET Identity table names and more.
        // Add your customizations after calling base.OnModelCreating(builder);

        builder.Entity<ConsignorUser>().AddFluentMapping<ConsignorUser>();
        builder.Entity<DealerUser>().AddFluentMapping<DealerUser>();           

    }

Auf diese Weise folgen wir demselben Muster, das auch von den anderen Builder-Methoden verwendet wird.

Was machst du?

Joseph Bailey
quelle
0

Hier ist das Problem für die Verbesserung des EF7 Github-Repos: https://github.com/aspnet/EntityFramework/issues/2805

Sie können das Problem direkt dort verfolgen, obwohl es sich immer noch nur im Rückstand ohne festgelegte Priorität befindet.

Denis Biondic
quelle
Es sollte ein Problem wie "Hör auf, gut gestaltete Dinge zu zerbrechen" geben.
Kamil
0

Ich habe ein Projekt, mit dem Sie Entitäten außerhalb von DbContext.OnModelCreatingkonfigurieren können. Sie konfigurieren jede Entität in einer separaten Klasse, von der erbtStaticDotNet.EntityFrameworkCore.ModelConfiguration.EntityTypeConfiguration

Zuerst müssen Sie eine Klasse , die erbt von erstellen , StaticDotNet.EntityFrameworkCore.ModelConfiguration.EntityTypeConfiguration<TEntity>wo TEntityist die Klasse , die Sie konfigurieren möchten.

using StaticDotNet.EntityFrameworkCore.ModelConfiguration;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

public class ExampleEntityConfiguration
    : EntityTypeConfiguration<ExampleEntity>
{
    public override void Configure( EntityTypeBuilder<ExampleEntity> builder )
    {
        //Add configuration just like you do in DbContext.OnModelCreating
    }
}

Dann müssen Sie in Ihrer Startup-Klasse Entity Framework nur mitteilen, wo sich alle Konfigurationsklassen befinden, wenn Sie Ihren DbContext konfigurieren.

using StaticDotNet.EntityFrameworkCore.ModelConfiguration;

public void ConfigureServices(IServiceCollection services)
{
    Assembly[] assemblies = new Assembly[]
    {
        // Add your assembiles here.
    };

    services.AddDbContext<ExampleDbContext>( x => x
        .AddEntityTypeConfigurations( assemblies )
    );
}

Es gibt auch eine Option zum Hinzufügen von Typkonfigurationen über einen Anbieter. Das Repo enthält eine vollständige Dokumentation zur Verwendung.

https://github.com/john-t-white/StaticDotNet.EntityFrameworkCore.ModelConfiguration

John White
quelle
Bitte posten Sie nicht dieselbe Antwort auf mehrere Fragen. Wenn die gleichen Informationen wirklich beide Fragen beantworten, sollte eine Frage (normalerweise die neuere) als Duplikat der anderen geschlossen werden. Sie können dies anzeigen, indem Sie abstimmen, um es als Duplikat zu schließen, oder, wenn Sie nicht genug Ruf dafür haben , eine Flagge hissen, um anzuzeigen, dass es sich um ein Duplikat handelt. Stellen Sie andernfalls sicher, dass Sie Ihre Antwort auf diese Frage anpassen und nicht nur dieselbe Antwort an mehreren Stellen einfügen.
Elixenid