Способ по умолчанию переопределить тип точности и шкалы десятичных данных в Entity Framework [duplicate]

Методы внутри монономического внутреннего класса могут быть вызваны после того, как поток, который породил его, завершился. В вашем примере внутренний класс будет вызываться в потоке отправки событий, а не в том же потоке, что и его созданный. Следовательно, объем переменных будет различным. Поэтому, чтобы защитить такие проблемы с областью выделения переменных, вы должны объявить их окончательными.

190
задан kjbartel 25 January 2016 в 02:08
поделиться

15 ответов

Ответ от Дейва Ван ден Эйнда теперь устарел. Существует 2 важных изменения: начиная с EF 4.1, теперь класс ModelBuilder теперь DbModelBuilder , и теперь есть метод DecimalPropertyConfiguration.HasPrecision, который имеет подпись:

public DecimalPropertyConfiguration HasPrecision(
byte precision,
byte scale )

, где точность это общее количество разрядов, которые будет храниться db, независимо от того, где падает десятичная точка, а масштаб - это количество десятичных мест, которое будет хранить.

Поэтому нет необходимости перебирать свойства, как показано, но можно просто вызвать из

public class EFDbContext : DbContext
{
   protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
   {
       modelBuilder.Entity<Class>().Property(object => object.property).HasPrecision(12, 10);

       base.OnModelCreating(modelBuilder);
   }
}
214
ответ дан AlexC 21 August 2018 в 02:47
поделиться
  • 1
    Для тех, кто получает проблемы с DbModelBuilder, попробуйте System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder – ThePower 15 November 2011 в 14:11
  • 2
    Я заметил, что вы никогда не называли base.OnModelCreating(modelBuilder);. Был ли это преднамеренным или просто жертвой ввода кода онлайн, а не в среде IDE? – BenSwayne 2 August 2012 в 00:31
  • 3
    @BenSwayne благодарит за место, это мое упущение, а не что-то преднамеренное. Я отредактирую ответ. – AlexC 2 August 2012 в 08:56
  • 4
    2 аргумента в HasPrecision (точность, масштаб) плохо документированы. точность - это общее количество цифр, которое он будет хранить, независимо от того, где падает десятичная точка. scale - количество десятичных знаков, которое оно будет хранить. – Chris Moschini 18 August 2012 в 22:29
  • 5
    Есть ли конфигурация EF, чтобы установить ее для всех десятичных свойств для всех объектов в одном месте? Мы обычно используем (19,4). Было бы хорошо, если бы это автоматически применялось ко всем десятичным свойствам, поэтому мы не можем забыть установить точность свойств и пропустить ожидаемую точность вычислений. – Mike de Klerk 16 November 2016 в 09:00

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

 public class ProductConfiguration : EntityTypeConfiguration<Product>
    {
        public ProductConfiguration()
        {
            this.Property(m => m.Price).HasPrecision(10, 2);
        }
    }
12
ответ дан armadillo.mx 21 August 2018 в 02:47
поделиться

В EF6

modelBuilder.Properties()
    .Where(x => x.GetCustomAttributes(false).OfType<DecimalPrecisionAttribute>().Any())
    .Configure(c => {
        var attr = (DecimalPrecisionAttribute)c.ClrPropertyInfo.GetCustomAttributes(typeof (DecimalPrecisionAttribute), true).FirstOrDefault();

        c.HasPrecision(attr.Precision, attr.Scale);
    });
3
ответ дан Brian 21 August 2018 в 02:47
поделиться
  • 1
    Этот ответ, похоже, является обновлением до другого ответа, который определяет атрибут, вы должны отредактировать это в этом ответе – Rhys Bevilaqua 5 October 2016 в 01:44

Используя DecimalPrecisonAttribute из KinSlayerUY, в EF6 вы можете создать соглашение, которое будет обрабатывать отдельные свойства, которые имеют атрибут (в отличие от установки DecimalPropertyConvention, как в , этот ответ , который повлияет все десятичные свойства).

[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = false)]
public sealed class DecimalPrecisionAttribute : Attribute
{
    public DecimalPrecisionAttribute(byte precision, byte scale)
    {
        Precision = precision;
        Scale = scale;
    }
    public byte Precision { get; set; }
    public byte Scale { get; set; }
}

