C#中如何从泛型方法返回自定义泛型类型并实现转换

我来帮你搞定这个泛型方法的转换问题！你的核心需求是在基类里写一个通用的网格结果方法，让每个子类返回不同的DTO类型对吧？

先说说你原来代码的问题：你在方法里直接生成了UsersDto的IQueryable，但方法声明要返回IQueryable<T>，编译器根本不知道UsersDto和T之间有什么关联，自然会报错。下面给你几种实用的解决方案，按推荐程度排序：

1. 使用映射库（最推荐：AutoMapper） #

AutoMapper专门用来处理对象之间的映射，而且支持在IQueryable层面直接做投影，性能也很好，不用手动写一堆Select代码。

步骤： #

• 首先配置映射关系（一般在项目启动时做一次全局配置）：

var mapperConfig = new MapperConfiguration(cfg =>
{
    // 配置User到UsersDto的映射
    cfg.CreateMap<User, UsersDto>()
       .ForMember(dest => dest.UserID, opt => opt.MapFrom(src => src.ID))
       .ForMember(dest => dest.UserName, opt => opt.MapFrom(src => src.Name));
    // 其他DTO的映射也可以在这里添加
});
// 可以把IMapper注册到依赖注入容器里，方便全局使用
var mapper = mapperConfig.CreateMapper();

• 然后改造你的基类方法：

internal IQueryable<T> GetGridResults<T>()
{
    // ProjectTo方法会直接在数据库层面生成对应的SQL，返回IQueryable<T>
    return db.Users.ProjectTo<T>(mapper.ConfigurationProvider);
}

这样调用var users = GetGridResults<UsersDto>()就能直接得到IQueryable<UsersDto>，完全不用手动处理转换！

2. 让子类提供投影逻辑（适合需要自定义转换逻辑的场景） #

因为你说这个方法放在基类，每个子类要返回不同的结果，那可以把投影逻辑抽象出来，让子类自己实现具体的转换规则。

方式一：基类为泛型类（类型更安全） #

// 基类定义泛型，绑定返回的DTO类型
public abstract class BaseGridService<T>
{
    protected readonly DbContext db;

    protected BaseGridService(DbContext db)
    {
        this.db = db;
    }

    // 子类必须实现的投影方法
    protected abstract Expression<Func<User, T>> GetProjection();

    internal IQueryable<T> GetGridResults()
    {
        return db.Users.Select(GetProjection());
    }
}

// 用户模块的子类实现
public class UserGridService : BaseGridService<UsersDto>
{
    public UserGridService(DbContext db) : base(db) { }

    protected override Expression<Func<User, UsersDto>> GetProjection()
    {
        // 这里写具体的转换逻辑
        return u => new UsersDto 
        { 
            UserID = u.ID, 
            UserName = u.Name 
        };
    }
}

调用的时候直接用子类实例：

var userGridService = new UserGridService(db);
var users = userGridService.GetGridResults();

这种方式类型安全，编译器能提前检查错误，比在方法上指定泛型更靠谱。

方式二：基类接收转换委托（更灵活） #

如果不想用泛型基类，也可以在方法里接收一个转换表达式，让调用方（子类）传入具体的转换逻辑：

internal IQueryable<T> GetGridResults<T>(Expression<Func<User, T>> projection)
{
    return db.Users.Select(projection);
}

子类调用时：

var users = GetGridResults(u => new UsersDto { UserID = u.ID, UserName = u.Name });

3. 泛型约束 + 显式转换（适合DTO有共同基类/接口的场景） #

如果你的所有DTO都继承自同一个基类或者实现了同一个接口，比如IGridDto，可以给T加约束，然后做显式转换：

// 定义通用接口
public interface IGridDto { }
public class UsersDto : IGridDto 
{ 
    public int UserID { get; set; }
    public string UserName { get; set; }
}

// 方法添加泛型约束
internal IQueryable<T> GetGridResults<T>() where T : IGridDto, new()
{
    // 这里需要确保User可以转换为T，比如通过构造或者映射
    return db.Users.Select(u => new UsersDto 
    { 
        UserID = u.ID, 
        UserName = u.Name 
    } as T).AsQueryable();
}

不过这种方式局限性比较大，因为as转换如果失败会返回null，而且只能处理实现了IGridDto的类型，不如前两种方法灵活。

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