使用不同的兼容类型覆盖属性

Question

我需要一个具有属性的基类，在其中我可以派生具有相同属性但不同（兼容）类型的类。基类可以是抽象的。

public class Base
{
    public virtual object prop { get; set; }
}

public class StrBase : Base
{
    public override string prop { get; set; } // compiler error
}

public class UseIt
{
    public void use()
    {
        List<Base> l = new List<Base>();
        //...
    }
}

---

我尝试使用泛型，但这在使用该类时给我带来了问题，因为我想在列表中存储不同类型的基类。

public class BaseG<T>
{
    public T prop { get; set; }
}

public class UseIt
{
    public void use()
    {
        List<BaseG> l = new List<BaseG>(); // requires type argument
        //...
    }
}

Answer 1

这是建议的解决方案的另一种方法：

public abstract class Base
{
    public abstract void Use();
    public abstract object GetProp();
}

public abstract class GenericBase<T> : Base
{
    public T Prop { get; set; }

    public override object GetProp()
    {
        return Prop;
    }
}

public class StrBase : GenericBase<string>
{
    public override void Use()
    {
        Console.WriteLine("Using string: {0}", Prop);
    }
}

public class IntBase : GenericBase<int>
{
    public override void Use()
    {
        Console.WriteLine("Using int: {0}", Prop);
    }
}

基本上，我在中间添加了一个通用类，用于存储正确类型的属性。假设您永远不需要从迭代 List 成员的代码中访问 Prop，这将起作用。 （您始终可以向 Base 添加一个名为 GetProp 的抽象方法，如果需要，该方法将泛型强制转换为对象。）

示例用法：

class Program
{
    static void Main(string[] args)
    {
        List<Base> l = new List<Base>();

        l.Add(new StrBase {Prop = "foo"});
        l.Add(new IntBase {Prop = 42});

        Console.WriteLine("Using each item");
        foreach (var o in l)
        {
            o.Use();
        }
        Console.WriteLine("Done");
        Console.ReadKey();
    }
}

编辑：添加了 GetProp() 方法来说明如何从基类直接访问属性。

Answer 2

您无法覆盖属性的类型。看一下下面的代码：

StrBase s = new StrBase();
Base b = s;

这是完全有效的代码。但是当你尝试这样做时会发生什么？

b.prop = 5;

整数可以转换为object，因为一切都是从object派生的。但由于 b 实际上是一个 StrBase 实例，因此它必须以某种方式将整数转换为字符串，但它不能。这就是为什么您不允许覆盖该类型的原因。

同样的原则也适用于泛型：

List<BaseG<object>> l = new List<BaseG<object>>();
BaseG<string> s = new BaseG<string>();

// The compiler will not allow this.
l.add(s);

// Here's the same problem, convert integer to string?
BaseG<object> o = l[0];
o.prop = 5;

这是因为 C# 2.0 中的泛型类型是不变的。 C# 4.0 确实允许这种类型的转换，称为协变和逆变。

解决方案

一个选项是在需要时将对象强制转换回字符串。您可以在子类中添加类型验证：

public class StrBase : Base
{
  private string propValue;

  public override object prop {
    get
    {
      return this.propValue;
    }
    set
    {
      if (value is string)
      {
        this.propValue = (string)value;
      }
    }
  }
}

您还可以在子类中公开类型安全的属性：

public class StrBase : Base
{
  public string strProp {
    get
    {
      return (string)this.prop;
    }
    set
    {
      this.prop = value;
    }
  }
}

Answer 3

从C# 9.0开始，这是可能的

从 C# 9.0 开始，重写方法支持协变返回类型。

（请参阅Microsoft 文档）

Answer 4

public class First
{
    private int someV;

    public virtual object SomeV { get => someV; set => someV = (int)value; }

    public First() { }
}

public class Two : First
{
    private string someV;

    public override object SomeV { get => someV; set => someV = value.ToString(); }

    public Two() { }
}

以及它们的使用：

First firstClass = new First();
firstClass.SomeV = 1;

Two twoClass = new Two();
twoClass.SomeV = "abcd";