EF कोर मैपिंग EntityTypeConfiguration

Question

EF6 में हम आमतौर पर इकाई को कॉन्फ़िगर करने के लिए इस तरह का उपयोग करने में सक्षम हैं।

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

ईएफ कोर में हम कैसे कर सकते हैं, जब से मैं कक्षा में प्रवेश करता है EntityTypeConfiguration जो कक्षा को खोजने में असमर्थ है।

मैं GitHub से EF कोर रॉ सोर्स कोड डाउनलोड करता हूं, मुझे यह नहीं मिल रहा है। क्या कोई इस पर मदद कर सकता है?

Comments

उस उत्तर को स्वीकार क्यों नहीं करते?

— डेन

चूंकि यह अब बीटा 5 में है, जब हम मैक्सलिफ्ट (50) डालते हैं। डीबी में यह नवरच (अधिकतम) उत्पन्न करता है

— हरमन

इसमें दिलचस्पी रखने वाले किसी और के लिए, अब IEntityTypeConfiguration<T>एक void Configure()विधि है जिसे आप कार्यान्वित कर सकते हैं। यहाँ विवरण: github.com/aspnet/EntityFramework/pull/6989

— गैलीलियो

Answer 1

EF Core 2.0 के बाद से है IEntityTypeConfiguration<TEntity>। आप इसे इस तरह से उपयोग कर सकते हैं:

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

इस पर और 2.0 में पेश किए गए अन्य नए फीचर्स यहां देखे जा सकते हैं ।

Comments

यह ईएफ कोर 2.0 के लिए सबसे अच्छा जवाब है। धन्यवाद!

— कोलिन एम। बैरेट

यह उत्कृष्ट है। मैं धाराप्रवाह एपीआई परिभाषाओं को अलग करने के लिए एक रास्ता तलाश रहा था। धन्यवाद

— ब्लेज़

"टोटेबल" और "हस्कॉल्यूमेननेम", आदि के लिए यह उत्तर भी देखें। ::: stackoverflow.com/questions/43200184/…

— granadaCoder

यदि आपके पास मैन कस्टम कॉन्फ़िगरेशन है, तो बस डाल दें builder.ApplyConfigurationsFromAssembly(typeof(ApplicationDbContext).Assembly);यह सभी कस्टम पुष्टिकरण लागू करेगा

— alim91

Answer 2

आप कुछ सरल अतिरिक्त प्रकारों के माध्यम से इसे प्राप्त कर सकते हैं:

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

उपयोग:

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

Comments

कहाँ है ForSqlServerToTable()?

— im1dermike

अब यह ToTableदेखिए, docs.microsoft.com/en-us/ef/core/modeling/relational/tables

— devdigital

इसके साथ HasColumnType का उपयोग कैसे करें? । उदाहरण के लिए। entity.Property(c => c.JoinDate).HasColumnType("date");

— बीजू सोमण

OnModelCreatingआवश्यकता होने पर अपडेट किया गया है DbModelBuilder। अब इसके लिए विन्यास जोड़ने का तरीका हैmodelBuilder.Configurations.Add(new UserConfiguration());

— इज़ी

@Izzy - DbModelBuilder एंटिटी फ्रेमवर्क 6.0 है, ModelBuilder ईएफ कोर है। वे अलग-अलग विधानसभाएं हैं और इस मामले में प्रश्न ईएफ कोर के लिए विशिष्ट था।

— जेसन

Answer 3

EF7 में, आप जिस DbContext क्लास को लागू कर रहे हैं, उस पर OnModelCreating को ओवरराइड करें।

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

Comments

तो अगर मेरे पास 20 इकाई प्रकार के कॉन्फ़िगरेशन हैं तो मैंने उन्हें एक विशाल विधि में रखा है?

— डेन

डिफ़ॉल्ट रूप से, ऐसा लगता है। आप अपनी खुद की FooMapper / FooModelBuilder कक्षाएं बना सकते हैं जो एक आधार वर्ग का विस्तार करती हैं और एक विधि है जो आप टाइप किए गए EntityBuilder <Foo> से गुजरती हैं। तुम भी नए निर्भरता इंजेक्शन और IConfiguration इंटरफ़ेस का उपयोग कर सकते हैं ताकि उन्हें खोजा जा सके / आपके लिए स्वचालित रूप से कॉल किया जा सके, अगर आप कल्पना करना चाहते थे!

