Question

我想创建一个通用（sic）解决方案，让一个类具有一堆属性。这些属性应该是简单类型（bool，int，float等）或复杂类型（矢量，颜色等）。他们都应该有办法从文本到他们的类型解析它们。

我将在这里使用的一种复杂类型是Vector：

public class Vector
{
    private float _x, _y, _z;

    public Vector(float x, float y, float z)
    {
        _x = x;
        _y = y;
        _z = z;
    }

    public Vector() : this(0.0f, 0.0f, 0.0f)
    {

    }

    public float X
    {
        get { return _x; }
        set { _x = value; }
    }

    public float Y
    {
        get { return _y; }
        set { _y = value; }
    }

    public float Z
    {
        get { return _z; }
        set { _z = value; }
    }
}

这是我的参数基类，只是给它一个名字：

public class Parameter
{
    protected string _name;

    public Parameter() : this("untitled")
    {

    }

    public Parameter(string name)
    {
        _name = name;
    }

    public string Name => _name;
}

这里是派生类，它添加了泛型类型TType的值，它具有约束：

public class Parameter<TType> : Parameter where TType : ParameterValue<TType>
{
    public Parameter(string name, TType value) : base(name)
    {
        Value = value;
    }

    public TType Value { get; set; }
}

现在这里是ParameterValue泛型类，它确保所有TType对象都具有解析函数

public abstract class ParameterValue<TType>
{
    protected TType _value;

    public ParameterValue(TType value)
    {
        _value = value;
    }

    public TType Value
    {
        get { return _value; }
        set { _value = value; }
    }

    public abstract void Parse(string text);
}

这里是字符串的定义：

public class StringValue : ParameterValue<string>
{
    public StringValue(string value) : base(value)
    {

    }

    public override void Parse(string text)
    {
        _value = text;
    }
}

这是Vector：

的定义

public class VectorValue : ParameterValue<Vector>
{
    public VectorValue(Vector value) : base(value)
    {

    }

    public override void Parse(string text)
    {
        var tokens = text.Split(',');

        var x = float.Parse(tokens[0]);
        var y = float.Parse(tokens[1]);
        var z = float.Parse(tokens[2]);

        _value = new Vector(x, y, z);
    }
}

这是我的经理类，其中包含所有参数：

public class ParameterManager
{
    private Dictionary<string, Parameter> _parameters;

    public ParameterManager()
    {
        _parameters = new Dictionary<string, Parameter>();
    }

    public void AddParameter<TType>(string name, TType value) where TType : ParameterValue<TType>
    {
        _parameters[name] = new Parameter<TType>(name, value);
    }

    public TType FindParameterValue<TType>(string name) where TType : ParameterValue<TType>
    {
        var parameter = _parameters[name];
        var parameterTyped = parameter as Parameter<TType>;
        return parameterTyped?.Value;
    }
}

现在，如果我创建一个使用ParamaterManager的类，我遇到了问题：

public class Thing
{
    private ParameterManager _parameters;

    public Thing()
    {
        _parameters = new ParameterManager();

        _parameters.AddParameter("name", new StringValue("untitled"));
        _parameters.AddParameter("position", new VectorValue(new Vector()));
    }
}

两行添加参数＆＃34; name＆＃34;和＆＃34;位置＆＃34;抛出错误：

1>...\Thing.cs(11,13,11,37): error CS0311: The type 'ParameterProblem.StringValue' cannot be used as type parameter 'TType' in the generic type or method 'ParameterManager.AddParameter<TType>(string, TType)'. There is no implicit reference conversion from 'ParameterProblem.StringValue' to 'ParameterProblem.ParameterValue<ParameterProblem.StringValue>'.
1>...\Thing.cs(12,13,12,37): error CS0311: The type 'ParameterProblem.VectorValue' cannot be used as type parameter 'TType' in the generic type or method 'ParameterManager.AddParameter<TType>(string, TType)'. There is no implicit reference conversion from 'ParameterProblem.VectorValue' to 'ParameterProblem.ParameterValue<ParameterProblem.VectorValue>'.

如何让它做我想做的事？

Answer 1

where TType : ParameterValue<TType>

这是一个递归泛型约束，它将简化为TType : ParameterValue<XYZParameterValue>，其中XYZParameterValue : ParameterValue<TType>不是你想要的，因为在你的情况下是实际的类型（例如string） 不继承其对应的ParameterValue（ParameterValue<string>）。

当使用通用接口/基类时，你的泛型约束会起作用，它由相同类型实现/继承，它是上的通用类，如IComparable<T>接口所实现的类型T（即System.String : IComparable<System.String>）。

相反，我会做以下事情：

public class Parameter<T> : Parameter
{
    public Parameter(string name, ParameterValue<T> value) : base(name)
    {
        Value = value;
    }

    public ParameterValue<T> Value { get; set; }
}

您还必须将ParameterManager方法更改为类似的形式：

public void AddParameter<T>(string name, ParameterValue<T> value)
{
    _parameters[name] = new Parameter<TType>(name, value);
}

public ParameterValue<T> FindParameterValue<T>(string name) 
{
    var parameter = _parameters[name];
    var parameterTyped = parameter as Parameter<TType>;
    return parameterTyped?.Value;
}

附注：由于类型参数中的TType前缀，因此命名类型约束T对一般约定没有任何意义意思是“类型”，所以T就足够了。

Answer 2

Your constraint should be replaced with a change in the second parameter type:

public void AddParameter<TType>(string name, ParameterValue<TType> value)

The calls should be done like this:

_parameters.AddParameter<string>("name", new StringValue("untitled"));
_parameters.AddParameter<Vector>("position", new VectorValue(new Vector()));

C＃的通用约束

2 个答案: