EntityFramework Базовая база данных первого подхода множественные имена таблиц

Question

У нас есть существующая база данных с именами с множественными именами. Пример Documents. Я пытаюсь использовать новый EF Core и Asp.Net Core с базой данных первого подхода, основанного на этой статье here

я выполнить следующую команду, чтобы создать модели из существующей базы данных

Эшафот-DbContext «Server = (локальный) ; Database = MyDatabase; Trusted_Connection = True; "Microsoft.EntityFrameworkCore.SqlServer -OutputDir модель

Однако при запуске команды люльки он создает модель с множественными именами. Например, таблица Documents, преобразованная в модель Documents.

Как изменить это, чтобы он мог использовать единое соглашение об именах для модели? (Я не могу изменить имена таблиц в базе данных)

Обратите внимание, что я прочитал несколько сообщений по SO, связанных с одной и той же проблемой, но в основном они касаются первого подхода кода. Я использую первый подход к базе данных.

Answer 1

В настоящее время в инструментах EF Core нет параметров для настройки вывода обратной инженерии существующей базы данных в соответствии с тем, как вы описываете. В настоящее время ваш единственный реалистичный вариант - изменить сгенерированный код.

Answer 2

Для DB-первых, я большой поклонник EntityFramework Reverse POCO Generator

... это имеет огромное количество опций для настройки просто обо всем. Возможно, даже слишком много ...

Это делает много вещей с помощью Pluralizations и позволяет создавать собственные сопоставления имен ad-hoc.

Answer 3

В настоящее время обратная инженерия не является уникальным (это слово?) Имена таблиц для типов сущностей или их множественность для свойств навигации. Это вопрос #3060. До тех пор вам придется вручную изменить их на то, что вы хотите, после генерации кода.

Answer 4

В Entity Framework Core v2 они представили крючок плюрализатора. Где вы можете: pluralize или введите свои объекты самостоятельно.

Вы можете сделать это, добавив в свой проект:

public class MyDesignTimeServices : IDesignTimeServices 
{ 
    public void ConfigureDesignTimeServices(IServiceCollection services) 
    { 
     services.AddSingleton<IPluralizer, MyPluralizer>(); 
    } 
} 

public class MyPluralizer : IPluralizer 
{ 
    public string Pluralize(string name) 
    { 
     return Inflector.Inflector.Pluralize(name) ?? name; 
    } 

    public string Singularize(string name) 
    { 
     return Inflector.Inflector.Singularize(name) ?? name; 
    } 
} 

Подробнее: What's new in EF core 2

Вы можете использовать этот класс в качестве инфлектор:

using System.Collections.Generic; 
using System.Text.RegularExpressions; 

namespace DMP.Generator 
{ 
    public static class Inflector 
    { 
     #region Default Rules 

     static Inflector() 
     { 
      AddPlural("$", "s"); 
      AddPlural("s$", "s"); 
      AddPlural("(ax|test)is$", "$1es"); 
      AddPlural("(octop|vir|alumn|fung)us$", "$1i"); 
      AddPlural("(alias|status)$", "$1es"); 
      AddPlural("(bu)s$", "$1ses"); 
      AddPlural("(buffal|tomat|volcan)o$", "$1oes"); 
      AddPlural("([ti])um$", "$1a"); 
      AddPlural("sis$", "ses"); 
      AddPlural("(?:([^f])fe|([lr])f)$", "$1$2ves"); 
      AddPlural("(hive)$", "$1s"); 
      AddPlural("([^aeiouy]|qu)y$", "$1ies"); 
      AddPlural("(x|ch|ss|sh)$", "$1es"); 
      AddPlural("(matr|vert|ind)ix|ex$", "$1ices"); 
      AddPlural("([m|l])ouse$", "$1ice"); 
      AddPlural("^(ox)$", "$1en"); 
      AddPlural("(quiz)$", "$1zes"); 

      AddSingular("s$", ""); 
      AddSingular("(n)ews$", "$1ews"); 
      AddSingular("([ti])a$", "$1um"); 
      AddSingular("((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$", "$1$2sis"); 
      AddSingular("(^analy)ses$", "$1sis"); 
      AddSingular("([^f])ves$", "$1fe"); 
      AddSingular("(hive)s$", "$1"); 
      AddSingular("(tive)s$", "$1"); 
      AddSingular("([lr])ves$", "$1f"); 
      AddSingular("([^aeiouy]|qu)ies$", "$1y"); 
      AddSingular("(s)eries$", "$1eries"); 
      AddSingular("(m)ovies$", "$1ovie"); 
      AddSingular("(x|ch|ss|sh)es$", "$1"); 
      AddSingular("([m|l])ice$", "$1ouse"); 
      AddSingular("(bus)es$", "$1"); 
      AddSingular("(o)es$", "$1"); 
      AddSingular("(shoe)s$", "$1"); 
      AddSingular("(cris|ax|test)es$", "$1is"); 
      AddSingular("(octop|vir|alumn|fung)i$", "$1us"); 
      AddSingular("(alias|status)$", "$1"); 
      AddSingular("(alias|status)es$", "$1"); 
      AddSingular("^(ox)en", "$1"); 
      AddSingular("(vert|ind)ices$", "$1ex"); 
      AddSingular("(matr)ices$", "$1ix"); 
      AddSingular("(quiz)zes$", "$1"); 

      AddIrregular("person", "people"); 
      AddIrregular("man", "men"); 
      AddIrregular("child", "children"); 
      AddIrregular("sex", "sexes"); 
      AddIrregular("move", "moves"); 
      AddIrregular("goose", "geese"); 
      AddIrregular("alumna", "alumnae"); 

      AddUncountable("equipment"); 
      AddUncountable("information"); 
      AddUncountable("rice"); 
      AddUncountable("money"); 
      AddUncountable("species"); 
      AddUncountable("series"); 
      AddUncountable("fish"); 
      AddUncountable("sheep"); 
      AddUncountable("deer"); 
      AddUncountable("aircraft"); 
     } 

