有没有办法将泛型类向下转换为具有派生 T 的实例？

Question

假设我有以下类用于包装给定类型的一些项目：

public class IndexedModelWithValue<T>
{
    public IndexedModelWithValue(T value, int index)
    {
        Index = index;
        InnerValue = value;
    } 

    public int index;

    public T InnerValue { get; }
}

我有这两个类：

class Animal { }
class Dog : Animal { }

在某些时候，我加载了不同的对象（这里我们将只使用 Dog 类），它们都继承自同一个基类型，所以我会有这样的东西：

Dog dog = LoadMyDerivedAnimalFromSomewhere();
Animal animal = dog;

// In my actual code I have something like
IEnumerable<Animal> animals = LoadMyDerivedAnimalsFromSomewhere();

然后继续包装所有这些项目，以便我最终得到如下内容：

IndexedModelWithValue<Animal> indexedAnimal = new IndexedModelWithValue(animal, 0);

现在，我知道索引模型中的动物实际上是一个 Dog 实例，那么有没有办法从那个实例中得到一个 IndexedModelWithValue<Dog> 对象？

我考虑过使用接口（我不介意以IIndexedModelWithValue<Dog> 之类的东西结束，只要我在那里得到Dog 类型），但据我了解，协变类只能强制转换在相反的方向（IEnumerable<String> 到 IEnumerable<object，反之亦然），我不能在这里使用逆变类，因为该类公开了一个 T 参数。

感谢您的帮助！

编辑：为澄清起见，这是我最终的清单：

IEnumerable<Animal> animals = LoadAllMyAnimalsFromSomewhere();
IEnumerable<IndexedModelWithValue<Animal>> = animals.Select((item, i) => new IndexedModelWithValue(item, i));

---

临时（坏）解决方法：现在我使用的解决方案是向索引类添加一个方法：

public IndexedModelWithValue<TValue> Downcast<TValue>() where TValue : T
{
    return new IndexedModelWithValue<TValue>((TValue)InnerValue, Index);
}

这样我就可以做到：

IndexedModelWithValue<Dog> indexedDog = indexedAnimal.Downcast<Dog>();

唯一的问题是这样我每次调用这个方法时都会创建IndexedModelWithValue类的一个新实例（所以我在浪费内存和CPU时间）而事实上我只想将该对象转换为我的派生类型。

---

解决方案：这是我现在用来解决问题的方法：

public static IEnumerable<ICovariantIndexedModelWithValue<T>> New([NotNull] IEnumerable<T> source)
{
    int index = 0;
    foreach (T item in source)
    {
        object instance = Activator.CreateInstance(typeof(IndexedModelWithValue<>).MakeGenericType(item.GetType()), item, index);
        yield return (ICovariantIndexedModelWithValue<T>)instance;
        index++;
    }
}

我可以调用它并传递原始列表以获得协变包装列表，其中每个单独的项目都具有“正确的类型”，具体取决于其派生类型。

界面如下：

public interface ICovariantIndexedModelWithValue<out T>
{
    int Index { get; }

    T InnerValue { get; }
}

Answer 1

您的indexedDog 和indexedAnimal 是两种不同的类型。不仅仅是您将它们存放在不同形状的盒子中，实际类型也不同。因此，如果不按原样创建新对象，就无法做到这一点。如果您想避免浪费内存、cpu 或其他任何东西，那么您首先需要将对象创建为IndexedModelWithValue<Dog>。如果你知道它绝对是一只狗，那么这就是你应该做的。如果你有一只确定的狗，那么首先不要创建IndexedModelWithValue<Animal>，你的问题就会消失。在没有看到创建对象的代码的情况下，很难确切说明如何执行此操作，但泛型应该允许您创建所需的类型。

Answer 2

如果对象本身是强类型创建的（例如，当为 Dog 创建 IndexedModelWithValue 时，它被创建为 IndexedModelWithValue<Dog> 而不是 IndexedModelWithValue<Animal> ），则可以使用接口来支持（协）方差和存储在接口类型列表中的所有不同值。

edit 基于 Animal 类型的源：虽然就构建时间检查而言不是一个很好的解决方案，但可以使用 Activator.CreateInstance 和typeof(IndexedModelWithValue<>).MakeGenericType(a.GetType())（其中 a 是 Animal 变量）。 （如果加载数据的方法可以以某种方式创建其他对象，则可以添加更好的设计时功能）

根据您当前的示例，可以使用以下命令创建可枚举： LoadAllMyAnimalsFromSomewhere().Select((a,i)=> (IIndexedModelWithValue<Animal>) Activator.CreateInstance(typeof(IndexedModelWithValue<>).MakeGenericType(a.GetType()), a,i));

Linqpad 安全码：

void Main()
{
    var list = LoadData().Select((a,i)=> (IIndexedModelWithValue<Animal>) Activator.CreateInstance(typeof(IndexedModelWithValue<>).MakeGenericType(a.GetType()), a,i)).ToList();

    foreach(var t in list.OfType<IIndexedModelWithValue<Dog>>())
        Console.WriteLine(t);
}

static IEnumerable<Animal> LoadData()
{
    yield return new Dog();
    yield return new Gecko();
}

public class IndexedModelWithValue<T>:IIndexedModelWithValue<T>
{
    public IndexedModelWithValue(T value, int index)
    {
        Index = index;
        InnerValue = value;
    } 

    public int Index{get;set;}

    public T InnerValue { get; }
}

public interface IIndexedModelWithValue<out T>
{
    int Index{get;}
    T InnerValue {get;}
}

class Animal { }
class Dog : Animal { }
class Gecko:Animal{}