EF 7 imposta il valore predefinito iniziale per la colonna DateTime

c# entity-framework-core

Domanda

Devo essere in grado di impostare un valore iniziale della colonna DateTime.

Quando specifico "getutcdate () o DateTime.UtcNow

entity.Property(e => e.ShipDate).DefaultValue("getutcdate()")
entity.Property(e => e.ShipDate).DefaultValue(DateTime.UtcNow)

e quindi eseguire dnx . ef migration add InitialMigration EF genera uno snapshot della migrazione con:

b.Property<DateTime?>("ShipDate")
  .Required()
  .Annotation("Relational:ColumnDefaultValue", "getutcdate()")
  .Annotation("Relational:ColumnDefaultValueType", "System.String");

quando uso DateTime.UtcNow ...

b.Property<DateTime?>("ShipDate")
  .Annotation("Relational:ColumnDefaultValue", "635754129448768827")
  .Annotation("Relational:ColumnDefaultValueType", "System.DateTime");

e una migrazione iniziale:

ShipDate = table.Column(
  type: "datetime2", 
  nullable: false, 
  defaultValue: "getutcdate()"),

quando uso DateTime.UtcNow ...

ShipDate = table.Column(
  type: "datetime2", 
  nullable: true, 
  defaultValue: new DateTime(2015, 8, 17, 12, 55, 44, 876, DateTimeKind.Unspecified)),

Sembrerebbe che debba funzionare, ma quando inserisco i dati nella tabella, il valore predefinito per la colonna è l '"istante" in cui è stato creato il timestamp.

Mi sto perdendo qualcosa?

INOLTRE, dato che, nello stesso senso, come specificare l'IDENTITY SEED in EF7?

Grazie

AGGIORNAMENTO Dopo aver generato lo script sql, con entrambe le opzioni ottengo:

Se si utilizza "getutcdate ()":

[ShipDate] datetime2 DEFAULT 'getutcdate()',

che non funziona a causa delle citazioni

o se si utilizza DateTime.utcNow:

[ShipDate] datetime2 DEFAULT '2015-08-17 12:55:44.8760000'

che spiega il valore statico che stavo ottenendo.

Immagino di poterlo fare con questo. È un bug o esiste un modo corretto per farlo? Grazie

Risposta accettata

Si desidera impostare il valore predefinito SQL, non un valore costante:

entity.Property(e => e.ShipDate).HasDefaultValueSql("getutcdate()");

Risposta popolare

Una soluzione più flessibile che utilizza gli attributi per EF Core:

nel tuo DbContext:

protected override void OnModelCreating(ModelBuilder builder)
{
    base.OnModelCreating(builder);
    // Add your customizations after calling base.OnModelCreating(builder);
    CustomDataTypeAttributeConvention.Apply(builder);
    DecimalPrecisionAttributeConvention.Apply(builder);
    SqlDefaultValueAttributeConvention.Apply(builder);
}

e creare queste classi:

public static class SqlDefaultValueAttributeConvention
{
    public static void Apply(ModelBuilder builder)
    {
        ConventionBehaviors
            .SetSqlValueForPropertiesWithAttribute<SqlDefaultValueAttribute>(builder, x => x.DefaultValue);
    }
}

public static class DecimalPrecisionAttributeConvention
{
    public static void Apply(ModelBuilder builder)
    {
        ConventionBehaviors
            .SetTypeForPropertiesWithAttribute<DecimalPrecisionAttribute>(builder,
                x => $"decimal({x.Precision}, {x.Scale})");
    }
}

public class CustomDataTypeAttributeConvention
{
    public static void Apply(ModelBuilder builder)
    {
        ConventionBehaviors
            .SetTypeForPropertiesWithAttribute<DataTypeAttribute>(builder,
                x => x.CustomDataType);
    }
}

public static class ConventionBehaviors
{
    public static void SetTypeForPropertiesWithAttribute<TAttribute>(ModelBuilder builder, Func<TAttribute, string> lambda) where TAttribute : class
    {
        SetPropertyValue<TAttribute>(builder).ForEach((x) => {
            x.Item1.Relational().ColumnType = lambda(x.Item2);
        });
    }

    public static void SetSqlValueForPropertiesWithAttribute<TAttribute>(ModelBuilder builder, Func<TAttribute, string> lambda) where TAttribute : class
    {
        SetPropertyValue<TAttribute>(builder).ForEach((x) =>
        {
            x.Item1.Relational().DefaultValueSql = lambda(x.Item2);
        });
    }

    private static List<Tuple<IMutableProperty, TAttribute>> SetPropertyValue<TAttribute>(ModelBuilder builder) where TAttribute : class
    {
        var propsToModify = new List<Tuple<IMutableProperty, TAttribute>>();
        foreach (var entity in builder.Model.GetEntityTypes())
        {
            var properties = entity.GetProperties();
            foreach (var property in properties)
            {
                var attribute = property.PropertyInfo
                    .GetCustomAttributes(typeof(TAttribute), false)
                    .FirstOrDefault() as TAttribute;
                if (attribute != null)
                {
                    propsToModify.Add(new Tuple<IMutableProperty, TAttribute>(property, attribute));
                }
            }
        }
        return propsToModify;
    }
}

e attributi personalizzati:

/// <summary>
/// Set a default value defined on the sql server
/// </summary>
[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = false)]
public class SqlDefaultValueAttribute : Attribute
{
    /// <summary>
    /// Default value to apply
    /// </summary>
    public string DefaultValue { get; set; }

    /// <summary>
    /// Set a default value defined on the sql server
    /// </summary>
    /// <param name="value">Default value to apply</param>
    public SqlDefaultValueAttribute(string value)
    {
        DefaultValue = value;
    }
}

/// <summary>
/// Set the decimal precision of a decimal sql data type
/// </summary>
[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = false)]
public class DecimalPrecisionAttribute : Attribute
{
    /// <summary>
    /// Specify the precision - the number of digits both left and right of the decimal
    /// </summary>
    public int Precision { get; set; }

    /// <summary>
    /// Specify the scale - the number of digits to the right of the decimal
    /// </summary>
    public int Scale { get; set; }

    /// <summary>
    /// Set the decimal precision of a decimal sql data type
    /// </summary>
    /// <param name="precision">Specify the precision - the number of digits both left and right of the decimal</param>
    /// <param name="scale">Specify the scale - the number of digits to the right of the decimal</param>
    public DecimalPrecisionAttribute(int precision, int scale)
    {
        Precision = precision;
        Scale = scale;
    }

    public DecimalPrecisionAttribute(int[] values)
    {
        Precision = values[0];
        Scale = values[1];
    }
}

Quindi sarai in grado di decorare le proprietà della tabella con uno qualsiasi di questi attributi (o di crearne di personalizzati):

[DecimalPrecision(18, 9)] [SqlDefaultValue("getutcdate()")] [DataType("decimal(18,9)")]



Related

Autorizzato sotto: CC-BY-SA with attribution
Non affiliato con Stack Overflow
Autorizzato sotto: CC-BY-SA with attribution
Non affiliato con Stack Overflow