A Brief Discussion on Default Value Behavior in Entity Framework

TLDR

• When a SQL Server column has a default value, if the Entity property value matches the C# default value for that type, EF Core may ignore that column during INSERT, causing the database to trigger the default value.
• It is recommended to avoid relying on SQL defaults whenever possible. If they must be used, ensure the SQL default value matches the C# default value.
• For string types, it is recommended to set them as NOT NULL Default '' to handle empty values consistently.
• When updating data, if the property values have not changed, SaveChanges() will return 0. When determining whether an update was successful, consider the EntityState.Unchanged case.
• After querying with AsNoTracking(), if you manually set the EntityState to Modified, all columns of that entity will be forced to update during UPDATE, rather than only updating the changed columns.

TIP

The complete executable sample for this article: CloudyWing/EfCoreBehaviorSample.

Default Value Writing Behavior in Entity Framework

When you might encounter this issue: When a database column has a default value defined, and the developer has not explicitly assigned a value in the code, or the assigned value is the same as the C# default value.

Test results show that Entity Framework does not determine changes based on "whether a value was set," but rather by comparing "new and old values" to decide whether to generate INSERT syntax. When the property value matches the default value of that type (such as null or 0), EF Core may ignore the column and let the database handle the default value.

If you use EF Core Power Tools for reverse engineering, and bool? is generated for types like bit and marked as Required, EF Core might generate DEFAULT VALUES syntax, thereby ignoring all columns.

Recommended Practices:

• Try to avoid relying on default values at the database level.
• If you must use them, ensure the SQL default value is consistent with the default value logic in your C# code.
• For string types, it is recommended to set them as NOT NULL Default '' to ensure consistent handling of null and empty strings.

State Determination When Updating Entities

When you might encounter this issue: When performing an Update operation, if the Entity property values are exactly the same as the existing values in the database, SaveChanges() will return 0.

When Entity property values have not changed, the EntityState remains Unchanged, and no UPDATE syntax will be generated.

Recommended Practices: In the update logic of your Business Service, you should use the following method to determine the execution result to avoid misjudgment:

bool isSuccess = context.Entry(entity).State == EntityState.Unchanged || context.SaveChanges() > 0;

Side Effects of AsNoTracking and EntityState

When you might encounter this issue: When you use AsNoTracking() during a query, and subsequently manually set the EntityState to Modified in order to update the data.

After querying with AsNoTracking(), the Entity is not tracked by the Change Tracker. If you manually set its state to Modified, EF Core will not know which columns have actually changed, resulting in UPDATE syntax that updates all columns of the table instead of only the changed columns.

Recommended Practices:

• Do not overuse AsNoTracking() unless necessary.
• If you need to update data, use standard query methods to allow EF Core to track changes. This ensures that the generated UPDATE syntax only includes the changed columns, resulting in better performance.

Change Log

• 2025-07-12 Initial version created.
• 2026-05-29 Added link to the corresponding GitHub sample project.