Como você implementaria a interface IEnumerator?

Question

Eu tenho uma classe que mapeia objetos para objetos, mas diferentemente do dicionário, ela mapeia os dois lados.Agora estou tentando implementar uma interface IEnumerator personalizada que itera pelos valores.

public class Mapper<K,T> : IEnumerable<T>, IEnumerator<T>

{
    C5.TreeDictionary<K,T> KToTMap = new TreeDictionary<K,T>();
    C5.HashDictionary<T,K> TToKMap = new HashDictionary<T,K>();

    public void Add(K key, T value)
    {
        KToTMap.Add(key, value);
        TToKMap.Add(value, key);

    }

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


    public K this[T obj]
    {
        get
        {
            return TToKMap[obj];
        }
    }

    public T this[K obj]
    {
        get
        {
            return KToTMap[obj];
        }
    }

    public IEnumerator<T> GetEnumerator()
    {
        return KToTMap.Values.GetEnumerator();
    }

    public T Current
    {
        get { throw new NotImplementedException(); }
    }

    public void Dispose()
    {
        throw new NotImplementedException();
    }

    object System.Collections.IEnumerator.Current
    {
        get { throw new NotImplementedException(); }
    }

    public bool MoveNext()
    {
        ;
    }

    public void Reset()
    {
        throw new NotImplementedException();
    }
}

Answer 1

Primeiro, não faça com que seu objeto de coleção implemente IEnumerator<>.Isso leva a bugs.(Considere a situação em que dois threads estão iterando na mesma coleção).

A implementação correta de um enumerador não é trivial, portanto, o C# 2.0 adicionou suporte de linguagem especial para fazê-lo, com base na instrução 'yield return'.

A recente série de postagens do blog de Raymond Chen ("A implementação de iteradores em C# e suas consequências") é um bom lugar para se atualizar.

• Parte 1: http://blogs.msdn.com/oldnewthing/archive/2008/08/12/8849519.aspx
• Parte 2: http://blogs.msdn.com/oldnewthing/archive/2008/08/13/8854601.aspx
• Parte 3: http://blogs.msdn.com/oldnewthing/archive/2008/08/14/8862242.aspx
• Parte 4: http://blogs.msdn.com/oldnewthing/archive/2008/08/15/8868267.aspx

Answer 2

Basta implementar a interface IEnumerable, não há necessidade de implementar o IEnumerator, a menos que você queira fazer algumas coisas especiais no enumerador, o que para o seu caso não parece ser necessário.

public class Mapper<K,T> : IEnumerable<T> {
    public IEnumerator<T> GetEnumerator()
    {
        return KToTMap.Values.GetEnumerator();
    }
}

e é isso.

Answer 3

CreateEnumerable() retorna um IEnumerable que implementa GetEnumerator()

public class EasyEnumerable : IEnumerable<int> {

    IEnumerable<int> CreateEnumerable() {
        yield return 123;
        yield return 456;
        for (int i = 0; i < 6; i++) {
            yield return i;
        }//for
    }//method

    public IEnumerator<int> GetEnumerator() {
        return CreateEnumerable().GetEnumerator();
    }//method

    IEnumerator IEnumerable.GetEnumerator() {
        return CreateEnumerable().GetEnumerator();
    }//method

}//class

Answer 4

Use retorno de rendimento.

Qual é a palavra-chave yield usada em C#?

Answer 5

Aqui está um exemplo do livro "Algoritmos (4ª Edição) de Robert Sedgewick".

Foi escrito em java e basicamente o reescrevi em C#.

public class Stack<T> : IEnumerable<T>
{
    private T[] array;

    public Stack(int n)
    {
        array = new T[n];
    }

    public Stack()
    {
        array = new T[16];
    }

    public void Push(T item)
    {
        if (Count == array.Length)
        {
            Grow(array.Length * 2);
        }

        array[Count++] = item;
    }

    public T Pop()
    {
        if (Count == array.Length/4)
        {
            Shrink(array.Length/2);
        }

        return array[--Count];
    }

    private void Grow(int size)
    {
        var temp = array;
        array = new T[size];
        Array.Copy(temp, array, temp.Length);
    }

    private void Shrink(int size)
    {
        Array temp = array;
        array = new T[size];
        Array.Copy(temp,0,array,0,size);
    }

    public int Count { get; private set; }
    public IEnumerator<T> GetEnumerator()
    {
        return new ReverseArrayIterator(Count,array);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }


    // IEnumerator implementation
    private class ReverseArrayIterator : IEnumerator<T>
    {
        private int i;

        private readonly T[] array;

        public ReverseArrayIterator(int count,T[] array)
        {
            i = count;
            this.array = array;
        }

        public void Dispose()
        {

        }

        public bool MoveNext()
        {
            return i > 0;
        }

        public void Reset()
        {

        }

        public T Current { get { return array[--i]; } }

        object IEnumerator.Current
        {
            get { return Current; }
        }
    }
}