如何在 C# 中实现一个类来访问几种不同类型的对象？

Question

我正在尝试实现一个类来访问不同类型的项目，以类似于数据库行的方式。

但是，我有两种不同的想法，不知道该选择哪一种：

设计 1

public enum ObjectTypeA
{
    Undefined,
    Integer,
    Float
}

public class MyObjectA
{
    private object val;

    public ObjectTypeA Type
    {
        get;
        private set;
    }

    public int Integer
    {
        get
        {
            if (Type != ObjectTypeA.Integer) throw new Exception();
            return (int)val;
        }
        set
        {
            Type = ObjectTypeA.Integer;
            val = value;
        }
    }

    public float Float
    {
        get
        {
            if (Type != ObjectTypeA.Float) throw new Exception();
            return (float)val;
        }
        set
        {
            Type = ObjectTypeA.Float;
            val = value;
        }
    }
}

• 可能的编译时检查更少。
• 不能使用 is 运算符、GetType() 等（重新发明类型系统）。
• 值类型的装箱和拆箱。
• 可以被其他类继承（例如，我可以使用继承创建一个“命名对象”）。

设计 2

public abstract class MyObjectB
{
}

public class MyIntegerB : MyObjectB
{
    public int Value
    {
        get;
        set;
    }

    public MyIntegerB(int _value)
    {
        Value = _value;
    }
}

public class MyFloatB : MyObjectB
{
    public float Value
    {
        get;
        set;
    }

    public MyFloatB(float _value)
    {
        Value = _value;
    }
}

• 实现更短更简单。
• 使用起来非常冗长（强制转换）。

---

性能并不重要，但仍然很重要，因为要存储的大多数对象都是整数或浮点数，因此装箱开销很重要。

类将只包含值，而不是依赖于类型等的方法，因此解决方案是否使用继承无关紧要。

重要提示：要求之一是可能有两种类型使用相同的底层类型（例如，从 MyObjectB 派生的两个类可能使用 int 作为值） ，因此可能无法使用 object 或泛型。

关于使用哪种设计或其他不同设计的任何建议？

编辑： 我不喜欢第二个的原因是因为它使用起来非常冗长：

MyObjectB objB = new MyIntegerB(12);
Console.WriteLine(((MyIntegerB)objB).Value);

而且因为我不能继承它来创建类似“命名对象”的东西，所以我必须将MyObjectB附加到该类中，并且用法更加冗长。

Answer 1

我不明白你为什么不在这里使用泛型。更强烈：我不明白你为什么需要这个：看起来Nullable<T> 可以很好地涵盖你所有的用例。如果没有，一般地实现它是微不足道的：

public class ValueWrapper<T>
{
    public T Value
    {
        get;
        private set;
    }

    public Type WrappedType
    {
        get { return typeof(T); }
    }
}

public MySpecialInt : ValueWrapper<int>
{
    /* etc */
}

Answer 2

为什么不使用泛型？

public abstract class MyObjectB<T>
{
    public T Value
    {
        get;
        set;
    }

    public MyObjectB(T _value)
    {
        Value = _value;
    }
}

此时您只需要一堂课。只是以不同的方式实例化它：

var myObj = new MyObjectB<Int>(1);

或

var myObj = new MyObjectB<Float>(0.012);

Answer 3

我知道你提到不想处理装箱和拆箱，但我仍然认为 Generic 类是你最好的选择。

public class MyObject<T>
{
    public MyObject(T t) {
        Value = t;
    }

    public T Value { get; set; }
}

编辑：

其中一个要求是 可能是两种使用相同的类型 基础类型（例如两个类 从 MyObjectB 派生的可以使用 int 作为 值），所以使用对象或 泛型可能是不可能的。

这仅适用于您扩展课程的情况。如果您将类包装起来，即创建一个MyObject<int> 并访问其Value 属性，而不是对其进行子类化，则没有问题。

话虽如此，如果你想继承一个泛型类，子类也需要是一个泛型类。

Answer 4

你考虑过泛型吗？

public class MyObjectA<T> { 

  public T Value { 
      get; set;
  } 

}

Answer 5

我编写了一个类似的类，它可以保存ClassX 的单个实例或ClassX 的数组。诀窍是它可以在运行时改变，所以泛型是不够的，但我仍然希望它在所有情况下都是强类型的。听起来这与您在此处尝试完成的任务相似。

我选择了第一个选项，原因如下：在可能的情况下，我将复杂性封装在一个类中以使该类更易于使用。类应该封装调用者的复杂性，并对其进行调用更简洁。如果使用MyObjectB 会使您的代码更加冗长，那么我认为这不是正确的答案。

Answer 6

如果您需要异构集合，那么就可以了。

public enum ObjectTypeA
{
    Undefined,
    Integer,
    Float
}

public class MyObjectA
{
    public MyObjectA(object value) : this(value, InfereType(value))
    { }

    public MyObjectA(object value, ObjectTypeA type)
    {
        Value = value;
        Type = type;
    }

    public object Value { get; private set; }

    public ObjectTypeA Type
    {
        get;
        private set;
    }

    public T ValueAs<T>()
    {
        return (T)Value;
    }
}

然后像这样使用它

List<MyObjectA> list = GetAllValues();
foreach (var item in list)
{
    switch (item.WrappedType)
    {
        case MyObjecttypeA.Float:
            float f = item.ValueAs<float>();
            // do something with float
    }
}