Question

好的，这是基本代码：

class foo
{
    String name;
    int property;
}

class bar
{
    private List<foo> a;
    private List<foo> b;
}

我想这样做，以便调用代码可以迭代任何列表但我想保护它们免受编辑。我已经研究了实现IEnumarable接口，但问题是它需要一个“GetEnumerable”定义，但我想要两个不同的枚举器。例如，我希望能够说出

foreach(foo in bar.getA())
{ //do stuff }

然后

foreach(foo in bar.getB())
{ //do stuff }

我是否必须对每个元素进行子类化并在每个元素上实现IEnumerable接口，然后将THOSE包含为属性？我误解了IEnumerable接口吗？我知道List类有它自己的Enumerator，所以我可以做类似

的事情

class bar
{
    private List<foo> a;
    private List<foo> b;

    public IEnumerator<foo> getAEnumerator()
    {  return a.GetEnumerator();

    public IEnumerator<foo> getBEnumerator()
    {  return b.GetEnumerator();

}

但是我的for循环看起来像这样：

bar x = new bar();
IEnumerator<foo> y = x.getAEnumerator();
while (y.moveNext())
{
    foo z = y.Current;
}

所以我失去了“foreach”的可读性。

有没有办法在这些列表上使用“foreach”而不公开公开这些列表？我仍然试图绕过IENumerable接口，所以也许我错过了一些明显的东西。

Answer 1

不要公开List<T>，而是公开其他内容，例如IReadOnlyList<T>：

class bar
{
    private readonly List<foo> a = new List<foo>();
    private readonly List<foo> b = new List<foo>();

    public IReadOnlyList<foo> A { get; private set; }
    public IReadOnlyList<foo> B { get; private set; }

    public bar()
    {
        A = a.AsReadOnly();
        B = b.AsReadOnly();
    }
}

对a和b的任何更改都会反映在A和B中。

另请注意，虽然您可以将List<T>投射到IReadOnlyList<T>，但调用代码可以将其强制转换回List<T>。上面的方法返回ReadOnlyCollection<T>，它提供了一种防止回退到可变集合类型的安全措施。

readonly关键字只会确保您不会在以后用其他内容替换对a和b的引用。

Answer 2

class bar
{
    private readonly List<foo> a = new List<foo>();
    private readonly List<foo> b = new List<foo>();

    public IReadOnlyList<foo> A { get {return a.AsReadOnly();}}
    public IReadOnlyList<foo> B { get {return b.AsReadOnly();}}

}

这样你甚至不需要初始化它，也不需要任何类型的设置

c＃为同一个类实现两个枚举器

2 个答案: