在泛型类中实现多个迭代器-C＃-IEnumerable（T）

Question

In the following class, I have implemented succesfully IEnumerable(T) in order to iterate through T. In the same class I was able to implement IEnumerable(DLLItem(T)) to iterate through DLLItem(T). Both are working independantkly. It's probably a basic question. What should I do to have both iterators working together in the same class ? I've tried several possibilities getting always compiler errors...

With IEnumerable(T)

public class DLL<T> :   IEnumerable<T>
{
    ...
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
    public IEnumerator<T> GetEnumerator()
    {
    ...
        yield return ...
    ...
    }
    ...
}

with IEnumerable(DLLItem(T))

public class DLL<T> :   IEnumerable<DLLItem<T>>
{
    ...
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
    public IEnumerator<DLLItem<T>> GetEnumerator()
    {
    ...
        yield return ...
    ...
    }
    ...
}

In advance, thanks for your support...

---

Solution as suggested by @dasblinkenlight (see below)

---

public class DLLItemEnum<T> : IEnumerable<DLLItem<T>>
{
    DLL<T> dll;
    public DLLItemEnum(DLL<T> d)
    {
        dll = d;
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
    public IEnumerator<DLLItem<T>> GetEnumerator()
    {
        ...
            yield return ...
        ...
    }
    public static explicit operator DLLItemEnum<T>(DLL<T> d)
    {
        DLLItemEnum<T> i = new DLLItemEnum<T>(d);
        return i;
    }
}
public class ItemEnum<T> : IEnumerable<T>
{
    DLL<T> dll;
    public ItemEnum(DLL<T> d)
    {
        dll = d;
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
    public IEnumerator<T> GetEnumerator()
    {
        ...
            yield return ...
        ...
    }
    public static explicit operator ItemEnum<T>(DLL<T> d)
    {
        ItemEnum<T> i = new ItemEnum<T>(d);
        return i;
    }

public class DLL<T> 
{
     ...
}
class Test
{
    static void Main(string[] args)
    {
        ...
        foreach (int i in (ItemEnum<int>)z)
            Console.WriteLine(i);
        foreach (DLLItem<int> i in (DLLItemEnum<int>)z)
           Console.WriteLine(i.Data);
        ...
    }
}

Answer 1

It's possible, but it will be messy to use.

You have to implement both the IEnumerable<DLLItem<T>> and IEnumerable<T> interfaces:

public class DLL<T> :   IEnumerable<DLLItem<T>>, IEnumerable<T>

The GetNumerator methods will collide, so you would have to resort to explicit interface implemenation, which forces the caller to cast the object to the right interface type before accessing the enumerator:

var dllItems = ((IEnumerable<DLLItem<T>>)someDll);
var Ts = ((IEnumerable<T>)someDll);

My recommendation is to not go that way. Instead expose properties for one or both of the enumerators. Look for example at the Dictionary<TKey, TValue> class. It implements IEnumerator<KeyValuePair<TKey, TValue>> and exposes a Values property of type IEnumerable<TValue> and a Keys property of type IEnumerable<TKey> .

Answer 2

Since IEnumerable.GetEnumerator() is shared among all generic IEnumerable objects, you cannot implement them both in the same class. You have two options in making it work:

• Provide two properties, EnumerableItem and EnumerableDllItem , that produce different iterator objects, the way suggested in this answer , or
• Make separate IEnumerable classes - ItemEnumerable<T> and DllItemEnumerable<T> . Do not implement IEnumerable in DLL<T> at all, and provide two conversion operator from DLL<T> to ItemEnumerable<T> and to DllItemEnumerable<T> . Users would be able to decide on what iterator to use by inserting a cast.

Answer 3

In general prefer composition over inheritance.

The following class is easy to ceate and to use:

public class DLL<T> : IEnumerable<T>
{
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public IEnumerator<T> GetEnumerator()
    {
        throw new NotImplementedException("Need to implement");
    }

    // Compose, not inherit
    public IEnumerable<DLLItem<T>> DLLItems
    {
        get
        {
            throw new NotImplementedException("Need to implement");
        }
    }
}