public class DecimalPrecisionAttributeConvention
    : PrimitivePropertyAttributeConfigurationConvention<DecimalPrecisionAttribute>
{
    public override void Apply(ConventionPrimitivePropertyConfiguration configuration, DecimalPrecisionAttribute attribute)
    {
        if (attribute.Precision < 1 || attribute.Precision > 38)
        {
            throw new InvalidOperationException("Precision must be between 1 and 38.");
        }

        if (attribute.Scale > attribute.Precision)
        {
            throw new InvalidOperationException("Scale must be between 0 and the Precision value.");
        }

        configuration.HasPrecision(attribute.Precision, attribute.Scale);
    }
}

Затем в вашем DbContext:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Conventions.Add(new DecimalPrecisionAttributeConvention());
}
44
ответ дан Community 21 August 2018 в 02:47
поделиться
  • 1
    @MichaelEdenfield На самом деле нет ни одного из них в EF6. Поэтому, почему я добавил два ответа, этот и другой, на которые вы ссылались. Это атрибут, который можно поместить на одно десятичное свойство, а не влиять на все десятичные свойства модели. – kjbartel 14 July 2014 в 01:04
  • 2
    мой плохой, не заметил, что вы написали их оба: \ – Michael Edenfield 14 July 2014 в 02:01
  • 3
    Если вы собираетесь ограничить проверку Precision, я рекомендую установить верхнюю границу до 28 (поэтому > 28 в вашем состоянии). Согласно документации MSDN, System.Decimal может отображать максимум 28-29 цифр точности ( msdn.microsoft.com/en-us/library/364x0z75.aspx ). Кроме того, атрибут объявляет Scale как byte, что означает, что ваше предварительное условие attribute.Scale < 0 не нужно. – NathanAldenSr 26 February 2015 в 23:48
  • 4
    @kjbartel Это правда, что некоторые поставщики баз данных поддерживают точность выше 28; однако, согласно MSDN, System.Decimal этого не делает. Поэтому нет смысла устанавливать предварительное условие сверху на что-либо большее, чем 28; System.Decimal не может представлять числа, большие, по-видимому. Кроме того, имейте в виду, что этот атрибут полезен для поставщиков данных, отличных от SQL Server. Например, тип numeric PostgreSQL поддерживает до 131072 цифр точности. – NathanAldenSr 27 February 2015 в 16:29
  • 5
  • 6
    На сегодняшний день это самое чистое решение. – Eli Arbel 11 May 2016 в 04:46

По-видимому, вы можете переопределить метод DbContext.OnModelCreating () и настроить такую ​​точность следующим образом:

protected override void OnModelCreating(System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Product>().Property(product => product.Price).Precision = 10;
    modelBuilder.Entity<Product>().Property(product => product.Price).Scale = 2;
}

Но это довольно утомительный код, когда вы должны сделать это со всеми вашими ценами свойства, поэтому я придумал следующее:

    protected override void OnModelCreating(System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder)
    {
        var properties = new[]
        {
            modelBuilder.Entity<Product>().Property(product => product.Price),
            modelBuilder.Entity<Order>().Property(order => order.OrderTotal),
            modelBuilder.Entity<OrderDetail>().Property(detail => detail.Total),
            modelBuilder.Entity<Option>().Property(option => option.Price)
        };

        properties.ToList().ForEach(property =>
        {
            property.Precision = 10;
            property.Scale = 2;
        });

        base.OnModelCreating(modelBuilder);
    }

Хорошая практика, что вы вызываете базовый метод при переопределении метода, хотя базовая реализация ничего не делает.

Update : Эта статья также очень полезна.

