Як видалити елементи із загального списку під час ітерації над ним?

Я шукаю кращу схему роботи зі списком елементів, які кожен потребує обробці, а потім залежно від результату видаляються зі списку.

Ви не можете використовувати .Remove(element)всередині foreach (var element in X)(бо це призводить до Collection was modified; enumeration operation may not execute.виключенню) ... Ви також не можете використовувати for (int i = 0; i < elements.Count(); i++)і .RemoveAt(i)тому що він руйнує вашу поточну позицію в колекції щодо i.

Чи є елегантний спосіб це зробити?

Ітерації списку зворотно циклом for:

for (int i = safePendingList.Count - 1; i >= 0; i--)
{
    // some code
    // safePendingList.RemoveAt(i);
}

Приклад:

var list = new List<int>(Enumerable.Range(1, 10));
for (int i = list.Count - 1; i >= 0; i--)
{
    if (list[i] > 5)
        list.RemoveAt(i);
}
list.ForEach(i => Console.WriteLine(i));

Крім того, ви можете використовувати метод RemoveAll з присудком для перевірки на:

safePendingList.RemoveAll(item => item.Value == someValue);

Ось спрощений приклад для демонстрації:

var list = new List<int>(Enumerable.Range(1, 10));
Console.WriteLine("Before:");
list.ForEach(i => Console.WriteLine(i));
list.RemoveAll(i => i > 5);
Console.WriteLine("After:");
list.ForEach(i => Console.WriteLine(i));

Просте і зрозуміле рішення:

Використовуйте стандартний цикл для циклу, який працює назад, і RemoveAt(i)видаліть елементи.

Зворотна ітерація повинна бути першою, що вам прийде в голову, коли ви хочете видалити елементи з колекції під час ітерації над нею.

На щастя, існує більш елегантне рішення, ніж написання циклу для циклу, який передбачає непотрібне введення тексту та може бути схильним до помилок.

ICollection<int> test = new List<int>(new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10});

foreach (int myInt in test.Reverse<int>())
{
    if (myInt % 2 == 0)
    {
        test.Remove(myInt);
    }
}

 foreach (var item in list.ToList()) {
     list.Remove(item);
 }

Якщо ви додасте ".ToList ()" до свого списку (або результати запиту LINQ), ви можете видалити "елемент" безпосередньо зі "списку" без страшного " Колекція була змінена; операція перерахування може не виконати ." помилка. Компілятор робить копію "списку", так що ви можете сміливо робити видалення з масиву.

Хоча ця модель не надто ефективна, вона має природне відчуття і є досить гнучкою для майже будь-якої ситуації . Наприклад, коли ви хочете зберегти кожен "елемент" у БД та видалити його зі списку лише тоді, коли збереження БД вдалося.

Виберіть потрібні елементи , а не намагайтеся видалити елементи, які ви не хочете. Це набагато простіше (і взагалі більш ефективно), ніж видаляти елементи.

var newSequence = (from el in list
                   where el.Something || el.AnotherThing < 0
                   select el);

Я хотів опублікувати це як коментар у відповідь на коментар, залишений Майклом Діллоном нижче, але це занадто довго і, напевно, корисно мати у своїй відповіді все одно:

Особисто я ніколи не видаляв елементи один за одним, якщо вам потрібно видалення, тоді дзвоніть, RemoveAllякий має предикат і лише один раз переставляє внутрішній масив, тоді як Removeвиконує Array.Copyоперацію з кожним видаленим вами елементом. RemoveAllнабагато ефективніше.

І коли ви переймете назад за списком, у вас вже є індекс елемента, який ви хочете видалити, тому було б набагато ефективніше дзвонити RemoveAt, оскількиRemove спочатку робиться обхід списку, щоб знайти індекс елемента, який ви Ви намагаєтесь видалити, але ви вже знаєте цей індекс.

Так що загалом я не бачу причин ніколи телефонувати Remove в циклі for. І в ідеалі, якщо це взагалі можливо, використовуйте вищевказаний код, щоб струмувати елементи зі списку за необхідністю, щоб взагалі не створювати другу структуру даних.

