使用Fluent API实现存在关联产品时阻止删除Category

Hey there! Let's sort out this problem where deleting a Category is currently wiping out its associated Products. What we want instead is to block that deletion entirely if there are any linked Products left. Here's how to make that happen step by step:

1. Fix the Fluent API Configuration (Database-Level Restriction) #

First off, your Product configuration has a tiny syntax error (an extra semicolon before OnDelete) that would break the delete behavior setup. We’ll fix that and ensure OnDelete(DeleteBehavior.Restrict) is properly configured—this tells the database to reject any delete attempt on a Category that still has linked Products.

Also, quick note: you’ve got a consistent typo in Catergory (should be Category). While it works as-is, fixing this will make your code cleaner and avoid potential bugs down the line.

Here’s the corrected ProductConfig:

public class ProductConfig : IEntityTypeConfiguration<Product>
{
    public void Configure(EntityTypeBuilder<Product> builder)
    {
        builder.ToTable("Product");
        builder.HasKey(p => p.ProductID);
        builder.Property(p => p.ProductName)
            .HasMaxLength(400)
            .IsRequired(true);
        builder.Property(p => p.ProductDescription)
            .HasMaxLength(2000)
            .IsRequired(true);
        
        // Fix syntax error and set restrict delete behavior
        builder.HasOne(f => f.Catergory)
            .WithMany(r => r.Products)
            .HasForeignKey(f => f.CatergoryID)
            .OnDelete(DeleteBehavior.Restrict);
    }
}

2. Add Application-Level Validation (Friendly Error Handling) #

The database restriction will throw a generic exception if you try to delete a Category with Products, but it’s better to catch this early and give users a clear message. Add a check in your service layer before attempting deletion:

public async Task DeleteCategoryAsync(int categoryId)
{
    // Check if any products are linked to this category
    var hasAssociatedProducts = await _context.Products
        .AnyAsync(p => p.CatergoryID == categoryId);

    if (hasAssociatedProducts)
    {
        // Throw a custom exception or return a user-friendly error
        throw new InvalidOperationException("Cannot delete this category—it still has associated products.");
        // For APIs, you might return: return BadRequest("Cannot delete category with existing products.");
    }

    // Proceed with deletion if no products are found
    var category = await _context.Catergories.FindAsync(categoryId);
    if (category == null)
    {
        throw new KeyNotFoundException("Category not found.");
    }

    _context.Catergories.Remove(category);
    await _context.SaveChangesAsync();
}

3. What Each Part Does #

• DeleteBehavior.Restrict: This enforces the rule at the database level, so even if someone bypasses your application logic (e.g., direct DB queries), the deletion will be blocked.
• Application-level check: Catches the issue before hitting the database, letting you return a clear, user-friendly error instead of a confusing database exception.

Bonus: Fix Typo Consistency #

For cleaner code, consider renaming all instances of Catergory to Category (fixing the typo in the 'e' and 'o'). Example corrected classes:

public class Category
{
    public int CategoryId { get; set; }
    public string CategoryName { get; set; }
    public string CategoryDescription { get; set; }
    public ICollection<Product> Products { get; set; }
}

public class Product
{
    public int ProductID { get; set; }
    public string ProductName { get; set; }
    public string ProductDescription { get; set; }
    public int CategoryID { get; set; }
    public Category Category { get; set; }
}

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