c#如何将不同类型的数据存储到一起

在 C# 中，存储不同类型的数据有多种方式，具体选择取决于你的需求（类型安全、性能、灵活性等）。以下是常见的解决方案及其适用场景：

1. 使用 object 类型（装箱 / 拆箱）

将所有数据转换为基类 object，利用 C# 的多态性存储任意类型。

List<object> mixedList = new List<object>();
mixedList.Add(123);            // int → 装箱为object
mixedList.Add("Hello");        // string（引用类型无需装箱）
mixedList.Add(new DateTime()); // DateTime → 装箱为object
​
// 访问时需手动拆箱（可能引发InvalidCastException）
int num = (int)mixedList[0];   // 拆箱
string str = (string)mixedList[1];

• 优点：简单直接，无需额外类型定义。

• 缺点：

  • 装箱 / 拆箱开销 ：值类型（如 int, DateTime）频繁转换会降低性能。

  • 类型不安全 ：运行时可能抛出 InvalidCastException。

2. 使用泛型集合 List<dynamic>

dynamic 关键字在运行时动态解析类型，避免编译时类型检查。

List<dynamic> dynamicList = new List<dynamic>();
dynamicList.Add(123);        // 无需装箱
dynamicList.Add("Hello");
dynamicList.Add(new { Name = "Alice" }); // 匿名类型也可存储
​
// 访问时无需显式转换
int num = dynamicList[0];    // 动态类型解析
string str = dynamicList[1];

• 优点：

  • 无需装箱拆箱（值类型以原始类型存储）。

  • 支持匿名类型等复杂结构。

• 缺点：

  • 运行时类型风险：若类型不匹配会在运行时抛出异常。

  • 性能开销：动态解析比静态类型稍慢。

3. 使用自定义类 / 结构体（推荐方案）

public class MixedData
{
    public int Id { get; set; }
    public string Name { get; set; }
    public DateTime BirthDate { get; set; }
}
​
// 使用方式
List<MixedData> dataList = new List<MixedData>();
dataList.Add(new MixedData { 
    Id = 1, 
    Name = "Alice", 
    BirthDate = DateTime.Now 
});

定义一个包含所需字段的类，每个字段使用明确的类型。

public class MixedData
{
    public int Id { get; set; }
    public string Name { get; set; }
    public DateTime BirthDate { get; set; }
}
​
// 使用方式
List<MixedData> dataList = new List<MixedData>();
dataList.Add(new MixedData { 
    Id = 1, 
    Name = "Alice", 
    BirthDate = DateTime.Now 
});

• 优点：

  • 类型安全：编译时检查类型。

  • 可读性高：字段含义明确。

  • 性能最优：无需装箱拆箱。

• 缺点：需提前定义类型，不够灵活。

4. 使用 Tuple 或 ValueTuple

适合临时存储少量不同类型的数据。

// Tuple（旧版，需通过Item1、Item2访问）
var tupleList = new List<Tuple<int, string>>();
tupleList.Add(Tuple.Create(1, "Alice"));
​
// ValueTuple（C# 7.0+，推荐，支持命名元素）
var valueTupleList = new List<(int Id, string Name)>();
valueTupleList.Add((1, "Alice"));
​
// 访问方式
int id = valueTupleList[0].Id;
string name = valueTupleList[0].Name;

• 优点：简洁，无需额外类定义。

• 缺点：

  • 元素数量有限（最多 8 个）。

  • 不适合复杂或大量数据。

5. 使用 Dictionary<string, object>

以键值对形式存储不同类型的值，类似动态对象。

var dict = new Dictionary<string, object>();
dict["Id"] = 123;
dict["Name"] = "Alice";
dict["IsActive"] = true;
​
// 访问时需转换类型
int id = (int)dict["Id"];
bool isActive = (bool)dict["IsActive"];

• 优点：灵活，可动态添加 / 删除键值对。

• 缺点：

  • 类型不安全，需手动转换。

  • 键名硬编码，易出错。

6. 使用接口或抽象类（面向对象设计）

定义公共接口，让不同类型实现该接口。

public interface IDataItem { }
​
public class Person : IDataItem
{
    public string Name { get; set; }
}
​
public class Product : IDataItem
{
    public decimal Price { get; set; }
}
​
// 使用方式
List<IDataItem> items = new List<IDataItem>();
items.Add(new Person { Name = "Alice" });
items.Add(new Product { Price = 9.99m });
​
// 通过模式匹配访问
foreach (var item in items)
{
    if (item is Person person)
        Console.WriteLine(person.Name);
    else if (item is Product product)
        Console.WriteLine(product.Price);
}

• 优点：

  • 类型安全，符合面向对象原则。

  • 可扩展，易于添加新类型。

• 缺点：需设计接口和继承体系，复杂度较高。

7. 使用 ExpandoObject（动态对象）

System.Dynamic.ExpandoObject 是动态类型的字典，支持运行时添加属性。

dynamic person = new ExpandoObject();
person.Name = "Alice";
person.Age = 30;
​
// 直接访问属性（无需转换）
Console.WriteLine(person.Name); // "Alice"

• 优点：

  • 语法简洁，像普通对象一样访问属性。

  • 无需提前定义类型。

• 缺点：

  • 编译时无类型检查，易出错。

  • 性能略低于静态类型。

  7. ArrayList（非泛型，不推荐）

  特点：

  • 来自 System.Collections 命名空间，可存储任意类型（实际存为 object）。

  • 动态扩容，但存在装箱 / 拆箱开销 和类型安全问题。

  示例：

  using System.Collections;
  ​
  ArrayList list = new ArrayList();
  list.Add("张三");    // string → object（装箱）
  list.Add(10);        // int → object（装箱）
  list.Add(2.2);       // double → object（装箱）
  ​
  // 访问时需手动拆箱，可能引发InvalidCastException
  int num = (int)list[1]; // 拆箱

方案	装箱开销	类型安全	性能（相对）
List<object>	有	否	低
List<dynamic>	无	否	中
自定义类 / 结构体	无	是	高
Dictionary<string, object>	有	否	中
ExpandoObject	无	否	中低
ArrayList	有	否	低