Entity Framework Core 自定义脚手架

Question

I have done scaffolding of my SQLServer database. And it creates the POCO objects in the specified folder. What i would like to do is that it extends from my base class. I also use repository pattern so i need to have Id key on every entity and I don't want to change that each time i rescaffold the database.

Scaffold Model Example

public partial class Food
{
     public int Id { get; set; }
     public string Name { get; set; }
     public string Description { get; set; }
     public double Price { get; set; }
}

Expected Result:

public partial class Food : EntityBase
{
     public string Name { get; set; }
     public string Description { get; set; }
     public double Price { get; set; }
}

public class EntityBase : IEntityBase
{
    public int Id { get; set; }
}

Answer 1

You can use DbContextWriter & EntityTypeWriter to customize scaffold output.

In newer versions of entity core writers renamed:

• DBContextWriter ==>> CSharpDbContextGenerator
• EntityTypeWriter ==>> CSharpEntityTypeGenerator

Write some custom type writer, you can override everything and you will get your own code generator:

//HERE YOU CAN CHANGE THE WAY TYPES ARE GENERATED AND YOU CAN ADD INTERFACE OR BASE CLASS AS PARENT.
public class CustomEntitiyTypeWriter : EntityTypeWriter
{
    public CustomEntitiyTypeWriter([NotNull] CSharpUtilities cSharpUtilities)
        : base(cSharpUtilities)
    { }

    // Write Code returns generated code for class and you can raplec it with your base class
    public override string WriteCode([NotNull] EntityConfiguration entityConfiguration)
    {
        var classStr = base.WriteCode(entityConfiguration);

        var defaultStr = "public partial class " + entityConfiguration.EntityType.Name;
        var baseStr = "public partial class " + entityConfiguration.EntityType.Name + " : EntityBase";

        classStr = classStr.Replace(defaultStr, baseStr);

        return classStr;
    }      
}

declare it in setup:

public static void ConfigureDesignTimeServices(IServiceCollection services)
           => services.AddSingleton<EntityTypeWriter, CustomEntitiyTypeWriter>();

and then scaffold db, you can do the same for DBContext with CustomDBContextWriter.

Answer 2

@Tornike Choladze's excellent answer led me in the right direction, but in the latest versions of .Net Core (2.0 >) this has to be done a little differently it seems, with regard to the setup.

The custom entity type generator:

class MyEntityTypeGenerator : CSharpEntityTypeGenerator
{
    public MyEntityTypeGenerator(ICSharpUtilities cSharpUtilities) : base(cSharpUtilities) { }

    public override string WriteCode(IEntityType entityType, string @namespace, bool useDataAnnotations)
    {
        string code = base.WriteCode(entityType, @namespace, useDataAnnotations);

        var oldString = "public partial class " + entityType.Name;
        var newString = "public partial class " + entityType.Name + " : EntityBase";

        return code.Replace(oldString, newString);
    }
}

And the setup, which consists of a class in the same assembly and implementing IDesignTimeServices :

public class MyDesignTimeServices : IDesignTimeServices
{
    public void ConfigureDesignTimeServices(IServiceCollection serviceCollection)
    {
        serviceCollection.AddSingleton<ICSharpEntityTypeGenerator, MyEntityTypeGenerator>();            
    }
}

Answer 3

In case you want to modify entity names (and file and class names) here's something that might help:

Based on Chris Peacock's answer (and comments) you can build two classes to modify the names of entities and files (this works in Core 2.2).

public class CustomEFUtilities : CSharpUtilities
{
    public override string Uniquifier(
        string proposedIdentifier, ICollection<string> existingIdentifiers)
    {
        var finalIdentifier = base.Uniquifier(proposedIdentifier, existingIdentifiers);
        
        // your changes here
        if (finalIdentifier.StartsWith("tl"))
        {
            finalIdentifier = finalIdentifier.Substring(2);
        }
        
        return finalIdentifier;
    }
}

And similarly:

public class CustomEFDesignTimeServices : IDesignTimeServices
{
    public void ConfigureDesignTimeServices(IServiceCollection serviceCollection)
    {
        serviceCollection.AddSingleton<ICSharpUtilities, CustomEFUtilities>();
    }
}

Edit (EF Core 3.1)