44
ответ дан Dave Van den Eynde 21 August 2018 в 02:47
поделиться
  • 1
    Спасибо, это указывало мне в правильном направлении. В CTP5 синтаксис изменился, чтобы добавить Точность и Масштаб в том же самом выражении: modelBuilder.Entity & lt; Product & gt; (). Свойство (продукт = & gt; product.Price) .HasPrecision (6, 2); – Col 12 January 2011 в 09:56
  • 2
    Тем не менее, было бы неплохо иметь какие-то «по умолчанию». вы можете установить для все десятичные числа? – Dave Van den Eynde 10 June 2011 в 07:55
  • 3
    Я не думаю, что нужно называть base.OnModelCreating(modelBuilder);. Из метаданных DbContext в VS: The default implementation of this method does nothing, but it can be overridden in a derived class such that the model can be further configured before it is locked down. – Matt Jenkins 24 July 2011 в 09:05
  • 4
    @Matt: Это хорошо, но в качестве разработчика я не должен заботиться об этом и всегда называть базу. – Dave Van den Eynde 25 July 2011 в 07:53
  • 5
    @ Dave и @Matt: Был комментарий, который был «ВАЖНО». вызвать базу. Это хорошая практика, но когда источник EF имеет пустую реализацию, вводить в заблуждение, чтобы утверждать, что это важно. Это заставляет людей задаваться вопросом, что делает база. Мне было так любопытно, что было ВАМ, я декомпилировался в ef5.0, чтобы проверить. Здесь пусто. Так что просто хорошая привычка. – phil soady 1 March 2013 в 05:57
[Column(TypeName = "decimal(18,2)")]

это будет работать с первыми миграциями кода, как описано здесь здесь .

1
ответ дан Elnoor 21 August 2018 в 02:47
поделиться

@ Mark007, я изменил критерии выбора типа для перемещения свойств DbSet & lt;> DbContext. Я думаю, что это безопаснее, потому что бывают случаи, когда у вас есть классы в данном пространстве имен, которые не должны быть частью определения модели, или они есть, но не являются сущностями. Или ваши объекты могут находиться в отдельных пространствах имен или отдельных сборках и объединяться в контекст.

Кроме того, даже если это маловероятно, я не думаю, что безопасно полагаться на упорядочение определений методов, поэтому лучше вытащите их с помощью списка параметров. (.GetTypeMethods () - это метод расширения, который я построил для работы с новой парадигмой TypeInfo и может сгладить иерархии классов при поиске методов).

Обратите внимание, что OnModelCreating делегирует этот метод:

    private void OnModelCreatingSetDecimalPrecisionFromAttribute(DbModelBuilder modelBuilder)
    {
        foreach (var iSetProp in this.GetType().GetTypeProperties(true))
        {
            if (iSetProp.PropertyType.IsGenericType
                    && (iSetProp.PropertyType.GetGenericTypeDefinition() == typeof(IDbSet<>) || iSetProp.PropertyType.GetGenericTypeDefinition() == typeof(DbSet<>)))
            {
                var entityType = iSetProp.PropertyType.GetGenericArguments()[0];

                foreach (var propAttr in entityType
                                        .GetProperties(BindingFlags.Public | BindingFlags.Instance)
                                        .Select(p => new { prop = p, attr = p.GetCustomAttribute<DecimalPrecisionAttribute>(true) })
                                        .Where(propAttr => propAttr.attr != null))
                {
                    var entityTypeConfigMethod = modelBuilder.GetType().GetTypeInfo().DeclaredMethods.First(m => m.Name == "Entity");
                    var entityTypeConfig = entityTypeConfigMethod.MakeGenericMethod(entityType).Invoke(modelBuilder, null);

                    var param = ParameterExpression.Parameter(entityType, "c");
                    var lambdaExpression = Expression.Lambda(Expression.Property(param, propAttr.prop.Name), true, new ParameterExpression[] { param });

                    var propertyConfigMethod =
                        entityTypeConfig.GetType()
                            .GetTypeMethods(true, false)
                            .First(m =>
                            {
                                if (m.Name != "Property")
                                    return false;

                                var methodParams = m.GetParameters();

                                return methodParams.Length == 1 && methodParams[0].ParameterType == lambdaExpression.GetType();
                            }
                            );

                    var decimalConfig = propertyConfigMethod.Invoke(entityTypeConfig, new[] { lambdaExpression }) as DecimalPropertyConfiguration;

                    decimalConfig.HasPrecision(propAttr.attr.Precision, propAttr.attr.Scale);
                }
            }
        }
    }



    public static IEnumerable<MethodInfo> GetTypeMethods(this Type typeToQuery, bool flattenHierarchy, bool? staticMembers)
    {
        var typeInfo = typeToQuery.GetTypeInfo();

        foreach (var iField in typeInfo.DeclaredMethods.Where(fi => staticMembers == null || fi.IsStatic == staticMembers))
            yield return iField;

        //this bit is just for StaticFields so we pass flag to flattenHierarchy and for the purpose of recursion, restrictStatic = false
        if (flattenHierarchy == true)
        {
            var baseType = typeInfo.BaseType;

            if ((baseType != null) && (baseType != typeof(object)))
            {
                foreach (var iField in baseType.GetTypeMethods(true, staticMembers))
                    yield return iField;
            }
        }
    }
