Wie Interface-Implementierung auf andere Klasse in C#

Question

Nehmen wir die folgende Klasse delegieren. Ist es jedoch möglich, die Implementierung für IEnumerator direkt an _myList zu delegieren oder umzuleiten, ohne die IEnumerator-Methoden implementieren zu müssen?

Answer 1

Methode 1: Verwenden Sie weiterhin die Kapselung und leiten Sie Aufrufe an die List-Implementierung weiter.

class SomeObject 
{ 
} 

class MyEnum : IEnumerable<SomeObject> 
{ 
    private List<SomeObject> _myList = new List<SomeObject>(); 

    public void Add(SomeObject o) 
    { 
     _myList.Add(o); 
    } 

    public IEnumerator<SomeObject> GetEnumerator() 
    { 
     return _myList.GetEnumerator(); 
    } 

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

class Program 
{ 
    static void Main(string[] args) 
    { 
     MyEnum a = new MyEnum(); 
     a.Add(new SomeObject()); 

     foreach (SomeObject o in a) 
     { 
      Console.WriteLine(o.GetType().ToString()); 
     } 

     Console.ReadLine(); 
    } 
} 

Methode 2: vererben Liste Implementierung Sie dieses Verhalten kostenlos.

class SomeObject 
{ 
} 

class MyEnum : List<SomeObject> 
{ 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     MyEnum a = new MyEnum(); 
     a.Add(new SomeObject()); 

     foreach (SomeObject o in a) 
     { 
      Console.WriteLine(o.GetType().ToString()); 
     } 

     Console.ReadLine(); 
    } 
} 

Methode 1 ermöglicht eine bessere Sandbox, da es keine Methode, die ohne MyEnum Wissen in Liste aufgerufen werden. Für den geringsten Aufwand wird Methode 2 bevorzugt.

Answer 2

Nicht, wenn Sie nicht von der Liste < T> abgeleitet sind.

public class MyEnum : List<SomeObject>, IEnumerable<SomeObject>{} 

Answer 3

Sie können dies tun:

public class MyEnum : IEnumerator { 
    private List<SomeObject> _myList = new List<SomeObject>(); 
    public IEnumerator GetEnumerator() { return this._myList.GetEnumerator(); } 
} 

Der Grund ist einfach. Ihre Klasse kann mehrere Felder enthalten, die Sammlungen sind, so dass der Compiler/die Umgebung nicht wissen kann, welches Feld für die Implementierung von "IEnumerator" verwendet werden soll.

EIDT: ich mit @pb einverstanden - Sie IEnumerator <Someobject> Schnittstelle implementiert sollte.

Answer 4

Wenn Sie Rückkehr in einer Weise, eine Sammlung wollen, wo der Anrufer nicht in der Lage ist, die Sammlung zu ändern, könnten Sie die Liste in eine Readonlycollection < wickeln wollen> und Rückkehr IEnumerable <> der Readonlycollection <>.

Auf diese Weise können Sie sicher sein, dass Ihre Sammlung nicht geändert wird.

Answer 5

Abgesehen von der Verwendung der Methode von pb ist dies aus einem "einfachen" Grund nicht möglich: Die Schnittstellenmethode muss einen this Zeiger als erstes Argument übergeben bekommen. Wenn Sie GetEnumerator auf Ihrem Objekt aufrufen, wird dieser Zeiger Ihr Objekt sein. Damit der Aufruf an der verschachtelten Liste funktioniert, müsste der Zeiger jedoch ein Verweis auf diese Liste und nicht auf Ihre Klasse sein.

Daher müssen Sie die Methode explizit an das andere Objekt delegieren.

(Und übrigens, die Beratung in der anderen Antwort war richtig: Verwenden Sie IEnumerator<T>, nichtIEnumerable!)

Answer 6

Vielen Dank für Ihre Eingabe und Erklärungen. Schließlich habe ich einige Ihrer Antworten kombiniert, um die folgenden:

class MyEnum : IEnumerable<SomeObject> 
{ 
    private List<SomeObject> _myList = new List<SomeObject>(); 
    public IEnumerator<SomeObject> GetEnumerator() 
    { 
     // Create a read-only copy of the list. 
     ReadOnlyCollection<CustomDevice> items = new ReadOnlyCollection<CustomDevice>(_myList); 
     return items.GetEnumerator(); 
    } 
} 

Diese Lösung ist der aufrufende Code nicht in der Lage ist, um sicherzustellen, um die Liste der Modifizierung und jeder Enumerator ist unabhängig von den anderen in jeder Hinsicht (zB mit Sortierung) . Danke nochmal.

Answer 7

Beachten Sie, dass dank duck-typing Sie foreach auf ein beliebiges Objekt verwenden können, die eine GetEnumerator Methode hat - der Objekttyp nicht wirklich IEnumerable implementieren muss.

Also, wenn Sie dies tun:

class SomeObject 
{ 
} 

class MyEnum 
{ 
    private List<SomeObject> _myList = new List<SomeObject>(); 

    public IEnumerator<SomeObject> GetEnumerator() 
    { 
     return _myList.GetEnumerator(); 
    } 
} 

Dann funktioniert das ganz gut:

MyEnum objects = new MyEnum(); 
// ... add some objects 
foreach (SomeObject obj in objects) 
{ 
    Console.WriteLine(obj.ToString()); 
}