Десятичная точность и масштаб в EF Code First

Я экспериментирую с этим первым подходом к коду, но теперь я выясню, что свойство типа System.Decimal сопоставляется с столбцом sql типа decimal (18, 0).

Как установить точность столбца базы данных?

Ответ от Дейва Ван ден Эйнда теперь устарел. Существует 2 важных изменения: начиная с EF 4.1, class 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().Property(object => object.property).HasPrecision(12, 10); base.OnModelCreating(modelBuilder); } } 

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

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

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

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

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

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

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

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

 [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 DeliveryPrice { get; set; } 

и волшебство происходит при создании модели с некоторым reflectionм

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

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

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

после этого я должен позвонить

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

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

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

 Property(Expression> propertyExpression) 

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

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

 Property(Expression> propertyExpression) 

метод.

Имея DecimalPropertyConfiguration, я вызываю метод HasPrecision.

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

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

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

  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 

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

Обновление: эта статья также была очень полезна.

Используя 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 { 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()); } 

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

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

Справка:

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

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

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

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

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

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

С помощью

 System.ComponentModel.DataAnnotations; 

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

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

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

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

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

Пользовательский атрибут 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() != 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, я изменил критерии выбора типа для перемещения свойств DbSet <> DbContext. Я думаю, что это безопаснее, потому что бывают случаи, когда у вас есть классы в данном пространстве имен, которые не должны быть частью определения модели, или они есть, но не являются сущностями. Или ваши объекты могут находиться в отдельных пространствах имен или отдельных сборках и объединяться в контекст.

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

Обратите внимание, что 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(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; } } } 
  • LINQ, Невозможно создать постоянное значение типа XXX. В этом контексте поддерживаются только примитивные типы или типы перечислений
  • Как отключить сущность из контекста в Entity Framework?
  • EF Code-First Индивидуальное отношение: множественность недействительна в Role * in relationship
  • Методы LINQPad
  • Массовое удаление в LINQ для объектов
  • Как группировать DateTime.Date в EntityFramework
  • Entity Framework - «Невозможно создать постоянное значение типа« Closure type »...» error
  • Entity Framework 4.1 загрузка по умолчанию по умолчанию
  • Понимание первых виртуальных свойств кода
  • Сколько Include я могу использовать в ObjectSet в EntityFramework для сохранения производительности?
  • Почему это происходит? Самый эффективный способ получения нескольких объектов с помощью первичного ключа?
  • Interesting Posts

    Рассчитать расстояние между двумя точками долготы широты? (Формула Хаверсина)

    Как программно добавлять представления в представления

    AngularJS – триггер при выборе переключателя

    Как обрабатывать параметры URL-строки строки запроса GET в резервном компоненте на загрузке страницы?

    Не удалось получить значение свойства margin из результата getComputedStyle

    Как я могу VLOOKUP в нескольких документах Excel?

    Как узнать пароль Wi-Fi после его подключения?

    Должна ли работать карта 2.0 на 1.0 слот PCI Express?

    Установка Windows 7 (с двойной загрузкой) после установки Windows 8

    Каков наилучший способ конкатенировать два вектора?

    Лучший способ защитить данные, чувствительные к приложениям Android?

    После установки Windows Phone 8 SDK Connectify не работает

    Нет GRUB после повторной установки Windows

    Доступ к родительскому DataContext из DataTemplate

    Как создать отдельные 7z-файлы из каждого выбранного каталога с помощью командной строки 7zip?

    Давайте будем гением компьютера.