Il modo migliore per scorrere su un elenco e rimuovere elementi da esso?

Question

Ho bisogno di scorrere su un List<myObject> e rimuovere elementi che rispondono a una determinata condizione.

ho visto questa risposta (https://stackoverflow.com/a/1582317/5077434):

iterare la vostra lista in retromarcia con un ciclo for:

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

Esempio:

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

Ma ho capito che for è meno efficiente di foreach,

così ho pensato di utilizzare il più avanti come segue:

foreach (var item in myList.ToList()) 
{ 
    // if certain condition applies: 
    myList.Remove(item) 
} 

è un metodo migliore rispetto agli altri?

EDIT:

Non voglio usare RemoveAll(...), in quanto v'è una grande quantità di codice all'interno del ciclo, prima la condizione.

Answer 1

Volenti o nolenti bisogna ciclo sulla lista, e il ciclo for è il più un efficiente:

for (int i = safePendingList.Count - 1; i >= 0; --i) 
    if (condition) 
     safePendingList.RemoveAt(i); 

Se si desidera rimuovere in gamma (non nel intera lista), basta modificare per ciclo:

// No Enumarable.Range(1, 10) - put them into "for" 
    for (int i = Math.Min(11, safePendingList.Count - 1); i >= 1; --i) 
    if (condition) 
     safePendingList.RemoveAt(i); 

O se è necessario rimuovere gli elementi in avanti looping:

for (int i = 0; i < safePendingList.Count;) // notice ++i abscence 
    if (condition) 
     safePendingList.RemoveAt(i); 
    else 
     i += 1; // ++i should be here 

Al contrario safePendingList.ToList() crea una copia di iniziale safePendingList e questo significa memoria e CPUoverhead:

// safePendingList.ToList() - CPU and Memory overhead (copying) 
    foreach (var item in safePendingList.ToList()) { 
    if (condition) 
     myList.Remove(item); // Overhead: searching 
    } 

Tuttavia, la più ragionevole piano in molti casi si tratta solo di lasciare .Net lavoro per voi:

safePendingList.RemoveAll(item => condition); 

Answer 2

Per rimuovere gli elementi con una certa condizione è possibile utilizzare

list.RemoveAll(item => item > 5); 

invece di

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

Answer 3

Il problema è che foreach non può funzionare con la raccolta mentre viene modificato questo porterà a InvalidOperationException.

Uso .ToList() all'interno foreach permette di evitare che ma questo copia l'intera collezione si comporti scorrendo raccolta due volte (prima volta quando esso copia tutti gli elementi e seconda volta per filtrano).

Il ciclo for è un'opzione migliore perché è possibile passare alla raccolta una sola volta. A parte che è possibile filtrare raccolta utilizzando LINQWhere() metodo, qualcosa tra le linee di:

var myFilteredCollection = myList.Where(i => i <= 5).ToList(); 

Se le condizioni sono complesse è possibile spostare questa logica al metodo separato:

private bool IsItemOk(myObject item) 
{ 
    ... your complicated logic. 
    return true; 
} 

e utilizzarlo in la tua domanda LINQ:

var myFilteredCollection = myList.Where(i => IsItemOk(i)).ToList(); 

Un'altra opzione è farlo viceversa. Crea nuova raccolta e aggiungi elementi in base alle condizioni. Che è possibile utilizzare foreach ciclo:

var newList = new List<MyObject>(myList.Count); 

foreach (var item in myList) 
{ 
    // if certain condition does not apply: 
    newList.Add(item); 
} 

P.S.

Ma, come già accennato .RemoveAll() è meglio perché in questo modo non c'è bisogno di 'reinventare la ruota'

Answer 4

Nessuno dei due metodi mostra differenze significative. for e RemoveAll sembrano un po 'più veloci (più probabilmente perché si utilizza Remove per la duplicazione dell'elenco e occorre ricrearlo ... utilizzando i tipi di valore, ciò significa anche il raddoppio della memoria necessaria). Ho fatto un po 'di profilazione:

public static void MethodA() 
{ 
    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); 
    } 
} 

public static void MethodB() 
{ 
    var list = new List<int>(Enumerable.Range(1, 10)); 
    foreach (var item in list.ToList()) 
    { 
     if (item > 5) 
      list.Remove(item); 
    } 
} 

public static void MethodC() 
{ 
    var list = new List<int>(Enumerable.Range(1, 10)); 
    list.RemoveAll(x => x > 5); 
} 

public static void Measure(string meas, Action act) 
{ 
    GC.Collect(); 
    GC.WaitForPendingFinalizers(); 
    var st = new Stopwatch(); 
    st.Start(); 
    for (var i = 0; i < 10000000; i++) 
     act(); 
    st.Stop(); 
    Console.WriteLine($"{meas}: {st.Elapsed}"); 
} 

static void Main(string[] args) 
{ 
    Measure("A", MethodA); 
    Measure("B", MethodB); 
    Measure("C", MethodC); 
} 

Il risultato:

A: 00: 00: 04,1179163

B: 00: 00: 07,7417853

C: 00: 00: 04,3525255

Altre corse danno risultati ancora più simili (si noti che questo è per 10 milioni ons su una lista di 10 articoli [facendo così 100 milioni di operazioni] ... una differenza di ~ 3 secondi non è quella che chiamerei "significativa", ma il tuo chilometraggio può variare)

Quindi vai con quello che pensi tu in grado di leggere meglio (io personalmente uso il metodo RemoveAll)

Nota: come far crescere la tua lista (questo a soli 10 elementi), MethodB (la foreach quella che duplica l'elenco) sarà più lenta e le differenze sarà più alto, dal momento che la duplicazione dell'elenco sarà più costosa. Ad esempio, facendo una lista di 1.000 articoli (con la condizione di 500 anziché 5) e 100.000 iterazioni, rende MethodB 34 secondi, mentre entrambi gli altri vengono eseguiti in meno di 2 secondi sulla mia macchina.Quindi sì, sicuramente non utilizzare MethodB :-)

Questo non significa che foreach è meno efficiente di for, significa solo che per l'utilizzo di foreach per rimuovere gli elementi da un elenco, è necessario duplicare detto lista, e questo è costoso.

Questo altro metodo (utilizzando foreach) dovrebbe essere di circa veloce come le for o RemoveAll metodi (si tratta di un piccolo po 'più lento nel mio profilazione -perché si assegna una nuova lista, ho figura-, ma praticamente trascurabile):

public static void MethodD() 
{ 
    var originalList = new List<int>(Enumerable.Range(1, 1000)); 
    var list = new List<int>(originalList.Count); 
    foreach (var item in originalList) 
    { 
     if (item <= 500) 
      list.Add(item); 
    } 
    list.Capacity = list.Count; 
} 

Hai solo bisogno di invertire la condizione.

non sto suggerendo questo metodo, solo dimostrando che foreach non è necessariamente più lento di for

Answer 5

Un altro modo potrebbe essere quello di foreach lista, impostare la voce su null e poi fare un LINQ togliere a (item = > null), come già detto, sta a te scegliere il modo che ti aggrada meglio