Traiter une liste avec une boucle, en prenant 100 éléments à chaque fois et automatiquement moins de 100 à la fin de la liste

Est-il un moyen d'utiliser une boucle qui prend le premier 100 articles dans une grande liste, fait quelque chose avec eux, puis les 100 prochaines etc, mais quand il s'approche de la fin automatiquement réduit le "100" étape pour les éléments restants.

Actuellement, je utiliser deux si les boucles: 

for (int i = 0; i < listLength; i = i + 100)
{
    if (i + 100 < listLength)
    {
        //Does its thing with a bigList.GetRange(i, 100)
    }
    else
    {
        //Does the same thing with bigList.GetRange(i, listLength - i)
    }
}

Est-il une meilleure manière de faire ceci? Si non je vais au moins faire la "chose", une fonction de sorte que le code ne doit pas être copié deux fois.

source d'informationauteur SecondLemon

  1. 27

    Vous pouvez utiliser LINQ Ignorer et et votre code sera plus propre.

    for (int i = 0; i < listLength; i=i+100)
{
    var items = bigList.Skip(i).Take(100); 
    //Do something with 100 or remaining items
}

    Remarque: Si les éléments sont de moins de 100 Take serait vous donner le reste.

  2. 3

    Vous pouvez garder un explicite des variables pour le point de fin:

    for (int i = 0, j; i < listLength; i = j)
{
    j = Math.min(listLength, i + 100);
    //do your thing with bigList.GetRange(i, j)
}
  3. 1
    List<int> list = null;
int amount_of_hundreds = Math.Floor(list.Count/100);
int remaining_number = list.Count - (amount_of_hundreds * 100);

for(int i = 0; i < amount_of_hundreds; ++i)
    {
    for(int j = 0; j < 100; ++j)
        {
        int item = list[(i * 100) + j];
        //do what you want with item
        }
    }

 for(int i = 0; i < remaining_number; ++i)
    {
    int item = list[(amount_of_hundreds * 100) + i];
    //do what you want with item
    }