Precisión decimal y escala en el código EF primero

Estoy experimentando con este enfoque de primer código, pero descubrí que una propiedad de tipo System.Decimal se asigna a una columna sql de tipo decimal (18, 0).

¿Cómo configuro la precisión de la columna de la base de datos?

La respuesta de Dave Van den Eynde ahora está desactualizada. Hay 2 cambios importantes, desde EF 4.1 en adelante, la clase ModelBuilder ahora es DbModelBuilder y ahora hay un método DecimalPropertyConfiguration.HasPrecision que tiene una firma de:

public DecimalPropertyConfiguration HasPrecision( byte precision, byte scale ) 

donde la precisión es el número total de dígitos que almacenará el db, independientemente de dónde caiga el punto decimal y la escala sea la cantidad de decimales que almacenará.

Por lo tanto, no es necesario iterar a través de las propiedades como se muestra, pero se puede llamar desde

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

Si desea establecer la precisión para todos los decimals en EF6, puede reemplazar la convención DbModelBuilder predeterminada utilizada en DbModelBuilder :

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

La DecimalPropertyConvention predeterminada en EF6 asigna propiedades decimal(18,2) columnas decimal(18,2) .

Si solo desea que las propiedades individuales tengan una precisión especificada, entonces puede establecer la precisión para la propiedad de la entidad en el DbModelBuilder :

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

O bien, agregue EntityTypeConfiguration<> para la entidad que especifica la precisión:

 protected override void OnModelCreating(DbModelBuilder modelBuilder) { modelBuilder.Configurations.Add(new MyEntityConfiguration()); } internal class MyEntityConfiguration : EntityTypeConfiguration { internal MyEntityConfiguration() { this.Property(e => e.Value).HasPrecision(38, 18); } } 

Me lo pasé muy bien creando un atributo personalizado para esto:

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

usándolo así

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

y la magia ocurre en la creación del modelo con algo de reflexión

 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() != null).Select( p => new { prop = p, attr = p.GetCustomAttribute(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); } } } 

la primera parte es obtener todas las clases en el modelo (mi atributo personalizado se define en ese ensamblaje, así que lo usé para obtener el ensamblaje con el modelo)

el segundo foreach obtiene todas las propiedades de esa clase con el atributo personalizado y el atributo en sí mismo para que pueda obtener la precisión y los datos de escala

después de eso tengo que llamar

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

así que llamo al modelBuilder.Entity () por reflection y lo almaceno en la variable entityConfig luego construyo la expresión lambda “c => c.PROPERTY_NAME”

Después de eso, si el decimal es nulo, llamo al

 Property(Expression> propertyExpression) 

método (lo llamo por la posición en la matriz, no es ideal, lo sé, cualquier ayuda será muy apreciada)

y si no es nulable llamo al

 Property(Expression> propertyExpression) 

método.

Al tener DecimalPropertyConfiguration, llamo al método HasPrecision.

Aparentemente, puede anular el método DbContext.OnModelCreating () y configurar la precisión de esta manera:

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

Pero este es un código bastante tedioso cuando tienes que hacerlo con todas tus propiedades relacionadas con los precios, así que se me ocurrió esto:

  protected override void OnModelCreating(System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder) { var properties = new[] { modelBuilder.Entity().Property(product => product.Price), modelBuilder.Entity().Property(order => order.OrderTotal), modelBuilder.Entity().Property(detail => detail.Total), modelBuilder.Entity 

Es una buena práctica que llame al método base cuando anula un método, aunque la implementación base no haga nada.

Actualización: este artículo también fue muy útil.

Usando DecimalPrecisonAttribute de KinSlayerUY, en EF6 puede crear una convención que maneje las propiedades individuales que tienen el atributo (a diferencia de establecer DecimalPropertyConvention como en esta respuesta que afectará todas las propiedades decimales).

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

Luego en tu DbContext :

 protected override void OnModelCreating(DbModelBuilder modelBuilder) { modelBuilder.Conventions.Add(new DecimalPrecisionAttributeConvention()); } 

Entity Framework Ver 6 (Alpha, rc1) tiene algo llamado Custom Conventions . Para establecer la precisión decimal:

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

Referencia:

esta línea de código podría ser una forma más simple de lograr lo mismo:

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

En EF6

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

Siempre puede decirle a EF que haga esto con las convenciones en la clase Contexto en la función OnModelCreating de la siguiente manera:

 protected override void OnModelCreating(DbModelBuilder modelBuilder) { // <... other configurations ...> // modelBuilder.Conventions.Remove(); // modelBuilder.Conventions.Remove(); // modelBuilder.Conventions.Remove(); // Configure Decimal to always have a precision of 18 and a scale of 4 modelBuilder.Conventions.Remove(); modelBuilder.Conventions.Add(new DecimalPropertyConvention(18, 4)); base.OnModelCreating(modelBuilder); } 

Esto solo se aplica a Code First EF fyi y se aplica a todos los tipos decimales mapeados a db.

Utilizando

 System.ComponentModel.DataAnnotations; 

Simplemente puede poner ese atributo en su modelo:

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

Puede encontrar más información sobre MSDN: faceta del modelo de datos de entidad. http://msdn.microsoft.com/en-us/library/ee382834.aspx Completo recomendado.

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

esto funcionará codifica las primeras migraciones como se describe aquí .

El atributo personalizado de KinSlayerUY funcionó bien para mí, pero tuve problemas con ComplexTypes. Se estaban mapeando como entidades en el código de atributo, por lo que no se pudieron mapear como un Tipo Complejo.

Por lo tanto, extendí el código para permitir esto:

 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() != null).Select( p => new { prop = p, attr = p.GetCustomAttribute(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() != 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, he cambiado los criterios de selección de tipo para montar las propiedades DbSet <> del DbContext. Creo que esto es más seguro porque hay ocasiones en las que tienes clases en el espacio de nombres dado que no deberían ser parte de la definición del modelo o son pero no son entidades. O sus entidades podrían residir en espacios de nombres separados o en ensamblajes separados y reunirse en Contexto una vez.

Además, aunque es poco probable, no creo que sea seguro confiar en el orden de las definiciones de métodos, por lo que es mejor sacarlos con la lista de parámetros. (.GetTypeMethods () es un método de extensión que construí para trabajar con el nuevo paradigma TypeInfo y puede aplanar las jerarquías de clase cuando se buscan métodos).

Tenga en cuenta que OnModelCreating delega en este método:

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