如何创建可容纳多类型Value属性的自定义Tag类的统一列表？

我明白你的痛点了——你想要一个能装下不同Value类型的Tag列表，但直接用泛型Tag<T>的话，列表只能存同一种类型的实例，根本没法混合int、double这些类型。别着急，我给你几个实用的解决方案，一步步来：

解决方案1：非泛型基类 + 泛型子类（推荐） #

这个方案既保证了类型安全，又能让列表容纳不同类型的Tag对象。核心思路是先定义一个非泛型的基类，再让泛型Tag<T>继承它：

步骤1：定义非泛型基类 #

public abstract class TagBase
{
    public string Name { get; set; }
    public int Id { get; set; }
    
    // 抽象方法，用于统一获取Value（子类必须实现）
    public abstract object GetValue();
}

步骤2：定义泛型子类 #

public class Tag<T> : TagBase
{
    public T Value { get; set; }

    // 实现基类的抽象方法，返回强类型的Value
    public override object GetValue()
    {
        return Value;
    }
}

步骤3：创建混合类型的列表 #

现在你就可以用List<TagBase>来存储不同类型的Tag<T>了：

var tagList = new List<TagBase>();

// 添加各种类型的Tag实例
tagList.Add(new Tag<int> { Name = "Age", Id = 1, Value = 25 });
tagList.Add(new Tag<double> { Name = "Height", Id = 2, Value = 1.75 });
tagList.Add(new Tag<string> { Name = "UserName", Id = 3, Value = "JohnDoe" });
tagList.Add(new Tag<bool> { Name = "IsActive", Id = 4, Value = true });

如何访问不同类型的Value？ #

可以用模式匹配来安全地转换类型：

foreach (var tag in tagList)
{
    switch (tag)
    {
        case Tag<int> intTag:
            Console.WriteLine($"Int Tag: {intTag.Name} = {intTag.Value}");
            break;
        case Tag<double> doubleTag:
            Console.WriteLine($"Double Tag: {doubleTag.Name} = {doubleTag.Value}");
            break;
        case Tag<string> stringTag:
            Console.WriteLine($"String Tag: {stringTag.Name} = {stringTag.Value}");
            break;
        case Tag<bool> boolTag:
            Console.WriteLine($"Bool Tag: {boolTag.Name} = {boolTag.Value}");
            break;
    }
}

这个方案的优点是编译时类型安全，每个Tag<T>的Value都是强类型的；缺点是值类型转object时会有轻微的拆箱开销，但大多数场景下可以忽略。

解决方案2：直接用object类型的Value #

如果你的场景不需要严格的类型安全，也可以把Value直接定义成object类型：

public class Tag
{
    public string Name { get; set; }
    public int Id { get; set; }
    public object Value { get; set; }
    
    // 可选：添加一个属性记录Value的实际类型，方便后续判断
    public Type ValueType { get; set; }
}

使用示例 #

var tagList = new List<Tag>();
tagList.Add(new Tag { Name = "Age", Id = 1, Value = 25, ValueType = typeof(int) });
tagList.Add(new Tag { Name = "Height", Id = 2, Value = 1.75, ValueType = typeof(double) });

访问Value的方式 #

foreach (var tag in tagList)
{
    if (tag.ValueType == typeof(int))
    {
        int intValue = (int)tag.Value;
        // 处理int类型的值
    }
    else if (tag.ValueType == typeof(double))
    {
        double doubleValue = (double)tag.Value;
        // 处理double类型的值
    }
}

这个方案的优点是简单直接，不需要继承结构；缺点是编译时没有类型检查，如果赋值错误（比如把字符串赋值给本该是int的Value），只有运行时才会报错，容易引发bug。

解决方案3：使用dynamic类型（谨慎使用） #

C#的dynamic类型可以让你绕过编译时类型检查，直接赋值和访问：

public class Tag
{
    public string Name { get; set; }
    public int Id { get; set; }
    public dynamic Value { get; set; }
}

使用示例 #

var tagList = new List<Tag>();
tagList.Add(new Tag { Name = "Age", Id = 1, Value = 25 });
tagList.Add(new Tag { Name = "Height", Id = 2, Value = 1.75 });

访问Value的方式 #

foreach (var tag in tagList)
{
    // 直接用tag.Value即可，编译时不检查类型
    Console.WriteLine($"{tag.Name} = {tag.Value}");
}

这个方案的优点是使用方便，不需要类型转换；但缺点也很明显：完全没有编译时类型安全，如果Value的类型和你预期的不符，运行时会抛出异常，而且性能也会比强类型略差，只适合简单场景临时使用。

为什么你原来的写法不行？ #

你之前尝试的List<Tag<T>>只能存储同一种T类型的Tag实例，比如List<Tag<int>>只能装Tag<int>，没法装Tag<double>——因为Tag<int>和Tag<double>是两个完全不同的类型，它们的共同父类只有object，所以直接用泛型无法满足混合存储的需求。

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