Início / coding / Perguntas / 79492960
Accepted
user29931385
Asked: 2025-03-08 00:49:04 +0800 CST

Restrição de chave estrangeira fina em INSERT, falha em UPDATE

  • 772

Estou usando o Entity Framework. No meu modelo, tornei uma chave estrangeira anulável, e parece que ela está refletida corretamente no banco de dados. Aqui está parte da minha classe de modelo Asset:

public class Asset
{
    [Key]
    public int AssetID { get; set; }

    [Required]
    [MaxLength(100)]
    public string AssetName { get; set; }

    [Required]
    public int AssetTypeID { get; set; }

    [ForeignKey("AssetTypeID")]
    public AssetType AssetType { get; set; }

    public int? SubtypeID { get; set; }

    [ForeignKey("SubtypeID")]
    public Subtype? Subtype { get; set; }
}

Como você pode ver, a SubtypeIDpropriedade e a propriedade de navegação estão ambas definidas como anuláveis, e a coluna na tabela está corretamente definida como anulável também. Ao inserir um novo Asset, ele aceita SubtypeIDcomo NULL, no entanto, ao atualizar um já existente Assetpara ter NULL para SubtypeID, recebo o seguinte erro:

SqlException: A instrução UPDATE entrou em conflito com a restrição FOREIGN KEY "FK_Assets_Subtypes_SubtypeID". O conflito ocorreu no banco de dados "assetinventory", tabela "dbo.Subtypes", coluna 'TypeID'.

Aqui está parte do método que lança essa exceção:

var updatedAsset = viewModel.Asset;

using (var scope = App.ServiceProvider.CreateScope())
{
    var context = scope.ServiceProvider.GetRequiredService<AssetDbContext>();

    SelectedAsset.AssetName = updatedAsset.AssetName;
    SelectedAsset.AssetTypeID = updatedAsset.AssetTypeID;
    SelectedAsset.AssetType = updatedAsset.AssetType;

    if (updatedAsset.SubtypeID == -1)
    {
        SelectedAsset.SubtypeID = null;
        SelectedAsset.Subtype = null;
    }
    else
    {
        SelectedAsset.SubtypeID = updatedAsset.SubtypeID;
        SelectedAsset.Subtype = updatedAsset.Subtype;
    }

    SelectedAsset.Owner = updatedAsset.Owner;
    SelectedAsset.Location = updatedAsset.Location;
    SelectedAsset.PurchaseDate = updatedAsset.PurchaseDate;
    SelectedAsset.Value = updatedAsset.Value;
    SelectedAsset.Status = updatedAsset.Status;
    SelectedAsset.Description = updatedAsset.Description;

    context.Assets.Update(SelectedAsset);

    var log = new AssetLog
    {
        AssetID = SelectedAsset.AssetID,
        Action = "Updated",
        Timestamp = DateTime.Now,
        PerformedBy = AuthenticationService.Instance.CurrentUser.GetTenantProfiles().ElementAt(0).Oid
    };

    context.AssetLogs.Add(log);

    await context.SaveChangesAsync();
}

A exceção é lançada na SaveChangesAsyncchamada do método.

Tentei um monte de coisas que encontrei aqui, perguntei ao ChatGPT, tudo. Não consegui entender por que isso pode estar acontecendo. O que posso tentar em seguida?

c#

