CODEWITHSUNDEEP
c#list
cozzy
cozzy

Reputation: 147

List<List<int>> Remove() method

I'd like to use Remove() method on list of lists, but it's not working for me.
Simple example should say everything:

List<List<int>> list = new List<List<int>>();
list.Add(new List<int> { 0, 1, 2 });
list.Add(new List<int> { 1, 2 });
list.Add(new List<int> { 4 });
list.Add(new List<int> { 0, 1, });

list.Remove(new List<int> { 1, 2 });

If I use RemoveAt(1) it works fine but Remove() not.
It is obviously the same reason that this code returns false:

List<int> l1 = new List<int>();
List<int> l2 = new List<int>();
l1.Add(1);
l2.Add(1);

bool b1 = l1 == l2; // returns False
bool b2 = l1.Equals(l2); // returns False too

So it seems to me that I cannot simply compare two lists or even arrays. I can use loops instead of Remove(), but there must be easier way.

Thanks in advance.

Upvotes: 4

Views: 4713

Answers (6)

Jon Skeet
Jon Skeet

Reputation: 1500555

The problem is that List<T> doesn't override Equals and GetHashCode, which is what List<T> will use when trying to find an item. (In fact, it will use the default equality comparer, which means it'll use the IEquatable<T> implementation if the object implements it, and fall back to object.Equals/GetHashCode if necessary). Equals will return false as you're trying to remove a different object, and the default implementation is to just compare references.

Basically you'd have write a method to compare two lists for equality, and use that to find the index of the entry you want to remove. Then you'd remove by index (using RemoveAt). EDIT: As noted, Enumerable.SequenceEqual can be used to compare lists. This isn't as efficient as it might be, due to not initially checking whether the counts are equal when they can be easily computed. Also, if you only need to compare List<int> values, you can avoid the virtual method call to an equality comparer.

Another alternative is to avoid using a List<List<int>> in the first place - use a List<SomeCustomType> where SomeCustomType includes a List<int>. You can then implement IEquatable<T> in that type. Note that this may well also allow you to encapsulate appropriate logic in the custom type too. I often find that by the type you've got "nested" collection types, a custom type encapsulates the meaning of the inner collection more effectively.

Upvotes: 11

jCoder
jCoder

Reputation: 2319

First approach:

List<int> listToRemove = new List<int> { 1, 2 };
list.RemoveAll(innerList => innerList.Except(listToRemove).Count() == 0);

This also removes the List { 2, 1 }

Second approach (preferred):

List<int> listToRemove = new List<int> { 1, 2 };
list.RemoveAll(innerList => innerList.SequenceEqual(listToRemove));

This removes all lists that contain the same sequence as the provided list.

Upvotes: 6

Grant Thomas
Grant Thomas

Reputation: 45083

This simply won't work because you're tying to remove a brand new list (the new keyword kind of dictates such), not one of the ones you just put in there. For example, the following code create two different lists, inasmuch as they are not the same list, however much they look the same:

var list0 = new List<int> { 1, 2 };

var list1 = new List<int> { 1, 2 };

However, the following creates one single list, but two references to the same list:

var list0 = new List<int> { 1, 2 };

var list1 = list0;

Therefore, you ought to keep a reference to the lists you put in there should you want to act upon them with Remove in the future, such that:

var list0 = new List<int> { 1, 2 };

listOfLists.Remove(list0);

Upvotes: 2

FerranB
FerranB

Reputation: 36807

They are different objects. Try this:

  List<int> MyList =  new List<int> { 1, 2 };   

  List<List<int>> list = new List<List<int>>();
  list.Add(new List<int> { 0, 1, 2 });
  list.Add(MyList);
  list.Add(new List<int> { 4 });
  list.Add(new List<int> { 0, 1, });

  list.Remove(MyList);

Upvotes: 1

Charlie Salts
Charlie Salts

Reputation: 13488

You need to specify the reference to the list you want to remove:

list.Remove(list[1]);

which, really, is the same as

list.RemoveAt(1);

Upvotes: 0

tvanfosson
tvanfosson

Reputation: 532465

List equality is reference equality. It won't remove the list unless it has the same reference as a list in the outer list. You could create a new type that implements equality as set equality rather than reference equality (or you do care about order as well?). Then you could make lists of this type instead.

Upvotes: 4

Related Questions