Existe-t-il un moyen "élégant" de donner à une propriété spécifique une valeur par défaut?

Peut-être par DataAnnotations, quelque chose comme:

[DefaultValue("true")]
public bool Active { get; set; }

Je vous remercie.

Vous pouvez le faire en modifiant manuellement la première migration du code:

public override void Up()
{    
   AddColumn("dbo.Events", "Active", c => c.Boolean(nullable: false, defaultValue: true));
} 

Cela fait un moment, mais laisser une note aux autres. J'ai obtenu ce qui est nécessaire avec un attribut et j'ai décoré mes champs de classe de modèle avec cet attribut comme je le souhaite.

[SqlDefaultValue(DefaultValue = "getutcdate()")]
public DateTime CreatedDateUtc { get; set; }

Vous avez l'aide de ces 2 articles:

• EF sur CodePlex
• Blog d'Andy Mehalick

Ce que j'ai fait:

Définir un attribut

[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
public class SqlDefaultValueAttribute : Attribute
{
    public string DefaultValue { get; set; }
}

Dans le "OnModelCreating" du contexte

modelBuilder.Conventions.Add( new AttributeToColumnAnnotationConvention<SqlDefaultValueAttribute, string>("SqlDefaultValue", (p, attributes) => attributes.Single().DefaultValue));

Dans le SqlGenerator personnalisé

private void SetAnnotatedColumn(ColumnModel col)
{
    AnnotationValues values;
    if (col.Annotations.TryGetValue("SqlDefaultValue", out values))
    {
         col.DefaultValueSql = (string)values.NewValue;
    }
}

Ensuite, dans le constructeur de configuration de migration, enregistrez le générateur SQL personnalisé.

SetSqlGenerator("System.Data.SqlClient", new CustomMigrationSqlGenerator());

Les réponses ci-dessus ont vraiment aidé, mais n'ont fourni qu'une partie de la solution. Le problème majeur est que dès que vous supprimez l'attribut Valeur par défaut, la contrainte sur la colonne dans la base de données ne sera pas supprimée. La valeur par défaut précédente restera donc toujours dans la base de données.

Voici une solution complète au problème, y compris la suppression des contraintes SQL sur la suppression des attributs. Je réutilise également le natif de .NET FrameworkDefaultValue attribut .

Usage

[DatabaseGenerated(DatabaseGeneratedOption.Computed)]
[DefaultValue("getutcdate()")]
public DateTime CreatedOn { get; set; }

Pour que cela fonctionne, vous devez mettre à jour IdentityModels.cs et Configuration.cs fichiers

Fichier IdentityModels.cs

Ajoutez / mettez à jour cette méthode dans votre ApplicationDbContextclasse

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
            base.OnModelCreating(modelBuilder);
            var convention = new AttributeToColumnAnnotationConvention<DefaultValueAttribute, string>("SqlDefaultValue", (p, attributes) => attributes.SingleOrDefault().Value.ToString());
            modelBuilder.Conventions.Add(convention);
}

Fichier Configuration.cs

Mettez à jour votre Configurationconstructeur de classe en enregistrant un générateur SQL personnalisé, comme ceci:

internal sealed class Configuration : DbMigrationsConfiguration<ApplicationDbContext>
{
    public Configuration()
    {
        // DefaultValue Sql Generator
        SetSqlGenerator("System.Data.SqlClient", new DefaultValueSqlServerMigrationSqlGenerator());
    }
}

