How to set default values in Entity Framework 6 (Database First)

1 . Open .edmx file

2 . Select the field that has the default value and go to the properties

3 . then select StoreGeneratedPattern

4 . then change the value to Computed

i think it's worked.

OP here – I’ve given credit for the answer to ErikEJ but I’d like to recap what I’ve learned on this topic to share with others. There are three goals:

1. Use the database-first approach and stick with it, even as the database schema is changed over time. That is, have EF produce the code for each database table entity, based on a preexisting database, and update the code when the database is altered.

2. Provide a mechanism to initialize entity object properties each time the object is constructed, such as Employee.Dependents = 1, for example. (I know simple defaults can be set by the database schema, but more complex initializations must be executed by code.)

3. The custom initialization code must be preserved when the database schema is altered and EF regenerates the model code.

EF doesn’t provide a way to set properties each time an entity object is constructed in the database-first scenario. Editing the EF-generated code doesn’t work because it gets overwritten whenever EF regenerates the code after a change to the database schema. So far, four workarounds come to mind:

1. One idea is to add a constructor with more than the default zero-parameter constructor for each entity class. For example, c = new Customer(x) rather than the default c = new Customer(). Application code would call the new constructor, which would inherit the default constructor and add additional code to initialize the class properties. This avoids duplicating the default constructor, something that isn’t permitted by C#. The new constructor is in a separate partial class file, so it will not be overwritten when EF generates updated models from the database.

   However, there is a risk that the application programmer may call the default constructor by accident, leading to subtle bugs.

2. Another solution is to wrap the entity classes in another class, say, a Customer2 class wrapped around the Customer class. The new class would inherit the original class and add initialization code for any properties as needed.

   Since these new classes are separate from the original entity class code, they will not be overwritten by EF when it regenerates model code. It may be possible to hide the entity classes from the top-level application code, to avoid accidentally referring to the original classes by accident. If so, this should be a good technique, although I haven’t tested it yet.

3. A third-party tool, EntityFramework Reverse POCO Generator, is a help. It generates POCO model code much as EF does, but it is not EF. It has an option to generate partial classes, and the entity classes include a InitializePartial() method much like Linq2Sql’s OnCreated(). I think this will work fine for regenerating code as the database is altered over time. My concern here is that this is a third-party product, and there’s always a risk that it can become obsolete or unsupported.

4. Finally, you can alter the template that EF uses to generate code. The basic idea is to have the generated code add “partial void OnCreated()” to each class, and this lets us use the same convenient technique built into Linq2Sql. I assume newer versions of EF may overwrite the template changes, but it’s just one change in the template rather than changes to every entity class. This method is described here (How to efficiently set default entity values in Entity Framework 6, Database First) and the YouTube video is here (https://www.youtube.com/watch?v=i8J2ipImMuU).

Thanks to all who contributed! I hope this page is helpful to others, so you don’t have to burn as much time as I did looking for a solution.

Coming from the EF background, I generally do it in the code first migration manually. In the up function of the generated migration, you can do something like this

AddColumn("dbo.Person", "IsActive", c => c.Boolean(nullable: false, defaultValue: true));
AddColumn("dbo.Person", "Name", c => c.String(nullable: false, defaultValue: "Mirza"));

Or to add default SQL value, use

AddColumn("dbo.Person", "CreatedDate",
           c => c.String(nullable: false, defaultValueSql: "GETDATE()"));

However there's a downside of this approach in my opinion which is you have to keep a track of your (useless) migrations.

Just found this post looking for an answer to the same issue. Here's a work around that works for me.

Create a partial class for the entity (DB Table) you want to specify default values for, eg:

namespace myApplication.MyModel
{
  public partial class myEntityName
  {
    public myEntityName(bool InitialiseOnConstruct) : this()
    {
      if (InitialiseOnConstruct) 
      {
        this.property1 = defaultValue1;
        this.property2 = defaultValue1;     
      }
    }
  }
}

Then in the code, to construct the entity:

thisEntity = new EntityName(true);

OK, it's an extra step, but it works. Hope that helps.