cómo puedo verificar si una entidad es el primer elemento de un bucle foreach

Question

Digamos que tengo un bucle foreach.

Tengo que hacer algo con el primer objeto del ciclo que no tengo que ver con ninguno de los otros objetos.

Cómo verifico si el elemento que está actualmente en el ciclo es el primer objeto.

Answer 1

Hay varias maneras que usted podría hacer eso.

1. utilizar un bucle en lugar
2. Establecer una bandera booleana
3. utilizar LINQ para obtener el list.First() y luego foreach sobre list.Skip (1)

Answer 2

Algo como esto:

bool first = true; 

foreach(var item in items) 
{ 
    if (first) 
    { 
     item.firstStuff(); 
     first = false; 
    } 
    item.otherStuff(); 
} 

Answer 3

bool first = true; 
foreach(var foo in bar) 
{ 
    if (first) 
    { 
    // do something to your first item 
    first = false; 
    } 
    // do something else to the rest 
} 

Answer 4

No se puede pensar en otra cosa que

var processedFirst = false; 
foreach(var x in items) { 
    if(!processedFirst) { 
     ProcessFirst(x); 
     processedFirst = true; 
    } 

Answer 5

Aquí hay una solución performant:

using (var erator = enumerable.GetEnumerator()) 
{ 
    if (erator.MoveNext()) 
    { 
     DoActionOnFirst(erator.Current); 

     while (erator.MoveNext()) 
      DoActionOnOther(erator.Current); 
    } 
} 

EDIT: Y aquí hay una LINQ uno:

if (enumerable.Any()) 
    { 
     DoActionOnFirst(enumerable.First()); 

     foreach (var item in enumerable.Skip(1)) 
      DoActionOnOther(item); 
    } 

EDIT: Si las acciones en los artículos tienen firmas asignables a Func<TItem, TResult>, que puede hacer:

enumerable.Select((item, index) => index == 0 ? GetResultFromFirstItem(item) : GetResultFromOtherItem(item)); 

Answer 6

prueba este

bool IsFirst = true; 

foreach(DataRow dr in dt.Rows) 
{ 
    if (IsFirst) 
    { 
     // do some thing 
     IsFirst = false; 
    }  
} 

Answer 7

Esto es más que una solución general para obtener el índice junto con cada objeto en una matriz. Debería probar las pruebas si es la primera.

 List<String> entries = new List<string>(); 
     entries.Add("zero"); 
     entries.Add("one"); 
     entries.Add("two"); 

     Dictionary<int, String> numberedEntries = new Dictionary<int, string>(); 
     int i = 0; 
     entries.ForEach(x => numberedEntries.Add(i++, x)); 
     foreach (KeyValuePair<int, String> pair in numberedEntries) { 
      Console.WriteLine(pair.Key + ": " + pair.Value); 
     } 

En esta configuración, la clave de la KeyValuePair es el índice y el valor es el objeto en ese índice, en mi ejemplo una cadena, pero cualquier objeto fuera colocado allí. Agrega un poco de sobrecarga, pero puede usarse para determinar cualquier objeto en el índice de la lista cuando sea necesario.

Answer 8

me gusta la forma en LINQ, pero sin el salto (1), de esta manera también se puede utilizar para el último elemento de la lista y su código permanece en mi humilde opinión limpia :)

foreach(var item in items) 
{ 
    if (items.First()==item) 
     item.firstStuff(); 

    else if (items.Last() == item) 
     item.lastStuff(); 

    item.otherStuff(); 
}