LINQ: RemoveAll et obtenir les éléments supprimés

Qui est la façon la plus simple pour supprimer les éléments qui correspondent à une condition d'une liste et ensuite, obtenir ces éléments.

Je peux penser à quelques égards, je ne sais pas qui est le meilleur:

var subList = list.Where(x => x.Condition);
list.RemoveAll(x => x.Condition);

var subList = list.Where(x => x.Condition);
list.RemoveAll(x => subList.Contains(x));

Tout cela est-il l'un des meilleurs moyens? Si elle l'est, lequel? Si elle ne l'est pas, comment dois je faire?

OriginalL'auteur Diego | 2012-04-16

c#linq removeall

5

Je voudrais aller avec la première option pour des raisons de lisibilité, avec la note que vous devrait se concrétiser la liste en premier, ou vous allez perdre des éléments que vous essayez de sélectionner sur la ligne suivante:
```
var sublist = list.Where(x => x.Condition).ToArray();
list.RemoveAll(x => x.Condition);
```
Le deuxième exemple est O(n^2) sans aucune raison et le dernier est parfaitement bien, mais moins lisible.

Edit: maintenant que j'ai relu ton dernier exemple, on note que, comme il est écrit maintenant va prendre tous les articles d'autres. Il vous manque la condition de vérifier et de supprimer la ligne qui devrait en fait être list.RemoveAt(i--); parce que le i+1ème élément devient le ième élément après l'enlèvement, et quand vous incrément i vous êtes à sauter sur elle.

C'est en fait O(n^3), mais je suis en supposant l'absence de matérialisation juste glissé votre avis 😉
Serait-éléments (comme je l'ai écrit) être retiré de sous-liste avec la deuxième instruction? :O
Er vous ne retirez jamais de sublist, ni comptez-vous le faire si j'ai lu correctement.
Votre montage est bon, je vais supprimer le troisième options, car ses vraiment mal et de faire il serait très illisible
Lorsque vous exécutez une requête linq sur une collection, vous n'obtenez pas un tableau, vous obtenez en retour un objet que lorsque vous parcourez vous exécutez votre sélection actuelle. Alors, prenez votre premier exemple. subList sera juste un objet, vous pouvez supprimer les éléments dans le tableau principal, et puis quand vous ne foreach(var item in subList) que vous obtenez en retour rien parce que la condition renverra toujours false.

OriginalL'auteur Blindy
4

Je tiens à utiliser une approche par programmation fonctionnelle (seulement faire de nouvelles choses, de ne pas modifier l'existant). Un avantage de ToLookup est que vous pouvez gérer plus d'un deux-partage des articles.
```
ILookup<bool, Customer> lookup = list.ToLookup(x => x.Condition);
List<Customer> sublist = lookup[true].ToList();
list = lookup[false].ToList();
```
Ou si vous avez besoin de modifier l'instance d'origine...
```
list.Clear();
list.AddRange(lookup[false]);
```
Je pense que c'est beaucoup plus complexe (et presque sans connaissance, je pense que c'est pas vraiment de la performance). Est ce que cela a un quelconque avantage?
La Condition est évaluée qu'une seule fois par article. Instance de liste n'est pas modifié, ce qui peut être un gros avantage si l'instance est partagé entre les threads.
C'est tout à fait une idée de génie.

OriginalL'auteur Amy B

Je cherchais la même chose. Je voulais faire un peu de journalisation des erreurs sur les articles que j'ai enlever. Depuis que j'ai ajouter tout un tas de règles de validation, les supprimer-et-journal d'appel doit être aussi concis que possible.

J'ai pris les méthodes d'extension:

public static class ListExtensions
{
    ///<summary>
    ///Modifies the list by removing all items that match the predicate. Outputs the removed items.
    ///</summary>
    public static void RemoveWhere<T>(this List<T> input, Predicate<T> predicate, out List<T> removedItems)
    {
        removedItems = input.Where(item => predicate(item)).ToList();
        input.RemoveAll(predicate);
    }

    ///<summary>
    ///Modifies the list by removing all items that match the predicate. Calls the given action for each removed item.
    ///</summary>
    public static void RemoveWhere<T>(this List<T> input, Predicate<T> predicate, Action<T> actionOnRemovedItem)
    {
        RemoveWhere(input, predicate, out var removedItems);
        foreach (var removedItem in removedItems) actionOnRemovedItem(removedItem);
    }
}

Exemple d'utilisation:

items.RemoveWhere(item => item.IsWrong, removedItem =>
    errorLog.AppendLine($"{removedItem} was wrong."));

OriginalL'auteur Timo

Vous devez vous connecter pour publier un commentaire.