Question

I have a DataSource in my control which is always a List<T> where T has to inherit from IEntity.

public class MyClass<T> where T : IEntity
{
    public List<T> DataSource
    {
        get;
        set;
    }
}

Now, obviously you can’t cast a List<T> to a List<IEntity> doing the following:

List<IEntity> wontWork = (List<IEntity>)this.DataSource;

How can I get the DataSource as a List of IEntity, whilst still being able to add and remove items from the DataSource? I.e. I could do the following, but removing from the List it returns would not remove from the DataSource:

public List<TOut> GetDataSourceCopyAsUnderlyingType<TOut>()
{

    if (this.DataSource == null)
    {
        return new List<TOut>();
    }
    else
    {

        // Get the list and the enumerator
        IList list = (IList)this.DataSource;
        IEnumerator enumerator = list.GetEnumerator();

        // Build the target list
        List<TOut> targetList = new List<TOut>();

        int i = 0;
        while (enumerator.MoveNext())
        {
            TOut entity = (TOut)list[i];
            targetList.Add(entity);
            i++;
        }

        return targetList;

        }

    }

Basically, I need some way of doing the following:

List<IEntity> interfaceList = this.GetDataSourceAsAnotherType<IEntity>();
int dataSourceCount = this.DataSource.Count;   // Equals 5
int interfaceCount = interfaceList.Count;      // Equals 5

interfaceList.RemoveAt(0);
int dataSourceCount = this.DataSource.Count;   // Equals 4
int interfaceCount = interfaceList.Count;      // Equals 4

And just to add, I don’t mind if it means I’ve got to use a different type instead of a List.

EDIT: Sorry, forgot to say I’m using .Net2.0 and cannot move to .Net 3.5.

Answer 1

It would be a monumentally bad idea if this were allowed, which is why it isn’t. I can add any old IEntity to a List<IEntity> which will blow up if that IEntity can’t be cast to T. Whilst all Ts are IEntities, not all IEntities are Ts.

This works with arrays because arrays have a deliberate subtyping hole (as they do in Java). Collections do not have a subtyping hole.