通用转换问题的接口

Question

I'm implementing a custom data store against an in memory state tree and I'm running into some issues with my indexing. My indexes are meant to be covering, so they should return the object not just a position. An index has a name, and a List of objects. Those objects can be different underlying types so the indexed objects are IHasUUID which indicates an item has a 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();
    }

}

I generate the key to the dictionary using a reflection method where I look at the things being used as the index key and append the type string names

So I ask my Engine to FindRecords, no problem

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

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

Here I run into a wall on the FindRecords return

I have

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

and I tried

return indexedIds.ToList();

Neither one is able to cast up to T. Is this possible?

Thanks in advance

EDIT

I do seem to be much closer,

    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>;
        }
}

However I am getting null back from GetIndexValues . I also tried returning it as an IEnumerable, also null

Here's my Add to index method

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> is not covariant . That is to say that, given two types T and U where a U is a T , a List<U> is not a List<T> .

This is why the cast fails, a list of a type implementing IHasUUID , T in your example, is not a List<IHasUUID> .

There are however, covariant ¹ generic types, such as System.Collections.Generic.IEnumerable<T> and System.Collections.Generic.IReadOnlyList<T> . For such types, given two types T and U where a U is a T , an IEnumerable<U> is an IEnumerable<T> .

In addition to solving your specific problem, using such types will also serve to make your APIs more flexible while at the same time making your implementation simpler and easier.

Consider the following:

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>;
    }
}

You can store any type that implements IEnumerable<IHasUuid> in DataIndex.Index . All generic collections in .NET implement this interface, including List<T> , HashSet<T> , ConcurrentQueue<T> and countless more.

If you wish to retain the defensive copying in the orginal code, which may well be wise, simply add the .ToWhatever() back to the code.

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();
}

For example, you can build up a DataIndex instance like this

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");

Here's a working fiddle: https://dotnetfiddle.net/qgjXR7

1 : A type is covariant over its type parameter if that type parameter is declared using the out modifier. As its name suggests, the out modifier means that type parameter to which it is ascribed may only be used in output positions in the declaring type.

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

    T Value { get; set; } // Error

    void SetValue(T value); // Error
}

Interface and delegate types can declare covariant type parameters, concrete types such as classes and structs may not.

---