EF码的十进制精度和比例

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

在重写方法时调用基方法是一种良好的实践，即使基实现什么也不做。

更新:这篇文章也是非常有用的。

你可以在实体数据模型的MSDN方面找到更多信息。 http://msdn.microsoft.com/en-us/library/ee382834.aspx 完整的建议。< / p >

下面的代码行可以更简单地实现相同的目的:

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

Dave Van den Eynde给出的答案现在已经过时了。有2个重要的变化，从EF 4.1开始，ModelBuilder类现在是DbModelBuilder，现在有一个DecimalPropertyConfiguration。HasPrecision方法，其签名为:

public DecimalPropertyConfiguration HasPrecision(
byte precision,
byte scale )

其中精度是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);
}
}

我有一个很好的时间为这个创建自定义属性:

[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方法。

实体框架版本6 (Alpha, rc1)有一个叫做定制的约定的东西。设置十进制精度。

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

参考:

• http://entityframework.codeplex.com/wikipage?title=Custom%20Conventions
• http://weblogs.asp.net/scottgu/archive/2012/12/11/entity-framework-6-alpha2-now-available.aspx

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

使用KinSlayerUY中的DecimalPrecisonAttribute，在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());
}

如果你想在EF6中为所有decimals设置精度，你可以替换DbModelBuilder中使用的默认DecimalPropertyConvention约定:

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

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

KinSlayerUY的自定义属性为我工作得很好，但我有复杂类型的问题。它们在属性代码中被映射为实体，因此不能被映射为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);
}
}
}

@Mark007，我已经改变了DbContext的DbSet<>属性的类型选择标准。我认为这是更安全的，因为有时在给定的名称空间中有类不应该是模型定义的一部分，或者它们是但不是实体。或者您的实体可以驻留在单独的名称空间或单独的程序集中，并被拉到一个Context中。

另外，尽管不太可能，但我认为依赖于方法定义的顺序是不安全的，因此最好使用by Parameter列表将它们拉出来。(. 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;
}
}
}

你总是可以告诉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，并适用于映射到db的所有十进制类型。

使用

System.ComponentModel.DataAnnotations;

你可以简单地把这个属性放在你的模型中:

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

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

这将与EF Core代码第一次迁移工作，如在这里所述。

编辑，来自。net 6，可以用precision属性替换

[Precision (精度 规模)]

EF Core之前的版本:

__abc0 (__abc1 __abc2 (__abc4， __abc5) __abc3

定义:

__abc0 = __abc1

__abc0 = __abc1

例子:

using System.ComponentModel.DataAnnotations; //.Net Core
using Microsoft.EntityFrameworkCore; //.NET 6+


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; }
[Precision(28, 8)]
public decimal RatingV6 { get; set; }
}

更多细节:https://learn.microsoft.com/en-us/ef/core/modeling/relational/data-types

实际的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)");

从。net EF Core 6开始，你可以使用Precision属性。

    [Precision(18, 2)]
public decimal Price { get; set; }

确保你需要安装EF Core 6，并遵循using行

using Microsoft.EntityFrameworkCore;

这就是我正在寻找的，适用于普通的MVC项目(没有。net核心)

public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
{
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Entity<YOUR_CLASS_NAME>().Property(x => x.YOUR_DECIAML_PROP).HasPrecision(18, 6);


base.OnModelCreating(modelBuilder);


}
}

包管理器控制台

add-migration changeDecimalPrecision

生成的迁移

    public override void Up()
{
AlterColumn("dbo.YOUR_CLASS_NAME", "YOUR_DECIAML_PROP", c => c.Decimal(nullable: false, precision: 18, scale: 6));
}