method - list pop c#

¿en qué situación un elemento de System.Collections.Generic.List no se eliminará correctamente?

Question

¿en qué situación un elemento de System.Collections.Generic.List no se eliminará correctamente?

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

verdadero si el artículo se elimina con éxito; de lo contrario, falso. Este método también devuelve falso si el artículo no se encontró en la Lista (De T).

La forma en que lo dicen me hace pensar que es posible que una operación de eliminación de un elemento que se encuentra en la lista (de T) en realidad podría fallar, de ahí esta pregunta.

Answer 1

En el código fuente de Mono para la comparación:

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;
}

Entonces, la documentación es demasiado borrosa

Answer 2

Sí, puede, si está tratando de eliminar un artículo que no está en la lista, se clasifica como un error y devuelve falso para mostrarle que no se eliminó nada.

Esto puede ser útil si luego desea hacer otro código si algo se eliminó realmente.

Actualización: si su clase implementa IEquality y eso arroja una excepción, el código permite que ocurra el lanzamiento, ya que no tiene posibilidad de regresar.

Junto con otros que publican la fuente reflejada, devolver falsa es solo cuando no puede encontrar un elemento.

Actualización: más allá de la fuente de otras personas. Si IndexOf cadena de métodos IndexOf , verás que se reduce a la igualdad y no hace nada especial.

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;
}

Todo el código de ILSpy, no gracias a Red Gate :-)

Answer 3

Si observamos la fuente System.Collections.Generic.List en Reflector, parecería que el elemento que no se encuentra en la colección es de hecho la única forma de que Remove devuelva false.

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

Answer 4

[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;
}

Código arriba vía reflector. Solo no se eliminará si no estuviera en la colección. Estoy adivinando una discrepancia de documentación / lenguaje.