Genel Liste - listedeki bir öğeyi taşıma

Yani genel bir liste ve bir oldIndexve bir newIndexdeğer var.

Ben de öğeyi taşımak istediğiniz oldIndexiçin, newIndex... basitçe mümkün olduğunca.

Baska öneri?

Not

Öğe , kaldırılmadan önceki(newIndex - 1) ve kaldırılmadan newIndex önce öğeler arasında olmalıdır .

"Genel liste" dediğini biliyorum ama burada farklı bir şeye bir atış yani List (T) sınıfını kullanmak için gerekli olduğunu belirtmediniz .

ObservableCollection (T) sınıfı bir sahiptir Taşı yöntemini tam olarak ne istediğinizi yapar.

public void Move(int oldIndex, int newIndex)

Altında temelde böyle uygulanır.

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

Gördüğünüz gibi, başkalarının önerdiği takas yöntemi esasen ObservableCollection'ın kendi Move yönteminde yaptığı şeydir.

GÜNCELLEME 2015-12-30: .NET açık kaynaklı olduğu için Reflector / ILSpy kullanmadan corefx'te Move ve MoveItem yöntemlerinin kaynak kodunu şimdi kendiniz görebilirsiniz.

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

Bu sorunun eski olduğunu biliyorum ama C # javascript kodu BU yanıtı adapte . Umarım yardımcı olur

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

Liste <T> .Remove () ve Liste <T> .RemoveAt () kaldırılmakta olan öğeyi döndürmez.

Bu nedenle bunu kullanmalısınız:

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

Öğe yerleştirin şu anda oldIndexolmak newIndexve daha sonra orijinal örneğini kaldırın.

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

Kaldırmak istediğiniz öğenin dizininin ekleme nedeniyle değişebileceğini dikkate almanız gerekir.

Bir listedeki öğeleri taşımak için bir uzantı yöntemi oluşturdum.

Bir öğeyi listedeki mevcut bir dizin konumuna taşıdığımızdan, mevcut bir öğeyi taşıdığımızda dizin değişmemelidir.

@Oliver'ın aşağıda belirttiği kenar durumu (bir öğeyi listenin sonuna taşımak) aslında testlerin başarısız olmasına neden olur, ancak bu tasarım gereğidir. Listenin sonuna yeni bir öğe eklemek için aramamız yeterli List<T>.Add. taşıma işleminden önce bu dizin konumu olmadığından başarısız list.Move(predicate, list.Count) olmalıdır .

Her durumda, iki ek uzantı yöntemi oluşturdum MoveToEndve MoveToBeginningkaynağı burada bulunabilir .

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

Ben de beklenir:

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

... veya:

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

... hile yapacaktı, ama kontrol etmek için bu makinede VS yok.

En basit yol:

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

DÜZENLE

Soru çok net değil ... Maddenin nereye list[newIndex]gittiğini umursamadığımız için bunu yapmanın en basit yolunun aşağıdaki gibi olduğunu düşünüyorum (bir uzantı yöntemi ile veya bir uzantı yöntemi olmadan):

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

Bu çözüm en hızlı çözümdür, çünkü liste ekleme / kaldırma işlemlerini içermez.

Daha basit çocuklar bunu yapar mı

    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 için de aynısını yapın ancak "if (ind! = Concepts.Count ())" ve Concepts.Insert (ind + 1, item.ToString ());

Bir taşıma elemanı uzantısı yöntemini bu şekilde uyguladım. Oldukça iyi elemanlar için önce / sonra ve aşırı hareket eder.

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