3 respostas

  1. Tenha cuidado ao atualizar entidades usando propriedades de navegação originadas de valores que chegam, especialmente algo como uma cópia desserializada. Por exemplo:

        SelectedAsset.SubtypeID = updatedAsset.SubtypeID;
    SelectedAsset.Subtype = updatedAsset.Subtype;

    Normalmente, recomendo usar uma propriedade shadow para FKs onde uma propriedade de navegação é usada em vez de expor ambas as colunas. Quando sua entidade expõe uma navegação e atualiza ambos os valores, é a propriedade de navegação que tem precedência. Verifique os valores da propriedade de navegação para ver se o ID desse Subtipo foi realmente preenchido e se não era #null. Normalmente, se isso for algo como uma API onde o updatedAsset e o Subtipo associado foram desserializados, o SubTipo não seria reconhecido automaticamente como um registro "existente" porque não está anexado ao DbContext. O EF por padrão tentaria inserir uma linha ou tentar associar uma linha a um ID padrão (ou seja, 0 ou -1)

    Você pode optar por apenas atualizar o relacionamento definindo o FK, desde que não esteja contando com a serialização/uso do SelectedAsset e seu Subtipo, pois definir o FK e não alterar a propriedade de navegação acionará uma ATUALIZAÇÃO no banco de dados, mas depois de salvar o SelectedAsset.Subtype não será recarregado automaticamente após SaveChangesser chamado, o que significa que se você serializar o SelectedAsset para uma visualização, ele será a antiga propriedade de navegação.

        SelectedAsset.SubtypeID = updatedAsset.SubtypeID;
    //SelectedAsset.Subtype = updatedAsset.Subtype; // --Only set FK

    Normalmente, ao expor uma propriedade de navegação e atualizar a referência (subtipo) usando um valor FK, você buscaria o SubType de DbContextou Attach()a cópia após verificar se o DbContextnão está rastreando. Então, por exemplo, se o passado em updatedAsset tiver um SubTypeId:

    Buscando o subtipo para associar:

    if (SelectedAsset.Subtype.Id != updatedAsset.SubtypeID)
    SelectedAsset.SubType = _dbContext.Subtypes.Single(x => x.ID == updatedAsset.SubtypeID)

    Buscar o subtipo puxará do BD se o subtipo ainda não estiver rastreado. Isso também serve como uma verificação de que o SubtypeID é válido.

    Anexando o subtipo:

    if (SelectedAsset.Subtype.Id != updatedAsset.SubtypeID)
{
    var existingSubtype = _dbContext.Subtypes.Local.FirstOrDefault(x => x.ID == updatedAsset.SubType.ID);
    if (existingSubtype == null)
        existingSubtype = _dbContext.Attach(updatedAsset.Subtype);
    SelectedAsset.SubType = existingSubtype;
}

    Anexar nem sempre é tão simples quanto chamar, Attach()pois pode haver situações em que o DbContextjá poderia estar rastreando uma instância do Subtipo para o mesmo ID, o que Attach()resultaria em uma exceção gerada. Isso é situacional com base em quais instâncias são rastreadas, então pode parecer um erro intermitente no tempo de execução. (Funciona na maioria das vezes, mas falha para algum usuário/cenário específico) As verificações acima verificam .Localo cache de rastreamento e usam essa referência se forem encontradas, ou anexam e usam se não forem.

    • 1

  2. você pode querer verificar novamente se a SubtypeIDcoluna no seu banco de dados permite NULL. Se não permitir, modifique a restrição para permitir. algo como isto:

    ALTER TABLE Assets
DROP CONSTRAINT FK_Assets_Subtypes_SubtypeID;
ALTER TABLE Assets
ADD CONSTRAINT FK_Assets_Subtypes_SubtypeID
FOREIGN KEY (SubtypeID) REFERENCES Subtypes(TypeID) ON DELETE SET NULL;

    Mesmo que você tenha executado migrações, certifique-se de que o esquema do banco de dados esteja totalmente atualizado:

    dotnet ef migrations add UpdateForeignKeyConstraint
dotnet ef database update

    Pode valer a pena revisitar como a atualização é feita. Como funciona com Add()mas não Update(), pode haver uma diferença no rastreamento do estado da entidade. Se necessário, use context.Attach()para rastrear a entidade durante a atualização:

    context.Attach(SelectedAsset); 
context.Entry(SelectedAsset).State = EntityState.Modified;

    Certifique-se de que o relacionamento esteja configurado corretamente com a API Fluent:

    modelBuilder.Entity<Asset>()
    .HasOne(a => a.Subtype)
    .WithMany()
    .HasForeignKey(a => a.SubtypeID)
    .OnDelete(DeleteBehavior.SetNull);

    Isso deve resolver o problema e permitir que você atualize o SubtypeIDto NULLsem violar a restrição de chave estrangeira.

    • 1
  3. Best Answer

    Desisti do EF, mudei para SQL puro e ele funciona perfeitamente.

    using(var scope = App.ServiceProvider.CreateScope())
{
    var context = scope.ServiceProvider.GetRequiredService<AssetDbContext>();
    var sql = @"UPDATE Assets SET AssetName = {0}, AssetTypeID = {1}, SubtypeID = {2}, Owner = {3}, Location = {4}, PurchaseDate = {5}, Value = {6}, Status = {7}, Description = {8} WHERE AssetID = {9}";
    await context.Database.ExecuteSqlRawAsync(sql, updatedAsset.AssetName, updatedAsset.AssetType.TypeID, updatedAsset.Subtype.TypeID == -1 ? null : updatedAsset.Subtype.TypeID, updatedAsset.Owner, updatedAsset.Location, updatedAsset.PurchaseDate, updatedAsset.Value, updatedAsset.Status, updatedAsset.Description, updatedAsset.AssetID);
}
    • 0

relate perguntas