Set decimal(16, 3) für eine Spalte im Code-First-Ansatz in EF4.3

Den DataType Attribut ist ein Validation-Attribut. Sie tun müssen, die mit dem ModelBuilder.

public class MyContext : DbContext
{
    public DbSet<MyClass> MyClass;
    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Entity<MyClass>().Property(x => x.SnachCount).HasPrecision(16, 3);
        modelBuilder.Entity<MyClass>().Property(x => x.MinimumStock).HasPrecision(16, 3);
        modelBuilder.Entity<MyClass>().Property(x => x.MaximumStock).HasPrecision(16, 3);
    }
}

InformationsquelleAutor dknaack

Dies ist kopiert von der Antwort hing ich die gleiche Frage hier; https://stackoverflow.com/a/15386883/1186032.

Ich hatte eine schöne Zeit mit der Erstellung eines Benutzerdefinierten Attributs für diese:

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

}

es diese

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

und die Magie passiert bei der Bildung des Modells mit einigen Reflexion

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

der erste Teil ist, um alle Klassen in das Modell (mein benutzerdefiniertes Attribut definiert ist, dass die Montage so habe ich, dass man die Montage mit dem Modell)

zweiten foreach bekommt alle Eigenschaften in dieser Klasse mit dem benutzerdefinierten Attribut und das Attribut selbst, so kann ich Holen Sie sich die Präzision und die Daten der Waage

danach habe ich zu nennen

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

also rufe ich im modelBuilder.Entität() durch Reflexion und speichern es in der variable entityConfig
dann Baue ich die "c => c.PROPERTY_NAME" lambda-Ausdruck

Danach, wenn der dezimal-null-Werte zulässt, nenne ich das

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

Methode (ich nenne dies durch die position im array, es ist nicht ideal, ich weiß, jede Hilfe wird sehr geschätzt)

und wenn es keine null-Werte zulässt, nenne ich das

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

Methode.

Dass die DecimalPropertyConfiguration ich nenne die HasPrecision Methode.

InformationsquelleAutor KinSlayerUY

Können Sie auch legen Sie die Genauigkeit von Dezimalstellen unter Verwendung des code-first-Modell mapping-Ansatz:

public class MyEntityMapping : EntityTypeConfiguration<MyEntity>
{
    public MyEntityMapping()
    {
        HasKey(x => x.Id);
        Property(x => x.Id).IsRequired();
        //.HasPrecision(precision, scale)
        //'precision' = total number of digits stored,
        //regardless of where the decimal point falls 
        //'scale' = number of decimal places stored
        Property(x => x.DecimalItem).IsRequired().HasPrecision(16, 6);
    }
}

InformationsquelleAutor RickL