Question

以下是我目前正在做的事情：

modelBuilder.Entity（）。Property（e =＆gt; e.Name）.IsRequired（）;
modelBuilder.Entity（）。Property（e =＆gt; e.UPC）.IsRequired（）;
modelBuilder.Entity（）。Property（e =＆gt; e.Price）.IsRequired（）;
modelBuilder.Entity（）。Property（e =＆gt; e.Description）.IsRequired（）;
以下是我想做的事情：

modelBuilder.Entity（） .Property（e =＆gt; e.Name）.IsRequired（） .Property（e =＆gt; e.UPC）.IsRequired（） .Property（e =＆gt; e.Price）.IsRequired（） .Property（e =＆gt; e.Description）.IsRequired（）

但后者不起作用。有没有其他方法不必每次都重复模型构建.Entity（）？

这是目前最精辟的选择：

var e = modelBuilder.Entity（）; e.Property（e =＆gt; e.Name）.IsRequired（）;
e.Property（e =＆gt; e.UPC）.IsRequired（）;
e.Property（e =＆gt; e.Price）.IsRequired（）;
e.Property（e =＆gt; e.Description）.IsRequired（）;

Answer 1

这与所有现有的DbModelBuilder扩展方法兼容，因为它只是在顶部添加了一个流畅的层，但它确实带来了一些语法开销。不完全是你要求的，但不涉及支持代码。尚未对此进行全面测试，但如果您对语法感到满意，它应该可以正常运行：

// First option - like this better because it has less cruft than multiple Has invocations

var modelBuilder = new DbModelBuilder();
var modelConfiguration = new ModelConfigurator(modelBuilder);

modelConfiguration.Entity<Product>().Has(e => {
                                         e.Property(en => en.Name).IsRequired();
                                         e.Property(en => en.UPC).IsRequired();
                                         e.Property(en => en.Price).IsRequired();
                                         e.Property(en => en.Description).IsRequired();}
                                        );

OR

var modelBuilder = new DbModelBuilder();
var modelConfiguration = new ModelConfigurator(modelBuilder);
modelConfiguration.Entity<Product>().Has(e => e.Property(en => en.Name).IsRequired())
                                    .Has(e => e.Property(en => en.UPC).IsRequired())
                                    .Has(e => e.Property(en => en.Price).IsRequired())
                                    .Has(e => e.Property(en => en.Description).IsRequired());

// continue configuring properties, and creating methods on ModelConfigurator as needed

支持代码：

  public class Product{
        public string Name {get;set;}
        public double Price {get;set;}
        public string UPC {get;set;}
        public string Description {get;set;}

    }

    public class ModelConfigurator{

        public DbModelBuilder ModelBuilder{get;set;}

        public ModelConfigurator(DbModelBuilder modelBuilder){
            ModelBuilder = modelBuilder;
        }

        public EntityConfigurator<TEntity> Entity<TEntity>() where TEntity : class {
            var entity = ModelBuilder.Entity<TEntity>();
            return new EntityConfigurator<TEntity>(entity);
        }
    }

    public class EntityConfigurator<TEntity> where TEntity : class{

        public EntityTypeConfiguration<TEntity> EntityTypeConfiguration {get;set;}

        public EntityConfigurator(EntityTypeConfiguration<TEntity> entityTypeConfiguration){
            EntityTypeConfiguration = entityTypeConfiguration;
        }

        public EntityConfigurator<TEntity> Has(Action<EntityTypeConfiguration<TEntity>> a){
            a(this.EntityTypeConfiguration);
            return this;
        }
    }

Answer 2

另一种选择，在Entity（）之上不需要Has（）：

modelConfiguration.Entity<Product>(e => {
                                   e.Property(en => en.Name).IsRequired();
                                   e.Property(en => en.UPC).IsRequired();
                                   e.Property(en => en.Price).IsRequired();
                                   e.Property(en => en.Description).IsRequired();}
                                  );

扩展方法：

public static EntityTypeConfiguration<TEntity> Entity<TEntity>(this DbModelBuilder modelBuilder, Action<EntityTypeConfiguration<TEntity>> action) where TEntity : class
{
    var r = modelBuilder.Entity<TEntity>();
    action(r);
    return r;
}

Answer 3

我想你可以做到以下几点，虽然我觉得这很尴尬。

public static class EntityConfigExtensions
{
    public static EntityTypeConfiguration<TEntity> Prop<TEntity, TProp>(this EntityTypeConfiguration<TEntity> self, Expression<Func<TEntity, TProp>> propExpression) where TEntity : class
    {
        self.Property(propExpression);
        return self;
    }
    public static EntityTypeConfiguration<TEntity> RequiredProp<TEntity, TProp>(this EntityTypeConfiguration<TEntity> self, Expression<Func<TEntity, TProp>> propExpression) where TEntity : class
    {
        self.Property(propExpression).IsRequired();
        return self;
    }
    // etcetera for other frequently used configs
    // ...
    // And, borrowing from David: a catch-all for the rest
    public static EntityTypeConfiguration<TEntity> Configure<TEntity, TProp>(this EntityTypeConfiguration<TEntity> self, Action<EntityTypeConfiguration<TEntity>> configAction) where TEntity : class
    {
        configAction(self);
        return self;
    }
}

用法：

modelBuilder.Entity<Product>()
    .Prop(e => e.Name)
    .RequiredProp(e => e.UPC)
    .RequiredProp(e => e.Price)
    .Configure(x => x.Ignore(e => e.Description));

Fluent API中的快捷方式，可根据需要设置多个属性

3 个答案: