ein leeres IEnumerable Argument auf ein Verfahren

Question

Passing habe ich diese Methode (vereinfacht):

void DoSomething(IEnumerable<int> numbers); 

und ruf es wie folgt:

DoSomething(condition==true?results:new List<int>()); 

Die Variablen results mit einer LINQ wählt Bedingung gebildet (IEnumerable).

Ich frage mich, ist das List<int>() der beste Weg (der schnellste?), Um eine leere Sammlung zu übergeben, oder ist new int[0] besser? Oder etwas anderes wäre schneller, ein Collection, etc.? In meinem Beispiel wäre null nicht in Ordnung.

Answer 1

würde ich Enumerable.Empty<int>()

DoSometing(condition ? results : Enumerable.Empty<int>()); 

Answer 2

@ avance70 verwenden. Nicht wirklich eine Antwort auf die ursprüngliche Frage, sondern eine Antwort auf Avance70s Frage nach einem IEnumerable mit nur einem Integer-Wert. Ich hätte es als Kommentar hinzugefügt, aber ich habe nicht genug Rep, um einen Kommentar hinzuzufügen. Wenn Sie Interesse an einer streng unveränderlichen Reihenfolge sind, haben Sie ein paar Optionen:

Generika-Extension-Methode:

public static IEnumerable<T> ToEnumerable<T>(this T item) 
{ 
    yield return item; 
} 

Verwendung wie folgt aus:

foreach (int i in 10.ToEnumerable()) 
{ 
    Debug.WriteLine(i); //Will print "10" to output window 
} 

oder dies:

int x = 10; 
foreach (int i in x.ToEnumerable()) 
{ 
    Debug.WriteLine(i); //Will print value of i to output window 
} 

oder dieses:

int start = 0; 
int end = 100; 
IEnumerable<int> seq = GetRandomNumbersBetweenOneAndNinetyNineInclusive(); 

foreach (int i in start.ToEnumerable().Concat(seq).Concat(end.ToEnumerable())) 
{ 
    //Do something with the random numbers, bookended by 0 and 100 
} 

Ich hatte kürzlich einen Fall wie das oben genannte Beispiel zum Anfang/Ende, wo ich aufeinanderfolgende Werte aus einer Sequenz "extrahieren" musste (mit Skip und Take) und dann Anfangs- und Endwerte voranstellte und anfügte. Die Start- und Endwerte wurden zwischen dem letzten nicht extrahierten Wert und dem ersten extrahierten Wert (für Start) und zwischen dem letzten extrahierten Wert und dem ersten nicht extrahierten Wert (für Ende) interpoliert. Die resultierende Sequenz wurde dann erneut betrieben, möglicherweise reversierend.

Also, wenn Originalsequenz ausgesehen:

Ich habe bis 3 extrahieren könnte und 4 und interpolierten Werte zwischen 2 addieren und 3 sowie 4 und 5:

2.5 3 4 4.5

Enumerable.Repeat. Verwenden Sie wie folgt aus:

foreach (int i in Enumerable.Repeat(10,1)) //Repeat "10" 1 time. 
{ 
    DoSomethingWithIt(i); 
} 

Natürlich, da diese sind IEnumerables, können sie auch in Verbindung mit anderen IEnumerable Operationen verwendet werden. Nicht sicher, ob das wirklich "gute" Ideen sind oder nicht, aber sie sollten den Job erledigen.