C# 从IList转换<；T>；到非泛型IList

我正在实现

IListSource

，它需要一个带有以下签名的方法

GetList（）

：

IList GetList()

我使用的是.NET framework 2，我希望返回一个实现IList的对象，如下所示：

public System.Collections.IList GetList()
{
    return this._mydata; // Implements IList<MyDataRow>            
}

但是，仅仅为了将列表从类型

IList

获取到

IList

，就必须重新创建列表，这似乎非常低效。为什么我可以从“GetList（）”返回

列表，但不能返回
IList
？有人知道我有什么方法可以返回
IList
，而不重新填充新列表吗

更新：

声明了
\u mydata
成员变量：

private MyData _mydata;

public class MyData : IList<MyDataRow>
{
   ....
}

并声明
MyData
：

private MyData _mydata;

public class MyData : IList<MyDataRow>
{
   ....
}

公共类MyData:IList
{
....
}

为什么我可以从
GetList（）
返回
List
，但不能返回
IList

这是因为
List
实现了
IList
，
IList
不能转换为
IList
，它们是两个独立的接口。所以要回答你的问题：

有人知道我有什么方法可以返回
IList
，而不重新填充新列表吗

如果具体类型实现了
IList
（而
List
实现了），那么您可以显式地强制转换它，例如

return (IList)this.mydata;

更新

根据您的更新，您必须更新
MyData
以实现
IList
，否则您别无选择，只能返回一个实现它的新集合

或者，如果
MyData
确实是一个通用列表，那么我建议您从
list
继承它，这样您就可以获得更多的灵活性和兼容性，例如

class MyData : List<MyDataRow>
{
}

类MyData:列表
{
}
MyData类需要实现
IList
以及通用版本
IList

类MyData:IList，IList
{
}
如果可以将
IList
直接转换为
IList
，您可以通过其
添加（对象）
方法返回一个可能（例如）被非
T
对象“污染”的列表。
IList
不扩展
IList
，因为期望通用版本的每个实现都提供与非通用版本相同的契约是不合理的。如果它确实扩展了
IList
，则有人可以获取从
GetList
返回的值并合理地期望调用，例如
Add（DateTime.Now）
，或
Add（Thread.CurrentThread）
。这就是IList的承诺

这就是为什么将列表复制到
列表
会起作用-
列表
实现这两个接口，并在使用不适当的参数类型调用其（显式实现的）
IList
方法时抛出

如果您可以通过返回
IEnumerable
而不受影响，请改为返回。如果可以返回
IList
，则执行该操作。如果您确实需要一个非泛型的
IList
返回，那么实现该接口并适当地处理非
MyDataRow
值。
在数据收集类上实现
IList
，或者创建一个适配器，它包装
IList
并实现
IList
：

public sealed class NonGenericList<T> : IList
{
    private readonly IList<T> _wrappedList;

    public NonGenericList(IList<T> wrappedList)
    {
        if(wrappedList == null) throw new ArgumentNullException("wrappedList");

        _wrappedList = wrappedList;
    }

    public int Add(object value)
    {
        _wrappedList.Add((T)value);
        return _wrappedList.Count - 1;
    }

    public void Clear()
    {
        _wrappedList.Clear();
    }

    public bool Contains(object value)
    {
        return _wrappedList.Contains((T)value);
    }

    public int IndexOf(object value)
    {
        return _wrappedList.IndexOf((T)value);
    }

    public void Insert(int index, object value)
    {
        _wrappedList.Insert(index, (T)value);
    }

    public bool IsFixedSize
    {
        get { return false; }
    }

    public bool IsReadOnly
    {
        get { return _wrappedList.IsReadOnly; }
    }

    public void Remove(object value)
    {
        _wrappedList.Remove((T)value);
    }

    public void RemoveAt(int index)
    {
        _wrappedList.RemoveAt(index);
    }

    public object this[int index]
    {
        get { return _wrappedList[index]; }
        set { _wrappedList[index] = (T)value; }
    }

    public void CopyTo(Array array, int index)
    {
        _wrappedList.CopyTo((T[])array, index);
    }

    public int Count
    {
        get { return _wrappedList.Count; }
    }

    public bool IsSynchronized
    {
        get { return false; }
    }

    public object SyncRoot
    {
        get { return this; }
    }

    public IEnumerator GetEnumerator()
    {
        return _wrappedList.GetEnumerator();
    }
}

公共密封类非通用列表：IList
{
私有只读IList包装列表；
公共非通用列表（IList wrappedList）
{
如果（wrappedList==null）抛出新的ArgumentNullException（“wrappedList”）；
_wrappedList=wrappedList；
}
公共整数加法（对象值）
{
_wrappedList.Add（（T）值）；
return _wrappedList.Count-1；
}
公共空间清除（）
{
_wrappedList.Clear（）；
}
公共布尔包含（对象值）
{
返回_wrappedList.Contains（（T）值）；
}
public int IndexOf（对象值）
{
返回_wrappedList.IndexOf（（T）值）；
}
公共void插入（int索引，对象值）
{
_wrappedList.Insert（索引，（T）值）；
}
公共图书馆是固定大小的
{
获取{return false；}
}
公共图书馆是只读的
{
获取{return\u wrappedList.IsReadOnly；}
}
公共无效删除（对象值）
{
_wrappedList.Remove（（T）值）；
}
公共无效删除（整数索引）
{
_wrappedList.RemoveAt（索引）；
}
公共对象此[int索引]
{
获取{return _wrappedList[index]；}
设置{u wrappedList[index]=（T）值；}
}
public void CopyTo（数组，int索引）
{
_wrappedList.CopyTo（（T[]）数组，索引）；
}
公共整数计数
{
获取{return\u wrappedList.Count；}
}
公共布尔值是同步的
{
获取{return false；}
}
公共对象同步根
{
获取{返回此；}
}
公共IEnumerator GetEnumerator（）
{
返回_wrappedList.GetEnumerator（）；
}
}

用法：

public System.Collections.IList GetList()
{
    return new NonGenericList<MyDataRow>(this._mydata);
}

public System.Collections.IList GetList（）
{
返回新的非通用列表（此.\u mydata）；
}
mydata
字段的声明类型是什么？@NicoleCalinoiu：根据他收到的错误消息，它是
mydata
+1。我冒昧地修改了类名。（根据OP的错误消息，类本身是MyData，而不是MyDataRow）。这确实解释了问题，但没有提供解决方案：MyData是IList类型的，他仍然需要调用.ToList（），他希望避免这种情况。@Baboon if
MyData
是
IList
类型的，但是具体的类型是
List
，那么只需要显式转换即可。谢谢你，James，给出了详细的答案。我要感谢你们，因为从列表继承的建议，而不是像我那样在我的类中封装列表成员，确实是解决我问题的最简单的方法。谢谢你的帮助。你的第二段说到了关键，但是第一段