Coder Perfect

In C#, how do you remove an item from a list?


In resultlist, I have the following list:

var resultlist = results.ToList();

This is what it appears to be like:

ID FirstName  LastName
-- ---------  --------
1  Bill       Smith
2  John       Wilson
3  Doug       Berg

What is the procedure for removing ID 2 from the list?

Asked by Nate Pet

Solution #1

You can use one of two ListT> techniques.

If you know the item’s index, you can use RemoveAt(int index). Consider the following scenario:


Remove(T item): Remove(T item): Remove(T item): Remove(T item): Remove(T

var itemToRemove = resultlist.Single(r => r.Id == 2);

When you’re not sure whether or not an object exists, use SingleOrDefault. If there is no item, SingleOrDefault will return null (Single will throw an exception if it cannot find the item). When a value is duplicated, both will throw an exception (two items with the same id).

var itemToRemove = resultlist.SingleOrDefault(r => r.Id == 2);
if (itemToRemove != null)

Answered by Wouter de Kort

Solution #2

Answer in a nutshell: (from list results)

results. RemoveAll(r => r.ID == 2) removes the item with ID 2 from the list of results (in place).

Filter (without removing anything from the original list):

filtered = result, var filtered = result, var filtered = result, var All items except the one with ID 2 are returned when where(f => f.ID!= 2); is used.

Detailed answer:

I believe. Because you might have a list of item IDs that you want to remove, RemoveAll() is quite flexible – see the example below.

If you have:

class myClass {
    public int ID; public string FirstName; public string LastName;

and assigned the following values to the outcomes:

var results = new List<myClass> {
    new myClass { ID=1, FirstName="Bill", LastName="Smith" },   // results[0]
    new myClass { ID=2, FirstName="John", LastName="Wilson" },  // results[1]
    new myClass { ID=3, FirstName="Doug", LastName="Berg" },    // results[2]
    new myClass { ID=4, FirstName="Bill", LastName="Wilson" }   // results[3]

Then you can create a list of IDs that you want to get rid of:

var removeList = new List<int>() { 2, 3 };

And just use this to get rid of them:

results.RemoveAll(r => removeList.Any(a => a==r.ID));

The items 2 and 3 will be removed, while items 1 and 4 will be kept, as indicated by the removeList. It’s worth noting that this occurs in real time, so no additional planning is required.

Of course, you may use it on individual items as well, such as:

results.RemoveAll(r => r.ID==4);

In our example, this will delete Bill with ID 4.

Last but not least, lists include an indexer, which means they may be accessed like a dynamic array, for example, results[3] will provide the fourth member in the results list (because the first element has the index 0, the 2nd has index 1 etc).

So, if you want to eliminate all items with the same first name as the fourth element of the results list, simply follow these steps:

results.RemoveAll(r => results[3].FirstName == r.FirstName);

Note that only John and Doug will remain on the list after that; Bill will be deleted (the first and last element in the example). The list will automatically shrink until there are only two members remaining – and hence the largest permitted index after performing RemoveAll in this example is 1 (results). 1) (Count() – 1) (Count() – 1) (Count() – 1) (Count

Some trivia: You can make a local function using this knowledge.

void myRemove()  { var last = results.Count() - 1; 
                   results.RemoveAll(r => results[last].FirstName == r.FirstName); }

If you call this function twice, what do you think will happen? Like

myRemove(); myRemove(); 

The first call will take Bill out of the first and last positions, the second call will take Doug out of the list, and just John Wilson will remain.

Note that you can now use results[1] instead of var last = results in C# Version 8. results[last]: Count() – 1; and Count() – 1

void myRemove()  =>  results.RemoveAll(r => results[^1].FirstName == r.FirstName); 

As a result, the local variable last is no longer required (see indices and ranges). Furthermore, because it is a one-liner, you can omit the curly braces and instead use =>. Look here for a complete list of Cnew #’s features.

Run the demo with DotNetFiddle.

Answered by Matt

Solution #3

resultList = results.Where(x=>x.Id != 2).ToList();

I like this small Linq helper because it’s simple to use and makes queries with “where not” conditions easier to read:

public static IEnumerable<T> ExceptWhere<T>(this IEnumerable<T> source, Predicate<T> predicate)
    return source.Where(x=>!predicate(x));

//usage in above situation
resultList = results.ExceptWhere(x=>x.Id == 2).ToList();

Answered by KeithS

Solution #4

You don’t say what sort of list you’re working with, but the general List can utilize the RemoveAt(index) or Remove(obj) methods:

// Remove(obj)
var item = resultList.Single(x => x.Id == 2);

// RemoveAt(index)

Answered by mgnoonan

Solution #5

More simplified:

resultList.Remove(resultList.Single(x => x.Id == 2));

A new var object is not required.

Answered by Javier Andres Caicedo

Post is based on