C＃IEnumerable实现

Question

I don't think I understand IEnumerable and have done several google search.

I'm supposed to make an Container of some objects, where the class Container should handle the updating of the collection the Container represent (add, remove).

the collection Container should be and instance of IEnumerable<element> .

namespace ....
{
    public class Container : Ienumerable<Elements>
    { 
        List<Elements> _elm = new List<Elements>();
        List<Elements> _add = new List<Elements>();
        List<Elements> _rem = new List<Elements>();

        public voic PendAdd(Element elm)
        {
            _add.Add(elm);
        }

        public voic Pendrem(Element elm)
        {
            _rem.remove(elm);
        }

         ...

        public IEnumerator<Element> GetEnumerator()
        {
            return _elm.GetEnumerator();
        }

    }
}

My problem is that IEnumerable<Elements> is an abstract type and if i make _elm this type i can't handle the state of the Container even if i make it

IEnumerable<Element> _elm = new List<Element> ();

VS complains about the error:

'Container' does not implement interface member 'IEnumerable.GetEnumerator()'. 'Container.GetEnumerator()' cannot implement 'IEnumerable.GetEnumerator()' because it does not have the matching return of 'IEnumerator'.

I know that there are several answers about IEnumerable but they do not help me.

Answer 1

You are missing the IEnumerable.GetEnumerator() : IEnumerable<T> inherits from IEnumerable . so in your class you need two distinct GetEnumerator() with two distinct return types.

public class Container : IEnumerable<Element>
{
    List<Element> _elm = new List<Element>();
    List<Element> _add = new List<Element>();
    List<Element> _rem = new List<Element>();

    public void PendAdd(Element elm)
    {
        _add.Add(elm);
    }

    public void Pendrem(Element elm)
    {
        _rem.Remove(elm);
    }

    public IEnumerator<Element> GetEnumerator()
    {
        return _elm.GetEnumerator();
    }

    // This is called "explicit interface implementation", see
    // https://msdn.microsoft.com/en-us/library/ms173157.aspx
    IEnumerator IEnumerable.GetEnumerator()
    {
        // will call the "other" GetEnumerator()
        return GetEnumerator();
    }
}

The next time you have to implement an interface, I suggest you right click on the interface in Visual Studio and select the Implement Interface to get the skeleton of all the methods you need.