通用转换问题的接口

Question

我正在针对内存状态树实现自定义数据存储，但我的索引遇到了一些问题。我的索引是用来覆盖的，所以它们应该返回对象而不仅仅是一个位置。索引具有名称和对象列表。这些对象可以是不同的底层类型，因此索引对象是IHasUUID，这表明项目具有 UUID。

public class DataIndex
{
    public string Name;
    public IDictionary<string, List<IHasUUID>> Index;
}

public class Indexer
{

    private List<DataIndex> Indexes;
...
    public List<IHasUUID> GetIndexedItems(List<IHasUUID> indexBy) 
    {
        var indexer = GetIndexByKeys<IHasUUID>(indexBy);
        var indexHash = GetHashKey(indexBy);

        return GetIndexValues<IHasUUID>(indexer, indexHash);
    }

    private List<T> GetIndexValues<T>(DataIndex indexBy, string indexHash) where T : IHasUUID
    {
        if (indexBy == null)
            return new List<T>();

        return ((IList<T>)indexBy.Index[indexHash]).ToList();
    }

}

我使用反射方法生成字典的键，我查看用作索引键的事物并附加类型字符串名称

所以我让我的引擎去 FindRecords，没问题

public List<T> FindRecords<T>(IHasUUID indexBy) where T : IHasUUID
{
   var indexedIds = Indexer.GetIndexedItems(new List<IHasUUID>() { indexBy });

   return ((IList<T>)indexedIds).ToList();
}

在这里，我在 FindRecords 返回时遇到了一堵墙

我有

return ((IList<T>)indexedIds).ToList();

我试过了

return indexedIds.ToList();

没有一个人能够施展到 T。这可能吗？

提前致谢

编辑

我确实看起来更近了，

    public class DataIndex
    {
        public DataIndex()
        {
            Index = new Dictionary<string, IEnumerable<IHasUUID>>();
        }

        public string Name;
        public Dictionary<string, IEnumerable<IHasUUID>> Index;
    }

    public class Indexer
    {

        private List<DataIndex> Indexes;

        public Indexer()
        {
            Indexes = new List<DataIndex>();
        }
        public IEnumerable<T> GetIndexedItems<T>(IEnumerable<IHasUUID> indexBy) where T : IHasUUID
        {
            var indexer = GetIndexByKeys<T>(indexBy);
            var indexHash = GetHashKey(indexBy);

            return GetIndexValues<T>(indexer, indexHash);
        }
        private IEnumerable<T> GetIndexValues<T>(DataIndex dataIndex, string indexHash) where T : IHasUUID
        {
            if (dataIndex == null)
                return new List<T>();

            return dataIndex.Index[indexHash].ToList() as List<T>;
        }
}

但是，我从GetIndexValues 得到了空回。我也尝试将它作为 IEnumerable 返回，也为 null

这是我的添加到索引方法

public void AddManyToIndex<T>(IEnumerable<IHasUUID> keys, IEnumerable<IHasUUID> newItems) where T : IHasUUID
{
    var index = GetIndexByKeys<T>(keys) ?? CreateIndex<T>(keys);

    string indexKey = GetHashKey(keys);

    if (!index.Index.ContainsKey(indexKey))
    {
        index.Index[indexKey] = new List<IHasUUID>();
    }

        var list = index.Index[indexKey].ToList();
        list.AddRange(newItems.ToList());
        index.Index[indexKey] = list as IEnumerable<IHasUUID>;
}

Answer 1

System.Collections.Generic.List<T> 不是covariant。也就是说，给定T 和U 两种类型，其中U 是T，List<U>不是List<T>。

这就是强制转换失败的原因，在您的示例中实现IHasUUID、T 的类型列表不是List<IHasUUID>。

但也有协变的¹ 泛型类型，例如System.Collections.Generic.IEnumerable<T> 和System.Collections.Generic.IReadOnlyList<T>。对于此类类型，给定两种类型 T 和 U，其中 U 是 T，IEnumerable<U> 是 IEnumerable<T>。

除了解决您的特定问题外，使用此类类型还可以使您的 API 更加灵活，同时使您的实现更简单、更容易。

考虑以下几点：

public interface IHasUuid
{
    Guid Uuid { get; }
}

public class DataIndex
{
    public string Name { get; set; }
    public IDictionary<string, IEnumerable<IHasUuid>> Index { get; } = new Dictionary<string, IEnumerable<IHasUuid>>();
}

public class Indexer
{
    public IEnumerable<IHasUuid> GetIndexedItems(IEnumerable<IHasUuid> indexBy)
    {
        var indexer = GetIndexByKeys<IHasUuid>(indexBy);
        var indexHash = GetHashKey(indexBy);

        return GetIndexValues<IHasUuid>(indexer, indexHash);
    }


    private IEnumerable<T> GetIndexValues<T>(DataIndex dataIndex, string hash) where T : IHasUuid
    {
        if (dataIndex == null)
            return Enumerable.Empty<T>();

        return dataIndex.Index[hash] as IEnumerable<T>;
    }
}

您可以将实现IEnumerable<IHasUuid> 的任何类型存储在DataIndex.Index 中。 .NET 中的所有泛型集合都实现了这个接口，包括List<T>、HashSet<T>、ConcurrentQueue<T> 等等。

如果您希望在原始代码中保留防御性复制，这可能是明智之举，只需将.ToWhatever() 添加回代码即可。

private IEnumerable<T> GetIndexValues<T>(DataIndex dataIndex, string hash) where T : IHasUuid
{
    if (dataIndex == null)
        return Enumerable.Empty<T>();

    return (dataIndex.Index[hash] as IEnumerable<T>).ToHashSet();
}

例如，您可以像这样构建DataIndex 实例

class Person: IHasUuid {
    public Guid Uuid { get; }
    public string Name { get; }
}

var index = new DataIndex {
    Index = {
        ["People"] = new List<Person>()
    }
};

var indexer = new Indexer();

var people = indexer.GetIndexValues(index, "People");

这是一个有效的小提琴：https://dotnetfiddle.net/qgjXR7

1：如果该类型参数是使用out 修饰符声明的，则该类型在其类型参数上是协变的。顾名思义，out 修饰符意味着它所归属的类型参数只能用于声明类型的输出位置。

interface Wrapper<out T>
{
    T Value { get; } // OK

    T Value { get; set; } // Error

    void SetValue(T value); // Error
}

Interface 和 delegate 类型可以声明协变类型参数，类和结构等具体类型不能。

---