Lista genérica - movendo um item dentro da lista

Então, eu tenho uma lista genérica, e um oldIndexe um newIndexvalor.

Quero mover o item em oldIndex, para newIndex... o mais simples possível.

Alguma sugestão?

Nota

O item deve terminar entre os itens antes(newIndex - 1) e newIndex depois da remoção.

Eu sei que você disse "lista genérica", mas não especificou que precisava usar a classe List (T), então aqui está uma amostra de algo diferente.

A classe ObservableCollection (T) possui um método Move que faz exatamente o que você deseja.

public void Move(int oldIndex, int newIndex)

Por baixo, é basicamente implementado assim.

T item = base[oldIndex];
base.RemoveItem(oldIndex);
base.InsertItem(newIndex, item);

Portanto, como você pode ver, o método de troca sugerido por outras pessoas é essencialmente o que o ObservableCollection faz em seu próprio método Move.

ATUALIZAÇÃO 30/12/2015: Agora você pode ver o código-fonte dos métodos Move e MoveItem no corefx sem usar o Reflector / ILSpy, pois o .NET é de código aberto.

var item = list[oldIndex];

list.RemoveAt(oldIndex);

if (newIndex > oldIndex) newIndex--; 
// the actual index could have shifted due to the removal

list.Insert(newIndex, item);

Eu sei que esta pergunta é antiga, mas eu adaptei ESTA resposta do código javascript em C #. Espero que ajude

 public static void Move<T>(this List<T> list, int oldIndex, int newIndex)
{

    // exit if possitions are equal or outside array
    if ((oldIndex == newIndex) || (0 > oldIndex) || (oldIndex >= list.Count) || (0 > newIndex) ||
        (newIndex >= list.Count)) return;
    // local variables
    var i = 0;
    T tmp = list[oldIndex];
    // move element down and shift other elements up
    if (oldIndex < newIndex)
    {
        for (i = oldIndex; i < newIndex; i++)
        {
            list[i] = list[i + 1];
        }
    }
        // move element up and shift other elements down
    else
    {
        for (i = oldIndex; i > newIndex; i--)
        {
            list[i] = list[i - 1];
        }
    }
    // put element from position 1 to destination
    list[newIndex] = tmp;
}

List <T> .Remove () e List <T> .RemoveAt () não retornam o item que está sendo removido.

Portanto, você deve usar isto:

var item = list[oldIndex];
list.RemoveAt(oldIndex);
list.Insert(newIndex, item);

Insira o item atualmente em oldIndexestar em newIndexe, em seguida, remova a instância original.

list.Insert(newIndex, list[oldIndex]);
if (newIndex <= oldIndex) ++oldIndex;
list.RemoveAt(oldIndex);

Você deve levar em consideração que o índice do item que você deseja remover pode mudar devido à inserção.

Eu criei um método de extensão para mover itens em uma lista.

Um índice não deve mudar se estiver movendo um item existente, pois estamos movendo um item para uma posição de índice existente na lista.

O caso de borda a que o @Oliver se refere abaixo (mover um item para o final da lista) realmente causaria uma falha nos testes, mas isso ocorre por design. Para inserir um novo item no final da lista, basta ligar List<T>.Add. list.Move(predicate, list.Count) deve falhar, pois essa posição de índice não existe antes da movimentação.

De qualquer forma, criei dois métodos de extensão adicionais MoveToEnde MoveToBeginning, cuja fonte pode ser encontrada aqui .

/// <summary>
/// Extension methods for <see cref="System.Collections.Generic.List{T}"/>
/// </summary>
public static class ListExtensions
{
    /// <summary>
    /// Moves the item matching the <paramref name="itemSelector"/> to the <paramref name="newIndex"/> in a list.
    /// </summary>
    public static void Move<T>(this List<T> list, Predicate<T> itemSelector, int newIndex)
    {
        Ensure.Argument.NotNull(list, "list");
        Ensure.Argument.NotNull(itemSelector, "itemSelector");
        Ensure.Argument.Is(newIndex >= 0, "New index must be greater than or equal to zero.");

        var currentIndex = list.FindIndex(itemSelector);
        Ensure.That<ArgumentException>(currentIndex >= 0, "No item was found that matches the specified selector.");

        // Copy the current item
        var item = list[currentIndex];

        // Remove the item
        list.RemoveAt(currentIndex);

        // Finally add the item at the new index
        list.Insert(newIndex, item);
    }
}

