A Lista <T> garante o pedido de inserção?

Digamos que eu tenha três strings em uma lista (por exemplo, "1", "2", "3").

Quero reorganizá-los para colocar "2" na posição 1 (por exemplo, "2", "1", "3").

Estou usando este código (definindo indexToMoveTo como 1):

listInstance.Remove(itemToMove);
listInstance.Insert(indexToMoveTo, itemToMove);

Isso parece funcionar, mas ocasionalmente estou obtendo resultados estranhos; Às vezes, o pedido está incorreto ou os itens da lista estão sendo excluídos!

Alguma ideia? O List<T>pedido de garantia?

Palavras-chave:

Uma Lista <T> garante que os itens serão devolvidos na ordem em que foram adicionados?

A List<>classe garante a ordem - as coisas serão retidas na lista na ordem em que você as adicionar, incluindo duplicatas, a menos que você classifique explicitamente a lista.

De acordo com o MSDN:

... Lista "Representa uma lista fortemente digitada de objetos que podem ser acessados pelo índice ."

Os valores do índice devem permanecer confiáveis ​​para que isso seja preciso. Portanto, o pedido é garantido.

Você pode estar obtendo resultados ímpares do seu código se estiver movendo o item posteriormente na lista, pois você Remove()moverá todos os outros itens para um lugar antes da chamada Insert().

Você pode resumir seu código em algo pequeno o suficiente para postar?

Aqui estão 4 itens, com seu índice

0  1  2  3
K  C  A  E

Você deseja mover K para entre A e E - você pode pensar na posição 3. Você deve ter cuidado com a indexação aqui, porque após a remoção, todos os índices são atualizados.

Então você remove o item 0 primeiro, deixando

0  1  2
C  A  E

Então você insere em 3

0  1  2  3
C  A  E  K

Para obter o resultado correto, você deveria ter usado o índice 2. Para tornar as coisas consistentes, você precisará enviar para (indexToMoveTo-1) if indexToMoveTo > indexToMove, por exemplo

bool moveUp = (listInstance.IndexOf(itemToMoveTo) > indexToMove);
listInstance.Remove(itemToMove);
listInstance.Insert(indexToMoveTo, moveUp ? (itemToMoveTo - 1) : itemToMoveTo);

Isso pode estar relacionado ao seu problema. Observe que meu código não foi testado!

EDIT : Como alternativa, você poderia Sortcom um comparador personalizado ( IComparer) se isso for aplicável à sua situação.

Como Bevan disse, mas lembre-se de que o índice de lista é baseado em 0. Se você deseja mover um elemento para a frente da lista, é necessário inseri-lo no índice 0 (não 1, como mostrado no seu exemplo).

Este é o código que tenho para mover um item para um local da lista:

if (this.folderImages.SelectedIndex > -1 && this.folderImages.SelectedIndex < this.folderImages.Items.Count - 1)
{
    string imageName = this.folderImages.SelectedItem as string;
    int index = this.folderImages.SelectedIndex;

    this.folderImages.Items.RemoveAt(index);
    this.folderImages.Items.Insert(index + 1, imageName);
    this.folderImages.SelectedIndex = index + 1;
 }

e isso para movê-lo um lugar para cima:

if (this.folderImages.SelectedIndex > 0)
{
    string imageName = this.folderImages.SelectedItem as string;
    int index = this.folderImages.SelectedIndex;

    this.folderImages.Items.RemoveAt(index);
    this.folderImages.Items.Insert(index - 1, imageName);
    this.folderImages.SelectedIndex = index - 1;
}

folderImagesé ListBoxclaro que a lista é a ListBox.ObjectCollection, não a List<T>, mas ela é herdada e, IListportanto, deve se comportar da mesma maneira. Isso ajuda?

É claro que o primeiro só funciona se o item selecionado não for o último item da lista e o último se o item selecionado não for o primeiro item.

Se você alterar a ordem das operações, evitará o comportamento estranho: primeiro insira o valor no lugar certo na lista e, em seguida, exclua-o da primeira posição. Exclua-o pelo índice dele, porque se você o excluir por referência, poderá excluir os dois ...