C# C语言中的泛型值对象#

我有一个VO类，它包含几个变量，包括一个可以是不同类型的变量，为了防止以后强制转换，我想知道是否可以将该类设置为泛型

public class InputVO<T>
{
    public bool isEnabled;
    public T value;
}

---

如何定义数组和GetInput方法，以便它们与通用InputVO一起工作？（InputType类型的

InputType参数是一个枚举。我认为在这里并不重要）。
泛型类型参数在编译时是固定的

无论何时使用InputVO，都需要填写该类型参数

  public InputVO<T1>[] Inputs { get; private set; }

public InputVO[]输入{get；private set；}

但您似乎希望每个数据类型具有不同的InputVO对象，并且能够在运行时按类型检索它们：

// Base class for all InputVOs
public abstract InputVOBase
{
    public bool isEnabled;
}

// InputVO for a specific data-type
public class InputVO<T> : InputVOBase
{
    public T Value;
}

//所有InputVO的基类
公共摘要输入库
{
公共场所被禁止；
}
//特定数据类型的InputVO
公共类InputVO:InputVOBase
{
公共价值观；
}

现在，您可以使用从Type到InputVOBase的字典

  // One InputVO per datatype
  public Dictionary<Type, InputVOBase> AllInputs { get; private set; }

  // Return the VO for type T, or null
  public InputVO<T> GetInput<T>()
  {
      InputVOBase vo = AllInputs[typeof(T)];

      return (vo as InputVO<T>);
  }

//每个数据类型一个InputVO
公共字典AllInputs{get；private set；}
//返回T类型的VO，或null
公共InputVO GetInput（）
{
InputVOBase vo=所有输入[类型（T）]；
返回（vo作为输入vo）；
}
稍微清理一下溶液。您主要需要在字典中收集您的值

void Main()
{
    var a = new InputVO<string> { Value = "test" };
    var b = new InputVO<int> { Value = 5 };
    Inputs.Add(typeof(string), a);
    Inputs.Add(typeof(int), b);

    var x = GetInput<string>();
    Console.WriteLine(x.Value);
    var y = GetInput<int>();
    Console.WriteLine(y.Value);
}

public abstract class InputVOBase
{
    public bool isEnabled;
}

public class InputVO<T> : InputVOBase
{
    public T Value;
}

public Dictionary<Type, InputVOBase> Inputs = new Dictionary<Type, InputVOBase>();

public InputVO<T> GetInput<T>()
{
    return Inputs[typeof(T)] as InputVO<T>;
}

void Main（）
{
var a=新输入VO{Value=“test”}；
var b=新输入VO{Value=5}；
输入.Add（typeof（string），a）；
输入。添加（类型（int），b）；
var x=GetInput（）；
控制台写入线（x.Value）；
var y=GetInput（）；
控制台写入线（y值）；
}
公共抽象类InputVOBase
{
公共场所被禁止；
}
公共类InputVO:InputVOBase
{
公共价值观；
}
公共字典输入=新字典（）；
公共InputVO GetInput（）
{
将输入[typeof（T）]返回为InputVO；
}
如果不指定类型，则无法创建泛型类的数组。但是，由于您可以控制基类型，因此可以使其实现一个非泛型接口，并拥有该接口的集合：

//Empty interface 
public interface IInputVO { }

//Your generic class now implements the interface
public class InputVO<T> : IInputVO
{
    public bool isEnabled { get; set; }
    public T Value { get; set; }
}

谢谢你给任何人的提示！Phew，因为没有办法绕过强制转换，我只需要考虑几种类型，我认为所有基于泛型的解决方案在我的案例中都有点过头了。所以我只是在我的VO中添加了铸造getter

public class InputVO
{
    public bool isEnabled;
    public bool isValid;
    public InputType type;
    public object value;

    public int IntValue { get { return (int)value; } }
    public float FloatValue { get { return (float)value; } }
    public bool BoolValue { get { return (bool)value; } }
    public Vector2 Vector2Value { get { return (Vector2) value; } }
    public Vector3 Vector3Value { get { return (Vector3)value; } }
}

请举例说明如何使用
GetInput
，特别是我想看看如何使用函数返回的对象。
IInputVO[] inputs = 
{ 
    new InputVO<int>(),
    new InputVO<string>(),
    new InputVO<SomeClass>(),
};

public class InputVO
{
    public bool isEnabled;
    public bool isValid;
    public InputType type;
    public object value;

    public int IntValue { get { return (int)value; } }
    public float FloatValue { get { return (float)value; } }
    public bool BoolValue { get { return (bool)value; } }
    public Vector2 Vector2Value { get { return (Vector2) value; } }
    public Vector3 Vector3Value { get { return (Vector3)value; } }
}