A breaking change was introduced ( https://docs.microsoft.com/en-us/ef/core/what-is-new/ef-core-3.0/breaking-changes#microsoftentityframeworkcoredesign-is-now-a-developmentdependency-package ) so you need to modify your project file:

If you need to reference this package to override EF Core's design-time behavior, then you can update PackageReference item metadata in your project.

<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="3.0.0">
  <PrivateAssets>all</PrivateAssets>
  <!-- Remove IncludeAssets to allow compiling against the assembly -->
  <!--<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>-->
</PackageReference>

Answer 4

Currently, the scaffolding tools do not support the scenario you describe. There are no options to customise their output, only the location of the generated files and whether to use Fluent API or data annotations for configuration.

EF Core is a Code First framework. The advice is that once you have reverse-engineered your model from the existing database, you use migrations to keep the two in sync with each other from then on.

Having said that, I realise that might not always be possible depending on how responsibilities are apportioned within teams. In that kind of case, you might want to consider opening an issue requesting this feature on the GitHub repo for EF Core: https://github.com/aspnet/EntityFramework .

Answer 5

In my scenario I wanted to prefix all table names with an underscore. Version: Core 2.2 .
I don't use Id as name of my primary key column, instead table name + Id like this: FoodId . This forced me to add the [Key] data annotation to the primary key.

Model
Scaffold Model Example:

using System;
using System.Collections.Generic;

namespace MyNamespace
{
    public partial class Food
    {
         public int FoodId { get; set; }
         public string Name { get; set; }
         public string Description { get; set; }
         public double Price { get; set; }
    }
}

Expected Result:

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations; //Add

namespace MyNamespace
{
    public partial class _Food //Prefix with underscore
    {
         [Key] //Add
         public int FoodId { get; set; }
         public string Name { get; set; }
         public string Description { get; set; }
         public double Price { get; set; }
    }
}

How I solved it
I used a combination of @Chris Peacock's and @DavidC's answers.

1. Firstly, rename all entities
To prevent renaming of properties I had to explicitly tell which unique identifiers to rename, because Uniquifier function doesn't tell which type it renames.

public class MyCSharpUtilities : CSharpUtilities
{
    public override string Uniquifier(string proposedIdentifier, ICollection<string> existingIdentifiers)
    {
        var finalIdentifier = base.Uniquifier(proposedIdentifier, existingIdentifiers);

        //Prefix entity names with underscore
        if (finalIdentifier == "Food" ||
            finalIdentifier == "Fruit" ||
            finalIdentifier == "Vegetables")
        {
            finalIdentifier = "_" + finalIdentifier;
        }

        return finalIdentifier;
    }
}

2. Secondly, add the using statement and the [Key]

public class MyEntityTypeGenerator : CSharpEntityTypeGenerator
{
    public MyEntityTypeGenerator(ICSharpHelper cSharpHelper) : base(cSharpHelper) { }   

    public override string WriteCode(IEntityType entityType, string @namespace, bool useDataAnnotations)
    {
        string code = base.WriteCode(entityType, @namespace, useDataAnnotations);           
        string entityTypeName = entityType.Name.Replace("_", "");
        string keyPropertyString = "public int " + entityTypeName + "Id { get; set; }";

        if (code.Contains(keyPropertyString))
        {
            //Add "using" for data annotation
            string oldString = "using System.Collections.Generic;" + Environment.NewLine + Environment.NewLine + "namespace MyNamespace";
            string newString = "using System.Collections.Generic;" + Environment.NewLine + "using System.ComponentModel.DataAnnotations;" + Environment.NewLine + Environment.NewLine + "namespace MyNamespace";
            code = code.Replace(oldString, newString);

            //Add [Key] data annotation
            string newKeyPropertyString = "[Key]" + Environment.NewLine + "\t\t" + keyPropertyString;
            code = code.Replace(keyPropertyString, newKeyPropertyString);
        }

        return code;
    }
}

3. Finally, add these services to Startup.cs

public class CustomEFDesignTimeServices : IDesignTimeServices
{
    //Used for scaffolding database to code
    public void ConfigureDesignTimeServices(IServiceCollection serviceCollection)
    {
        serviceCollection.AddSingleton<ICSharpUtilities, MyCSharpUtilities>();
        serviceCollection.AddSingleton<ICSharpEntityTypeGenerator, MyEntityTypeGenerator>();
    }
}