Danh sách chung - di chuyển một mục trong danh sách

Vì vậy, tôi có một danh sách chung, và một oldIndexvà một newIndexgiá trị.

Tôi muốn chuyển món đồ đó vào oldIndex, newIndex... đơn giản nhất có thể.

Bất kỳ đề xuất?

Ghi chú

Các mục nên được kết thúc giữa các mục tại (newIndex - 1)và newIndex trước khi nó được gỡ bỏ.

Tôi biết bạn đã nói "danh sách chung" nhưng bạn không xác định rằng bạn cần sử dụng Danh sách (T) vì vậy đây là một cách khác biệt.

Lớp ObservableCollection (T) có một phương thức Move thực hiện chính xác những gì bạn muốn.

public void Move(int oldIndex, int newIndex)

Bên dưới nó về cơ bản được thực hiện như thế này.

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

Vì vậy, như bạn có thể thấy phương thức hoán đổi mà những người khác đã đề xuất về cơ bản là những gì mà ObservableCollection thực hiện trong phương thức Move của chính nó.

CẬP NHẬT 2015-12-30: Bạn có thể xem mã nguồn cho các phương thức Move và MoveItem trong corefx ngay bây giờ mà không cần sử dụng Reflector / ILSpy vì .NET là nguồn mở.

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

Tôi biết câu hỏi này đã cũ nhưng tôi đã điều chỉnh câu trả lời NÀY của mã javascript thành C #. Hy vọng nó giúp

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

Danh sách <T> .Remove () và Danh sách <T> .RemoveAt () không trả về mục đang bị xóa.

Vì vậy, bạn phải sử dụng điều này:

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

Chèn mục hiện tại oldIndexvào lúc newIndexđó và sau đó loại bỏ thể hiện ban đầu.

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

Bạn phải tính đến việc chỉ mục của mục bạn muốn xóa có thể thay đổi do chèn.

Tôi đã tạo một phương thức mở rộng để di chuyển các mục trong danh sách.

Một chỉ mục không nên thay đổi nếu chúng ta đang di chuyển một mục hiện có vì chúng ta đang di chuyển một mục sang một mục hiện có vị trí chỉ mục trong danh sách.

Trường hợp cạnh mà @Oliver đề cập dưới đây (di chuyển một mục đến cuối danh sách) thực sự sẽ khiến các bài kiểm tra thất bại, nhưng đây là do thiết kế. Để chèn một mục mới vào cuối danh sách, chúng tôi sẽ chỉ cần gọi List<T>.Add. list.Move(predicate, list.Count) Nên thất bại vì vị trí chỉ số này không tồn tại trước khi di chuyển.

Trong mọi trường hợp, tôi đã tạo hai phương thức mở rộng bổ sung MoveToEndvà MoveToBeginningnguồn có thể được tìm thấy ở đây .

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

Tôi cũng mong đợi:

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

... hoặc là:

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

... sẽ thực hiện thủ thuật, nhưng tôi không có VS trên máy này để kiểm tra.

Cách đơn giản nhất:

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

BIÊN TẬP

Câu hỏi không rõ ràng lắm ... Vì chúng tôi không quan tâm list[newIndex]mục đó đi đâu nên tôi nghĩ cách đơn giản nhất để thực hiện việc này là như sau (có hoặc không có phương thức mở rộng):

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

Giải pháp này là nhanh nhất vì nó không liên quan đến việc chèn / xóa danh sách.

Là những người đơn giản hơn chỉ cần làm điều này

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

Thực hiện tương tự với MoveDown nhưng thay đổi if cho "if (ind! = Conception.Count ())" và Conception.Insert (ind + 1, item.ToString ());

Đây là cách tôi thực hiện một phương thức mở rộng phần tử di chuyển. Nó xử lý di chuyển trước / sau và cực đoan cho các yếu tố khá tốt.

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