— एवी चेरी

आपका स्वागत है। एक जवाब को वोट देना (और प्रश्नकर्ता को इसे स्वीकार करने के लिए प्रोत्साहित करना) और भी बेहतर है!

— एवी चेरी

मैं आमतौर पर ऐसा करता हूं :)

— डेन

नए निर्भरता इंजेक्शन उपकरण का प्रयास करें? IEntityMapperStrategyएक void MapEntity(ModelBuilder, Type)हस्ताक्षर के साथ एक इंटरफ़ेस बनाएं और bool IsFor(Type)। इंटरफ़ेस को कई बार या जितनी बार चाहें उतनी बार लागू करें (ताकि आप अपनी इच्छानुसार कक्षाएं बना सकें, जो एक से अधिक इकाइयों को मैप कर सकें) और फिर एक और वर्ग (एक स्ट्रेटेजी प्रोवाइडर) बनाएं, IEnumerableजो सभी को इंजेक्ट करे IEntityMapperStrategies। 'विशेष प्रकार' के तहत यहां देखें । उस संदर्भ में अपने संदर्भ।

— एवी चेरी

Answer 4

यह वर्तमान नवीनतम, बीटा 8 का उपयोग कर रहा है। यह प्रयास करें:

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

फिर अपने DbContext में:

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

        new AccountMap(modelBuilder.Entity<Account>());
    }

Comments

मैंने इसी तरह करना समाप्त कर दिया। मैंने हालांकि एक कंस्ट्रक्टर के बजाय एक स्थिर विधि का उपयोग करने का निर्णय लिया।

— मैट सैंडर्स

मैं इस पद्धति का उपयोग कर रहा हूं और इस बात तक कि मेरे पास विरासत के अलावा कोई मुद्दा नहीं है। अगर मैं आपके उदाहरण में एक नया खाता खोलना चाहता हूं और एक वैकल्पिक कुंजी जोड़ूं - सबसे अच्छा तरीका क्या होगा?

— क्रिस

Answer 5

आप प्रत्येक इकाई के लिए एक अलग मैपिंग क्लास के साथ, ईएफ 6 में कैसे काम करते हैं, इसके समान चीजों को करने के लिए प्रतिबिंब का उपयोग कर सकते हैं। RC1 फाइनल में यह काम करता है:

सबसे पहले, अपने मानचित्रण प्रकारों के लिए एक इंटरफ़ेस बनाएँ:

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

फिर अपनी प्रत्येक इकाई के लिए एक मैपिंग क्लास बनाएं, जैसे कि Personक्लास के लिए:

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

अब, OnModelCreatingआपके DbContextकार्यान्वयन में प्रतिबिंब जादू :

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

Comments

संदर्भ DataContextऔर .Whereउपयोग क्या है? मैंने इसके लिए एक अलग परियोजना बनाई और संदर्भ को खोजने के लिए नहीं लगता।

— रूचन

