Generische Liste - Verschieben eines Elements innerhalb der Liste

Ich habe also eine generische Liste und einen oldIndexund einen newIndexWert.

Ich möchte den Gegenstand verschieben oldIndex, um newIndex... so einfach wie möglich.

Irgendwelche Vorschläge?

Hinweis

Der Gegenstand sollte zwischen den Gegenständen am (newIndex - 1)und newIndex vor dem Entfernen liegen.

Ich weiß, dass Sie "generische Liste" gesagt haben, aber Sie haben nicht angegeben, dass Sie die List (T) -Klasse verwenden müssen. Hier ist ein Schuss auf etwas anderes.

Die ObservableCollection (T) -Klasse verfügt über eine Move-Methode , die genau das tut, was Sie wollen.

public void Move(int oldIndex, int newIndex)

Darunter ist es grundsätzlich so implementiert.

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

Wie Sie sehen können, ist die von anderen vorgeschlagene Swap-Methode im Wesentlichen das, was die ObservableCollection in ihrer eigenen Move-Methode tut.

UPDATE 30.12.2015: Sie können den Quellcode für die Methoden Move und MoveItem in corefx jetzt selbst anzeigen, ohne Reflector / ILSpy zu verwenden, da .NET Open Source ist.

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

Ich weiß, dass diese Frage alt ist, aber ich habe DIESE Antwort des Javascript-Codes an C # angepasst . Ich hoffe es hilft

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

List <T> .Remove () und List <T> .RemoveAt () geben das zu entfernende Element nicht zurück.

Deshalb müssen Sie dies verwenden:

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

Legen Sie das Element derzeit auf oldIndexseinen an newIndexund dann die ursprüngliche Instanz entfernen.

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

Sie müssen berücksichtigen, dass sich der Index des Elements, das Sie entfernen möchten, aufgrund des Einfügens ändern kann.

Ich habe eine Erweiterungsmethode zum Verschieben von Elementen in einer Liste erstellt.

Ein Index sollte sich nicht verschieben, wenn wir ein vorhandenes Element verschieben, da wir ein Element an eine vorhandene Indexposition in der Liste verschieben.

Der Randfall, auf den sich @Oliver unten bezieht (Verschieben eines Elements an das Ende der Liste), würde tatsächlich dazu führen, dass die Tests fehlschlagen. Dies ist jedoch beabsichtigt. Um ein neues Element am Ende der Liste einzufügen, rufen wir einfach an List<T>.Add. list.Move(predicate, list.Count) sollte fehlschlagen, da diese Indexposition vor dem Verschieben nicht vorhanden ist.

Auf jeden Fall habe ich zwei zusätzliche Erweiterungsmethoden erstellt, MoveToEndund MoveToBeginningdie Quelle von denen gefunden werden kann hier .

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

Ich würde entweder erwarten:

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

... oder:

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

... würde den Trick machen, aber ich habe kein VS auf diesem Computer, um es zu überprüfen.

Einfachster Weg:

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

BEARBEITEN

Die Frage ist nicht sehr klar ... Da es uns egal ist, wohin der list[newIndex]Artikel geht, ist meiner Meinung nach der einfachste Weg, dies zu tun (mit oder ohne Erweiterungsmethode):

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

Diese Lösung ist die schnellste, da keine Listen eingefügt / entfernt werden müssen.

Ist einfacher Jungs machen das einfach

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

Machen Sie dasselbe mit MoveDown, aber ändern Sie das if für "if (ind! = Concepts.Count ())" und das Concepts.Insert (ind + 1, item.ToString ());

So habe ich eine Erweiterungsmethode für Verschiebungselemente implementiert. Es handhabt das Bewegen vor / nach und bis zum Äußersten für Elemente ziemlich gut.

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