如何将泛型与基类结合使用？基于ValueType实例化子类的问题

问题核心 #

你当前的泛型基类Base<T>缺少非泛型的公共父类型，导致switch无法推断统一的返回类型，且后续调用SetValue时会因类型不匹配报错。以下是几种可行的解决思路：

方案一：引入非泛型基类（推荐长期使用） #

通过定义一个非泛型的抽象基类，让泛型Base<T>继承它，统一类型体系，同时保留类型安全检查。

修改基类结构 #

// 非泛型基类，提供统一接口
public abstract class Base
{
    public abstract ValueType Type { get; }
    public abstract void SetValue(object value);
    public abstract object GetValue();
}

// 泛型基类继承非泛型基类
public abstract class Base<T> : Base
{
    protected T _value;
    public new T GetValue => _value;

    // 实现非泛型GetValue，返回object
    public override object GetValue() => _value;

    // 实现非泛型SetValue，做类型校验后调用泛型方法
    public override void SetValue(object value)
    {
        if (value is T typedValue)
            SetValue(typedValue);
        else
            throw new ArgumentException($"值类型必须为 {typeof(T)}");
    }

    public abstract void SetValue(T newValue);
}

原实现类无需大幅修改 #

public class Text : Base<string>
{
    public override ValueType Type => ValueType.Text;

    public override void SetValue(string newValue)
    {
        _value = newValue;
    }
}

public class Boolean : Base<bool>
{
    public override ValueType Type => ValueType.Boolean;

    public override void SetValue(bool newValue)
    {
        _value = newValue;
    }
}

使用方式 #

var valueType = ValueType.Boolean;

Base obj = valueType switch
{
    ValueType.Text => new Text(),
    ValueType.Boolean => new Boolean(),
    _ => throw new NotSupportedException(),
};

obj.SetValue(false); // 内部自动做类型校验，安全调用

优点：编译时类型安全、扩展性强，新增类型只需实现泛型基类即可，无需修改其他逻辑。

方案二：工厂模式封装（无需修改原有基类） #

如果无法修改现有基类结构，可以用工厂类封装实例创建和方法调用的逻辑。

工厂类实现 #

public static class BaseFactory
{
    // 根据ValueType创建实例
    public static Base Create(ValueType type)
    {
        return type switch
        {
            ValueType.Text => new Text(),
            ValueType.Boolean => new Boolean(),
            _ => throw new NotSupportedException(),
        };
    }

    // 封装SetValue调用，避免类型转换问题
    public static void SetValue(Base obj, object value)
    {
        switch (obj)
        {
            case Text text: text.SetValue(value as string ?? string.Empty); break;
            case Boolean boolean: boolean.SetValue((bool)(value ?? false)); break;
            default: throw new NotSupportedException($"不支持的实例类型 {obj.GetType()}");
        }
    }
}

使用方式 #

var valueType = ValueType.Boolean;
var obj = BaseFactory.Create(valueType);
BaseFactory.SetValue(obj, false);

优点：无需修改原有基类代码；缺点：新增类型时需要同步修改工厂类的switch逻辑，维护成本较高。

方案三：使用dynamic类型（快速原型场景） #

利用C#的动态类型绕过编译时检查，代码最简洁，但会失去类型安全。

使用方式 #

var valueType = ValueType.Boolean;

dynamic obj = valueType switch
{
    ValueType.Text => new Text(),
    ValueType.Boolean => new Boolean(),
    _ => throw new NotSupportedException(),
};

obj.SetValue(false); // 运行时动态解析方法调用

优点：代码极简；缺点：无编译时类型检查，若传入值类型不匹配，会在运行时抛出异常，适合小型项目或快速原型开发。

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