it-swarm.com.de

Verarbeiten Sie eine Liste mit einer Schleife, nehmen Sie jedes Mal 100 Elemente und am Ende der Liste automatisch weniger als 100 Elemente auf

Gibt es eine Möglichkeit, eine Schleife zu verwenden, die die ersten 100 Elemente einer großen Liste enthält, etwas mit ihnen macht, dann die nächsten 100 usw. Wenn sich jedoch das Ende nähert, verkürzt es automatisch den Schritt "100" auf die verbleibenden Elemente.

Momentan muss ich zwei if-Schleifen verwenden: 

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)
    }
}

Gibt es einen besseren Weg, dies zu tun? Wenn nicht, werde ich das "Ding" zumindest zu einer Funktion machen, damit der Code nicht zweimal kopiert werden muss.

15
SecondLemon

Sie können LINQ Skip und Take verwenden und Ihr Code wird sauberer.

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

Hinweis: Wenn die Elemente weniger als 100 sind, würde Take die restlichen Elemente ergeben.

33
adricadar

Sie können eine explizite Variable für den Endpunkt beibehalten:

for (int i = 0, j; i < listLength; i = j)
{
    j = Math.min(listLength, i + 100);
    // do your thing with bigList.GetRange(i, j)
}
4
Ted Hopp
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
    }
1
user3476093

Ich mochte keine der aufgeführten Antworten. Daher habe ich meine eigene Erweiterung erstellt:

public static class IEnumerableExtensions
{
    public static IEnumerable<IEnumerable<T>> MakeGroupsOf<T>(this IEnumerable<T> source, int count)
    {
        var grouping = new List<T>();
        foreach (var item in source)
        {
            grouping.Add(item);
            if(grouping.Count == count)
            {
                yield return grouping;
                grouping = new List<T>();
            }
        }

        if (grouping.Count != 0)
        {
            yield return grouping;
        }
    }
}

Dann kannst du es benutzen:

foreach(var group in allItems.MakeGroupsOf(100))
{
    // Do something
}
0
Kyle W

sie können auch versuchen, wie folgt vorzugehen:

        int i = 1;
        foreach (item x in bigList)
        {

            batchOperation.Insert(x); //replace it with your action; create the batch
            i++;
            if (i >100)
            {
                table.ExecuteBatch(batchOperation); //execute the batch
                batchOperation.Clear();
                i = 1; // re-initialize 
            }

        }

        if (batchOperation.Count >= 1 )
        {
            table.ExecuteBatch(batchOperation); //do this for the residue items 
        }
0
nabanita