0
ответ дан Eniola 21 August 2018 в 02:47
поделиться
  • 1
    Я просто понял, что этим методом не занимался ComplexTypes. Пересмотрит его позже. – Eniola 23 October 2014 в 15:28
  • 2
    Однако решение, предложенное Брайаном , является простым, изящным и работает. Я не буду делать каких-либо категоричных заявлений о производительности, но езда с уже отраженным PropertyInfo, а не охота на вас, должна давать лучшую производительность на очень больших моделях (порядка 200 и выше). – Eniola 23 October 2014 в 16:27

Вы всегда можете сказать EF об этом с условностями в классе Context в функции OnModelCreating следующим образом:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    // <... other configurations ...>
    // modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
    // modelBuilder.Conventions.Remove<ManyToManyCascadeDeleteConvention>();
    // modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>();

    // Configure Decimal to always have a precision of 18 and a scale of 4
    modelBuilder.Conventions.Remove<DecimalPropertyConvention>();
    modelBuilder.Conventions.Add(new DecimalPropertyConvention(18, 4));

    base.OnModelCreating(modelBuilder);
}

Это относится только к Code First EF fyi и применяется ко всем десятичным типам, сопоставленным с db.

2
ответ дан Gecko IT 21 August 2018 в 02:47
поделиться
  • 1
    Он не работал до Remove<DecimalPropertyConvention>(); до Add(new DecimalPropertyConvention(18, 4));. Я думаю, странно, что это не просто автоматически переопределяется. – Mike de Klerk 16 November 2016 в 12:01

Вы можете найти дополнительную информацию о грани MSDN-модели данных сущностей. http://msdn.microsoft.com/en-us/library/ee382834.aspx Полностью рекомендуется.

1
ответ дан Jaider 21 August 2018 в 02:47
поделиться
  • 1
    Это здорово и все, но как это относится к Code-First? – Dave Van den Eynde 10 June 2011 в 07:57
  • 2
    Это полезно, но я не могу указать атрибут [Precision] для десятичного разряда. Поэтому я использовал решение, предоставленное @KinSlayerUY. – Colin 31 August 2013 в 04:15

Мне было приятно создать пользовательский атрибут для этого:

[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = false)]
public sealed class DecimalPrecisionAttribute : Attribute
{
    public DecimalPrecisionAttribute(byte precision, byte scale)
    {
        Precision = precision;
        Scale = scale;

    }

    public byte Precision { get; set; }
    public byte Scale { get; set; }

}

, используя его, как это

[DecimalPrecision(20,10)]
public Nullable<decimal> DeliveryPrice { get; set; }

, и магия возникает при создании модели с некоторым отражением