Ensuite, ajoutez une classe de générateur SQL personnalisée (vous pouvez l'ajouter au fichier Configuration.cs ou à un fichier distinct)

internal class DefaultValueSqlServerMigrationSqlGenerator : SqlServerMigrationSqlGenerator
{
    private int dropConstraintCount = 0;

    protected override void Generate(AddColumnOperation addColumnOperation)
    {
        SetAnnotatedColumn(addColumnOperation.Column, addColumnOperation.Table);
        base.Generate(addColumnOperation);
    }

    protected override void Generate(AlterColumnOperation alterColumnOperation)
    {
        SetAnnotatedColumn(alterColumnOperation.Column, alterColumnOperation.Table);
        base.Generate(alterColumnOperation);
    }

    protected override void Generate(CreateTableOperation createTableOperation)
    {
        SetAnnotatedColumns(createTableOperation.Columns, createTableOperation.Name);
        base.Generate(createTableOperation);
    }

    protected override void Generate(AlterTableOperation alterTableOperation)
    {
        SetAnnotatedColumns(alterTableOperation.Columns, alterTableOperation.Name);
        base.Generate(alterTableOperation);
    }

    private void SetAnnotatedColumn(ColumnModel column, string tableName)
    {
        AnnotationValues values;
        if (column.Annotations.TryGetValue("SqlDefaultValue", out values))
        {
            if (values.NewValue == null)
            {
                column.DefaultValueSql = null;
                using (var writer = Writer())
                {
                    // Drop Constraint
                    writer.WriteLine(GetSqlDropConstraintQuery(tableName, column.Name));
                    Statement(writer);
                }
            }
            else
            {
                column.DefaultValueSql = (string)values.NewValue;
            }
        }
    }

    private void SetAnnotatedColumns(IEnumerable<ColumnModel> columns, string tableName)
    {
        foreach (var column in columns)
        {
            SetAnnotatedColumn(column, tableName);
        }
    }

    private string GetSqlDropConstraintQuery(string tableName, string columnName)
    {
        var tableNameSplittedByDot = tableName.Split('.');
        var tableSchema = tableNameSplittedByDot[0];
        var tablePureName = tableNameSplittedByDot[1];

        var str = $@"DECLARE @var{dropConstraintCount} nvarchar(128)
SELECT @var{dropConstraintCount} = name
FROM sys.default_constraints
WHERE parent_object_id = object_id(N'{tableSchema}.[{tablePureName}]')
AND col_name(parent_object_id, parent_column_id) = '{columnName}';
IF @var{dropConstraintCount} IS NOT NULL
    EXECUTE('ALTER TABLE {tableSchema}.[{tablePureName}] DROP CONSTRAINT [' + @var{dropConstraintCount} + ']')";

        dropConstraintCount = dropConstraintCount + 1;
        return str;
    }
}

Vos propriétés de modèle ne doivent pas nécessairement être des «propriétés automatiques» Même si c'est plus facile. Et l'attribut DefaultValue n'est vraiment que des métadonnées informatives. La réponse acceptée ici est une alternative à l'approche constructeur.

public class Track
{

    private const int DEFAULT_LENGTH = 400;
    private int _length = DEFAULT_LENGTH;
    [DefaultValue(DEFAULT_LENGTH)]
    public int LengthInMeters {
        get { return _length; }
        set { _length = value; }
    }
}

contre.

public class Track
{
    public Track()
    {
        LengthInMeters = 400;   
    }

    public int LengthInMeters { get; set; }        
}

Cela ne fonctionnera que pour les applications créant et consommant des données à l'aide de cette classe spécifique. Habituellement, ce n'est pas un problème si le code d'accès aux données est centralisé. Pour mettre à jour la valeur dans toutes les applications, vous devez configurer la source de données pour définir une valeur par défaut. La réponse de Devi montre comment cela peut être fait en utilisant des migrations, SQL ou la langue parlée par votre source de données.

Ce que j'ai fait, j'ai initialisé des valeurs dans le constructeur de l'entité

Remarque: les attributs DefaultValue ne définissent pas automatiquement les valeurs de vos propriétés, vous devez le faire vous-même

Après le commentaire de @SedatKapanoglu, j'ajoute toute mon approche qui fonctionne, car il avait raison, le simple fait d'utiliser l'API couramment ne fonctionne pas.

1- Créer un générateur de code personnalisé et remplacer Générer pour un ColumnModel.

   public class ExtendedMigrationCodeGenerator : CSharpMigrationCodeGenerator
{

    protected override void Generate(ColumnModel column, IndentedTextWriter writer, bool emitName = false)
    {

        if (column.Annotations.Keys.Contains("Default"))
        {
            var value = Convert.ChangeType(column.Annotations["Default"].NewValue, column.ClrDefaultValue.GetType());
            column.DefaultValue = value;
        }


        base.Generate(column, writer, emitName);
    }

}

2- Attribuez le nouveau générateur de code:

public sealed class Configuration : DbMigrationsConfiguration<Data.Context.EfSqlDbContext>
{
    public Configuration()
    {
        CodeGenerator = new ExtendedMigrationCodeGenerator();
        AutomaticMigrationsEnabled = false;
    }
}

3- Utilisez une API fluide pour créer l'annotation:

public static void Configure(DbModelBuilder builder){    
builder.Entity<Company>().Property(c => c.Status).HasColumnAnnotation("Default", 0);            
}

C'est simple! Annotez simplement avec requis.

[Required]
public bool MyField { get; set; }

la migration qui en résultera sera:

migrationBuilder.AddColumn<bool>(
name: "MyField",
table: "MyTable",
nullable: false,
defaultValue: false);

Si vous voulez true, remplacez defaultValue par true dans la migration avant de mettre à jour la base de données

J'avoue que mon approche échappe à tout le concept de "Code First". Mais si vous avez la possibilité de simplement changer la valeur par défaut dans le tableau lui-même ... c'est beaucoup plus simple que les longueurs que vous devez parcourir ci-dessus ... Je suis juste trop paresseux pour faire tout ce travail!

Il semble presque que l'idée originale des affiches fonctionnerait:

[DefaultValue(true)]
public bool IsAdmin { get; set; }

Je pensais qu'ils avaient juste fait l'erreur d'ajouter des citations ... mais hélas pas une telle intuition. Les autres suggestions étaient tout simplement trop pour moi (étant donné que j'ai les privilèges nécessaires pour entrer dans le tableau et apporter les modifications ... où tous les développeurs ne le seront pas dans toutes les situations). En fin de compte, je l'ai fait à l'ancienne. J'ai défini la valeur par défaut dans la table SQL Server ... Je veux dire vraiment, déjà assez! REMARQUE: J'ai en outre testé la création d'une base de données d'ajout-migration et de mise à jour et les modifications sont bloquées.

