C# - 可以列出吗？无缝转换为列表或类似的？

Question

我的控件中有一个 DataSource ，它始终是一个 List ，其中 T 必须从 IEntity 继承。

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

现在，显然您不能将 List 转换为 List 执行以下操作：

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

How can I get the DataSource as a List of IEntity，同时仍然能够从 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;

        }

    }

基本上，我需要某种方法来执行以下操作：

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

只是补充一下，我不介意这是否意味着我必须使用不同的类型而不是列表。

编辑：抱歉，忘了说我正在使用 .Net2.0，无法移动到 .Net 3.5。

Answer 1

DrPizza 所说的，但有更多代码：

public class ListFacade<TIn, TOut> : IList<TOut> where TIn : TOut
{
    private readonly IList<TIn> innerList;

    public ListFacade(IList<TIn> innerList)
    {
        this.innerList = innerList;
    }

    public int Count
    {
        get { return this.innerList.Count; }
    }

    public bool IsReadOnly
    {
        get { return this.innerList.IsReadOnly; }
    }

    public TOut this[int index]
    {
        get { return this.innerList[index]; }
        set { this.innerList[index] = (TIn)value; }
    }

    public void Add(TOut item)
    {
        this.innerList.Add((TIn)item);
    }

    public void Clear()
    {
        this.innerList.Clear();
    }

    public bool Contains(TOut item)
    {
        return (item is TIn) && this.innerList.Contains((TIn)item);
    }

    public void CopyTo(TOut[] array, int arrayIndex)
    {
        var inArray = new TIn[this.innerList.Count];
        this.innerList.CopyTo(inArray, arrayIndex);
        Array.Copy(inArray, array, inArray.Length);
    }

    public IEnumerator<TOut> GetEnumerator()
    {
        foreach (var item in this.innerList)
        {
            yield return item;
        }
    }

    System.Collections.IEnumerator
        System.Collections.IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }

    public int IndexOf(TOut item)
    {
        return (item is TIn) ? this.innerList.IndexOf((TIn)item) : -1;
    }

    public void Insert(int index, TOut item)
    {
        this.innerList.Insert(index, (TIn)item);
    }

    public bool Remove(TOut item)
    {
        return (item is TIn) && this.innerList.Remove((TIn)item);
    }

    public void RemoveAt(int index)
    {
        this.innerList.RemoveAt(index);
    }

如果参数不是 TIn 类型，则添加、插入和索引器集将会崩溃。

Answer 2

好吧，这可能完全不是重点，但是，使用一点 Linq 怎么样？

var interfaceList = objectList.ConvertAll<Interface>(o => (Interface)o);

这样你就可以轻松地转换objectList。
希望这有助于找到解决方案......

Answer 3

我也赞成 linq，但你可以这样做：

var interfaceList = objectList.Cast<IEntity>();

更短且更具表现力。

Answer 4

如果允许这样做，那将是一个非常糟糕的主意，这就是为什么不允许这样做。我可以将任何旧的 IEntity 添加到 List 中，如果该 IEntity 无法转换为 T，该列表将会爆炸。虽然所有 T 都是 IEntities，但并非所有 IEntities 都是 T。

这适用于数组，因为数组有一个故意的子类型漏洞（就像在 Java 中一样）。集合没有子类型漏洞。

Answer 5

创建一个无缝转换的包装类。未经测试的示例：

public class CastList<TTarget, TOriginal> 
  : IList<TTarget> where TOriginal : TTarget
{
  List<TOriginal> _orig;
  public CastList(List<TOriginal> orig) { _orig = orig; }

  public Add(TTarget item) { _orig.Add(item); }

  public TTarget this[int i] 
  {
    get { return (TTarget)_orig[i]; }
    set { _orig[i] = value; }
  }

  public IEnumerator<TTarget> GetEnumerator() 
  {
     foreach(TOriginal item in _orig)
       yield return (TTarget)item;
  }

  // etc...
}

对原始列表的操作也将反映在包装器中。要使用它，只需使用您的数据源构建它即可。