EntityFrameworkRuler 9.0.1

Entity Framework Ruler - Command Line Tool

This is a dotnet command line tool and cannot be referenced directly from a project. Its main purpose is to generate a DB context rule file from an EDMX. The VS Extension can also do the same thing with a UI.

Automate the customization of the EF Core Reverse Engineered model. Features include:

• Legacy EF6 (EDMX) migration support
• Class renaming
• Property renaming (including both primitives and navigations)
• Type changing (useful for enum mapping)
• Custom navigations that have no database foreign key, such as adding navigations to views
• Table splitting (multiple entities using subsets of columns from the same table)
• Entity inheritance (TPH, TPT, TPC)
• Auto-naming tables and columns using regex
• Skipping tables or columns
• Forcing inclusion of simple many-to-many entities into the model
• Entity type configuration file splitting

EF Ruler applies customizations from a rule document stored in the project folder. Rules can be initialized with a call to ef dbcontext scaffold, or they can be fully generated from an EDMX such that the scaffolding output will align with the old EF6 EDMX-based model.

"EF Ruler provides a smooth upgrade path from EF6 to EF Core by ensuring that the Reverse Engineered model maps perfectly from the old EDMX structure."

Upgrading from EF6 with EDMX:

1. Use the command line tool or the VS Extension to generated DB Context rules from an EDMX file.
2. Reference EntityFrameworkRuler.Design from the EF Core project.
3. Run the ef dbcontext scaffold command and the design-time service will do the rest.

Initializing DB Context Rules without an EDMX:

1. Reference EntityFrameworkRuler.Design from the EF Core project.
2. Run the ef dbcontext scaffold command and a complete rule file will be generated based on the reverse engineered model. The rules can then be modified, and changes applied by re-running the scaffold command.

DB Context Customization and Ongoing DB Maintenance

1. Edit the rules json by hand, or with the VS Extension installed, right click on the rules file and go to Edit DB Context Rules.
2. Apply the customizations (see below).

Applying Model Customizations:

1. Reference NuGet package EntityFrameworkRuler.Design from the EF Core project. This is a design-time reference, meaning it will not appear in the project build output, but will interact with EF Core's reverse engineer process.
2. Run the ef dbcontext scaffold command and the design-time service will apply all changes as per the json rule file. The rule file itself will also sync up with the reverse engineered model.

Adding or Removing Tables From the Model:

By default, a rule file generated from EDMX limits tables and columns to just what was in the EDMX. That way, an identical model can be generated.

If it's time to add a table or column to the model, adjust the IncludeUnknownTables or IncludeUnknownColumns flags at the relevant level.

If the database schema contains a lot of tables that you don't want to generate entities for, then enabling IncludeUnknownTables is not a good idea. Instead, manually create the table entry in the rule file (using the Editor) and set IncludeUnknownColumns to true. On the next scaffold, the new entity will be generated fully.

You can remove entities from the model by marking the corresponding table (or column) as Not Mapped.

Entity Configuration Splitting:

The ef dbcontext scaffold command does not natively support splitting entity type configurations into separate files. Instead, all type configurations are stored in the same file as the context.

With EF7, EntityFrameworkRuler.Design can split configurations for you.

Just enable "SplitEntityTypeConfigurations" in the rule file (at the root level).

Installation of the Command Line Tool:

> dotnet tool install --global EntityFrameworkRuler --version <the latest version>

See the NuGet page for details.

Command Line Tool Usage:

To generate rules from an EDMX, run the following:

> efruler -g <edmxFilePath> <efCoreProjectBasePath>

If both paths are the same, i.e. the EDMX is in the EF Core project folder, it is acceptable to run:

> efruler -g <projectFolderWithEdmx>

DB context rules will be extracted from the EDMX and saved in the EF Core project folder.

To Apply rules to an already generated EF Core model:

It is strongly recommended to just run ef dbcontext scaffold with the EntityFrameworkRuler.Design library referenced in order to apply customizations. However, if this is not an option, the following command can apply renaming and type mapping to existing entities (using Roslyn). For very large projects, this can take a minute.

> efruler -a <efCoreProjectBasePath>

API Usage

While the command line tool, EntityFrameworkRuler.Design package, and VS Extension are intended to provide all the features necessary to customize the reverse engineered model, without writing any code, the API is available and fully extensible if you need to tailor the process further.

Reference NuGet package EntityFrameworkRuler.Common

To override default services:

serviceCollection
   .AddRuler()
   .AddSingleton<IRuleSerializer, MyBinaryRuleSerializer>()
   .AddTransient<IRulerNamingService, MyCustomNamingService>()
   .AddTransient<IEdmxParser, MyEdmxParser>()    

To generate rules from an EDMX:

var generator = new RuleGenerator(); // or use injected IRuleGenerator instance
var response = generator.GenerateRules(edmxPath);
if (response.Success)
    await generator.SaveRules(response.Rules.First(), projectBasePath);

Apply rules using Roslyn to a project with rules file in the same path:

var applicator = new RuleApplicator(); // or use injected IRuleApplicator instance
var response = await applicator.ApplyRulesInProjectPath(projectBasePath);

Customize rule file name:

var generator = new RuleGenerator();
var response = generator.GenerateRules(edmxPath);
if (response.Success)
    await generator.SaveRules(projectBasePath, dbContextRulesFile: "DbContextRules.json", response.Rules.First());

Handle log activity:

var applicator = new RuleApplicator();
applicator.Log += (sender, message) => Console.WriteLine(message);
var response = await applicator.ApplyRulesInProjectPath(projectBasePath);

This project is under development! Check back often, and leave comments here.