C# 将多态对象强制转换为特定类型，而不知道该“特定类型”是什么

社区！这是个好问题。这很有趣。 我认为这是这个问题的简单解决方案。 我们只需要创建一个简单的构造函数，如下所示

public class Holder
{
    public string SomeData;  // just example data

    public Holder()
    {
        
    }
    
    public Holder(Holder someData)
    {
        SomeData = someData.SomeData;
    }
}

public class Holder<T> : Holder
{
    public T Value;

    public Holder(Holder a, T t = default)
        :base(a)
    {
        Value = t;
    }
}

public class Programm
{
    void Main()
    {
        var h = new Holder();
        var g = new Holder<string>(h);
    }
    
}

如果需要强制转换为特定类型，则多态性是错误的。当然，你可以做这样的事情：

switch (holder)
{
    case Holder<string> stringHolder:
        DoStringThing(stringHolder.Value);
        break;
    case Holder<int> intHolder:
        DoIntThing(intHolder.Value);
        break;
    ...
}

另请参阅：使用模式切换语句。

然而，多态性背后的想法是能够在不必知道特定类型的情况下做事。因此，重新设计持有者类，并让它们自己执行特定于类型的事情：

public abstract class Holder
{
    public abstract void DoThing();
}

public abstract class Holder<T> : Holder
{
    public abstract T Value { get; }
}

特定类型的一些示例：

public class StringHolder : Holder<string>
{
    public StringHolder(string value)
    {
        Value = value;
    }

    public override string Value { get; }

    public override void DoThing()
    {
        Console.WriteLine($"String of length {Value.Length} is \"{Value}\"");
    }
}

public class IntHolder : Holder<int>
{
    public IntHolder(int value)
    {
        Value = value;
    }

    public override int Value { get; }

    public override void DoThing()
    {
        Console.WriteLine($"The integer {Value} is {(Value % 2 == 0 ? "even" : "odd")}");
    }
}

现在你可以简单地写

holder.DoThing();

...无需投射。

更新

您编辑的问题确实显示了多态版本。

在这里，我想介绍另一种方法，通过使用接口将 和 合并到一个类中。HolderHolder<T>

public interface IHolder
{
    object Value { get; set; }
}

public interface IHolder<T> : IHolder
{
    new T Value { get; set; } // The new keyword hides the inherited property.
}

public class Holder<T> : IHolder<T>
{
    object IHolder.Value
    {
        get => Value; // Returns T Holder<T>.Value as object.
        set => Value = value is T t ? t : default; // Sets T Holder<T>.Value.
    }

    public T Value { get; set; }
}

Holder<T>现在实现基于类型声明的“中性”属性。由于它显式实现它（即，而不是我们编写），因此此属性是隐藏的，除非通过接口访问它。例如，这允许您声明 a 并使用 as 对象检索不同类型的值。ValueIHolderobjectpublic object Valueobject IHolder.ValueList<IHolder>Holder<T>list[i].Value

但是你有一个变量，你可以得到强类型值。Holder<float> floatHolderfloat

请注意，这仍然允许您派生更具体的类型，例如 ，但它甚至可能不是必需的。class FloatHolder : Holder<float>

如果打算只使用派生类型，则可以标记为抽象类型，也可以将派生类必须实现的所有成员标记为抽象类型。这使得无法创建 with 的实例，并且还允许您声明没有 body 的抽象方法。Holder<T>Holder<T>new