C#泛型循环返回指定类型列表：如何消除重复代码实现通用化？

嘿，这个问题太典型了——刚接触C#泛型的时候，很多人都会卡在怎么把重复的逻辑抽成通用代码这一步，不过放心，你的需求完全可以实现！先拆解一下问题：你每个BaseObject的子类都在写几乎一样的循环，把ID列表转成对应对象，核心重复点就是「遍历ID→查找单个对象→收集非空结果」这部分逻辑，用泛型方法就能把这部分通用逻辑抽出来。

先看一下你现在的重复代码（还原场景） #

假设你的BaseObject有一个Id属性，子类比如Product、Customer都各自实现了类似这样的方法：

public class BaseObject
{
    public int Id { get; set; }
    // 其他公共属性
}

public class Product : BaseObject
{
    public string Name { get; set; }

    public List<Product> GetProductsByIds(IEnumerable<int> productIds)
    {
        var products = new List<Product>();
        foreach (var id in productIds)
        {
            var product = GetProductById(id); // 子类自己的单个对象获取逻辑
            if (product != null) products.Add(product);
        }
        return products;
    }

    private Product GetProductById(int id)
    {
        // 比如从数据库/内存集合查单个Product
        return null;
    }
}

// Customer类逻辑几乎一模一样
public class Customer : BaseObject
{
    public string Email { get; set; }

    public List<Customer> GetCustomersByIds(IEnumerable<int> customerIds)
    {
        var customers = new List<Customer>();
        foreach (var id in customerIds)
        {
            var customer = GetCustomerById(id);
            if (customer != null) customers.Add(customer);
        }
        return customers;
    }

    private Customer GetCustomerById(int id)
    {
        // 单个Customer的获取逻辑
        return null;
    }
}

用泛型方法重构：抽离通用逻辑 #

我们可以写一个泛型工具方法，把重复的循环和收集逻辑抽出来，只让子类提供自己的「单个对象获取逻辑」就行。

方式1：用委托传递子类的获取逻辑

创建一个静态工具类，定义泛型方法，通过Func<int, T>委托让子类传入自己的GetById方法：

public static class ObjectHelper
{
    // 泛型约束：T必须是BaseObject的子类，保证我们操作的对象有Id属性
    public static List<T> GetObjectsByIds<T>(IEnumerable<int> ids, Func<int, T> getObjectById) 
        where T : BaseObject
    {
        // 用LINQ简化循环（也可以保留foreach，看你习惯）
        return ids
            .Select(id => getObjectById(id)) // 每个ID对应一个对象
            .Where(obj => obj != null) // 过滤掉空值
            .ToList();
    }
}

然后子类的方法就可以简化成一行：

public class Product : BaseObject
{
    public string Name { get; set; }

    public List<Product> GetProductsByIds(IEnumerable<int> productIds)
    {
        // 直接调用泛型方法，传入我们的GetProductById逻辑
        return ObjectHelper.GetObjectsByIds(productIds, GetProductById);
    }

    private Product GetProductById(int id)
    {
        // 原有获取逻辑不变
        return null;
    }
}

public class Customer : BaseObject
{
    public string Email { get; set; }

    public List<Customer> GetCustomersByIds(IEnumerable<int> customerIds)
    {
        return ObjectHelper.GetObjectsByIds(customerIds, GetCustomerById);
    }

    private Customer GetCustomerById(int id)
    {
        // 原有获取逻辑不变
        return null;
    }
}

方式2：用泛型基类统一管理（适合有Repository场景）

如果你的项目用了仓储模式（Repository Pattern），可以把泛型逻辑放到仓储基类里，让所有子类仓储自动拥有这个方法：

// 仓储基类，泛型约束T是BaseObject
public abstract class BaseRepository<T> where T : BaseObject
{
    public List<T> GetByIds(IEnumerable<int> ids)
    {
        return ids
            .Select(id => GetById(id))
            .Where(obj => obj != null)
            .ToList();
    }

    // 让子类重写这个方法，实现自己的单个对象获取逻辑
    protected abstract T GetById(int id);
}

// Product仓储子类
public class ProductRepository : BaseRepository<Product>
{
    protected override Product GetById(int id)
    {
        // 具体的Product获取逻辑
        return null;
    }
}

// Customer仓储子类
public class CustomerRepository : BaseRepository<Customer>
{
    protected override Customer GetById(int id)
    {
        // 具体的Customer获取逻辑
        return null;
    }
}

这样你直接用productRepository.GetByIds(ids)就能得到对应的对象列表，完全不用重复写循环了。

为什么泛型能解决这个问题？ #

泛型的核心作用就是编写与类型无关但类型安全的代码：

• 我们用where T : BaseObject约束了T的类型，保证所有传入的类型都继承自BaseObject，编译器会帮我们检查类型合法性；
• 编译时会根据你传入的具体类型（比如Product）生成对应的方法版本，返回的List<T>就是正确的类型，不需要强制转换，避免了类型错误。

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