LINQ Liste<> Déplacer les Éléments vers le haut et vers le bas

Serait-il possible de me dire la meilleure façon de se déplacer des éléments dans une List<> en haut et en bas.

Par exemple, j'ai une classe appelée la construction et la Construction a une liste de Chambres d'objets List<Room>. Les chambres sont ajoutés à l'édifice par son nom, mais je suis à l'aide de cette structure, afin de générer une arborescence. L'utilisateur a la possibilité de déplacer une chambre en haut et en bas à l'intérieur d'un bâtiment.

J'ai essayé d'utiliser .Reverse(index, count) mais cela ne semble pas faire quoi que ce soit:

//can this item actually be moved up (is it at the first position in it's current parent?)
if (moveDirection == MoveDirection.UP)
{
    int roomIndex = parentBuilding.Rooms.IndexOf(room);

    if (roomIndex == 0)
    {
        return;
    }
    else
    {
        //move this room up.                            
        parentBuilding.Rooms.Reverse(roomIndex, 1);
    }
}
L'inverse de la fonction renvoie un IEnumerable qui est dans le sens inverse de la liste, la fonction est utilisée. De sorte que la liste elle-même ne sera pas changé. Vous pouvez utiliser de l'indice de base de remplacement. Si vous avez deux éléments dans une liste et vous souhaitez déplacer le deuxième élément, vous stockez le premier élément dans une variable temporaire et de désigner le deuxième élément pour le premier élément, puis attribuer le deuxième élément de la variable temp.
WinForms ou WPF? Et comment allez-vous générer l' TreeView?
En utilisant MVC 3 avec une lame de Rasoir et je suis en train de construire l'arborescence moi-même et à l'aide de jQuery pour développer et réduire les éléments UL
Qu'entendez-vous par "meilleure" façon? La manière la plus rapide, la plus correcte, la plus rapide à mettre en œuvre?

OriginalL'auteur Andrew Rayner | 2013-02-28

  1. 10

    Créer une liste de l'extension. Appel List<T>.Move(1, MoveDirection.Up).

    public static class ListExtensions
{
    public static void Move<T>(this IList<T> list, int iIndexToMove, 
        MoveDirection direction)
    {

        if (direction == MoveDirection.Up)
        {
            var old = list[iIndexToMove - 1];
            list[iIndexToMove - 1] = list[iIndexToMove];
            list[iIndexToMove] = old;
        }
        else
        {
            var old = list[iIndexToMove + 1];
            list[iIndexToMove + 1] = list[iIndexToMove];
            list[iIndexToMove] = old;
        }
    }
}

public enum MoveDirection
{
    Up,
    Down
}

    Choses à considérer

    • La gestion des exceptions - ce que si vous essayez de déplacer la bas
      élément bas ou en haut de l'élément? Vous recevrez un index out of range
      parce que vous ne pouvez pas vous déplacer vers le haut ou vers le bas.

    • On pourrait améliorer cette situation et empêcher la manipulation d'exception, par l'extension
      la fonctionnalité de déplacement de l'élément de plus haut niveau de l'élément inférieur et
      élément bas vers le haut de l'élément etc.

    Merci j'ai utilisé cet exemple, je vais vérifier ce que l'Indice actuel est avant que j'ai essayer de déplacer un élément.

    OriginalL'auteur LukeHennerley

  2. 4

    Viens de faire un swap:

    int roomIndex = parentBuilding.Rooms.IndexOf(room);

if (roomIndex == 0)
{
    return;
}
else
{
    //move this room up.                            
    var temp = parentBuilding.Rooms[index-1];
    parentBuilding.Rooms[index-1] = parentBuilding.Rooms[index];
    parentBuilding.Rooms[index] = temp;
}
    Vous semblez avoir de la sawped certaines lettres dans votre texte.

    OriginalL'auteur Dave Bish

  3. 1

    Personnellement, je voudrais faire une extension de la méthode:

    static void Swap<TSource>(this IList<TSource> source, int fromIndex, int toIndex)
{
    if (source == null)
        throw new ArgumentNullExcpetion("source");

    TSource tmp = source[toIndex];
    source[toIndex] = source[fromIndex];
    source[fromIndex] = tmp;
}

    Utilisation:

    if (moveDirection == MoveDirection.UP)
{
    int roomIndex = parentBuilding.Rooms.IndexOf(room);

    if (roomIndex == 0)
    {
        return;
    }
    else
    {
        //move this room up.                            
        parentBuilding.Rooms.Swap(roomIndex, roomIndex - 1);
    }
}
    C'est le "swap", je pense.
    Oui, merci.

    OriginalL'auteur Leri

  4. 0

    Comment sur l'utilisation de SortedDictionary<int, Room> au lieu d'une liste. Vous pouvez stocker un index en tant que Clé du Dictionnaire et juste changer les valeurs en cas de besoin.

    Vous ne pouvez pas compter sur un Dictionnaire<K,V> pour retourner le contenu dans l'ordre spécifié par la clé. Le dictionnaire utilise une table de hachage en interne.
    Maintenant, il sera de retour dans le bon ordre, mais vous ne pouvez pas modifier la clé sans retrait/remise en place des valeurs, ce qui n'est pas efficace.
    Je n'ai rien écrit sur le retrait et la réinsertion. J'ai mentionné le fait de permuter les valeurs comme ceci: var temp = dictionnaire[index]; dictionnaire[index] = dictionnaire[index+1] ; dictionnaire[index + 1] = temp;
    Alors pourquoi êtes-vous à l'aide d'un dictionnaire?
    car triés dictionnaire est plus expressive à propos de l'exigence précisée dans la question. Mon avis, bien sûr.

    OriginalL'auteur TKharaishvili

  5. 0

    Échangent leurs places avec la pièce qui sert à être au-dessus devrait le faire:

    int roomIndex = parentBuilding.Rooms.IndexOf(room);

if (roomIndex == 0)
{
    return;
}

var wasAbove = parentBuilding.Rooms[roomIndex - 1];
parentBuilding.Rooms[roomIndex - 1] = room;
parentBuilding.Rooms[roomIndex] = wasAbove;

    Cela dit, je ne suis pas sûr que ce soit le meilleur modèle d'objet pour la situation; il n'est pas clair que l'ordre de chambres dans la liste joue un rôle, et il n'est également pas clair comment une pièce peut être "déplacé" -- qu'est-ce que cela signifie?

    Il pourrait être préférable d'avoir un RoomPlacement classe que les agrégats d'une chambre et d'assez d'informations pour le localiser, et de travailler avec la place.

    OriginalL'auteur Jon

  6. 0

    essayez ceci:

    int newIndex = whateverIndexYouWantItAt;

int oldIndex = parentBuilding.Rooms.IndexOf(room);
var item = parentBuilding.Rooms[oldIndex];

list.RemoveAt(oldIndex);

if (newIndex > oldIndex) newIndex--; 

parentBuilding.Rooms.Insert(newIndex, item);
    Je pense que l'insertion et le retrait d'une liste n'est pas efficace. Je pense que c'est mieux pour permuter les valeurs au lieu de cela, et de garder la liste à la même taille tout le temps.
    donc, si vous voulez déplacer un seul endroit, vous serait tout simplement faire newIndex = oldIndex - 1; je suppose

    OriginalL'auteur Toon Casteele