Como remover elementos de uma lista genérica enquanto itera sobre ela?

Estou procurando um padrão melhor para trabalhar com uma lista de elementos que cada um precisa ser processado e, dependendo do resultado, serão removidos da lista.

Você não pode usar .Remove(element)dentro de um foreach (var element in X)(porque resulta em Collection was modified; enumeration operation may not execute.exceção) ... você também não pode usar for (int i = 0; i < elements.Count(); i++)e .RemoveAt(i)porque isso interrompe sua posição atual na coleção em relação a i.

Existe uma maneira elegante de fazer isso?

Itere sua lista no sentido inverso com um loop for:

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

Exemplo:

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

Como alternativa, você pode usar o método RemoveAll com um predicado para testar:

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

Aqui está um exemplo simplificado para demonstrar:

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

Uma solução simples e direta:

Use um loop for padrão correndo para trás em sua coleção e RemoveAt(i)para remover elementos.

A iteração reversa deve ser a primeira coisa a se lembrar quando você deseja remover elementos de uma coleção enquanto itera sobre ela.

Felizmente, existe uma solução mais elegante do que escrever um loop for, que envolve digitação desnecessária e pode estar sujeito a erros.

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

Se você adicionar ".ToList ()" à sua lista (ou aos resultados de uma consulta LINQ), poderá remover o "item" diretamente da "lista" sem a temida " Coleção modificada; a operação de enumeração pode não ser executada ". erro. O compilador faz uma cópia da "lista", para que você possa remover com segurança a matriz.

Embora esse padrão não seja super eficiente, ele tem uma sensação natural e é flexível o suficiente para quase qualquer situação . Por exemplo, quando você deseja salvar cada "item" em um banco de dados e removê-lo da lista somente quando o salvamento do banco de dados for bem-sucedido.

Selecione os elementos que você não quer, em vez de tentar remover os elementos que você não quer. Isso é muito mais fácil (e geralmente mais eficiente também) do que remover elementos.

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

Eu queria postar isso como um comentário em resposta ao comentário deixado por Michael Dillon abaixo, mas é muito longo e provavelmente útil para ter em minha resposta de qualquer maneira:

Pessoalmente, eu nunca removeria itens um por um, se você precisar removê-los, em seguida, chamar RemoveAllque leva um predicado e reorganiza a matriz interna apenas uma vez, enquanto Removefaz uma Array.Copyoperação para cada elemento que você remove. RemoveAllé muito mais eficiente.

E quando você está repetindo a iteração sobre uma lista, você já possui o índice do elemento que deseja remover, portanto seria muito mais eficiente chamar RemoveAt, porque Removeprimeiro é percorrida a lista para encontrar o índice do elemento que você deseja remover. está tentando remover, mas você já conhece esse índice.

Então, apesar de tudo, não vejo motivo para chamar Removeum loop for. E, idealmente, se for possível, use o código acima para transmitir elementos da lista conforme necessário, para que nenhuma segunda estrutura de dados tenha que ser criada.

O uso do ToArray () em uma lista genérica permite que você remova (item) na sua lista genérica:

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

O uso de .ToList () fará uma cópia da sua lista, conforme explicado nesta pergunta: ToList () - Cria uma nova lista?

Usando ToList (), você pode remover da sua lista original, porque na verdade está iterando sobre uma cópia.

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

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

     }

Se a função que determina quais itens excluir não tem efeitos colaterais e não altera o item (é uma função pura), uma solução simples e eficiente (tempo linear) é:

list.RemoveAll(condition);

Se houver efeitos colaterais, eu usaria algo como:

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

Ainda é um tempo linear, assumindo que o hash seja bom. Mas tem um aumento no uso de memória devido ao hashset.

Finalmente, se sua lista é apenas um em IList<T>vez de um List<T>, sugiro minha resposta para Como posso fazer esse iterador especial para cada um? . Isso terá um tempo de execução linear, considerando as implementações típicas de IList<T>, em comparação com o tempo de execução quadrático de muitas outras respostas.

Como qualquer remoção é feita sob uma condição, você pode usar

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

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

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

Você não pode usar o foreach, mas pode iterar para frente e gerenciar sua variável de índice de loop ao remover um item, assim:

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

Observe que, em geral, todas essas técnicas dependem do comportamento da coleção que está sendo iterada. A técnica mostrada aqui funcionará com a lista padrão (T). (É bem possível escrever sua própria classe de coleção e iterator que faz permitir a remoção item durante um loop foreach.)

