Entity Framework 7 Imposta la precisione decimale per il model builder

Question

Ho cercato di capire come impostare la precisione decimale per EF7 (Beta 4) senza fortuna.

mi aspettavo di fare qualcosa di simile:

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

Questo non sembra essere disponibile, ma sono stato in grado di trovare la seguente classe nel repository di GitHub:

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

Non ci sono esempi di utilizzo delle classi RelationalTypeMapping o delle firme del metodo con esse. Forse questo è solo usato come parte della API di mappatura per il recupero delle informazioni?

Un altro posto potrei aspetto che questo sia è il seguente:

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

o

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

questi solo prende una stringa, è questa funzionalità non solo ancora implementato o Non sono io solo cercando nel posto giusto?

Edit: appena realizzato che stringa è probabilmente per .ColumnType ("decimale (10,6)") tipo di soluzione fino a quando questo è costruita inoltre, ancora non mi dispiacerebbe ottenere qualche chiarimento anche se, come io preferirei non usare le stringhe per questo

Edit: dopo chiarimenti da bricelam ho finito per creare la seguente estensione da utilizzare per ora per evitare di utilizzare la stringa, e apprezzo la semplicità del loro approccio:

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

Esempio di utilizzo:

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

Edit: Fare di modifica per RC1

non ho ancora testato questi fuori, ma ho appena gettato insieme il seguente 2 campioni di ciò che questo sarà probabilmente simile con 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})"); 
    } 

Poiché non ho ancora provato questo non sono sicuro quale sarebbe l'uso corretto tra "HasColumnType" o "ForSqlServerHasColumnType", ma si spera che questo indicherà qualcuno nella giusta direzione.

Answer 1

La vostra soluzione è il design che intendevamo. Invece di avere un sacco di "sfaccettature" puoi impostare un tipo come precisione, scala, lunghezza massima, unicode/ansi, lunghezza fissa/variabile, ecc. Abbiamo deciso di mantenerlo semplice: se il tipo di mappatura di default non è quello vuoi, dicci che tipo usare. Si è parlato di tornare su questa decisione e di reintrodurre le "sfaccettature". Se ti senti fortemente, ti incoraggio a create a new issue.

Si noti inoltre che ci sono un sacco di altri bug nella mappatura dei tipi in questo momento, ma dovrebbero essere corretti al momento del rilascio di beta5.

Answer 2

L'esempio mostrato sembra obsoleto come da EF RC1.

Ecco come ho impostato la precisione su un campo decimale.

Dire che ho un'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; } 
} 

poi nella mia classe contesto, il modello di creazione, ho un'istanza di mappatura (ho potuto fare la mappatura lì, ma mi piace di tenerlo separato)

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

e quindi la mappatura. Ricordare di utilizzare lo spazio dei nomi in cui sono le estensioni del modello:

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