Entity Framework 7 Définir la précision décimale pour le constructeur de modèle

entity-framework-core

Question

J'ai essayé de comprendre comment régler la précision décimale pour EF7 (version bêta 4) sans succès.

Je m'attendais à faire quelque chose comme:

modelBuilder.Entity<SomeClass>().Property(p => p.DecimalProperty).Precision(10, 6)

Cela ne semble pas être disponible, mais j'ai pu trouver la classe suivante dans le référentiel de GitHub:

https://github.com/aspnet/EntityFramework/blob/7.0.0-beta4/src/EntityFramework.Relational/RelationalDecimalTypeMapping.cs

Il n'y a aucun exemple d'utilisation des classes RelationalTypeMapping ou des signatures de méthodes avec celles-ci. Peut-être que ceci est simplement utilisé dans le cadre de l’API de cartographie pour récupérer des informations?

Un autre endroit auquel je pourrais m'attendre est le suivant:

modelBuilder.Entity<SomeClass>().Property(p => p.DecimalProperty).ForRelational().ColumnType() 

ou

modelBuilder.Entity<SomeClass>().Property(p => p.DecimalProperty).ForSqlServer().ColumnType()

Ceux-ci ne prennent qu'une chaîne, cette fonctionnalité n'est-elle pas encore implémentée ou est-ce que je ne cherche pas au bon endroit?

Edit: Je viens de me rendre compte que la chaîne est probablement pour le type de solution .ColumnType ("décimal (10,6)") jusqu’à ce que cela soit construit plus loin, n’aimerais pas obtenir des éclaircissements, bien que je préfère ne pas utiliser de chaînes pour cela

Edit: après clarification de bricelam, j'ai fini par créer l'extension suivante à utiliser pour le moment afin d'éviter d'utiliser la chaîne, et j'apprécie la simplicité de leur approche:

public static RelationalPropertyBuilder DecimalPrecision(this RelationalPropertyBuilder propertyBuilder, int precision, int scale)
    {
        return propertyBuilder.ColumnType($"decimal({precision},{scale})");
    }

Exemple d'utilisation:

modelBuilder.Entity<SomeClass>().Property(p => p.DecimalProperty).ForRelational().DecimalPrecision(10,6);

Edit: Modification pour RC1

Je ne les ai pas encore testées, mais je viens de rassembler les 2 exemples suivants de ce à quoi cela ressemblera probablement avec RC1

    public static PropertyBuilder DecimalPrecision(this PropertyBuilder propertyBuilder, string precision, string scale)
    {
        return propertyBuilder.HasColumnType($"decimal({precision},{scale})");
    }

    public static PropertyBuilder SqlDecimalPrecision(this PropertyBuilder propertyBuilder, string precision, string scale)
    {
        return propertyBuilder.ForSqlServerHasColumnType($"decimal({precision},{scale})");
    }

Comme je n'ai pas encore essayé, je ne sais pas quel serait le bon usage entre "HasColumnType" ou "ForSqlServerHasColumnType", mais j'espère que cela orientera quelqu'un dans la bonne direction.

Réponse acceptée

Votre solution de contournement est la conception que nous voulions. Au lieu d'avoir un tas de "facettes", vous pouvez définir un type comme précision, échelle, longueur maximale, unicode / ansi, longueur fixe / variable, etc. Nous avons décidé de garder les choses simples: vous voulez, dites-nous quel type utiliser. Il a été question de revenir sur cette décision et de réintroduire les "facettes". Si cela vous tient à cœur, je vous encourage à créer un nouveau numéro .

Notez également qu’il existe d’autres bogues dans le mappage de types à l’heure actuelle, mais ils devraient être corrigés au moment de la publication de la version beta5.


Réponse populaire

L'exemple présenté semble être obsolète selon EF RC1.

Voici comment définir la précision sur un champ décimal.

Dis que j'ai une entité

public class Review
{
    public int ReviewId { get; set; }
    public decimal TotalScore { get; set; } //I want a precision field in DB
    public DateTime CreatedOn { get; set; }
    [Timestamp]
    public byte[] RowVersion { get; set; }
}

puis dans ma classe de contexte, lors de la création de modèle, j'instancie le mappage (je pourrais faire le mappage ici, mais j'aime le garder séparé)

public class MyDbContext : DbContext
{
    public MyDbContext(DbContextOptions<MyDbContext> options ) : base(options)
    {
    }

    public DbSet<Review> Reviews { get; set; }
    //etc.

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);

        //Mappings
        new ReviewMap(modelBuilder.Entity<Review>());
        //etc..
    }
}

et puis la cartographie. N'oubliez pas d'utiliser l'espace de noms dans lequel se trouvent les extensions de modèle:

using Microsoft.Data.Entity; //here is where the extensions are
public class ReviewMap
{
    public ReviewMap(EntityTypeBuilder<Review> entityBuilder)
    {
        entityBuilder.HasKey(r => r.ReviewId);

        //Using the column type extension
        entityBuilder.Property(r => r.TotalScore)
            .HasColumnType($"decimal(5,2)")
            .IsRequired(true);

        //and this has nothing to do with the example but it's interesting
        //to show how to use Sql command to automatically fulfil a value 
        //when adding a new Entity
        entityBuilder.Property(r => r.CreatedOn)
            .ValueGeneratedOnAdd()
            .HasDefaultValueSql("GETUTCDATE()")
            .IsRequired(true);
    }
}



Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow
Est-ce KB légal? Oui, apprenez pourquoi
Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow
Est-ce KB légal? Oui, apprenez pourquoi