.Whereहै System.Linq, DataContextवह वर्ग है जहाँ कोड जोड़ा गया है (मेरा EF DbContext

— निहित

Answer 6

EF Core 2.2 के बाद से आप क्लास में OnModelCreating विधि में एक पंक्ति में सभी कॉन्फिगर (कक्षाएं, जो IEntityTypeConfiguration इंटरफ़ेस लागू किया है) जोड़ सकते हैं, जो DbContext वर्ग से विरासत में मिला है

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

और, जैसा कि पिछले उत्तर में उल्लेख किया गया था, ईएफ कोर 2.0 के बाद से, आप इंटरफ़ेस IEntityTypeConfiguration, सेटअप मैपिंग कॉन्फ़िगरेशन को फ़्लॉन्गएंपी का उपयोग करके कॉन्फ़िगर विधि में लागू कर सकते हैं।

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

Answer 7

यह वही है जो मैं इस समय एक परियोजना में कर रहा हूं, जिस पर मैं काम कर रहा हूं।

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

उपयोग:

आपके संदर्भ में OnModelCreating विधि:

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

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

उदाहरण मानचित्रण वर्ग:

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

विजुअल स्टूडियो 2015 के तह व्यवहार का लाभ उठाने के लिए एक और चीज जो मुझे पसंद है वह है 'यूजर' नामक एंटिटी के लिए, आप अपनी मैपिंग फाइल का नाम 'User.Mapping.cs' रखें, विजुअल स्टूडियो समाधान एक्सप्लोरर में फाइल को फोल्ड करेगा। ताकि यह इकाई वर्ग फ़ाइल के अंतर्गत निहित हो।

Comments

आपके समाधान के लिए धन्यवाद। मैं अपनी परियोजना के अंत में अपने समाधान कोड का अनुकूलन करूंगा ... मैं इसे भविष्य में सुनिश्चित करता हूं।

— मिरोस्लाव सिस्का

मैं केवल 'IEntityTypeConfiguration <T>' मान सकता हूं और Configure(builder)2016 में मौजूद नहीं था? वायरकॉन्फिगरेशन को इंगित करने के लिए वायरिंग के थोड़े बदलाव के साथ, 'अतिरिक्त' इंटरफ़ेस की कोई आवश्यकता नहीं है।

— वर्नरसीडी

Answer 8

मैं इस समाधान के साथ समाप्त हुआ:

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

नमूना उपयोग:

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

तथा

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

Comments

मुझे एक संकलन-समय त्रुटि मिल रही है: " Operator '! X.IsAbstract' को 'x.IsAbstract' (System.Type.IsAbstract) पर Model.uilderExtenions.GetMappingTypes () में टाइप 'मेथड ग्रुप' के ऑपरेंड पर लागू नहीं किया जा सकता है। । क्या मुझे mscorlib का संदर्भ जोड़ना होगा? मैं एक .NET कोर 1.0 परियोजना के लिए कैसे करूँ?

— RandyDaddis

के लिए .net कोर परियोजनाओं (netstandard का उपयोग करके) आपको System.Reflection नाम स्थान में GetTypeInfo () का विस्तार करने की आवश्यकता है। X.GetTypeInfo ()। IsAbstract या x.GetTypeInfo () के रूप में उपयोग करें। GetInterfaces ()

— animalito maquina

मैंने आपके समाधान का हिस्सा खदान पर उपयोग किया है और यह अच्छा काम किया है। धन्यवाद!

— डिएगो कोटिनी

Answer 9

बस IEntityTypeConfiguration को लागू करें

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

और फिर इसे अपनी इकाई के संदर्भ में जोड़ें

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

Answer 10

Ef core में हमें EntityTypeConfiguration के बजाय IEntityTypeConfiguration को इम्प्लीमेंट करना है, इस मामले में हमारे पास DbContext modelBuilder तक पूरी पहुंच है और हम धाराप्रवाह एपीआई का उपयोग कर सकते हैं, लेकिन ef कोर में यह एपीआई पिछले संस्करणों से एक litle bit diferent है। आप एफई कोर मॉडल कॉन्फ़िगरेशन पर अधिक जानकारी पा सकते हैं

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

Answer 11

इकाई फ्रेमवर्क कोर 2.0 में:

मैंने Cocowalla का उत्तर लिया और इसे v2.0 के लिए अनुकूलित किया:

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


    }

और यह इस तरह DbContext में उपयोग किया जाता है:

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

और यह है कि आप एक इकाई के लिए एक इकाई प्रकार विन्यास कैसे बनाते हैं:

    public class UserUserRoleEntityTypeConfiguration : IEntityTypeConfiguration<UserUserRole>
    {
        public void Configure(EntityTypeBuilder<UserUserRole> builder)
        {
            builder.ToTable("UserUserRole");
            // compound PK
            builder.HasKey(p => new { p.UserId, p.UserRoleId });
        }
    }

Comments

मेरे लिए काम नहीं किया। अपवाद:Late bound operations cannot be performed on types or methods for which ContainsGenericParameters is true.

— तोहिद

पुनश्च: समाधान मिला: &&! T.sGenericType क्योंकि मेरे पास एक आधार वर्ग था जो एक सामान्य ( class EntityTypeConfigurationBase<TEntity> : IEntityTypeConfiguration<TEntity>) है। आप इस बेस क्लास का उदाहरण नहीं बना सकते।

