Общий список - перемещение элемента в списке - PullRequest
132 голосов
/ 16 января 2009

Итак, у меня есть общий список, значения oldIndex и newIndex.

Я хочу переместить элемент на oldIndex, на newIndex ... как можно проще.

Есть предложения?

Примечание

Элемент должен находиться между элементами на (newIndex - 1) и newIndex до того, как был удален.

Ответы [ 10 ]

118 голосов
/ 30 марта 2011

Я знаю, что вы сказали "универсальный список", но вы не указали, что вам нужно использовать класс List (T) , так что здесь вы видите что-то другое.

Класс ObservableCollection (T) имеет метод Move , который делает именно то, что вы хотите.

public void Move(int oldIndex, int newIndex)

Под ним в основном реализован так.

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

Итак, как вы можете видеть, метод swap, предложенный другими, по сути, является тем, что ObservableCollection делает в своем собственном методе Move.

ОБНОВЛЕНИЕ 2015-12-30: Вы можете увидеть исходный код для методов Move и MoveItem в corefx теперь для себя без использования Reflector / ILSpy так как .NET с открытым исходным кодом.

117 голосов
/ 16 января 2009
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);
8 голосов
/ 19 февраля 2015

Я знаю, что этот вопрос старый, но я адаптировал ЭТОТ ответ кода JavaScript на C #. Надеюсь, это поможет

 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;
}
8 голосов
/ 16 января 2009

Список .Remove () и Список .RemoveAt () не возвращают удаляемый элемент.

Поэтому вы должны использовать это:

var item = list[oldIndex];
list.RemoveAt(oldIndex);
list.Insert(newIndex, item);
4 голосов
/ 07 августа 2012

Я создал метод расширения для перемещения элементов в списке.

Индекс не должен сдвигаться, если мы перемещаем существующий элемент , поскольку мы перемещаем элемент в существующую позицию индекса в списке.

Пограничный случай, на который ссылается @Oliver ниже (перемещение элемента в конец списка), фактически приведет к сбою тестов, но это сделано специально. Чтобы вставить новый элемент в конец списка, мы просто позвоним List<T>.Add. list.Move(predicate, list.Count) должен потерпеть неудачу, так как эта позиция индекса не существует до движения.

В любом случае я создал два дополнительных метода расширения MoveToEnd и MoveToBeginning, источник которых можно найти здесь .

/// <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);
        };
    }
}
4 голосов
/ 16 января 2009

Вставьте элемент в настоящее время в oldIndex, чтобы быть в newIndex, а затем удалите исходный экземпляр.

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

Примите во внимание, что индекс элемента, который вы хотите удалить, может измениться из-за вставки.

1 голос
/ 16 января 2009

Я бы ожидал либо:

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

... или:

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

... сделал бы трюк, но у меня нет VS для проверки на этой машине.

0 голосов
/ 27 июня 2016

Это более простые парни, просто сделайте это

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

Сделайте то же самое с MoveDown, но измените if для "if (ind! = Concepts.Count ())" и Concepts.Insert (ind + 1, item.ToString ());

0 голосов
/ 13 января 2016

Так я реализовал метод расширения элемента move. Очень хорошо справляется с перемещением до, после и до крайности для элементов.

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);
  }
}
0 голосов
/ 16 января 2009

Самый простой способ:

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

EDIT

Вопрос не очень ясен ... Так как нас не волнует, куда идет элемент list[newIndex], я думаю, что самый простой способ сделать это следующим образом (с или без метода расширения):

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

Это самое быстрое решение, поскольку оно не включает вставки / удаления списка.

Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.
...