Загальний список - переміщення елемента в списку

Отже, у мене є загальний список, і значення, oldIndexі newIndexзначення.

Я хочу перемістити предмет на oldIndex, до newIndex... якомога простіше.

Будь-які пропозиції?

Примітка

Елемент повинен бути в кінці між елементами на (newIndex - 1)і newIndex до його вилучення.

Я знаю, що ви сказали "загальний список", але ви не вказали, що вам потрібно використовувати клас List (T), тож ось вистрілив щось інше.

Клас ObservableCollection (T) має метод Move, який робить саме те, що ви хочете.

public void Move(int oldIndex, int newIndex)

Внизу це в основному реалізовано так.

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

Отже, як ви можете бачити метод swap, який запропонували інші, - це по суті те, що OservableCollection робить у своєму власному Move методі.

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

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

Я знаю, що це питання давнє, але я адаптував ЦЕ відповідь коду 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;
}

Список <T>. Видалити () та Список <T> .RemoveAt () не повертає вилучений елемент.

Тому ви повинні використовувати це:

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

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

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

Ви повинні врахувати, що індекс елемента, який ви хочете вилучити, може змінюватися через вставку.

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

Індекс не повинен зміщуватися, якщо ми переміщуємо існуючий елемент, оскільки ми переміщуємо елемент до існуючого позиції індексу у списку.

Крайній випадок, на який @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);
        };
    }
}

Я очікував би будь-якого:

// 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 на цій машині для перевірки.

Найпростіший спосіб:

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

Це рішення є найшвидшим, оскільки воно не включає вставки / видалення списків.

Більш прості хлопці просто роблять це

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

Ось як я реалізував метод розширення елемента переміщення. Він досить добре справляється з переміщенням до / після і до крайностей для елементів.

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