C# generics：如何将当前类的类型作为参数传递

Question

I would like to

1. Move my OnModelCreating to the base class and
2. Call modelBuilder.Entity<T> without explicitly specifying the T. I would just like to say, the 'current class' (meaning in this example UserType as it is UserType on which the index needs creating)

public class BaseLookupEntity : BaseEntity
{
    [Key()]
    [DatabaseGenerated(DatabaseGeneratedOption.None)]
    public override int Id { get; set; }

    //...

}

public class UserType: BaseLookupEntity
{
    internal static void OnModelCreating(ModelBuilder modelBuilder)
    {
        // unique 
        modelBuilder.Entity<UserType>()
            .HasIndex(c => c.Enum)
            .IsUnique();
    }

}

Answer 1

class someBaseClass
{
    public void Foo<TInferrConcreteDerivedTypeCallingThisMethodHere>()
}

No, thats not possible, and if you understand how generics works you'd see why. Generic types are not resolved at runtime (excluding dynamic and reflection scenarios), all generic type parameters are resolved at compile time. Therefore, there is no way the compiler can know what the real type of TInferrConcreteDerivedTypeCallingThisMethodHere is from within SomeBaseClass without running the code.

Inheritance is a red herring here, the same issue arises with the classical example of statically unknown types:

void Foo<T>(T t) { ... }

object o = GetSomeRuntimeObjectIDontKnowTheTypeOf();
Foo(o); T is inferred

Can you guess what T is inferred to? You can narrow it down to two options: Foo<RuntimeTypeOfUnkownObject> or Foo<object> ? If you have doubts, run it and figure it out.

Also, as far as type inference goes, a rule of the thumb, whenever you have a generic method with a signature similar to:

void Foo<T>(/*no arguments from which T can be inferred*/)

or even

T Foo<T>(/*no arguments from which T can be inferred*/)

T can not or will not be inferred.

Answer 2

You would want to make your base class generic as well in that case

public class BaseLookupEntity<T> : BaseEntity where T : BaseLookupEntity<T>
{
    [Key()]
    [DatabaseGenerated(DatabaseGeneratedOption.None)]
    public override int Id { get; set; }

    internal static void OnModelCreating(ModelBuilder modelBuilder)
    {
        // unique 
        modelBuilder.Entity<T>()
            .HasIndex(c => c.Enum)
            .IsUnique();
    }
}

public class UserType: BaseLookupEntity<UserType>
{
}

Answer 3

There is in-built support for decoupled (from DB context) configurations. Your configuration class must implement IEntityTypeConfiguration<T> interface .

Then you can easily apply configurations inside your DbContext 's OnModelCreating method using ApplyConfiguration<T> method .

Your example, could look like:

public class CustomDbContext : DbContext
{
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.ApplyConfiguration<UserTypeConfiguration>(new UserTypeConfiguration());
    }
}

public class UserTypeConfiguration : IEntityTypeConfiguration<UserType>
{
    public void Configure(EntityTypeBuilder<UserType> builder)
    {
        builder
            .HasIndex(c => c.Enum)
            .IsUnique();
    }
}

Note: I can't try your inheritance chain, but it should work out of the box, if you do:

Answer 4

Using generics, you can't.

Generics are evaluated at compile time, but as your base class will have multiple sub classes, the type will only be known at runtime.

There is an overload for ModelBuilder.Enity that accepts a System.Type object, which can be used at runtime, so you could use that in your base class.

Personally i would do this in your DbContext and list all the base classes individually eg

private void MapLookupEntitity<TLookup>(DbModelBuilder modelBuilder) where TLookup : BaseLookupEntity
{
    // unique 
    modelBuilder.Entity<TLookup>()
        .HasIndex(c => c.Enum)
        .IsUnique();
}

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    MapLookupEntitity<UserType>(modelBuilder);
    MapLookupEntitity<AnotherType>(modelBuilder);
    // map some more..
}