从字符串转换时返回泛型值的实现问题：泛型GetValue编译报错求解

我的系统依赖一款存储数据元素的第三方软件，存储中的数据元素拥有DataType和Value属性来描述底层数据对象，每个DataElement可通过名称从存储中获取（类似外部数据库）：

public class DataElement
{
    public string Type { get; }
    public string Value { get; }
}

我希望创建一个BL对象来封装DataElement的细节，初始实现如下：

public class DataGetter
{
    private readonly DataElement dataObject;
    public DataGetter(string name)
    {
        this.dataObject = <third_party>.GetObject(name);
    }

    public int GetValue()
    {
        if (this.dataObject.Type != "integer")
           throw new Exception();
        
        return int.Parse(this.dataObject.Value);
    }
}

但第三方软件中的Type支持多种类型（例如List<int>、double、List<string>等），由于无法通过重载GetValue返回不同类型，我尝试了泛型方案：

public T GetValue<T>()
{
    if (typeof(T) != this.dataObject.Type)
       throw new Exception();
    
    return (T)Convert.ChangeType(this.dataObject.Value, typeof(T));
}

该方案仅支持基本类型，无法转换List<int>这类类型，因此我尝试通过分支处理各类型：

public T GetValue<T>()
{
    if (typeof(T) != this.dataObject.Type)
       throw new Exception();

    if (typeof(T) == typeof(int))
       return int.Parse(this.dataObject.Value);
    else if (typeof(T) == typeof(bool))
       return bool.Parse(this.dataObject.Value);
    // ... 其他类型分支
}

但编译器报错，无法将int/bool转换为T，请问这种实现方式是否可行？

可行，但需要调整类型转换方式 #

编译器报错是因为它无法在编译期确认int/bool和T的类型兼容性，你需要先把转换后的结果强制转换为object，再转成T，或者使用显式的类型转换：

调整后的代码示例：

public T GetValue<T>()
{
    // 注意：第三方返回的Type字符串可能需要和typeof(T)的名称做对应调整
    if (typeof(T).Name != this.dataObject.Type)
    {
        throw new InvalidOperationException($"类型不匹配：期望{typeof(T).Name}，实际{this.dataObject.Type}");
    }

    if (typeof(T) == typeof(int))
    {
        return (T)(object)int.Parse(this.dataObject.Value);
    }
    else if (typeof(T) == typeof(bool))
    {
        return (T)(object)bool.Parse(this.dataObject.Value);
    }
    else if (typeof(T) == typeof(List<int>))
    {
        // 假设Value是逗号分隔的数字字符串，比如"1,2,3"
        var list = this.dataObject.Value.Split(',').Select(int.Parse).ToList();
        return (T)(object)list;
    }
    // 其他类型分支...
    else
    {
        throw new NotSupportedException($"不支持的类型：{typeof(T).Name}");
    }
}

关键说明 #

• 装箱中转：先转成object再转T，因为所有值类型都能装箱为object，而object可以显式转换为任意T（编译期允许，运行时确保类型匹配即可）
• 类型匹配逻辑：第三方返回的Type字符串可能和typeof(T).Name不完全一致（比如List<int>的Name是List，但第三方可能返回List<int>），需要根据实际返回格式调整，比如用typeof(T).FullName或者自定义类型映射字典
• 集合类型处理：需要根据第三方存储集合的格式（JSON、逗号分隔字符串等）解析Value，如果是JSON格式，可以用序列化库处理：

  else if (typeof(T) == typeof(List<int>))
  {
      return (T)(object)JsonConvert.DeserializeObject<List<int>>(this.dataObject.Value);
  }
  

更优雅的扩展方式 #

如果要支持大量类型，分支判断会变得臃肿，可以用类型转换字典解耦：

private static readonly Dictionary<Type, Func<string, object>> _converters = new Dictionary<Type, Func<string, object>>
{
    { typeof(int), val => int.Parse(val) },
    { typeof(bool), val => bool.Parse(val) },
    { typeof(List<int>), val => JsonConvert.DeserializeObject<List<int>>(val) },
    // 添加其他类型的转换逻辑
};

public T GetValue<T>()
{
    if (!_converters.TryGetValue(typeof(T), out var converter))
    {
        throw new NotSupportedException($"不支持的类型：{typeof(T).Name}");
    }

    if (typeof(T).Name != this.dataObject.Type) // 调整类型匹配逻辑
    {
        throw new InvalidOperationException($"类型不匹配：期望{typeof(T).Name}，实际{this.dataObject.Type}");
    }

    return (T)converter(this.dataObject.Value);
}

这种方式可以在不修改GetValue方法的前提下新增支持的类型，符合开闭原则。

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