protected override void OnModelCreating(System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder)
{
    foreach (Type classType in from t in Assembly.GetAssembly(typeof(DecimalPrecisionAttribute)).GetTypes()
                                   where t.IsClass && t.Namespace == "YOURMODELNAMESPACE"
                                   select t)
     {
         foreach (var propAttr in classType.GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(p => p.GetCustomAttribute<DecimalPrecisionAttribute>() != null).Select(
                p => new { prop = p, attr = p.GetCustomAttribute<DecimalPrecisionAttribute>(true) }))
         {

             var entityConfig = modelBuilder.GetType().GetMethod("Entity").MakeGenericMethod(classType).Invoke(modelBuilder, null);
             ParameterExpression param = ParameterExpression.Parameter(classType, "c");
             Expression property = Expression.Property(param, propAttr.prop.Name);
             LambdaExpression lambdaExpression = Expression.Lambda(property, true,
                                                                      new ParameterExpression[]
                                                                          {param});
             DecimalPropertyConfiguration decimalConfig;
             if (propAttr.prop.PropertyType.IsGenericType && propAttr.prop.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
             {
                 MethodInfo methodInfo = entityConfig.GetType().GetMethods().Where(p => p.Name == "Property").ToList()[7];
                 decimalConfig = methodInfo.Invoke(entityConfig, new[] { lambdaExpression }) as DecimalPropertyConfiguration;
             }
             else
             {
                 MethodInfo methodInfo = entityConfig.GetType().GetMethods().Where(p => p.Name == "Property").ToList()[6];
                 decimalConfig = methodInfo.Invoke(entityConfig, new[] { lambdaExpression }) as DecimalPropertyConfiguration;
             }

             decimalConfig.HasPrecision(propAttr.attr.Precision, propAttr.attr.Scale);
        }
    }
}

первая часть состоит в том, чтобы получить все классы в модели (мой пользовательский атрибут определен в этой сборке, поэтому я использовал это, чтобы получить сборку с моделью)

второй foreach получает все свойства этого класса с помощью настраиваемого атрибута и самого атрибута, поэтому я могу получить данные о точности и масштабировании

после этого, я должен вызвать

modelBuilder.Entity<MODEL_CLASS>().Property(c=> c.PROPERTY_NAME).HasPrecision(PRECISION,SCALE);

, поэтому i вызовите modelBuilder.Entity () отражением и сохраните его в переменной entityConfig, после чего я создаю lambda выражение c => c.PROPERTY_NAME

. После этого, если десятичное значение является нулевым, я вызываю

Property(Expression<Func<TStructuralType, decimal?>> propertyExpression) 

метод (я называю это положением в массиве, он не идеален, я знаю, любая помощь будет очень оценена)

, и если она не может быть нулевой, я вызываю

Property(Expression<Func<TStructuralType, decimal>> propertyExpression)

.

Наличие DecimalPropertyConfiguration i вызывает Метод HasPrecision.

66
ответ дан Jess 21 August 2018 в 02:47
поделиться
  • 1
    работал как шарм! – Bart Calixto 13 March 2013 в 21:18
  • 2
    Спасибо за это. Это спасло меня от создания тысяч лямбда-выражений. – Sean 5 July 2013 в 14:58
  • 3
    Это отлично работает, и супер чисто! Для EF 5 я изменил System.Data.Entity.ModelConfiguration.ModelBuilder на System.Data.Entity.DbModelBuilder – Colin 31 August 2013 в 04:07
  • 4
    Я использую MethodInfo methodInfo = entityConfig.GetType().GetMethod("Property", new[] { lambdaExpression.GetType() }); для получения правильной перегрузки. похоже, работает до сих пор. – fscan 7 February 2014 в 20:53
  • 5
    Я завернул это в библиотеку и упростил вызов из DbContext: github.com/richardlawley/EntityFrameworkAttributeConfig (также доступный через nuget) – Richard 24 March 2014 в 23:33

Если вы хотите установить точность для всех decimals в EF6, вы можете заменить стандартное соглашение DecimalPropertyConvention, используемое в DbModelBuilder:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Conventions.Remove<DecimalPropertyConvention>();
    modelBuilder.Conventions.Add(new DecimalPropertyConvention(38, 18));
}

По умолчанию DecimalPropertyConvention в EF6 отображает свойства decimal в столбцы decimal(18,2).

Если вы хотите, чтобы отдельные свойства имели заданную точность, вы можете установить точность для свойства объекта в DbModelBuilder:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<MyEntity>().Property(e => e.Value).HasPrecision(38, 18);
}

Или добавьте EntityTypeConfiguration<> для объекта, который задает точность:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Configurations.Add(new MyEntityConfiguration());
}

internal class MyEntityConfiguration : EntityTypeConfiguration<MyEntity>
{
    internal MyEntityConfiguration()
    {
        this.Property(e => e.Value).HasPrecision(38, 18);
    }
}
66
ответ дан kjbartel 21 August 2018 в 02:47
поделиться
  • 1
    Мое любимое решение. Работает отлично при использовании CodeFirst и миграции: EF ищет все свойства во всех классах, где «decimal» & quot; используется и генерирует миграцию для этих свойств. Большой! – okieh 17 April 2015 в 08:33