Il suffit de surcharger le constructeur par défaut de la classe Model et de passer tout paramètre pertinent que vous pouvez utiliser ou non. Par cela, vous pouvez facilement fournir des valeurs par défaut pour les attributs. Voici un exemple.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Aim.Data.Domain
{
    [MetadataType(typeof(LoginModel))]
    public partial class Login
    {       
        public Login(bool status)
        {
            this.CreatedDate = DateTime.Now;
            this.ModifiedDate = DateTime.Now;
            this.Culture = "EN-US";
            this.IsDefaultPassword = status;
            this.IsActive = status;
            this.LoginLogs = new HashSet<LoginLog>();
            this.LoginLogHistories = new HashSet<LoginLogHistory>();
        }


    }

    public class LoginModel
    {

        [Key]
        [ScaffoldColumn(false)] 
        public int Id { get; set; }
        [Required]
        public string LoginCode { get; set; }
        [Required]
        public string Password { get; set; }
        public string LastPassword { get; set; }     
        public int UserGroupId { get; set; }
        public int FalseAttempt { get; set; }
        public bool IsLocked { get; set; }
        public int CreatedBy { get; set; }       
        public System.DateTime CreatedDate { get; set; }
        public Nullable<int> ModifiedBy { get; set; }      
        public Nullable<System.DateTime> ModifiedDate { get; set; }       
        public string Culture { get; set; }        
        public virtual ICollection<LoginLog> LoginLogs { get; set; }
        public virtual ICollection<LoginLogHistory> LoginLogHistories { get; set; }
    }

}

Considérons que vous avez un nom de classe nommé Products et que vous avez un champ IsActive. vous avez juste besoin d'un constructeur create:

Public class Products
{
    public Products()
    {
       IsActive = true;
    }
 public string Field1 { get; set; }
 public string Field2 { get; set; }
 public bool IsActive { get; set; }
}

Votre valeur par défaut IsActive est alors True!

Edite :

si vous voulez le faire avec SQL, utilisez cette commande:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .Property(b => b.IsActive)
        .HasDefaultValueSql("true");
}

Dans EF core publié le 27 juin 2016, vous pouvez utiliser l'API couramment pour définir la valeur par défaut. Accédez à la classe ApplicationDbContext, recherchez / créez le nom de la méthode OnModelCreating et ajoutez l'API courante suivante.

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<YourTableName>()
        .Property(b => b.Active)
        .HasDefaultValue(true);
}

Dans .NET Core 3.1, vous pouvez effectuer les opérations suivantes dans la classe de modèle:

    public bool? Active { get; set; } 

Dans le DbContext OnModelCreating, vous ajoutez la valeur par défaut.

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Foundation>()
            .Property(b => b.Active)
            .HasDefaultValueSql("1");

        base.OnModelCreating(modelBuilder);
    }

Entraînant ce qui suit dans la base de données

Remarque: Si vous n'avez pas de valeur nulle (bool?) Pour votre propriété, vous obtiendrez l'avertissement suivant

The 'bool' property 'Active' on entity type 'Foundation' is configured with a database-generated default. This default will always be used for inserts when the property has the value 'false', since this is the CLR default for the 'bool' type. Consider using the nullable 'bool?' type instead so that the default will only be used for inserts when the property value is 'null'.

J'ai trouvé qu'il suffit d'utiliser Auto-Property Initializer sur la propriété d'entité pour faire le travail.

Par exemple:

public class Thing {
    public bool IsBigThing{ get; set; } = false;
}

Hmm ... Je fais d'abord DB, et dans ce cas, c'est en fait beaucoup plus facile. EF6 non? Ouvrez simplement votre modèle, faites un clic droit sur la colonne pour laquelle vous souhaitez définir une valeur par défaut, choisissez les propriétés et vous verrez un champ "DefaultValue". Remplissez-le et enregistrez. Il configurera le code pour vous.

Votre kilométrage peut d'abord varier sur le code, je n'ai pas travaillé avec cela.

Le problème avec beaucoup d'autres solutions, c'est que même si elles peuvent fonctionner initialement, dès que vous reconstruisez le modèle, il va jeter tout code personnalisé que vous avez inséré dans le fichier généré par la machine.

Cette méthode fonctionne en ajoutant une propriété supplémentaire au fichier edmx:

<EntityType Name="Thingy">
  <Property Name="Iteration" Type="Int32" Nullable="false" **DefaultValue="1"** />

Et en ajoutant le code nécessaire au constructeur:

public Thingy()
{
  this.Iteration = 1;

Définissez la valeur par défaut de la colonne dans la table dans MSSQL Server et dans l'attribut add de code de classe, comme ceci:

[DatabaseGenerated(DatabaseGeneratedOption.Computed)]

pour la même propriété.