in what situation will an item in System.Collections.Generic.List not be removed successfully?

Question

in what situation will an item in System.Collections.Generic.List not be removed successfully?

From http://msdn.microsoft.com/en-us/library/cd666k3e.aspx:

true if item is successfully removed; otherwise, false. This method also returns false if item was not found in the List(Of T).

The way they phrase it makes me think that it is possible that a Remove operation on an item found in the List(Of T) could actually fail, hence this question.

Flotation

I understand it failing if the item was not found, but am also interested as to how else it can fail... Good question :) – Paleo

Answer 1

Looking at the System.Collections.Generic.List source in Reflector, it would appear that the item not being found in the collection is indeed the only way for Remove to return false.

int index = this.IndexOf(item);
if (index >= 0)
{
    this.RemoveAt(index);
    return true;
}
return false;

Coacher

Answer 2

Yes it can, if you are trying to remove an item that isn't in the list - it is classed as a fail and returns false to show you that nothing was removed.

This can be useful if you then want to do other code if something was actually removed.

Update: if your class implements IEquality and that throws an exception, the code lets the throw occur, as in it doesn't get a chance to return.

Coupled with others posting the reflected source, returning false is only when it cannot find an item.

Update: further to other people's source. If you look at the IndexOf chain of methods, you will see that it boils down to equality and does nothing special.

List.Remove:

public bool Remove(T item)
{
    int num = this.IndexOf(item);
    if (num >= 0)
    {
        this.RemoveAt(num);
        return true;
    }
    return false;
}

List.IndexOf:

public int IndexOf(T item)
{
    return Array.IndexOf<T>(this._items, item, 0, this._size);
}

Array.IndexOf:

public static int IndexOf<T>(T[] array, T value, int startIndex, int count)
{
    if (array == null)
    {
        throw new ArgumentNullException("array");
    }
    if (startIndex < 0 || startIndex > array.Length)
    {
        throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_Index"));
    }
    if (count < 0 || count > array.Length - startIndex)
    {
        throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_Count"));
    }
    return EqualityComparer<T>.Default.IndexOf(array, value, startIndex, count);
}

EqualityComparer.IndexOf:

internal virtual int IndexOf(T[] array, T value, int startIndex, int count)
{
    int num = startIndex + count;
    for (int i = startIndex; i < num; i++)
    {
        if (this.Equals(array[i], value))
        {
            return i;
        }
    }
    return -1;
}

All code from ILSpy, no thanks to Red Gate :-)

Paulus

The MSDN docs quoted state that it returns false if the item was not found in the list, as well as if it is not successfully removed... – Paleo

Answer 3

[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
public bool Remove(T item)
{
    int index = this.IndexOf(item);
    if (index >= 0)
    {
        this.RemoveAt(index);
        return true;
    }
    return false;
}

Code above via reflector. Will only not be removed if it wasn't in the collection. I'm guessing a documentation/language discrepancy.

Tremulous

Answer 4

In Mono's source code for comparison:

https://github.com/mono/mono/raw/master/mcs/class/corlib/System.Collections.Generic/List.cs

public bool Remove (T item)
{
    int loc = IndexOf (item);
    if (loc != -1)
        RemoveAt (loc);

    return loc != -1;
}

So, the documentation is overly fuzzy

Philemon