ASP.NET Core Development Notes: Standardizing Entity and Property Naming Conventions with EFCore

Preface

In C# coding conventions, classes and properties follow PascalCase (UpperCamelCase) naming style, while in databases we often use snake_case. By default, EFCore directly maps the original class and property names to the database, which does not comply with database naming conventions.

To adhere to naming standards and also for better readability, custom naming conversion processing is required.

FreeSQL's Naming Conversion Feature

FreeSQL has a built-in convenient naming style conversion feature that can be implemented simply by setting UseNameConvert, enabling conversion from PascalCase to snake_case.

var fsql = new FreeSqlBuilder()
  .UseConnectionString(DataType.MySql, Default.Value)
  .UseAutoSyncStructure(true)
  .UseNameConvert(NameConvertType.PascalCaseToUnderscoreWithLower)
  .UseMonitorCommand(cmd => Trace.WriteLine(cmd.CommandText))
  .Build();

EFCore does not have this feature built-in, so we need to implement it ourselves.

Implementing Naming Style Conversion with Regular Expressions

Using regular expressions can achieve this functionality.

Here, we'll write an extension method.

public static class StringExt {
    public static string ToSnakeCase(this string input) {
        if (string.IsNullOrEmpty(input)) {
            return input;
        }

        var startUnderscores = Regex.Match(input, @"^_+");
        return startUnderscores + Regex.Replace(input, @"([a-z0-9])([A-Z])", "$1_$2").ToLower();
    }
}

This method adds an underscore between each lowercase letter or digit and an uppercase letter, and converts the entire string to lowercase.

Modifying EFCore Behavior

EFCore is feature-rich, and changing table and field names is naturally well within its capabilities.

Simply override the OnModelCreating method of your DbContext.

public class AppDbContext : DbContext {
  // ...

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

    // CamelCase to SnakeCase
    foreach (var entity in modelBuilder.Model.GetEntityTypes()) {
      // Replace table names
      if (!string.IsNullOrWhiteSpace(entity.GetTableName())) {
        entity.SetTableName(entity.GetTableName()!.ToSnakeCase());
      }

      // Replace column names            
      foreach (var property in entity.GetProperties()) {
        property.SetColumnName(property.GetColumnName().ToSnakeCase());
      }

      foreach (var key in entity.GetKeys()) {
        if (!string.IsNullOrWhiteSpace(key.GetName())) {
          key.SetName(key.GetName()!.ToSnakeCase());
        }
      }

      foreach (var key in entity.GetForeignKeys()) {
        if (!string.IsNullOrWhiteSpace(key.GetConstraintName())) {
          key.SetConstraintName(key.GetConstraintName()!.ToSnakeCase());
        }
      }

      foreach (var index in entity.GetIndexes()) {
        if (!string.IsNullOrWhiteSpace(index.GetDatabaseName())) {
          index.SetDatabaseName(index.GetDatabaseName()!.ToSnakeCase());
        }
      }
    }
  }
}

The code above will convert the names of tables, columns, keys, and indexes.

Done~

Extension: Implementing Name Conversion Using Plugins

2023-10-10 addendum: After this article was published on the blog, a fellow developer shared the EFCore.NamingConventions plugin, which can conveniently implement naming style conversions.

Project address: https://github.com/efcore/EFCore.NamingConventions

Usage

First, install the EFCore.NamingConventions NuGet package.

Then, override the OnConfiguring method of DbContext.

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) {
  base.OnConfiguring(optionsBuilder);
  optionsBuilder.UseSnakeCaseNamingConvention();
}

Name conversion can be achieved with just one line of code.

This plugin supports conversion to multiple styles simultaneously. Simply call different extension methods.

• UseSnakeCaseNamingConvention: FullName becomes full_name
• UseLowerCaseNamingConvention: FullName becomes fullname
• UseCamelCaseNamingConvention: FullName becomes fullName
• UseUpperCaseNamingConvention: FullName becomes FULLNAME
• UseUpperSnakeCaseNamingConvention: FullName becomes FULL_NAME

References

• https://andrewlock.net/customising-asp-net-core-identity-ef-core-naming-conventions-for-postgresql/