Problèmes de suppression d'éléments d'une liste lors de l'itération dans la liste

J'ai une boucle qui parcourt les éléments dans une liste. Je suis dans l'obligation de supprimer des éléments de cette liste à l'intérieur de la boucle en fonction de certaines conditions. Quand j'essaie de le faire en C#, j'obtiens une exception. apparemment, il n'est pas autorisé à supprimer des éléments de la liste qui est en cours d'itérer. Le problème a été observé avec une boucle foreach. Est-il un standard moyen de contourner ce problème?

Remarque : Une seule solution, je pense à créer une copie de la liste uniquement pour l'itération but et de supprimer des éléments de la liste initiale à l'intérieur de la boucle. Je suis à la recherche d'une meilleure façon de traiter cette question.

source d'informationauteur

  1. 14

    Lors de l'utilisation de List<T> la ToArray() méthode permet dans ce scénario très:

    List<MyClass> items = new List<MyClass>();
foreach (MyClass item in items.ToArray())
{
    if (/* condition */) items.Remove(item);
}

    L'alternative est d'utiliser une boucle for à la place d'un foreach, mais ensuite, vous avez à décrémenter la variable d'index à chaque fois que vous supprimez un élément, c'est à dire

    List<MyClass> items = new List<MyClass>();
for (int i = 0; i < items.Count; i++)
{
    if (/* condition */)
    {
        items.RemoveAt(i);
        i--;
    }
}
  2. 13

    Si votre liste est une réelle List<T> ensuite, vous pouvez utiliser le haut- RemoveAll méthode pour supprimer les éléments en fonction d'un prédicat:

    int numberOfItemsRemoved = yourList.RemoveAll(x => ShouldThisItemBeDeleted(x));
  3. 5

    Vous pouvez utiliser entier d'indexation pour supprimer des éléments:

    List<int> xs = new List<int> { 1, 2, 3, 4 };
for (int i = 0; i < xs.Count; ++i)
{
    //Remove even numbers.
    if (xs[i] % 2 == 0)
    {
        xs.RemoveAt(i);
        --i;
    }
}

    Cela peut être bizarre à lire et difficile à maintenir, même si, surtout si la logique de la boucle est plus complexe.

  4. 4

    Vous pouvez utiliser LINQ pour remplacer la liste initiale par une nouvelle liste par le filtrage des éléments:

    IEnumerable<Foo> initialList = FetchList();
initialList = initialList.Where(x => SomeFilteringConditionOnElement(x));
//Now initialList will be filtered according to the condition
//The filtered elements will be subject to garbage collection

    De cette façon, vous n'avez pas à vous soucier de boucles.

  5. 2

    Une autre astuce est de faire une boucle par la liste vers l'arrière.. la suppression d'un élément à ne pas avoir d'incidence sur les éléments que vous allez rencontrer dans le reste de la boucle.

    Je ne recommande pas de cela ou d'autre chose, bien que. Tout ce dont vous avez besoin pour peut probablement être réalisée à l'aide de LINQ déclarations pour filtrer la liste de vos exigences.

  6. 1

    La solution recommandée est de mettre tous vos éléments que vous souhaitez supprimer dans une liste séparée et après la première boucle, mettre une deuxième boucle où vous parcourez les supprimer-la liste et supprimer ces éléments forment la première liste.

  7. 0

    La raison pour laquelle vous obtenez une erreur est parce que vous êtes à l'aide d'une boucle foreach. Si vous pensez à la façon d'une boucle foreach fonctionne ce sens. La boucle foreach appelle la méthode GetEnumerator sur la Liste. Si l'endroit où vous pouvez modifier le nombre d'éléments dans la Liste, l'Énumérateur la boucle foreach est titulaire ne serait pas le bon nombre d'éléments. Si vous avez supprimé un élément null erreur d'exception sera levée, et si vous avez ajouté un élément de la boucle de manquer d'un élément.

    Si vous aimez Linq et Lamda expressions je recommanderais Darin Dimitrov solution, sinon j'aurais l'utilisation de la solution fournie par Chris Schmich.

  8. 0

    Vous pouvez parcourir avec un foreach de cette façon:

    List<Customer> custList = Customer.Populate();

foreach (var cust in custList.ToList())

{

        custList.Remove(cust);

}

    Remarque: ToList sur la liste de variable, il parcourt la liste créé par l'ToList mais supprime les éléments de la liste initiale.

    Espère que cette aide.