EF Code First中的小数精度和小数位数


230

我正在尝试使用这种代码优先的方法,但是现在我发现System.Decimal类型的属性映射到类型为October(18,0)的sql列。

如何设置数据库列的精度?


11
一种方法是将[Column(TypeName = "decimal(18,4)")]属性用作十进制属性
S.Serpooshan

[Column(TypeName =“ decimal(18,4)”)]很棒!!!
布莱恩·赖斯

Answers:


257

Dave Van den Eynde的答案现在已过时。从EF 4.1开始,有2个重要的更改,ModelBuilder类现在是DbModelBuilder,现在有DecimalPropertyConfiguration.HasPrecision方法,其签名为:

public DecimalPropertyConfiguration HasPrecision(
byte precision,
byte scale )

其中precision是db将存储的总位数,而不管小数点在哪里,而scale是它将存储的小数位数。

因此,无需遍历所示的属性,而可以仅从中调用

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);
   }
}

对于任何遇到DbModelBuilder问题的人,请尝试System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder
Lloyd Powell,

1
我注意到你从未打电话base.OnModelCreating(modelBuilder);。这是故意的,还是只是在线而不是在IDE中键入代码的受害者?
BenSwayne

1
@BenSwayne感谢您的关注,这是我的遗漏,不是故意的。我将编辑答案。
AlexC 2012年

26
HasPrecision(precision,scale)的2个参数的文献资料很少。精度是它将存储的总位数,而不管小数点在哪里。scale是它将存储的小数位数。
克里斯·莫斯奇尼

1
是否有一个EF配置可在一处设置所有实体的所有十进制属性?我们通常使用(19,4)。将此属性自动应用于所有十进制属性会很好,因此我们不能忘记设置属性精度并错过计算中的预期精度。
Mike de Klerk

89

如果要decimals在EF6中设置所有精度,则可以替换DecimalPropertyConventionDbModelBuilder:中使用的默认约定:

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

DecimalPropertyConventionEF6中的默认值将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);
    }
}

1
我最喜欢的解决方案。在使用CodeFirst和迁移时可以完美地工作:EF在所有使用“十进制”的类中查找所有属性,并为这些属性生成一个迁移。大!
好的,我

75

我很高兴为此创建一个自定义属性:

[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);

所以我通过反射调用modelBuilder.Entity()并将其存储在EntityConfig变量中,然后构建“ c => c.PROPERTY_NAME” lambda表达式

之后,如果小数可为空,则调用

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

方法(我通过数组中的位置来称呼它,我知道这不是理想的,任何帮助将不胜感激)

如果它不为空,我打电话给

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

方法。

让DecimalPropertyConfiguration我调用HasPrecision方法。


3
谢谢你 它使我免于生成数千个lambda表达式。
肖恩

1
这很棒,而且超级干净!对于EF 5,我将System.Data.Entity.ModelConfiguration.ModelBuilder更改为System.Data.Entity.DbModelBuilder
Colin

3
MethodInfo methodInfo = entityConfig.GetType().GetMethod("Property", new[] { lambdaExpression.GetType() });用来获取正确的过载。到目前为止似乎仍然有效。
fscan

3
我将其包装到一个库中,并使得从DbContext调用起来更容易:github.com/richardlawley/EntityFrameworkAttributeConfig(也可以通过nuget获得)
理查德(Richard

理查德(Richard),我喜欢您的项目的构想,但是其中有需要EF6的内容吗?如果有与EF5兼容的版本,我将使用它,以便可以将其与ODP.NET版本一起使用。
Patrick Szalapski 2014年

50

通过使用DecimalPrecisonAttributeKinSlayerUY中的from,可以在EF6中创建一个约定,该约定将处理具有该属性的单个属性(而不是DecimalPropertyConvention此答案中设置like,会影响所有十进制属性)。

[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());
}

@MichaelEdenfield实际上,EF6中没有这些功能之一。因此,为什么我要添加两个答案,一个和您提到的另一个。您可以将此属性置于单个十进制属性上,而不影响模型中的所有十进制属性。
kjbartel 2014年

我不好,没注意到你们两个都写了:\
Michael Edenfield 2014年

1
如果您要进行bounds-check Precision,那么我建议将上限设置为28(> 28以您的情况为准)。根据MSDN文档,System.Decimal最多只能表示28-29位精度(msdn.microsoft.com/en-us/library/364x0z75.aspx)。同样,该属性声明Scalebyte,这意味着attribute.Scale < 0不需要您的前提条件。
NathanAldenSr 2015年

2
@kjbartel的确,某些数据库提供程序支持的精度大于28。但是,根据MSDN,System.Decimal事实并非如此。因此,将上限条件设置为大于28的值是没有意义的。System.Decimal显然不能代表这么大的数字。另外,请注意,此属性对SQL Server以外的数据提供程序很有用。例如,PostgreSQL的numeric类型最多支持131072位精度。
NathanAldenSr 2015年

1
@NathanAldenSr如我所说,数据库使用定点十进制(msdn),而System.Decimal是浮点。他们是完全不同的。例如,拥有一decimal(38,9)列将很乐意持有,System.Decimal.MaxValue但一decimal(28,9)列则不会。没有理由将精度限制为仅
28。– kjbartel

47

显然,您可以重写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);
    }

优良作法是在覆盖方法时调用基本方法,即使基本实现不执行任何操作。

更新:本文也非常有帮助。


