Daftar Generik - memindahkan item dalam daftar

Jadi saya punya daftar generik, dan oldIndexdan newIndexnilai.

Saya ingin memindahkan item di oldIndex, ke newIndex... sesederhana mungkin.

Ada saran?

Catatan

Item tersebut harus berada di antara item di (newIndex - 1)dan newIndex sebelum dihapus.

Saya tahu Anda mengatakan "daftar generik" tetapi Anda tidak menentukan bahwa Anda perlu menggunakan kelas Daftar (T) jadi di sini ada kesempatan untuk sesuatu yang berbeda.

Kelas ObservableCollection (T) memiliki metode Pindahkan yang melakukan apa yang Anda inginkan.

public void Move(int oldIndex, int newIndex)

Di bawahnya pada dasarnya dilaksanakan seperti ini.

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

Sehingga Anda dapat melihat metode swap yang disarankan orang lain pada dasarnya adalah apa yang dilakukan ObservableCollection dalam metode Move itu sendiri.

UPDATE 2015-12-30: Anda dapat melihat kode sumber untuk metode Move dan MoveItem di corefx sekarang untuk Anda sendiri tanpa menggunakan Reflector / ILSpy karena .NET adalah 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);

Saya tahu pertanyaan ini sudah lama tetapi saya mengadaptasi respons kode javascript INI ke C #. Semoga ini bisa membantu

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

Daftar <T> .Remove () dan List <T> .RemoveAt () tidak mengembalikan item yang sedang dihapus.

Karena itu Anda harus menggunakan ini:

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

Masukkan item saat ini di oldIndexberada di newIndexkemudian hapus instance asli.

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

Anda harus mempertimbangkan bahwa indeks item yang ingin Anda hapus dapat berubah karena penyisipan.

Saya membuat metode ekstensi untuk memindahkan item dalam daftar.

Indeks tidak boleh bergeser jika kami memindahkan item yang ada karena kami memindahkan item ke posisi indeks yang ada dalam daftar.

Huruf tepi yang @Oliver rujuk di bawah (memindahkan item ke akhir daftar) sebenarnya akan menyebabkan tes gagal, tetapi ini adalah desain. Untuk memasukkan item baru di akhir daftar kami hanya akan memanggil List<T>.Add. list.Move(predicate, list.Count) harus gagal karena posisi indeks ini tidak ada sebelum pindah.

Bagaimanapun, saya telah membuat dua metode ekstensi tambahan, MoveToEnddan MoveToBeginning, sumbernya dapat ditemukan di sini .

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

Saya harapkan:

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

... atau:

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

... akan melakukan trik, tetapi saya tidak memiliki VS pada mesin ini untuk memeriksa.

Cara termudah:

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

EDIT

Pertanyaannya tidak terlalu jelas ... Karena kita tidak peduli ke mana list[newIndex]barang tersebut saya pikir cara paling sederhana untuk melakukan ini adalah sebagai berikut (dengan atau tanpa metode ekstensi):

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

Solusi ini adalah yang tercepat karena tidak melibatkan penyisipan / pemindahan daftar.

Apakah lebih sederhana kawan lakukan saja ini

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

Lakukan hal yang sama dengan MoveDown tetapi ubah if untuk "if (ind! = Concepts.Count ())" dan Concepts.Insert (ind + 1, item.ToString ());

Ini adalah bagaimana saya menerapkan metode ekstensi elemen bergerak. Ini menangani bergerak sebelum / sesudah dan ke ekstrem untuk elemen dengan cukup baik.

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