基于EF Core的通用按Id获取实体泛型方法：抽象类方案合理性与实现正确性探讨

First off, great call noticing the repeated code and looking to abstract it out—this is exactly the kind of DRY (Don’t Repeat Yourself) practice that makes codebases maintainable. Let’s tackle your two questions one by one:

1. Is creating a generic abstract class for this scenario reasonable? #

Absolutely! Every one of your GetOneXQueryHandler classes follows the exact same pattern:

• Query the database for an entity by its Guid ID
• Map the database entity to a DTO

Abstracting this into a generic method in a base class eliminates redundant code, makes future changes (like adjusting how you query or map entities) easier to apply everywhere, and keeps your handler classes focused on their specific business logic (rather than repetitive data access code). This is a perfect use case for generics.

2. Is your current generic method implementation correct? #

Not quite—there are a few issues with the code you shared that hurt its maintainability and efficiency:

• Redundant obj parameter: You’re passing new Product() or new Seller() just to trigger the switch statement, but this instance is never actually used. It’s unnecessary boilerplate.
• Hardcoded switch statement: If you add a new entity (like Customer), you’ll have to modify this method to add another case. This violates the Open/Closed Principle (code should be open for extension, closed for modification).
• Unnecessary Convert.ChangeType: The switch cases already return the correct T type, so casting/converting here is redundant.
• Behavior mismatch: Your original code uses SingleOrDefaultAsync() (returns null if no entity is found), but your generic method uses SingleAsync() (throws an exception if no entity exists). This could break existing behavior.

Improved Implementation #

Let’s fix these issues with a cleaner, more scalable approach. The key is to use a generic constraint to ensure all entities have a Guid Id property, then leverage Entity Framework’s Set<T>() to access the correct database set without hardcoding.

Step 1: Define an Interface for Entities with Guid IDs

First, create an interface that all your entities will implement:

public interface IEntityWithGuidId
{
    Guid Id { get; }
}

Update your entities to implement this interface:

public class Seller : IEntityWithGuidId
{
    public Guid Id { get; set; }
    // Your other Seller properties
}

public class Product : IEntityWithGuidId
{
    public Guid Id { get; set; }
    // Your other Product properties
}

Step 2: Build the Generic Base Class

Now, create an abstract base class with the generic GetElementById method. We’ll inject the DbContext and IMapper via constructor so all handlers inherit them:

public abstract class BaseQueryHandler
{
    protected readonly DbContext Context;
    protected readonly IMapper Mapper;

    protected BaseQueryHandler(DbContext context, IMapper mapper)
    {
        Context = context;
        Mapper = mapper;
    }

    protected async Task<F> GetElementById<T, F>(Guid id) 
        where T : class, IEntityWithGuidId
    {
        // Use Set<T>() to get the correct DbSet without hardcoding
        var dbItem = await Context.Set<T>()
            .SingleOrDefaultAsync(x => x.Id == id);
        
        // Map to the DTO and return
        return Mapper.Map<F>(dbItem);
    }
}

Step 3: Update Your Handlers

Now your handler classes can inherit from the base class and use the generic method with minimal code:

public class GetOneSellerQueryHandler : BaseQueryHandler
{
    public GetOneSellerQueryHandler(DbContext context, IMapper mapper) 
        : base(context, mapper) { }

    public async Task<SellerDto> Handle(GetOneSellerQuery request, CancellationToken cancellationToken)
    {
        return await GetElementById<Seller, SellerDto>(request.Id);
    }
}

public class GetOneProductQueryHandler : BaseQueryHandler
{
    public GetOneProductQueryHandler(DbContext context, IMapper mapper) 
        : base(context, mapper) { }

    public async Task<ProductDto> Handle(GetOneProductQuery request, CancellationToken cancellationToken)
    {
        return await GetElementById<Product, ProductDto>(request.Id);
    }
}

Key Improvements #

• No more hardcoding: Adding a new entity only requires implementing IEntityWithGuidId—no changes to the base class needed.
• Cleaner calls: No more passing unused entity instances; just specify the type parameters and pass the ID.
• Consistent behavior: We kept SingleOrDefaultAsync() to match your original code (swap to SingleAsync() if you want exceptions for missing entities).
• Maintainable: Any changes to how you retrieve or map entities only need to be made once in the base class.

内容的提问来源于stack exchange，提问作者Adam Wróbel