Le moyen le plus efficace pour supprimer plusieurs éléments à partir d'un IList<T>

Que le nombre d'éléments à supprimer devient plus grand, vous trouverez probablement parcourant la liste et de vérifier chaque élément contre un hashset "des éléments à supprimer" est plus efficace. Une méthode d'extension, comme cela pourrait aider:

static void RemoveAll<T>(this IList<T> iList, IEnumerable<T> itemsToRemove)
{
    var set = new HashSet<T>(itemsToRemove);

    var list = iList as List<T>;
    if (list == null)
    {
        int i = 0;
        while (i < iList.Count)
        {
            if (set.Contains(iList[i])) iList.RemoveAt(i);
            else i++;
        }
    }
    else
    {
        list.RemoveAll(set.Contains);
    }
}

Je comparés à l'aide de ce petit programme ci-dessous. (Note qu'il utilise un chemin d'accès optimisé si IList<T> est en fait un List<T>.)

Sur ma machine (et l'utilisation de mes données de test), cette extension de la méthode a pris 1,5 secondes pour exécuter vs 17 secondes pour le code dans votre question. Cependant, je n'ai pas testé avec différentes tailles de données. Je suis sûr que pour enlever juste un couple de points RemoveAll2 sera plus rapide.

static class Program
{
static void RemoveAll<T>(this IList<T> iList, IEnumerable<T> itemsToRemove)
{
var set = new HashSet<T>(itemsToRemove);
var list = iList as List<T>;
if (list == null)
{
int i = 0;
while (i < iList.Count)
{
if (set.Contains(iList[i])) iList.RemoveAt(i);
else i++;
}
}
else
{
list.RemoveAll(set.Contains);
}
}
static void RemoveAll2<T>(this IList<T> list, IEnumerable<T> itemsToRemove)
{
foreach (var item in itemsToRemove)
list.Remove(item);
}
static void Main(string[] args)
{
var list = Enumerable.Range(0, 10000).ToList();
var toRemove = new[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 
43,  47,  53,  59,  61,  67,  71,  73,  79,  83,  89,  97, 101,
103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167,
173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239,
241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313,
317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397,
401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467,
479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569,
571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643,
647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733,
739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823,
827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911,
919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997};
list.RemoveAll(toRemove); //JIT 
//list.RemoveAll2(toRemove); //JIT 
var sw = Stopwatch.StartNew();
for (int i = 0; i < 10000; i++)
{
list.RemoveAll(toRemove);
//list.RemoveAll2(toRemove);
}
sw.Stop();
Console.WriteLine("Elapsed: {0} ms", sw.ElapsedMilliseconds);
Console.ReadKey();
}
}

---

Mise à JOUR (pour @KarmaEDV & Marque Sowul les commentaires ci-dessous):
Si vous avez besoin d'utiliser un comparateur d'égalité, la méthode d'extension pourrait avoir une surcharge qui prend une telle comparer:

public static void RemoveAll<T>(this IList<T> iList, IEnumerable<T> itemsToRemove, IEqualityComparer<T> comparer = null)
{
var set = new HashSet<T>(itemsToRemove, comparer ?? EqualityComparer<T>.Default);
if (iList is List<T> list)
{
list.RemoveAll(set.Contains);
}
else
{
int i = iList.Count - 1;
while (i > -1)
{
if (set.Contains(iList[i])) iList.RemoveAt(i);
else i--;
}
}
}

OriginalL'auteur Eren Ersönmez

Peut-être cela peut vous aider. D'autres idées du même type pourraient être inclus.

IList<T> items;
IEnumerable<T> itemsToDelete;
...
{
if(items.Equals(itemsToDelete)) //Equal lists?
{
items.Clear(); 
return true;
}
if(  (double) items.Count/itemsToDelete.Count < 1){
/* It is faster to iterate the small list first. */ 
foreach (var x in items)
{
if(itemsToDelete.Contains(x)){/**/} 
}
}
else{
foreach (var x in itemsToDelete)
{
items.Remove(x);
}
}
}

OriginalL'auteur celerno