Lista ogólna - przenoszenie pozycji w ramach listy

Mam więc listę ogólną oraz wartość oldIndexi newIndex.

Chcę przenieść element o adres oldIndexdo newIndex... tak prosto, jak to możliwe.

Jakieś sugestie?

Uwaga

Przedmiot powinien znaleźć się między elementami na miejscu (newIndex - 1)i newIndex przed jego usunięciem.

Wiem, że powiedziałeś „lista ogólna”, ale nie określiłeś, że musisz użyć klasy List (T), więc oto próbka na coś innego.

Klasa ObservableCollection (T) ma metodę Move, która robi dokładnie to, co chcesz.

public void Move(int oldIndex, int newIndex)

Pod spodem jest zasadniczo zaimplementowany w ten sposób.

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

Jak widać, metoda zamiany, którą sugerowali inni, jest zasadniczo tym, co robi ObservableCollection w swojej własnej metodzie Move.

AKTUALIZACJA 2015-12-30: Możesz teraz zobaczyć kod źródłowy metod Move i MoveItem w corefx teraz dla siebie bez używania Reflector / ILSpy, ponieważ .NET jest 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);

Wiem, że to pytanie jest stare, ale dostosowałem TĘ odpowiedź kodu javascript do C #. Mam nadzieję, że to pomoże

 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 () i List <T> .RemoveAt () nie zwracają usuwanego elementu.

Dlatego musisz tego użyć:

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

Wstaw element, w którym aktualnie oldIndexma być, newIndexa następnie usuń oryginalne wystąpienie.

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

Musisz wziąć pod uwagę, że indeks elementu, który chcesz usunąć, może ulec zmianie w wyniku wstawienia.

Stworzyłem metodę rozszerzenia do przenoszenia elementów na liście.

Indeks nie powinien się przesuwać, jeśli przenosimy istniejący element, ponieważ przenosimy element do istniejącej pozycji indeksu na liście.

Przypadek skrajny, do którego odnosi się @Oliver poniżej (przeniesienie elementu na koniec listy) w rzeczywistości spowodowałby niepowodzenie testów, ale jest to zgodne z projektem. Aby wstawić nową pozycję na końcu listy, po prostu zadzwonilibyśmy List<T>.Add. list.Move(predicate, list.Count) powinien nie powieść, ponieważ ta pozycja indeksu nie istnieje przed ruchem.

W każdym razie, mam utworzone dwa dodatkowe metody rozszerzenie, MoveToEndi MoveToBeginning, których źródłem mogą być znalezione tutaj .

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

Spodziewałbym się:

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

... lub:

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

... by załatwił sprawę, ale nie mam VS na tym komputerze do sprawdzenia.

Najprostszy sposób:

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

EDYTOWAĆ

Pytanie nie jest zbyt jasne ... Ponieważ nie obchodzi nas, dokąd list[newIndex]trafia element, myślę, że najprostszy sposób na zrobienie tego jest następujący (z metodą rozszerzającą lub bez):

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

To rozwiązanie jest najszybsze, ponieważ nie obejmuje wstawiania / usuwania list.

Czy prostsze faceci po prostu to robią

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

Zrób to samo z MoveDown, ale zmień if dla "if (ind! = Concepts.Count ())" i Concepts.Insert (ind + 1, item.ToString ());

W ten sposób zaimplementowałem metodę rozszerzenia elementu Move. Całkiem dobrze radzi sobie z przesuwaniem się przed / po i do skrajności dla elementów.

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