c# - values - vb net list find




Usando LINQ per rimuovere elementi da un elenco<T> (10)

È molto semplice:

authorsList.RemoveAll((x) => x.firstname == "Bob");

Dì che ho una query LINQ come:

var authors = from x in authorsList
              where x.firstname == "Bob"
              select x;

Dato che authorsList è di tipo List<Author> , come posso eliminare gli elementi Author da authorsList che vengono restituiti dalla query agli authors ?

O, per dirla in altro modo, come posso eliminare tutti gli equivalenti Bob del primo nome da authorsList ?

Nota: questo è un esempio semplificato ai fini della domanda.


Bene, sarebbe più facile escluderli in primo luogo:

authorsList = authorsList.Where(x => x.FirstName != "Bob").ToList();

Tuttavia, ciò cambierebbe semplicemente il valore di authorsList invece di rimuovere gli autori dalla raccolta precedente. In alternativa, puoi usare RemoveAll :

authorsList.RemoveAll(x => x.FirstName == "Bob");

Se hai davvero bisogno di farlo in base a un'altra raccolta, utilizzerei un HashSet, RemoveAll e Contains:

var setToRemove = new HashSet<Author>(authors);
authorsList.RemoveAll(x => setToRemove.Contains(x));

Di seguito è riportato l'esempio per rimuovere l'elemento dall'elenco.

 List<int> items = new List<int>() { 2, 2, 3, 4, 2, 7, 3,3,3};

 var result = items.Remove(2);//Remove the first ocurence of matched elements and returns boolean value
 var result1 = items.RemoveAll(lst => lst == 3);// Remove all the matched elements and returns count of removed element
 items.RemoveAt(3);//Removes the elements at the specified index

LINQ ha le sue origini nella programmazione funzionale, che enfatizza l'immutabilità degli oggetti, quindi non fornisce un modo integrato per aggiornare l'elenco originale sul posto.

Nota sull'immutabilità (presa da un'altra risposta SO):

Ecco la definizione di immutabilità da Wikipedia (link)

"Nella programmazione orientata agli oggetti e funzionale, un oggetto immutabile è un oggetto il cui stato non può essere modificato dopo la sua creazione."


Non è possibile farlo con gli operatori LINQ standard perché LINQ fornisce query, non aggiorna il supporto.

Ma puoi generare un nuovo elenco e sostituire quello vecchio.

var authorsList = GetAuthorList();

authorsList = authorsList.Where(a => a.FirstName != "Bob").ToList();

Oppure puoi rimuovere tutti gli elementi degli authors in un secondo passaggio.

var authorsList = GetAuthorList();

var authors = authorsList.Where(a => a.FirstName == "Bob").ToList();

foreach (var author in authors)
{
    authorList.Remove(author);
}

Penso che devi solo assegnare gli articoli dalla lista degli autori a una nuova lista per ottenere quell'effetto.

//assume oldAuthor is the old list
Author newAuthorList = (select x from oldAuthor where x.firstname!="Bob" select x).ToList();
oldAuthor = newAuthorList;
newAuthorList = null;

Puoi rimuovere in due modi

var output = from x in authorsList
             where x.firstname != "Bob"
             select x;

o

var authors = from x in authorsList
              where x.firstname == "Bob"
              select x;

var output = from x in authorsList
             where !authors.Contains(x) 
             select x;

Ho avuto lo stesso problema, se si desidera un output semplice basato sulla condizione in cui si trova, quindi la prima soluzione è migliore.


Questa è una domanda molto vecchia, ma ho trovato un modo molto semplice per farlo:

authorsList = authorsList.Except(authors).ToList();

Si noti che poiché la variabile return authorsList è una List<T> , IEnumerable<T> restituito da Except() deve essere convertito in una List<T> .


Se hai davvero bisogno di rimuovere elementi, allora che dire di Except ()?
È possibile rimuovere in base a un nuovo elenco o rimuovere al volo nidificando il Linq.

var authorsList = new List<Author>()
{
    new Author{ Firstname = "Bob", Lastname = "Smith" },
    new Author{ Firstname = "Fred", Lastname = "Jones" },
    new Author{ Firstname = "Brian", Lastname = "Brains" },
    new Author{ Firstname = "Billy", Lastname = "TheKid" }
};

var authors = authorsList.Where(a => a.Firstname == "Bob");
authorsList = authorsList.Except(authors).ToList();
authorsList = authorsList.Except(authorsList.Where(a=>a.Firstname=="Billy")).ToList();

Soluzione semplice:

static void Main()
{
    List<string> myList = new List<string> { "Jason", "Bob", "Frank", "Bob" };
    myList.RemoveAll(x => x == "Bob");

    foreach (string s in myList)
    {
        //
    }
}




list