Wie kann ich verspotte den Typ IEnumerable<T>, so dass ich testen kann, eine Methode, die es erhält

Habe ich eine Methode, die ich testen will, die erwartet, dass ein IEnumerable<T> als parameter.

Ich bin derzeit Spott der Inhalt der IEnumerable<T> wie folgt (Mit Moq):

 var mockParent = new Mock<ICsvTreeGridExportable>();
 var mockChild = new Mock<ICsvTreeGridExportable>();

Wie er diese verspottet, Objekte innerhalb einer IEnumerable<T> so dass ich übergeben Sie als parameter an die Methode, die ich testen möchte?

Die Methode, die ich Teste zu erhalten erwartet ein IEnumerable<ICsvTreeGridExportable>

InformationsquelleAutor Jamie Dixon | 2009-11-13

20

Ich würde einfach erstellen ein array mit der Auflistung intialiser syntax. also
```
var mockParent = new Mock<ICsvTreeGridExportable>();
var mockChild = new Mock<ICsvTreeGridExportable>();

TestMethod(new[] { mockParent.Object, mockChild.Object });
```
Arrays in .NET-Implementierung der IEnumerable<T> - Schnittstelle, so dass Sie sind alle gesetzt.

Hinweis: Wenn Sie möchten, eine "Reine" IEnumerable<T> (wie Lukas hervorhebt), Sie könnte verwenden Sie ein wenig von LINQ zu tun:
```
TestMethod((new[] { mockParent.Object, mockChild.Object }).TakeWhile(true));
```
- yap... viel einfacher als meine Lösung (+1)
- Noldorin, Wenn Sie ändern, können Sie Ihre Antwort zu haben mockParent.Objekt-und mockChild.Objekt kann ich dann markieren Sie diese als die richtige Antwort. Lukes Antwort unten war auch extrem hilfreich. Schande, ich kann nicht markieren Sie die beiden als angenommen 🙂
- Getan. 🙂
InformationsquelleAutor Noldorin
6

Könnte man einfach ein array erstellen. (Arrays implementieren die IEnumerable<T> - interfaces).
```
var mockEnumerable = new[] { mockParent.Object, mockChild.Object };
```
Wenn Sie wollen ein "reines" IEnumerable<T> können nicht gewirkt werden, wieder in ein array etc, dann könnten Sie es über eine helper-Methode:
```
var mockEnumerable = CreateEnumerable(mockParent.Object, mockChild.Object);

//...

public static IEnumerable<T> CreateEnumerable<T>(params T[] items)
{
    foreach (T item in items)
    {
        yield return item;
    }
}
```
(Jamie erwähnt in den Kommentaren, die Sie verwenden müssen, die verspottet Objekte, nicht die Mock Objekte. Zum Beispiel mockParent.Object, mockChild.Object etc, nicht nur mockParent oder mockChild.)
- Dank Lukas. Wenn ich versuche und gebe meine mockEnumerable der Methode bekomme ich die folgende Fehlermeldung: Argument.Typ 'Moq.Mock<ICsvTreeGridExportable>[] nicht zuordenbar parameter den Typ " IEnumerable<ICsvTreeGridExportable>. Was muss ich tun, um sicherzustellen, dass meine mock objcts sind der richtige Typ?
- Die CreateEnumerable Methode ist genau das, was ich ursprünglich erwogen, aber es hat nicht wirklich irgendeinen Vorteil über ein array. Der compiler generiert eine dummy-Klasse sowieso, also meh. Wenn Sie jedoch möchten, lazy-Initialisierung (siehe sebastian ' s Antwort), kann es nützlich sein.
- Dies gibt mir immer noch das gleiche Problem. Wenn ich IEnumerable<ICsvTreeGridExportable> x = CreateEnumerable(mockParent, mockChild); ich bin immer noch informiert, dass "Cannot convert source type". Man ist der Typ IEnum...<ICsv...> und die andere vom Typ IEnum...<Moq.Mock<ICsv...>. Ich bin sicherlich fehlt etwas sehr einfach hier.
- Mit einem "reinen" enumerable ist praktisch für die Prüfung. Ich habe gesehen, Methoden, Anspruch zu nehmen IEnumerable<T> aber dann blind gewirkt IList<T> oder ähnliches intern. Wenn Sie testen Sie diese Methoden ein array oder eine Liste, dann Sie ' ll-pass, test mit einer "reinen" IEnumerable<T> und finden Sie den Fehler!
- Ich werde schauen, dass später vielleicht, wenn ich eine Zeit habe. Jedenfalls funktioniert meine Lösung nicht genügt?
- Noch nicht begegnet, die mich, aber ich nehme Ihr Wort. Wenn er schreibt, die Methode selbst, sollte es kein problem sein.
- Ok ich habe es herausgefunden mit viel Hilfe von Euch. Was ich tun musste, war fügen Sie verspottet Objekte Objekt des Arrays für die Verwendung in meiner Methode. var mockEnumerable = new[] {mockParent.Objekt, mockChild.Objekt}; -- So bin ich mit mockParent.Objekt statt nur mockParent. Dies wirft nun einen der richtige Typ für meine Methode zu akzeptieren. 🙂
- Ich wollte gerade vorschlagen, versuchen, die. Ich werde aktualisieren, meine Antwort für die Referenz.
InformationsquelleAutor LukeH
1

Sie könnte so etwas wie dies:

Erstellen Sie eine Dummy-Funktion
```
private IEnumerable<ICsvTreeGridExportable> Dummy()
{
     yield return new ICsvTreeGridExportable();
}
```
Und in der test-Funktion ist etwas wie
```
private void TestFunction()
{
   ThisIsTheOneThatNeedsIenumerable(Dummy());
}
```
hoffe es hilft
- Ich denke, er möchte ein IEnumerable von mehr als einem element.
- ja, mit der yield return zurück können Sie so viele wie Sie wollen... ich übersehen, dass...
- In der Tat. Diese Methode könnte allerdings hilfreich sein, wenn Sie wollen, "lazy-Initialisierung", D. H. nur das Objekt erstellen, wenn es benötigt wird.
- Ist das nicht Dummy() - Funktion gehen, um eine nie endende Reihe von Objekten?
- nop... eigentlich ist in dem gegebenen Beispiel würde es einfach nur wieder ein einzelnes Objekt
InformationsquelleAutor sebagomez

List<ICsvTreeGridExportable> myList = new List<ICsvTreeGridExportable>();
myList.Add(mockParent);
myList.Add(mockChild);
return myList;

InformationsquelleAutor Josh Pearce

Hier ist eine alternative zu sebastian ' s Antwort, dass Sie angeben können, wie viele dummies jeglicher Art, die Sie wollen:

private IEnumerable<T> GetDummies<T>(int numDummies) where T : new() {
    for (int i = 0; i < numDummies; i++) yield return new T();
    yield break;
}

Oder (wenn Sie verwenden möchten in der Lage sein zu verwenden, Typen ohne leere Konstruktoren):

private IEnumerable<T> GetDummies<T>(Func<T> generator, int numDummies) {
    for (int i = 0; i < numDummies; i++) yield return generator.Invoke();
    yield break;
}

InformationsquelleAutor Dan Tao

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.