Liste générique - déplacer un élément dans la liste

J'ai donc une liste générique et un oldIndex et unnewIndex valeur.

Je souhaite déplacer l'élément à oldIndex , versnewIndex ... aussi simplement que possible.

Aucune suggestion?

Remarque

L'élément doit se retrouver entre les éléments avant(newIndex - 1) et newIndex avant sa suppression.

Je sais que vous avez dit "liste générique" mais vous n'avez pas précisé que vous deviez utiliser la liste (T) classe , alors voici un aperçu de quelque chose de différent.

La classe ObservableCollection (T) a une méthode Move qui fait exactement ce que vous voulez.

public void Move(int oldIndex, int newIndex)

En dessous, il est fondamentalement implémenté comme ça.

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

Ainsi, comme vous pouvez le voir, la méthode d'échange que d'autres ont suggérée est essentiellement ce que fait l' ObservableCollection dans sa propre méthode Move.

MISE À JOUR 2015-12-30: Vous pouvez voir le code source des méthodes Move et MoveItem dans corefx maintenant pour vous-même sans utiliser Reflector / ILSpy puisque .NET est 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);

Je sais que cette question est ancienne mais j'ai adapté CETTE réponse de code javascript en C #. J'espère que ça aide

 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 () et List <T> .RemoveAt () ne renvoient pas l'élément en cours de suppression.

Par conséquent, vous devez utiliser ceci:

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

Insérez l'élément actuellement dans lequel oldIndexse trouver newIndex, puis supprimez l'instance d'origine.

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

Vous devez tenir compte du fait que l'index de l'élément que vous souhaitez supprimer peut changer en raison de l'insertion.

J'ai créé une méthode d'extension pour déplacer des éléments dans une liste.

Un index ne doit pas changer si nous déplaçons un élément existant car nous déplaçons un élément vers une position d'index existante dans la liste.

Le cas de bord auquel @Oliver fait référence ci-dessous (déplacer un élément à la fin de la liste) entraînerait en fait l'échec des tests, mais c'est par conception. Pour insérer un nouvel élément à la fin de la liste, nous appellerions simplement List<T>.Add. list.Move(predicate, list.Count) devrait échouer car cette position d'index n'existe pas avant le déplacement.

Dans tous les cas, j'ai créé deux méthodes d'extension supplémentaires, MoveToEndet MoveToBeginningdont la source peut être trouvée ici .

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

Je m'attendrais soit:

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

... ou:

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

... ferait l'affaire, mais je n'ai pas de VS sur cette machine à vérifier.

Manière la plus simple:

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

ÉDITER

La question n'est pas très claire ... Comme nous ne nous soucions pas de savoir où list[newIndex]va l' élément, je pense que la façon la plus simple de le faire est la suivante (avec ou sans méthode d'extension):

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

Cette solution est la plus rapide car elle n'implique pas d'insertion / suppression de liste.

Est-ce que les gars plus simples font juste ça

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

Faites la même chose avec MoveDown mais modifiez le if pour "if (ind! = Concepts.Count ())" et Concepts.Insert (ind + 1, item.ToString ());

C'est ainsi que j'ai implémenté une méthode d'extension d'élément de déplacement. Il gère assez bien les mouvements avant / après et aux extrêmes pour les éléments.

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