Re-creating naming conventions for EF6 in EF Core

Question

We're in the process of migrating our moderately large application from Entity Framework 6.2 to Entity Framework Core 2.0, and while many things have been easier than I had dared to hope for, I've run into a problem that I doubt I'm the first (or the thousandth) one to have, but can't find a compact solution for it: Naming conventions.

Specifically, naming conventions for relational properties.

A typical one-to-many entity pair in our application looks something like this:

public class Foo
{
    [Key, DatabaseGenerated(DatabaseGeneratedOption.None)]
    public int FooId { get; set; }

    [Required]
    public string Bar { get; set; }

    [InverseProperty(nameof(Baz.Foo))]
    public ICollection<Baz> Bazzes { get; set; }
}

public class Baz
{
    [Key, DatabaseGenerated(DatabaseGeneratedOption.None)]
    public int BazId { get; set; }

    [Required]
    public string Qux { get; set; }

    [Required]
    public Foo Foo { get; set; }
}

In our existing database, EF6 mapped that to the following tables:

Foos                        Bazzes -- named after the DbSets on the DbContext
****                        ******
FooId : int                 BazId : int
Bar : nvarchar(max)         Qux : nvarchar(max)
                            Foo_FooId : int

With the default naming conventions in EF Core, it seems that the ported context looks for a column FooId instead of Foo_FooId.

I've tried modifying this with something what's described here, but I can't figure out what condition to impose on the property metadata to only change the navigational properties. (I also have a couple of complex type, which I configure with .Entity<Owner>().OwnsOne(o => o.Owned), so the solution needs to capture that as well.)

Is there no ready-made solution to make this transition easier?

---

I've published an MVCE for this problem here: https://github.com/tlycken/MCVE_EfCoreNavigationalProperties

Answer 1

AFAIK you can't change the name of the Shadow Property, but you can change the name of the table column. Like this

protected override void OnModelCreating(ModelBuilder modelBuilder)
{

    base.OnModelCreating(modelBuilder);

    //modelBuilder.Model.FindEntityType(typeof(Baz)).FindProperty("FooId").Relational().ColumnName = "Foo_FooId";
    foreach( var m in modelBuilder.Model.GetEntityTypes())
    {
        foreach (var sp in m.GetProperties().Where( p => p.IsShadowProperty ))
        {
            var fk = sp.GetContainingForeignKeys().Where(f => f.Properties.Count == 1).FirstOrDefault();
            if (fk != null && fk.PrincipalKey.Properties.Count == 1)
            {
                sp.Relational().ColumnName = fk.PrincipalEntityType.Relational().TableName + "_" + fk.PrincipalKey.Properties.Single().Relational().ColumnName;
            }
        }
    }

}

Of course if you have a Foreign Key Property in your model, you wouldn't have to do this.

Answer 2

Here's how I managed to re-create the naming conventions for EF6 in EF Core 5.

FK name from TableNameId to TableName_Id

The most common scenario (AFAIK) is when your primary keys are simply set as Id in your models, as in:

public class Foo
{
    public int Id { get; set; }
    ...
}

The EF Core 5 default column name for foreign keys is TableNameId (e.g. FooId). To create them in EF6 style TableName_Id (e.g. Foo_Id), here is the configuration:

public class TestContext : DbContext
{
    public DbSet<Foo> Foos { get; set; }
    public DbSet<Baz> Bazzes { get; set; }

    // ...

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        AddConfigurations(modelBuilder);

        RenameForeignKeys(modelBuilder);

        base.OnModelCreating(modelBuilder);
    }

    private static void AddConfigurations(ModelBuilder modelBuilder)
    {
        modelBuilder.ApplyConfiguration(new FooConfiguration());
    }

    private static void RenameForeignKeys(ModelBuilder modelBuilder)
    {
        foreach (var entityType in modelBuilder.Model.GetEntityTypes())
        {
            var properties = entityType.GetProperties()
                .Where(property => property.IsForeignKey() && !property.DeclaringEntityType.IsOwned());

            foreach (var property in properties)
            {
                var newName = GetNewColumnName(property.Name);

                property.SetColumnName(newName);
            }
        }
    }

    private static string GetNewColumnName(string name)
    {
        if (name.Length > 2 && name[^2..] == "Id" && name[^3..] != "_Id")
        {
            return $"{name[0..^2]}_Id";
        }

        return name;
    }
}

public class FooConfiguration : IEntityTypeConfiguration<Foo>
{
    public void Configure(EntityTypeBuilder<Foo> builder)
    {
    }
}

FK name from TableNameId to TableName_TableNameId

In the OP's case, the primary keys are set as TableNameId (e.g. FooId) in the model. In order to create foreign keys as TableName_TableNameId (e.g. Foo_FooId), just replace these two methods from the previous example:

private static void RenameForeignKeys(ModelBuilder modelBuilder)
{
    foreach (var entityType in modelBuilder.Model.GetEntityTypes())
    {
        var properties = entityType.GetProperties()
            .Where(property => property.IsForeignKey() && !property.DeclaringEntityType.IsOwned());

        foreach (var property in properties)
        {
            var foreignKey = property.GetContainingForeignKeys().Single();

            var principalEntityName = foreignKey.PrincipalEntityType.FullName();

            var newName = GetNewColumnName(property.Name, principalEntityName);

            property.SetColumnName(newName);
        }
    }
}

private static string GetNewColumnName(string name, string tableName)
{
    if (name.Length > 2 && name[^2..] == "Id" && !name.Contains("_"))
    {
        return $"{name[0..^2]}_{tableName}Id";
    }

    return name;
}

Notes:

• I'm using .Single() in property.GetContainingForeignKeys().Single() since I didn't find any cases where that method didn't return only one entry.
• !name.Contains("_") is there to prevent overwriting any foreign key configurations you might have set manually.