Elenco generico: spostamento di un elemento nell'elenco

Quindi ho un elenco generico e un oldIndexe un newIndexvalore.

Voglio spostare l'oggetto in oldIndex, a newIndex... il più semplicemente possibile.

Eventuali suggerimenti?

Nota

L'articolo dovrebbe trovarsi tra gli elementi in (newIndex - 1)e newIndex prima che fosse rimosso.

So che hai detto "elenco generico" ma non hai specificato che dovevi usare la classe List (T) , quindi ecco una panoramica di qualcosa di diverso.

La classe ObservableCollection (T) ha un metodo Move che fa esattamente quello che vuoi.

public void Move(int oldIndex, int newIndex)

Sotto è praticamente implementato in questo modo.

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

Quindi, come puoi vedere, il metodo di scambio suggerito da altri è essenzialmente quello che fa l' ObservableCollection nel suo metodo Move.

AGGIORNAMENTO 2015-12-30: Puoi vedere il codice sorgente per i metodi Move e MoveItem in corefx ora senza usare Reflector / ILSpy poiché .NET è open source.

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

So che questa domanda è vecchia ma ho adattato QUESTA risposta del codice javascript a C #. Spero che sia d'aiuto

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

Elenco <T> .Remove () e Elenco <T> .RemoveAt () non restituiscono l'elemento che viene rimosso.

Pertanto devi usare questo:

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

Inserisci l'elemento attualmente in oldIndexessere in newIndexe quindi rimuovere l'istanza originale.

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

Devi tenere conto del fatto che l'indice dell'articolo che desideri rimuovere potrebbe cambiare a causa dell'inserimento.

Ho creato un metodo di estensione per spostare elementi in un elenco.

Un indice non dovrebbe spostarsi se stiamo spostando un articolo esistente poiché stiamo spostando un articolo in una posizione di indice esistente nell'elenco.

Il caso limite a cui fa riferimento @Oliver di seguito (spostando un elemento alla fine dell'elenco) provocherebbe effettivamente l'esito negativo dei test, ma questo è in base alla progettazione. Per inserire un nuovo elemento alla fine dell'elenco, chiameremmo semplicemente List<T>.Add. list.Move(predicate, list.Count) dovrebbe fallire poiché questa posizione dell'indice non esiste prima dello spostamento.

In ogni caso, ho creato due metodi di estensione aggiuntivi MoveToEnde MoveToBeginningla cui fonte è disponibile qui .

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

Mi aspetterei neanche:

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

... o:

// 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);

... farebbe il trucco, ma non ho VS su questa macchina da controllare.

Il modo più semplice:

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

MODIFICARE

La domanda non è molto chiara ... Dal momento che non ci interessa dove list[newIndex]va l' articolo, penso che il modo più semplice per farlo sia il seguente (con o senza un metodo di estensione):

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

Questa soluzione è la più veloce perché non prevede inserimenti / rimozioni di elenchi.

I ragazzi più semplici lo fanno e basta

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

Fai lo stesso con MoveDown ma modifica if per "if (ind! = Concepts.Count ())" e Concepts.Insert (ind + 1, item.ToString ());

Ecco come ho implementato un metodo di estensione degli elementi di spostamento. Gestisce lo spostamento prima / dopo e agli estremi per elementi abbastanza bene.

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