¿La eliminación de elementos de una lista de C# <T> retiene los pedidos de otros artículos?

Question

Últimamente, he estado escribiendo un montón de código que tiene este aspecto:

List<MyObject> myList = new List<MyObject>(); 
... 
for(int i = 0; i < myList.Count; ++i) 
{ 
    if(/*myList[i] meets removal criteria*/) 
    { 
    myList.RemoveAt(i); 
    --i; //Check this index again for the next item 
    //Do other stuff as well 
    } 
} 

y yo acabo de ser un poco paranoico que tal lista no retiene el orden de los objetos en la eliminación. No sé la especificación de C# lo suficientemente bien como para saberlo con certeza. ¿Alguien puede verificar que estoy o no estoy buscando problemas con este patrón?

EDITAR: Tal vez debería aclarar que lo anterior es un ejemplo muy simplificado y que suceden más cosas si el artículo necesita ser eliminado, así que no creo que List<T>.RemoveAll() sea terriblemente aplicable aquí. Aunque es una buena función. He agregado un comentario en el bloque anterior if() para mencionarlo específicamente.

Answer 1

List<T>siempre mantener el orden relativo al agregar, insertar y quitar; no sería una lista si no fuera así.

Aquí está el (ILSpy'ed) código de RemoveAt():

public void RemoveAt(int index) 
{ 
    if (index >= this._size) 
    { 
     ThrowHelper.ThrowArgumentOutOfRangeException(); 
    } 
    this._size--; 
    if (index < this._size) 
    { 
     Array.Copy(this._items, index + 1, this._items, index, this._size - index); 
    } 
    this._items[this._size] = default(T); 
    this._version++; 
} 

Nota copiar la matriz index + 1-index; esos son los artículos que se cambian al por mayor y "exprimen" la matriz juntos. Pero definitivamente no hay reordenamiento de los elementos.

Answer 2

De Reflector:

public void RemoveAt(int index) 
{ 
    if (index >= this._size) 
    { 
     ThrowHelper.ThrowArgumentOutOfRangeException(); 
    } 
    this._size--; 
    if (index < this._size) 
    { 
     Array.Copy(this._items, index + 1, this._items, index, this._size - index); 
    } 
    this._items[this._size] = default(T); 
    this._version++; 
} 

Así, al menos, con la EM' aplicación - artículo en orden no cambia en RemoveAt.

Answer 3

Cuando llame al RemoveAt, se copiarán y desplazarán todos los elementos que siguen al índice que elimine.

Ordene la lista de posiciones en orden descendente y elimine los elementos en ese orden.

foreach (var position in positions.OrderByDescending(x=>x)) 
    list.RemoveAt(position); 

positions es la lista de índices. list es el que desea eliminar (contiene los datos reales).

Answer 4

Está en lo cierto, List<T>.RemoveAt no cambiará el orden de los elementos de la lista.

que el fragmento del embargo podría simplificarse a utilizar List<T>.RemoveAll así:

List<MyObject> myList = new List<MyObject>(); 
... 
myList.RemoveAll(/* Removal predicate */); 

---

Editar comentario siguiente:

myList.Where(/* Removal predicate */).ToList().ForEach(/* Removal code */); 
myList.RemoveAll(/* Removal predicate */); 

Answer 5

El orden debe mantenerse.Un mejor enfoque consiste en recorrer la lista en orden inverso:

for(int i = myList.Count - 1; i >= 0; i--) 
{ 
    if(/*myList[i] meets removal criteria*/) 
    { 
     myList.RemoveAt(i); 
    } 
} 

O usted podría utilizar el RemoveAll method:

myList.RemoveAll(item => [item meets removal criteria]); 

Answer 6

Aunque la respuesta aceptada es una gran respuesta a la pregunta original, la respuesta de la cigarra sugiere una alternativa enfoque.

Con CLR 4 (VS 2010) obtenemos otro enfoque, que tiene la ventaja adicional de ejecutar solo el predicado una vez por elemento (y hacer que sea conveniente evitar escribir el predicado dos veces en nuestro código).

Suponga que tiene un IEnumerable<string>:

IEnumerable<string> myList = new[] {"apples", "bananas", "pears", "tomatoes"}; 

Es necesario dividirla en dos listas en función de si los artículos pasan algunos criterios:

var divided = myList.ToLookup(i => i.Length > 6); 

El objeto devuelto es algo así como un Dictionary de liza. Supongamos que se desea mantener los que pasan los criterios:

myList = divided[true]; 

Y puede utilizar un bucle imperativo familiar para operar en los demás artículos:

foreach (var item in divided[false]) 
    Console.WriteLine("Removed " + item); 

Tenga en cuenta que no hay necesidad de usar List<T> específicamente. Nunca modificamos una lista existente, solo hacemos otras nuevas.