[Subject(typeof(ListExtensions), "Move")]
public class List_Move
{
    static List<int> list;

    public class When_no_matching_item_is_found
    {
        static Exception exception;

        Establish ctx = () => {
            list = new List<int>();
        };

        Because of = ()
            => exception = Catch.Exception(() => list.Move(x => x == 10, 10));

        It Should_throw_an_exception = ()
            => exception.ShouldBeOfType<ArgumentException>();
    }

    public class When_new_index_is_higher
    {
        Establish ctx = () => {
            list = new List<int> { 1, 2, 3, 4, 5 };
        };

        Because of = ()
            => list.Move(x => x == 3, 4); // move 3 to end of list (index 4)

        It Should_be_moved_to_the_specified_index = () =>
            {
                list[0].ShouldEqual(1);
                list[1].ShouldEqual(2);
                list[2].ShouldEqual(4);
                list[3].ShouldEqual(5);
                list[4].ShouldEqual(3);
            };
    }

    public class When_new_index_is_lower
    {
        Establish ctx = () => {
            list = new List<int> { 1, 2, 3, 4, 5 };
        };

        Because of = ()
            => list.Move(x => x == 4, 0); // move 4 to beginning of list (index 0)

        It Should_be_moved_to_the_specified_index = () =>
        {
            list[0].ShouldEqual(4);
            list[1].ShouldEqual(1);
            list[2].ShouldEqual(2);
            list[3].ShouldEqual(3);
            list[4].ShouldEqual(5);
        };
    }
}

Eu esperaria:

// Makes sure item is at newIndex after the operation
T item = list[oldIndex];
list.RemoveAt(oldIndex);
list.Insert(newIndex, item);

... ou:

// Makes sure relative ordering of newIndex is preserved after the operation, 
// meaning that the item may actually be inserted at newIndex - 1 
T item = list[oldIndex];
list.RemoveAt(oldIndex);
newIndex = (newIndex > oldIndex ? newIndex - 1, newIndex)
list.Insert(newIndex, item);

... faria o truque, mas não tenho o VS nesta máquina para verificar.

Maneira mais simples:

list[newIndex] = list[oldIndex];
list.RemoveAt(oldIndex);

EDITAR

A questão não é muito clara ... Como não nos importamos para onde o list[newIndex]item vai, acho que a maneira mais simples de fazer isso é a seguinte (com ou sem um método de extensão):

    public static void Move<T>(this List<T> list, int oldIndex, int newIndex)
    {
        T aux = list[newIndex];
        list[newIndex] = list[oldIndex];
        list[oldIndex] = aux;
    }

Esta solução é a mais rápida porque não envolve inserções / remoções de listas.

São caras mais simples, basta fazer isso

    public void MoveUp(object item,List Concepts){

        int ind = Concepts.IndexOf(item.ToString());

        if (ind != 0)
        {
            Concepts.RemoveAt(ind);
            Concepts.Insert(ind-1,item.ToString());
            obtenernombres();
            NotifyPropertyChanged("Concepts");
        }}

Faça o mesmo com MoveDown, mas altere o if for "if (ind! = Concepts.Count ())" e o Concepts.Insert (ind + 1, item.ToString ());

Foi assim que implementei um método de extensão de elemento de movimentação. Ele lida muito bem com a movimentação antes / depois e nos extremos dos elementos.

public static void MoveElement<T>(this IList<T> list, int fromIndex, int toIndex)
{
  if (!fromIndex.InRange(0, list.Count - 1))
  {
    throw new ArgumentException("From index is invalid");
  }
  if (!toIndex.InRange(0, list.Count - 1))
  {
    throw new ArgumentException("To index is invalid");
  }

  if (fromIndex == toIndex) return;

  var element = list[fromIndex];

  if (fromIndex > toIndex)
  {
    list.RemoveAt(fromIndex);
    list.Insert(toIndex, element);
  }
  else
  {
    list.Insert(toIndex + 1, element);
    list.RemoveAt(fromIndex);
  }
}