Passando un argomento IEnumerable vuoto ad un metodo

Question

ho questo metodo (semplificato):

void DoSomething(IEnumerable<int> numbers); 

E invoco così:

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

La variabile results è formato con una seleziona condizione LINQ (IEnumerable).

Mi chiedevo è questo List<int>() il modo migliore (il più veloce?) Per passare una raccolta vuota, o è meglio new int[0]? Oppure qualcos'altro sarebbe più veloce, un Collection, ecc.? Nel mio esempio null non sarebbe ok.

Answer 1

userei Enumerable.Empty<int>()

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

Answer 2

@ avance70. Non proprio una risposta alla domanda originale, ma una risposta alla domanda di avance70 su un oggetto IEnumerable con solo 1 valore intero. Lo avrei aggiunto come commento, ma non ho abbastanza rep per aggiungere un commento. Se siete interessati in una sequenza rigorosamente immutabile, si dispone di un paio di opzioni:

metodo di estensione generico:

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

Usa come questo:

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

o questo:

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

o questo:

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 
} 

Recentemente ho avuto un caso come l'esempio di inizio/fine sopra in cui ho dovuto "estrarre" i valori consecutivi da una sequenza (utilizzando Skip e Take) e quindi anteporre e aggiungere i valori di inizio e fine. I valori iniziale e finale sono stati interpolati tra l'ultimo valore non estratto e il primo valore estratto (per l'inizio) e tra l'ultimo valore estratto e il primo valore non estratto (per il fine). La sequenza risultante è stata quindi riattivata, eventualmente invertendo.

Quindi, se sequenza originale sembrava:

avrei potuto estrarre 3 e 4 e aggiungere i valori interpolati tra il 2 e il 3 e 4 e 5:

2.5 3 4 4.5

Enumerable.Repeat. Usare in questo modo:

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

Naturalmente, poiché si tratta di IEnumerables, possono essere utilizzati anche in combinazione con altre operazioni IEnumerable. Non sono sicuro che queste siano idee "buone" o meno, ma dovrebbero portare a termine il lavoro.