C#如何创建可容纳三种不同模型类型的列表

针对你的需求，有几种简洁且符合C#（假设你用的是C#，其他OOP语言思路类似）开发习惯的方案，具体如下：

1. 直接使用重载方法（最推荐） #

这是最直观的方式，针对每种列表类型编写对应的处理方法，编译器会自动根据传入的列表类型匹配正确的方法，无需额外的类型判断。

示例代码：

// 你的三个模型类
public class Fuel { /* 模型字段与逻辑 */ }
public class Trip { /* 模型字段与逻辑 */ }
public class Purchase { /* 模型字段与逻辑 */ }

// 针对每种列表的重载处理方法
public void ProcessList(List<Fuel> fuelList)
{
    // Fuel列表专属处理逻辑
    foreach(var fuel in fuelList)
    {
        // ...
    }
}

public void ProcessList(List<Trip> tripList)
{
    // Trip列表专属处理逻辑
    foreach(var trip in tripList)
    {
        // ...
    }
}

public void ProcessList(List<Purchase> purchaseList)
{
    // Purchase列表专属处理逻辑
    foreach(var purchase in purchaseList)
    {
        // ...
    }
}

// 使用时直接传入对应列表即可
var fuels = new List<Fuel>();
ProcessList(fuels);

var trips = new List<Trip>();
ProcessList(trips);

2. 引入共同接口/基类+多态处理 #

如果三个模型有相似的属性或通用行为，可以定义一个共同接口或基类，先统一存放列表，再通过类型判断分发到专属处理逻辑。

示例代码：

// 定义共同接口，提取模型的通用属性/方法
public interface IRecord
{
    int Id { get; set; }
    DateTime CreateTime { get; set; }
}

// 让三个模型实现接口
public class Fuel : IRecord { /* 实现接口字段 */ }
public class Trip : IRecord { /* 实现接口字段 */ }
public class Purchase : IRecord { /* 实现接口字段 */ }

// 统一处理方法，内部分发到专属逻辑
public void ProcessRecords(List<IRecord> records)
{
    foreach(var record in records)
    {
        // 先执行通用逻辑
        Console.WriteLine($"处理记录ID：{record.Id}");
        
        // 再分发到专属处理
        switch(record)
        {
            case Fuel fuel:
                ProcessSingleFuel(fuel);
                break;
            case Trip trip:
                ProcessSingleTrip(trip);
                break;
            case Purchase purchase:
                ProcessSinglePurchase(purchase);
                break;
        }
    }
}

// 单个对象的专属处理方法
private void ProcessSingleFuel(Fuel fuel) { /* ... */ }
private void ProcessSingleTrip(Trip trip) { /* ... */ }
private void ProcessSinglePurchase(Purchase purchase) { /* ... */ }

3. 泛型容器+类型匹配（适合需要统一存储的场景） #

如果必须用一个容器存储不同类型的列表，可以用object或泛型容器，再通过类型判断分发到对应方法：

// 统一存储不同类型的列表
object genericList;
if (someCondition)
{
    genericList = new List<Fuel>();
}
else if (anotherCondition)
{
    genericList = new List<Trip>();
}
else
{
    genericList = new List<Purchase>();
}

// 分发到对应处理方法
switch(genericList)
{
    case List<Fuel> fuelList:
        ProcessList(fuelList);
        break;
    case List<Trip> tripList:
        ProcessList(tripList);
        break;
    case List<Purchase> purchaseList:
        ProcessList(purchaseList);
        break;
    default:
        throw new ArgumentException("不支持的列表类型");
}

总结 #

• 如果只是需要将不同列表传递到对应方法，重载方法是最简洁、不易出错的方案。
• 如果需要统一处理批量元素且模型有通用属性，共同接口+类型判断更合适。
• 尽量避免直接使用List<object>，会丢失类型安全，增加转换出错风险。

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