decreciente - C#- ¿Se llama a la función para cada iteración de un bucle foreach?

foreach c#

Question

Posible duplicado:
¿Cómo funciona foreach cuando se recorren los resultados de la función?

Si tengo una funcionalidad como la siguiente: ¿se llamará a ReturnParts () para cada iteración en un bucle foreach o se llamará solo una vez?

private void PrintParts()
{
foreach(string part in ReturnParts())
{
// Do Something or other.
}
}
private string[] ReturnParts()
{
// Build up and return an array.
}

Answer 1

Al preguntarme las diferencias entre for, foreach, while y goto hace unas semanas, escribí este código de prueba. Todos los métodos se compilarán en la misma IL (además de un nombre de variable en la versión foreach). En el modo de depuración, algunas declaraciones NOP estarán en diferentes posiciones.

static void @for<T>(IEnumerable<T> input)
{
T item;
using (var e = input.GetEnumerator())
for (; e.MoveNext(); )
{
item = e.Current;
Console.WriteLine(item);
}
}
static void @foreach<T>(IEnumerable<T> input)
{
foreach (var item in input)
Console.WriteLine(item);
}
static void @while<T>(IEnumerable<T> input)
{
T item;
using (var e = input.GetEnumerator())
while (e.MoveNext())
{
item = e.Current;
Console.WriteLine(item);
}
}
static void @goto<T>(IEnumerable<T> input)
{
T item;
using (var e = input.GetEnumerator())
{
goto check;
top:
item = e.Current;
Console.WriteLine(item);
check:
if (e.MoveNext())
goto top;
}
}
static void @gotoTry<T>(IEnumerable<T> input)
{
T item;
var e = input.GetEnumerator();
try
{
goto check;
top:
item = e.Current;
Console.WriteLine(item);
check:
if (e.MoveNext())
goto top;
}
finally
{
if (e != null)
e.Dispose();
}
}

Per @ el comentario de Eric ...

Me he expandido for , while , ''goto'' y foreach con matrices genéricas. Ahora el aspecto for each instrucción usa el indexador para la matriz. Las matrices de objetos y las cadenas se expanden de manera similar. Los objetos eliminarán un boxeo que ocurra antes de que el método llame a Console.WriteLine y Strings reemplazarán el T item T[] copy... y T[] copy... con el char item y string copy... respectivamente. Tenga en cuenta que la sección crítica ya no es necesaria porque el enumerador desechable ya no se usa.

static void @for<T>(T[] input)
{
T item;
T[] copy = input;
for (int i = 0; i < copy.Length; i++)
{
item = copy[i];
Console.WriteLine(item);
}
}
static void @foreach<T>(T[] input)
{
foreach (var item in input)
Console.WriteLine(item);
}
static void @while<T>(T[] input)
{
T item;
T[] copy = input;
int i = 0;
while (i < copy.Length)
{
item = copy[i];
Console.WriteLine(item);
i++;
}
}
static void @goto<T>(T[] input)
{
T item;
T[] copy = input;
int i = 0;
goto check;
top:
item = copy[i];
Console.WriteLine(item);
i++;
check:
if (i < copy.Length)
goto top;
}

Answer 2

Puede determinar esto usted mismo colocando un punto de interrupción en la función "ReturnParts". Si se trata de tiempos de mutliple para cada iteración, entonces sí lo hace.

Answer 3

Sólo se llamará una vez.

El bucle foreach es equivalente al siguiente código:

IEnumerable<string> enumerator = (collection).GetEnumerator();
try {
while (enumerator.MoveNext()) {
string part = (string)enumerator.Current;
// Do Something or other.
}
} finally {
IDisposable disposable = enumerator as System.IDisposable;
if (disposable != null) disposable.Dispose();
}

Answer 4

Se llamará una sola vez.

PS Llamarlo varias veces tendría poco sentido. Lo volvería a llamar cada vez que esperara que el resultado fuera diferente cada vez. ¿Y cómo iterarías en un conjunto que cambia continuamente?