Використання ToArray () у загальному списку дозволяє зробити Remove (елемент) у вашому загальному списку:

        List<String> strings = new List<string>() { "a", "b", "c", "d" };
        foreach (string s in strings.ToArray())
        {
            if (s == "b")
                strings.Remove(s);
        }

Використання .ToList () зробить копію вашого списку, як це пояснено в цьому запитанні: ToList () - чи створює новий список?

Використовуючи ToList (), ви можете видалити зі свого оригінального списку, оскільки ви насправді переглядаєте копію.

foreach (var item in listTracked.ToList()) {    

        if (DetermineIfRequiresRemoval(item)) {
            listTracked.Remove(item)
        }

     }

Якщо функція, яка визначає, які елементи для видалення не має побічних ефектів, і не мутує елемент (це чиста функція), просте та ефективне (лінійний час) рішення:

list.RemoveAll(condition);

Якщо є побічні ефекти, я б використав щось на кшталт:

var toRemove = new HashSet<T>();
foreach(var item in items)
{
     ...
     if(condition)
          toRemove.Add(item);
}
items.RemoveAll(toRemove.Contains);

Це ще лінійний час, якщо припустити, що хеш хороший. Але у нього збільшується використання пам’яті завдяки хештету.

Нарешті, якщо ваш список є лише IList<T>замість того, List<T>я пропоную свою відповідь на те, як я можу зробити цей спеціальний ітератор передбачення? . Це матиме лінійний час виконання за типовими реалізаціями IList<T>, порівняно з квадратичним виконанням багатьох інших відповідей.

Оскільки будь-яке видалення здійснюється за умови, яке ви можете використовувати

list.RemoveAll(item => item.Value == someValue);

List<T> TheList = new List<T>();

TheList.FindAll(element => element.Satisfies(Condition)).ForEach(element => TheList.Remove(element));

Ви не можете використовувати foreach, але ви можете ітератувати вперед і керувати змінною індексу циклу, коли ви виймаєте елемент, наприклад:

for (int i = 0; i < elements.Count; i++)
{
    if (<condition>)
    {
        // Decrement the loop counter to iterate this index again, since later elements will get moved down during the remove operation.
        elements.RemoveAt(i--);
    }
}

Зауважимо, що загалом усі ці методи покладаються на ітерацію поведінки колекції. Показана тут техніка працюватиме зі стандартним списком (T). (Цілком можливо написати власний клас колекції та ітератор, який дозволяє видаляти елементи під час циклу foreach.)

Використання Removeабо RemoveAtв списку під час повторного повторення цього списку навмисно ускладнюється, оскільки це майже завжди неправильно робити . Можливо, ви зможете змусити це працювати якоюсь хитрою хитрістю, але це буде дуже повільно. Кожен раз, коли ви Removeїї телефонуєте, доводиться переглядати весь список, щоб знайти елемент, який потрібно видалити. Кожен раз, коли ви RemoveAtїї телефонуєте , потрібно переміщувати наступні елементи 1 вліво. Таким чином, будь-яке рішення, що використовує Removeабо RemoveAtвимагає квадратичного часу, O (n²) .

Використовуйте, RemoveAllякщо можете. В іншому випадку наступний шаблон буде фільтрувати список на місці за лінійним часом, O (n) .