— १५:०४

Answer 12

क्या मैं सही हू?

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

मैं कॉन्‍फ़िगर कर सकता हूं:

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

    } 

Comments

स्वीकृत उत्तर इससे बेहतर लगता है। दोनों का एक ही नकारात्मक साइड-इफ़ेक्ट है एक बड़े पैमाने पर बंद OnModelCreating () लेकिन स्वीकृत उत्तर में किसी भी सहायक वर्ग की आवश्यकता नहीं है। क्या मुझे कुछ याद आ रहा है जो आपके उत्तर को बेहतर बनाता है?

— सेलिंग जूडो

Answer 13

मैंने Microsoft द्वारा ForSqlServerToTable को लागू करने के तरीके के समान दृष्टिकोण का पालन किया

विस्तार विधि का उपयोग कर ...

आंशिक ध्वज के लिए आवश्यक है कि आप एक से अधिक फ़ाइलों में एक ही वर्ग के नाम उपयोग करना चाहते हैं

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

तो DataContext OnModelCreating में प्रत्येक एक्सटेंशन के लिए अपनी कॉल करें ...

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

    }

इस तरह हम अन्य बिल्डर विधियों द्वारा उपयोग किए जाने वाले समान पैटर्न का अनुसरण कर रहे हैं ।

आपको क्या लगता है?

Answer 14

अच्छी तरह से यहाँ EF7 Github रेपो पर वृद्धि के लिए मुद्दा है: https://github.com/aspnet/EntityFramework/issues/2805

आप सीधे इस मुद्दे को ट्रैक कर सकते हैं, इसके बावजूद अभी भी केवल निर्दिष्ट प्राथमिकता के बिना बैकलॉग में है।

Comments

एक मुद्दा होना चाहिए जैसे "अच्छी तरह से डिज़ाइन की गई चीजों को रोकना"।

— कामिल

Answer 15

मेरे पास एक परियोजना है जो आपको संस्थाओं के बाहर कॉन्फ़िगर करने की अनुमति देती है आप DbContext.OnModelCreatingप्रत्येक इकाई को एक अलग वर्ग में कॉन्फ़िगर करते हैं जो विरासत में मिला हैStaticDotNet.EntityFrameworkCore.ModelConfiguration.EntityTypeConfiguration

सबसे पहले आपको एक वर्ग बनाने की आवश्यकता है जो उस श्रेणी से विरासत में मिला है StaticDotNet.EntityFrameworkCore.ModelConfiguration.EntityTypeConfiguration<TEntity>जहाँ से TEntityआप कॉन्फ़िगर करना चाहते हैं।

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

तब आपके स्टार्टअप वर्ग में आपको केवल एंटिटी फ्रेमवर्क बताने की आवश्यकता होती है, जहां आप अपने DbContext को कॉन्फ़िगर करते समय अपने सभी कॉन्फ़िगरेशन वर्गों को ढूंढ सकते हैं।

using StaticDotNet.EntityFrameworkCore.ModelConfiguration;

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

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

प्रदाता का उपयोग करके प्रकार के कॉन्फ़िगरेशन को जोड़ने का एक विकल्प भी है। रेपो में इसका उपयोग करने के तरीके के बारे में पूरा दस्तावेज है।

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

Comments

कृपया एक से अधिक प्रश्नों के उत्तर एक ही न दें। यदि समान जानकारी वास्तव में दोनों प्रश्नों का उत्तर देती है, तो एक प्रश्न (आमतौर पर नया एक) दूसरे के डुप्लिकेट के रूप में बंद होना चाहिए। आप इसे डुप्लिकेट के रूप में बंद करने के लिए मतदान द्वारा इंगित कर सकते हैं या, यदि आपके पास इसके लिए पर्याप्त प्रतिष्ठा नहीं है, तो यह इंगित करने के लिए कि यह एक डुप्लिकेट है, एक ध्वज उठाएं । अन्यथा, सुनिश्चित करें कि आपने इस प्रश्न का उत्तर दिया है और एक ही उत्तर को कई स्थानों पर चिपकाएँ नहीं।

— elixenide