10
谢谢,这为我指明了正确的方向。在CTP5中,语法已更改为允许在同一语句中添加Precision和Scale:modelBuilder.Entity <Product>()。Property(product => product.Price).HasPrecision(6,2);
上校

2
仍然,可以为所有小数设置某种“默认”值,这不是很好吗?
Dave Van den Eynde 2011年

3
我认为没有base.OnModelCreating(modelBuilder);必要打来电话。从VS中的DbContext元数据中: 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

@Matt:很好,但是作为一个实现者,我不必关心这个,而总是调用它的基础。
Dave Van den Eynde 2011年

@ Dave和@Matt:有个评论称呼基地是“重要的”。这是一个很好的做法,但是当EF源代码的实现为空时,声称它很重要会产生误导。这使人们怀疑基地的作用。我很好奇我反编译为ef5.0时要检查的重要内容。空空如也。所以只是个好习惯。
phil soady 2013年


22
[Column(TypeName = "decimal(18,2)")]

这将作为描述EF核心代码首先迁移工作在这里


1
如果您仅将其添加到模型中,则可以获得The store type 'decimal(18,2)' could not be found in the SqlServer provider manifest
Savage,

@Savage似乎是数据库提供商或数据库版本存在问题
Elnoor

@Elnoor Savage是正确的,这将在EF Migrations 6.x中引发错误。旧版非Core版本不支持通过Column属性指定精度/小数位数,如果使用DataType属性,则不执行任何操作(默认为18,2)。要使其通过EF 6.x中的Attribute起作用,您需要实现自己的ModelBuilder扩展。
克里斯·莫斯基尼

1
@ChrisMoschini,我更改了提及EF Core的答案。谢谢
Elnoor

14

此代码行可能是完成相同操作的更简单方法:

 public class ProductConfiguration : EntityTypeConfiguration<Product>
    {
        public ProductConfiguration()
        {
            this.Property(m => m.Price).HasPrecision(10, 2);
        }
    }

9

- EF的核心-使用System.ComponentModel.DataAnnotations;

使用 [ColumnTypeName = "decimal精度刻度")]

精度 = 使用的字符总数

比例 = 点后的总数。(容易混淆)

范例

public class Blog
{
    public int BlogId { get; set; }
    [Column(TypeName = "varchar(200)")]
    public string Url { get; set; }
    [Column(TypeName = "decimal(5, 2)")]
    public decimal Rating { get; set; }
}

此处有更多详细信息:https : //docs.microsoft.com/zh-cn/ef/core/modeling/relational/data-types


3

在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);
    });

该答案似乎是对定义该属性的另一个答案的升级,您应该将其编辑为该答案
Rhys Bevilaqua

3

您总是可以告诉EF使用OnModelCreating函数的Context类中的约定来执行此操作,如下所示:

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,并且适用于映射到数据库的所有十进制类型。


直到Remove<DecimalPropertyConvention>();之前才起作用Add(new DecimalPropertyConvention(18, 4));。我认为奇怪的是,它不会自动被覆盖。
Mike de Klerk

2

使用

System.ComponentModel.DataAnnotations;

您可以简单地将该属性放入模型中:

[DataType("decimal(18,5)")]

1
对于可读性和简单性而言,这是最简单的实现。恕我直言
赎金

11
根据msdn.microsoft.com/zh-CN/library/jj591583(v=vs.113).aspx,此答案实际上是错误的。“不要将Column的TypeName属性与DataType DataAnnotation混淆。DataType是用于UI的注释,并且被Code First忽略。”
斑点

2
@ransems我也这么认为,直到我刚刚对其进行测试为止,如上所述,这不适用于CodeFirst并且不会迁移到数据库
RoLYroLLs


1

实际对于EntityFrameworkCore 3.1.3:

OnModelCreating中的一些解决方案:

var fixDecimalDatas = new List<Tuple<Type, Type, string>>();
foreach (var entityType in builder.Model.GetEntityTypes())
{
    foreach (var property in entityType.GetProperties())
    {
        if (Type.GetTypeCode(property.ClrType) == TypeCode.Decimal)
        {
            fixDecimalDatas.Add(new Tuple<Type, Type, string>(entityType.ClrType, property.ClrType, property.GetColumnName()));
        }
    }
}

foreach (var item in fixDecimalDatas)
{
    builder.Entity(item.Item1).Property(item.Item2, item.Item3).HasColumnType("decimal(18,4)");
}

//custom decimal nullable:
builder.Entity<SomePerfectEntity>().Property(x => x.IsBeautiful).HasColumnType("decimal(18,4)");

0

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,我已更改类型选择条件以使用DbContext的DbSet <>属性。我认为这样做比较安全,因为有时在给定名称空间中有一些类不应属于模型定义,或者它们不是实体。或者,您的实体可以驻留在单独的名称空间或单独的程序集中,并一起放入一个Context中。

另外,尽管不太可能,但我认为依赖方法定义的顺序并不安全,因此最好通过“参数”列表将它们拉出。(.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;
            }
        }
    }

我只是意识到我没有用这种方法处理ComplexTypes。稍后将对其进行修改。
Eniola 2014年

但是,Brian提出的解决方案简单,优雅且可行。我不会对性能做出任何明确的陈述,但是骑乘已经反映出的PropertyInfo而不是追逐您的PropertyInfo应该会在非常大的模型(大约200及以上)上产生更好的性能。
Eniola 2014年
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.