Question

我有以下课程：

class Parameter<T>
{
    public string Index { get; set; }
    public T Value { get; set; }
}

我希望有一个这样的清单：

class ParameterModel
{
    public List<Parameter<>> Parameters {get;}
}

然后我会有如下代码：

...
Parameter<> parameter = parameterModel.Parameters.Where(p => p.Index == "AAA");
if (parameter is Parameter<bool>)
{
    ...
}
else if (parameter is Parameter<int>)
{
    ...
}
...

这是可行的还是我应该使用继承而不是泛型？

提前致谢。

Answer 1

不会

class ParameterModel<T>
{
    public List<Parameter<T>> Parameters { get; }
}

做这个工作？

或许你想成为不同类型的参数？然后你可以做

public interface IParameter
{
    string Index { get; set; }
    Type ParameterType { get; }
}

public class Parameter<T> : IParameter
{
    public string Index { get; set; }
    public T Value { get; set; }
    public Type ParameterType
    {
        get
        {
            return typeof(T);
        }
    }
}

class ParameterModel
{
    public List<IParameter> Parameters { get; }
}

所以你可以做到，

var aaaParameter = parameterModel.Parameters.Single(p => p.Index == "AAA");
if (aaaParameter.ParameterType == typeof(bool))
{
    ...
}
else if (aaaParameter.ParameterType == typeof(string))
{
    ...
}

但是，考虑到你描述的问题的界限，一个简单的字典可能是最好的。

var parameterModel = new Dictionary<string, object>();

允许

var aaaParameter = parameterModel["AAA"];
if (aaaParameter is bool)
{
    ...
}
else if (aaaParameter is string)
{
    ...
}

Answer 2

你可以这样做 - 短而甜蜜：

 public class Parameter
 {
     public string Index { get; set; }
     public dynamic Value { get; set; }
 }

 var param1 = new Parameter() { Index = "qw", Value = 34 };
 var param2 = new Parameter() { Index = "qr", Value = "rere" };

 int val1 = (int)param1.Value;
 string val2 = (string)param2.Value;

获得类型：

  var t1 = param1.Value.GetType();
  var t2 = param2.Value.GetType();

或者在你的情况下是这样的：

 if (param1.Value.GetType() == typeof(int))
 {...}
 else if (param1.Value.GetType() == typeof(string))
 {...}

带

 List<Parameter> myParams=new List<Parameter>();

Answer 3

您可以使用继承。

这是最近工作的一个例子：

abstract public class AttributeVariant
{
    string key;
    string name;

    public AttributeVariant(string key, string name)
    {
        this.key = key;
        this.name = name;
    }

    public string GetKey()
    {
        return key;
    }

    public string GetName()
    {
        return name;
    }
}

public class AttributeVariant<T> : AttributeVariant
{
    T value;

    public AttributeVariant(string key, string name, T value = default) : base(key, name)
    {
        this.value = value;
    }

    public object GetValue()
    {
        return value;
    }

    public void SetValue(T value)
    {
        this.value = value;
    }
}

public class AttributeVariant<T, T2> : AttributeVariant<T>
{
    T2 data;

    public AttributeVariant(string key, string name, T value = default, T2 data = default) : base(key, name, value)
    {
        this.data = data;
    }

    public object GetData()
    {
        return data;
    }

    public void SetData(T2 data)
    {
        this.data = data;
    }
}

这样，我可以将通用类类型存储到一个简单的变量中，而不会出现任何问题。这是我的用法：

static Dictionary<string, AttributeVariant> AttributesList = new Dictionary<string, AttributeVariant>()
{
    { "age", new AttributeVariant<string>("age", "Age") },
    { "arms", new AttributeVariant<string>("arms", "Arms") },
    { "bridge", new AttributeVariant<string>("bridge", "Bridge") },
    { "color", new AttributeVariant<string>("color", "Model") },
    { "condition", new AttributeVariant<string, double>("condition", "Condition") },
    { "full_color", new AttributeVariant<string>("full_color", "Full Color") },
    { "gender", new AttributeVariant<string>("gender", "Gender") },
    { "height", new AttributeVariant<string>("height", "Height") },
    { "lenses", new AttributeVariant<string>("lenses", "Lenses") },
    { "material", new AttributeVariant<string>("material", "Material") },
    { "rim_type", new AttributeVariant<string>("rim_type", "Rim Type") },
    { "shape", new AttributeVariant<string>("shape", "Shape") },
};

如何在列表中存储泛型类而不指定类型？

3 个答案: