使用EF/EF Core 2创建记录时为SQL表新列添加带Id前缀内容

Hey there! Let's work through this issue where you want to add an ID-prefixed value to a new column (like Reference) when creating records, without relying on SQL Server-side logic. Since your existing context configuration isn't hitting the mark, let's break down practical, code-first solutions tailored to EF/EF Core 2.

First, let's assume your entity looks something like this (adjust names to match your code):

public class YourEntity
{
    public int Id { get; set; } // Assuming this is your primary key (could be database-generated or client-generated)
    public string Reference { get; set; } // The column you want to populate with "ID-{Id}"
    // Other properties...
}

Solution 1: Override SaveChanges/SaveChangesAsync (Best for Database-Generated IDs) #

If your Id is a SQL Server identity column (auto-incrementing), EF won't populate the Id value until after the initial save. That means you need to split the process into two steps: save to get the generated ID, then update the Reference column.

Here's how to implement this in your DbContext:

public class YourDbContext : DbContext
{
    // Your DbSets and constructor...

    public override int SaveChanges()
    {
        HandleReferenceForNewEntities();
        return base.SaveChanges();
    }

    public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
    {
        await HandleReferenceForNewEntitiesAsync(cancellationToken);
        return await base.SaveChangesAsync(cancellationToken);
    }

    private void HandleReferenceForNewEntities()
    {
        // Get all newly added entities of your type
        var newEntities = ChangeTracker.Entries<YourEntity>()
            .Where(e => e.State == EntityState.Added)
            .Select(e => e.Entity);

        // First, save to get the generated Id
        base.SaveChanges();

        // Now update the Reference column with the Id prefix
        foreach (var entity in newEntities)
        {
            entity.Reference = $"ID-{entity.Id}";
            Entry(entity).State = EntityState.Modified;
        }
    }

    private async Task HandleReferenceForNewEntitiesAsync(CancellationToken cancellationToken)
    {
        var newEntities = ChangeTracker.Entries<YourEntity>()
            .Where(e => e.State == EntityState.Added)
            .Select(e => e.Entity);

        await base.SaveChangesAsync(cancellationToken);

        foreach (var entity in newEntities)
        {
            entity.Reference = $"ID-{entity.Id}";
            Entry(entity).State = EntityState.Modified;
        }
    }
}

This works because after the first SaveChanges call, EF populates the Id property with the database-generated value. We then update Reference and mark the entity as modified to save the change in the second call.

Solution 2: Client-Side Generation (For Predefined IDs) #

If you're generating the Id on the client side (e.g., using a GUID or custom number sequence), you can populate Reference immediately—no need for double saves.

Option A: Entity Constructor #

Set the Reference directly in the entity's constructor when the Id is provided:

public class YourEntity
{
    public YourEntity(int id)
    {
        Id = id;
        Reference = $"ID-{id}";
    }

    // Required for EF
    protected YourEntity() { }

    public int Id { get; set; }
    public string Reference { get; set; }
}

Just make sure you use the parameterized constructor when creating new entities.

Option B: Pre-Save Hook in SaveChanges #

If you prefer keeping constructor logic minimal, populate Reference right before saving:

public override int SaveChanges()
{
    var newEntities = ChangeTracker.Entries<YourEntity>()
        .Where(e => e.State == EntityState.Added)
        .Select(e => e.Entity);

    foreach (var entity in newEntities)
    {
        // Id is already set by your client code
        entity.Reference = $"ID-{entity.Id}";
    }

    return base.SaveChanges();
}

Solution 3: Custom Value Generator (EF Core 2.x) #

For client-generated IDs, you can create a custom ValueGenerator to let EF handle the Reference population automatically.

First, create the generator:

public class ReferenceValueGenerator : ValueGenerator<string>
{
    // Set to false because we're generating a permanent value, not a temporary one
    public override bool GeneratesTemporaryValues => false;

    public override string Next(EntityEntry entry)
    {
        var entity = entry.Entity as YourEntity;
        return entity != null ? $"ID-{entity.Id}" : string.Empty;
    }
}

Then configure it in your DbContext's OnModelCreating:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<YourEntity>()
        .Property(e => e.Reference)
        .HasValueGenerator<ReferenceValueGenerator>()
        .ValueGeneratedOnAdd();
}

This will tell EF to use your generator to populate Reference when a new entity is added—just ensure the Id is set before saving.

Troubleshooting Your Existing Configuration #

If your previous setup didn't work, here are common pitfalls to check:

• If you were using ValueGeneratedOnAdd without a custom generator, EF might have been treating the column as database-generated (which it's not).
• For database-generated IDs, you can't populate Reference before saving—EF hasn't retrieved the Id yet.
• Make sure you're not overwriting the Reference value somewhere else in your code after setting it.

内容的提问来源于stack exchange，提问作者arisfan_77