// Create a list to be filtered
IList<int> elements = new List<int>(new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
// Filter the list
int kept = 0;
for (int i = 0; i < elements.Count; i++) {
    // Test whether this is an element that we want to keep.
    if (elements[i] % 3 > 0) {
        // Add it to the list of kept elements.
        elements[kept] = elements[i];
        kept++;
    }
}
// Unfortunately IList has no Resize method. So instead we
// remove the last element of the list until: elements.Count == kept.
while (kept < elements.Count) elements.RemoveAt(elements.Count-1);

Я б хотів, щоб «візерунок» був приблизно таким:

foreach( thing in thingpile )
{
    if( /* condition#1 */ )
    {
        foreach.markfordeleting( thing );
    }
    elseif( /* condition#2 */ )
    {
        foreach.markforkeeping( thing );
    }
} 
foreachcompleted
{
    // then the programmer's choices would be:

    // delete everything that was marked for deleting
    foreach.deletenow(thingpile); 

    // ...or... keep only things that were marked for keeping
    foreach.keepnow(thingpile);

    // ...or even... make a new list of the unmarked items
    others = foreach.unmarked(thingpile);   
}

Це дозволило б вирівняти код з процесом, який триває в мозку програміста.

Припускаючи, що предикат - булева властивість елемента, що якщо це правда, то елемент слід видалити:

        int i = 0;
        while (i < list.Count())
        {
            if (list[i].predicate == true)
            {
                list.RemoveAt(i);
                continue;
            }
            i++;
        }

Я б перепризначив цей список за запитом LINQ, який відфільтрував елементи, які ви не хотіли зберігати.

list = list.Where(item => ...).ToList();

Якщо список не дуже великий, у цьому не повинно виникнути суттєвих проблем.

Найкращий спосіб видалити елементи зі списку під час ітерації над ним - це використовувати RemoveAll() . Але головне занепокоєння, яке пишуть люди, полягає в тому, що вони повинні робити якісь складні речі всередині циклу та / або мати складні випадки порівняння.

Рішення все-таки використовувати, RemoveAll()але використовувати це позначення:

var list = new List<int>(Enumerable.Range(1, 10));
list.RemoveAll(item => 
{
    // Do some complex operations here
    // Or even some operations on the items
    SomeFunction(item);
    // In the end return true if the item is to be removed. False otherwise
    return item > 5;
});

foreach(var item in list.ToList())

{

if(item.Delete) list.Remove(item);

}

Просто створіть абсолютно новий список з першого. Я кажу "Легко", а не "Правильно", оскільки створення абсолютно нового списку, ймовірно, приносить премію за ефективність за попередній метод (я не переймався жодним бенчмаркінг.) Я, як правило, віддаю перевагу цій схемі, вона також може бути корисною для подолання Обмеження Linq-To-Entities.

for(i = list.Count()-1;i>=0;i--)

{

item=list[i];

if (item.Delete) list.Remove(item);

}

Таким чином прокручується список назад звичайним старим циклом For. Робити це вперед може бути проблематично, якщо розмір колекції змінюється, але назад завжди повинен бути безпечним.

Скопіюйте список, який ви повторюєте. Потім вийміть із копії та інтегруйте оригінал. Повернення назад є заплутаним і не працює добре при циклічному паралельному циклі.

var ids = new List<int> { 1, 2, 3, 4 };
var iterableIds = ids.ToList();

Parallel.ForEach(iterableIds, id =>
{
    ids.Remove(id);
});

Я б так зробив

using System.IO;
using System;
using System.Collections.Generic;

class Author
    {
        public string Firstname;
        public string Lastname;
        public int no;
    }

class Program
{
    private static bool isEven(int i) 
    { 
        return ((i % 2) == 0); 
    } 

    static void Main()
    {    
        var authorsList = new List<Author>()
        {
            new Author{ Firstname = "Bob", Lastname = "Smith", no = 2 },
            new Author{ Firstname = "Fred", Lastname = "Jones", no = 3 },
            new Author{ Firstname = "Brian", Lastname = "Brains", no = 4 },
            new Author{ Firstname = "Billy", Lastname = "TheKid", no = 1 }
        };

        authorsList.RemoveAll(item => isEven(item.no));

        foreach(var auth in authorsList)
        {
            Console.WriteLine(auth.Firstname + " " + auth.Lastname);
        }
    }
}

ВИХІД

Fred Jones
Billy TheKid

Я опинився в подібній ситуації, коли мені довелося видаляти кожен n- ^й елемент у заданій List<T>.

for (int i = 0, j = 0, n = 3; i < list.Count; i++)
{
    if ((j + 1) % n == 0) //Check current iteration is at the nth interval
    {
        list.RemoveAt(i);
        j++; //This extra addition is necessary. Without it j will wrap
             //down to zero, which will throw off our index.
    }
    j++; //This will always advance the j counter
}

Вартість вилучення предмета зі списку пропорційна кількості предметів, що слідують за вилученим. У випадку, коли перша половина елементів відповідає вимогам для вилучення, будь-який підхід, заснований на вилученні елементів окремо, в кінцевому підсумку повинен виконати близько N * N / 4 операцій з копіювання предмета, які можуть стати дуже дорогими, якщо список великий .

Більш швидкий підхід полягає в перегляді списку, щоб знайти перший елемент, який потрібно видалити (якщо такий є), а потім з цього моменту скопіюйте кожен елемент, який слід зберегти до місця, де він належить. Після цього, якщо R елементів слід зберегти, першими R елементами у списку будуть R-елементи, а всі елементи, що потребують видалення, будуть наприкінці. Якщо ці елементи буде видалено у зворотному порядку, системі не доведеться копіювати будь-який з них, тому якщо в списку було N елементів, з яких R елементів, у тому числі всіх перших F, було збережено, необхідно буде копіюйте РФ-елементи та скорочуйте список на один NR разів. Весь лінійний час.

Мій підхід полягає в тому, що я спершу створюю список індексів, які слід видалити. Згодом перебираю індекси та вилучаю елементи з початкового списку. Це виглядає приблизно так:

var messageList = ...;
// Restrict your list to certain criteria
var customMessageList = messageList.FindAll(m => m.UserId == someId);

if (customMessageList != null && customMessageList.Count > 0)
{
    // Create list with positions in origin list
    List<int> positionList = new List<int>();
    foreach (var message in customMessageList)
    {
        var position = messageList.FindIndex(m => m.MessageId == message.MessageId);
        if (position != -1)
            positionList.Add(position);
    }
    // To be able to remove the items in the origin list, we do it backwards
    // so that the order of indices stays the same
    positionList = positionList.OrderByDescending(p => p).ToList();
    foreach (var position in positionList)
    {
        messageList.RemoveAt(position);
    }
}

У C # один простий спосіб - позначити ті, які ви хочете видалити, а потім створити новий список для повторення ...

foreach(var item in list.ToList()){if(item.Delete) list.Remove(item);}  

або навіть простіше використовувати linq ....

list.RemoveAll(p=>p.Delete);

але варто задуматися, чи будуть інші завдання або потоки мати доступ до того ж списку в той же час, коли ви зайняті видаленням, і, можливо, замість цього використовувати ConcurrentList.

Простежте за властивістю елементи, які потрібно видалити, і видаліть їх після закінчення процесу.

using System.Linq;

List<MyProperty> _Group = new List<MyProperty>();
// ... add elements

bool cond = true;
foreach (MyProperty currObj in _Group)
{
    if (cond) 
    {
        // SET - element can be deleted
        currObj.REMOVE_ME = true;
    }
}
// RESET
_Group.RemoveAll(r => r.REMOVE_ME);

Просто хотів додати свої 2 центи до цього, якщо це допомагає комусь, у мене була подібна проблема, але мені потрібно було видалити декілька елементів зі списку масиву, коли він перебирався. відповідь з найвищими цінами зробив це для мене здебільшого, поки я не зіткнувся з помилками і не зрозумів, що індекс перевищує розмір списку масиву в деяких випадках, оскільки було видалено кілька елементів, але індекс циклу не зберігався слід цього. Я виправив це за допомогою простої перевірки:

ArrayList place_holder = new ArrayList();
place_holder.Add("1");
place_holder.Add("2");
place_holder.Add("3");
place_holder.Add("4");

for(int i = place_holder.Count-1; i>= 0; i--){
    if(i>= place_holder.Count){
        i = place_holder.Count-1; 
    }

// some method that removes multiple elements here
}

myList.RemoveAt(i--);

simples;