Пользовательский атрибут KinSlayerUY работал хорошо для меня, но у меня были проблемы с ComplexTypes. Они были сопоставлены как сущности в коде атрибута, поэтому не могли затем отображаться как ComplexType.

Поэтому я расширил код, чтобы это можно было сделать:

public static void OnModelCreating(DbModelBuilder modelBuilder)
    {
        foreach (Type classType in from t in Assembly.GetAssembly(typeof(DecimalPrecisionAttribute)).GetTypes()
                                   where t.IsClass && t.Namespace == "FA.f1rstval.Data"
                                   select t)
        {
            foreach (var propAttr in classType.GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(p => p.GetCustomAttribute<DecimalPrecisionAttribute>() != null).Select(
                   p => new { prop = p, attr = p.GetCustomAttribute<DecimalPrecisionAttribute>(true) }))
            {

                ParameterExpression param = ParameterExpression.Parameter(classType, "c");
                Expression property = Expression.Property(param, propAttr.prop.Name);
                LambdaExpression lambdaExpression = Expression.Lambda(property, true,
                                                                         new ParameterExpression[] { param });
                DecimalPropertyConfiguration decimalConfig;
                int MethodNum;
                if (propAttr.prop.PropertyType.IsGenericType && propAttr.prop.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
                {
                    MethodNum = 7;
                }
                else
                {
                    MethodNum = 6;
                }

                //check if complextype
                if (classType.GetCustomAttribute<ComplexTypeAttribute>() != null)
                {
                    var complexConfig = modelBuilder.GetType().GetMethod("ComplexType").MakeGenericMethod(classType).Invoke(modelBuilder, null);
                    MethodInfo methodInfo = complexConfig.GetType().GetMethods().Where(p => p.Name == "Property").ToList()[MethodNum];
                    decimalConfig = methodInfo.Invoke(complexConfig, new[] { lambdaExpression }) as DecimalPropertyConfiguration;
                }
                else
                {
                    var entityConfig = modelBuilder.GetType().GetMethod("Entity").MakeGenericMethod(classType).Invoke(modelBuilder, null);
                    MethodInfo methodInfo = entityConfig.GetType().GetMethods().Where(p => p.Name == "Property").ToList()[MethodNum];
                    decimalConfig = methodInfo.Invoke(entityConfig, new[] { lambdaExpression }) as DecimalPropertyConfiguration;
                }

                decimalConfig.HasPrecision(propAttr.attr.Precision, propAttr.attr.Scale);
            }
        }
    }
0
ответ дан Mark007 21 August 2018 в 02:47
поделиться

Entity Framework Ver 6 (Alpha, rc1) имеет нечто вроде пользовательских условных обозначений. Чтобы установить десятичную точность:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Properties<decimal>().Configure(config => config.HasPrecision(18, 4));
}

Ссылка:

28
ответ дан nhahtdh 21 August 2018 в 02:47
поделиться

Использование

System.ComponentModel.DataAnnotations;

Вы можете просто поместить этот атрибут в свою модель:

[DataType("decimal(18,5)")]
2
ответ дан VinnyG 21 August 2018 в 02:47
поделиться
  • 1
    это самая простая реализация для удобства чтения и простоты. ИМХО – ransems 21 March 2018 в 18:30
  • 2
    Per msdn.microsoft.com/en-us/library/jj591583 (v = vs.113) .aspx , этот ответ фактически неверен. msgstr "Не путать атрибут TypeName столбца с DataType DataAnnotation. DataType - это аннотация, используемая для пользовательского интерфейса и игнорируется кодом First. & Quot; – speckledcarp 23 May 2018 в 18:58
  • 3
    @ransems Я так и думал, пока я просто не протестировал его и, как было сказано выше, это не работает для CodeFirst и не переносится в базу данных – RoLYroLLs 9 July 2018 в 18:20
3
ответ дан sofsntp 31 October 2018 в 21:55
поделиться
Другие вопросы по тегам:

Похожие вопросы: