IEnumerable mit einem Array implementieren

Question

Dies ist wahrscheinlich eine einfache Syntax Frage, aber ich kann es nicht herausfinden.

Normalerweise würde ich dies tun:

public class OrderBook : IEnumerable<PriceLevel> 
{ 
    private readonly List<PriceLevel> PriceLevels = new List<PriceLevel>(); 

    public IEnumerator<PriceLevel> GetEnumerator() 
    { 
     return PriceLevels.GetEnumerator(); 
    } 

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

Aber statt einer Liste, ich möchte ein Array verwenden - wie folgt aus:

public class ArrayOrderBook : IEnumerable<PriceLevel> 
{ 
    private PriceLevel[] PriceLevels = new PriceLevel[500]; 

    public IEnumerator<PriceLevel> GetEnumerator() 
    { 
     return PriceLevels.GetEnumerator(); 
    } 

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

Die IEnumerator IEnumerable.GetEnumerator() fein zu kompilieren scheint - aber die Öffentlichkeit IEnumerator<PriceLevel> sagt, dass ich eine Art Besetzung brauche - was ist der beste Weg, dies zu tun?

William

Answer 1

Try this:

public class ArrayOrderBook : IEnumerable<PriceLevel> 
{ 
    private PriceLevel[] PriceLevels = new PriceLevel[500]; 

    public IEnumerator<PriceLevel> GetEnumerator() 
    { 
     return PriceLevels.AsEnumerable().GetEnumerator(); 
    } 

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

Answer 2

Wie Sie aus Ihrer eigenen IEnumerable<T> Implementierung sehen können, müssen Sie sowohl eine generische und nicht-generische Version des Verfahrens, um die Schnittstelle zu erfüllen. Da die Methoden dieselbe Signatur haben, muss eine davon eine explizite Schnittstellenimplementierung sein. Im Fall von List ist die generische Version eine Methode in der Klasse und die nicht-generische Version ist eine explizite Schnittstellendefinition, da die generische Version im Allgemeinen nützlicher ist. Im Fall eines Arrays hatte es bereits die nicht-generische Version als Implementierung und es wurde die generische Version der Methode in einer nachfolgenden Version hinzugefügt. Um die brechende Änderung zu vermeiden, ist die generische Version stattdessen die explizite Schnittstellendefinition.

Es gibt eine Reihe von Möglichkeiten, dieses Problem zu lösen. Hier sind drei einfache.

public IEnumerator<PriceLevel> GetEnumerator() 
{ 
    return PriceLevels.AsEnumerable().GetEnumerator(); 
} 


public IEnumerator<PriceLevel> GetEnumerator() 
{ 
    IEnumerable<PriceLevel> enumerator = PriceLevels; 
    return enumerator.GetEnumerator(); 
} 

public IEnumerator<PriceLevel> GetEnumerator() 
{ 
    return ((IEnumerable<PriceLevel>)PriceLevels).GetEnumerator() 
} 

Answer 3

Guss T[] zum entsprechenden IEnumerable<T>:

public IEnumerator<PriceLevel> GetEnumerator() 
    { 
     return ((IEnumerable<PriceLevel>)PriceLevels).GetEnumerator(); 
    } 

Answer 4

Nach ECMA-335 Partition I, §8.9.1, ein Vektortyp (Array eindimensional wie T[]) implementiert, die IList<T>, dass sie impliziert, implementiert auch IEnumerable<T>. Die Implementierung der Methoden ist jedoch explizit. Sie müssen also eine der folgenden Methoden verwenden:

Option 1: Verwenden Sie einfach die implizite Zuweisung von Arrays zu IList<T>.

private IList<PriceLevel> PriceLevels = new PriceLevel[500]; 

Option 2: Lassen Sie die Member-Variable als Array, und verwenden die Methode AsEnumerable Erweiterung. Diese Erweiterungsmethode verwendet eine unterstützte implizite Zuweisung, die einer direkten Umwandlung wie (IEnumerable<PriceLevel>)PriceLevels vorzuziehen ist.

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

Artikel zu vermeiden:

1. Die Cast<T> Methode stellt eine unnötige Typprüfung für jedes Element Ihres Arrays und sollte vermieden werden.
2. Wenn Sie nur Nicht-Null-Elemente aus der Enumeration einschließen müssen, verwenden Sie die Erweiterungsmethode OfType<T>. Andernfalls führt diese Methode auch eine unnötige Typprüfung für jedes Element ein.