O uso Removeou RemoveAtem uma lista durante a iteração sobre essa lista foi intencionalmente difícil, porque quase sempre é a coisa errada a se fazer . Você pode fazê-lo funcionar com algum truque inteligente, mas seria extremamente lento. Toda vez que você ligar, Removeele deve percorrer toda a lista para encontrar o elemento que você deseja remover. Toda vez que você ligar, RemoveAtele deve mover os elementos subsequentes 1 posição para a esquerda. Como tal, qualquer solução que use Removeou RemoveAt, exigiria tempo quadrático, O (n²) .

Use RemoveAllse puder. Caso contrário, o padrão a seguir filtrará a lista no local em tempo linear, 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);

Eu gostaria que o "padrão" fosse algo assim:

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

Isso alinharia o código com o processo que ocorre no cérebro do programador.

Assumindo que predicado é uma propriedade booleana de um elemento, que, se for verdadeiro, o elemento deve ser removido:

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

Eu reatribuiria a lista a partir de uma consulta LINQ que filtrasse os elementos que você não queria manter.

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

A menos que a lista seja muito grande, não deve haver problemas significativos de desempenho ao fazer isso.

A melhor maneira de remover itens de uma lista durante a iteração é usando RemoveAll(). Mas a principal preocupação escrita pelas pessoas é que elas precisam fazer algumas coisas complexas dentro do loop e / ou ter casos complexos de comparação.

A solução ainda é usar, RemoveAll()mas use esta notação:

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

}

Basta criar uma lista totalmente nova a partir da primeira. Digo "Fácil" ao invés de "Certo", pois a criação de uma lista totalmente nova provavelmente tem um prêmio de desempenho em relação ao método anterior (não me importei com nenhum benchmarking). Geralmente prefiro esse padrão, mas também pode ser útil para superar Limitações do Linq-To-Entities.

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

{

item=list[i];

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

}

Dessa maneira, percorre a lista para trás com um loop For simples e antigo. Fazer isso adiante pode ser problemático se o tamanho da coleção for alterado, mas sempre deve ser seguro.

Copie a lista que você está iterando. Em seguida, retire da cópia e interaja com o original. Retroceder é confuso e não funciona bem ao fazer um loop paralelo.

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

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

Eu faria assim

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

RESULTADO

Fred Jones
Billy TheKid

Eu me encontrei em uma situação semelhante, onde eu tinha que remover todos os n ^º elemento em uma determinada 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
}

O custo de remover um item da lista é proporcional ao número de itens após o item a ser removido. No caso em que a primeira metade dos itens se qualifica para remoção, qualquer abordagem baseada na remoção de itens individualmente terá que executar cerca de N * N / 4 operações de cópia de itens, que podem ficar muito caras se a lista for grande .

Uma abordagem mais rápida é percorrer a lista para encontrar o primeiro item a ser removido (se houver) e, a partir desse momento, copiar cada item que deve ser mantido no local a que pertence. Uma vez feito isso, se os itens R devem ser retidos, os primeiros itens R na lista serão esses itens R e todos os itens que requerem exclusão estarão no final. Se esses itens forem excluídos na ordem inversa, o sistema não precisará copiar nenhum deles; portanto, se a lista tiver N itens dos quais itens R, incluindo todos os primeiros F, foram retidos, será necessário copie itens de RF e reduza a lista por um item NR vezes. Todo o tempo linear.

Minha abordagem é que primeiro crie uma lista de índices, que devem ser excluídos. Depois, percorro os índices e removo os itens da lista inicial. É assim:

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

Em C #, uma maneira fácil é marcar as que você deseja excluir e criar uma nova lista para repetir ...

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

ou ainda mais simples usar linq ....

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

mas vale a pena considerar se outras tarefas ou threads terão acesso à mesma lista ao mesmo tempo em que você estiver removendo e, talvez, use uma ConcurrentList.

Rastreie os elementos a serem removidos com uma propriedade e remova todos eles após o processo.

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

Só queria adicionar meus 2 centavos a isso, caso isso ajude alguém, eu tive um problema semelhante, mas precisava remover vários elementos de uma lista de matriz enquanto ela estava sendo repetida. a resposta mais votada mais alta fez por mim a maior parte do tempo, até que encontrei erros e percebi que o índice era maior do que o tamanho da lista de matrizes em alguns casos porque vários elementos estavam sendo removidos, mas o índice do loop não foi mantido. faixa disso. Corrigi isso com uma verificação simples:

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;