     #endregion 

     private class Rule 
     { 
      private readonly Regex _regex; 
      private readonly string _replacement; 

      public Rule(string pattern, string replacement) 
      { 
       _regex = new Regex(pattern, RegexOptions.IgnoreCase); 
       _replacement = replacement; 
      } 

      public string Apply(string word) 
      { 
       if (!_regex.IsMatch(word)) 
       { 
        return null; 
       } 

       return _regex.Replace(word, _replacement); 
      } 
     } 

     private static void AddIrregular(string singular, string plural) 
     { 
      AddPlural("(" + singular[0] + ")" + singular.Substring(1) + "$", "$1" + plural.Substring(1)); 
      AddSingular("(" + plural[0] + ")" + plural.Substring(1) + "$", "$1" + singular.Substring(1)); 
     } 

     private static void AddUncountable(string word) 
     { 
      _uncountables.Add(word.ToLower()); 
     } 

     private static void AddPlural(string rule, string replacement) 
     { 
      _plurals.Add(new Rule(rule, replacement)); 
     } 

     private static void AddSingular(string rule, string replacement) 
     { 
      _singulars.Add(new Rule(rule, replacement)); 
     } 

     private static readonly List<Rule> _plurals = new List<Rule>(); 
     private static readonly List<Rule> _singulars = new List<Rule>(); 
     private static readonly List<string> _uncountables = new List<string>(); 

     public static string Pluralize(this string word) 
     { 
      return ApplyRules(_plurals, word); 
     } 

     public static string Singularize(this string word) 
     { 
      return ApplyRules(_singulars, word); 
     } 

#if NET45 || NETFX_CORE 
     [MethodImpl(MethodImplOptions.AggressiveInlining)] 
#endif 
     private static string ApplyRules(List<Rule> rules, string word) 
     { 
      string result = word; 

      if (!_uncountables.Contains(word.ToLower())) 
      { 
       for (int i = rules.Count - 1; i >= 0; i--) 
       { 
        if ((result = rules[i].Apply(word)) != null) 
        { 
         break; 
        } 
       } 
      } 

      return result; 
     } 

     public static string Titleize(this string word) 
     { 
      return Regex.Replace(Humanize(Underscore(word)), @"\b([a-z])", 
           delegate (Match match) 
           { 
            return match.Captures[0].Value.ToUpper(); 
           }); 
     } 

     public static string Humanize(this string lowercaseAndUnderscoredWord) 
     { 
      return Capitalize(Regex.Replace(lowercaseAndUnderscoredWord, @"_", " ")); 
     } 

     public static string Pascalize(this string lowercaseAndUnderscoredWord) 
     { 
      return Regex.Replace(lowercaseAndUnderscoredWord, "(?:^|_)(.)", 
           delegate (Match match) 
           { 
            return match.Groups[1].Value.ToUpper(); 
           }); 
     } 

     public static string Camelize(this string lowercaseAndUnderscoredWord) 
     { 
      return Uncapitalize(Pascalize(lowercaseAndUnderscoredWord)); 
     } 

     public static string Underscore(this string pascalCasedWord) 
     { 
      return Regex.Replace(
       Regex.Replace(
        Regex.Replace(pascalCasedWord, @"([A-Z]+)([A-Z][a-z])", "$1_$2"), @"([a-z\d])([A-Z])", 
        "$1_$2"), @"[-\s]", "_").ToLower(); 
     } 

     public static string Capitalize(this string word) 
     { 
      return word.Substring(0, 1).ToUpper() + word.Substring(1).ToLower(); 
     } 

     public static string Uncapitalize(this string word) 
     { 
      return word.Substring(0, 1).ToLower() + word.Substring(1); 
     } 

     public static string Ordinalize(this string numberString) 
     { 
      return Ordanize(int.Parse(numberString), numberString); 
     } 

     public static string Ordinalize(this int number) 
     { 
      return Ordanize(number, number.ToString()); 
     } 

#if NET45 || NETFX_CORE 
     [MethodImpl(MethodImplOptions.AggressiveInlining)] 
#endif 
     private static string Ordanize(int number, string numberString) 
     { 
      int nMod100 = number % 100; 

      if (nMod100 >= 11 && nMod100 <= 13) 
      { 
       return numberString + "th"; 
      } 

      switch (number % 10) 
      { 
       case 1: 
        return numberString + "st"; 
       case 2: 
        return numberString + "nd"; 
       case 3: 
        return numberString + "rd"; 
       default: 
        return numberString + "th"; 
      } 
     } 


     public static string Dasherize(this string underscoredWord) 
     { 
      return underscoredWord.Replace('_', '-'); 
     } 
    } 
} 

Его изогнутый класс может here

Для строительных лесов Я использую команду dotnet ef.

Следующие пакеты NuGet включены в мой проект:

<ItemGroup> 
    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="2.0.1" /> 
    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.0.1" /> 
    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="2.0.1" /> 
    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="2.0.1" /> 
    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="2.0.1" /> 
    <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Tools" Version="2.0.1" /> 
    </ItemGroup> 
    <ItemGroup> 
    <DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools" Version="2.0.1" /> 
    <DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="2.0.1" /> 
    </ItemGroup>