Al pasar un argumento IEnumerable vacío a un método

Question

tengo este método (simplificada):

void DoSomething(IEnumerable<int> numbers); 

e invoco así:

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

La variable results se forma con un seleccione condición LINQ (IEnumerable).

Me preguntaba ¿es este List<int>() la mejor manera (el más rápido?) Para pasar una colección vacía, o es new int[0] mejor? ¿O algo más sería más rápido, un Collection, etc.? En mi ejemplo null no estaría bien.

Answer 1

que haría uso de Enumerable.Empty<int>()

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

Answer 2

@ avance70. Realmente no es una respuesta a la pregunta original, sino una respuesta a la pregunta de avance70 sobre un IEnumerable con solo 1 valor entero. Lo habría agregado como comentario, pero no tengo suficientes representantes para agregar un comentario. Si usted está interesado en una secuencia estrictamente inmutable, que tiene un par de opciones:

método de extensión genérico:

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

uso como esto:

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

o esto:

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

o esto:

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 
} 

Hace poco tuve un caso como el ejemplo de inicio/fin anterior donde tuve que "extraer" valores consecutivos de una secuencia (usando Omitir y Tomar) y luego anteponer y anexar los valores de inicio y fin. Los valores de inicio y fin se interpolaron entre el último valor no extraído y el primer valor extraído (para el inicio) y entre el último valor extraído y el primer valor no extraído (para el final). La secuencia resultante fue operada nuevamente, posiblemente revertida.

lo tanto, si secuencia original parecía:

que podría tener que extraer 3 y 4 y añadir valores interpolados entre 2 y 3 y 4 y 5:

2,5 3 4 4,5

Enumerable.Repeat. Utilice la siguiente manera:

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

Por supuesto, ya que estos son IEnumerables, también se pueden utilizar en combinación con otras operaciones IEnumerable. No estoy seguro si estas ideas son realmente "buenas" o no, pero deberían hacer el trabajo.