Intercambiar dos elementos en List <T>

¿Existe una forma LINQ de intercambiar la posición de dos elementos dentro de a list<T>?

Verifique la respuesta de Marc de C #: Buena / mejor implementación del método Swap .

public static void Swap<T>(IList<T> list, int indexA, int indexB)
{
    T tmp = list[indexA];
    list[indexA] = list[indexB];
    list[indexB] = tmp;
}

que puede ser linq-i-fied como

public static IList<T> Swap<T>(this IList<T> list, int indexA, int indexB)
{
    T tmp = list[indexA];
    list[indexA] = list[indexB];
    list[indexB] = tmp;
    return list;
}

var lst = new List<int>() { 8, 3, 2, 4 };
lst = lst.Swap(1, 2);

Quizás alguien piense en una forma inteligente de hacer esto, pero tú no deberías. El intercambio de dos elementos en una lista está intrínsecamente cargado de efectos secundarios, pero las operaciones LINQ deben estar libres de efectos secundarios. Por lo tanto, solo use un método de extensión simple:

static class IListExtensions {
    public static void Swap<T>(
        this IList<T> list,
        int firstIndex,
        int secondIndex
    ) {
        Contract.Requires(list != null);
        Contract.Requires(firstIndex >= 0 && firstIndex < list.Count);
        Contract.Requires(secondIndex >= 0 && secondIndex < list.Count);
        if (firstIndex == secondIndex) {
            return;
        }
        T temp = list[firstIndex];
        list[firstIndex] = list[secondIndex];
        list[secondIndex] = temp;
    }
}

List<T>tiene un Reverse()método, sin embargo, solo invierte el orden de dos (o más) elementos consecutivos .

your_list.Reverse(index, 2);

Donde el segundo parámetro 2indica que estamos invirtiendo el orden de 2 elementos, comenzando con el elemento dado index.

Fuente: https://msdn.microsoft.com/en-us/library/hf2ay11y(v=vs.110).aspx

No existe un método Swap, por lo que debe crear uno usted mismo. Por supuesto que puede linqificarlo, pero eso debe hacerse con una regla (¿no escrita?) En mente: ¡Las operaciones LINQ no cambian los parámetros de entrada!

En las otras respuestas "linqify", la lista (entrada) se modifica y se devuelve, pero esta acción frena esa regla. Si sería extraño tener una lista con elementos sin clasificar, realice una operación LINQ "OrderBy" y luego descubra que la lista de entrada también está ordenada (como el resultado). ¡Esto no está permitido!

¿Entonces como hacemos esto?

Mi primer pensamiento fue simplemente restaurar la colección después de que terminara de iterar. Pero esta es una solución sucia , así que no la use:

static public IEnumerable<T> Swap1<T>(this IList<T> source, int index1, int index2)
{
    // Parameter checking is skipped in this example.

    // Swap the items.
    T temp = source[index1];
    source[index1] = source[index2];
    source[index2] = temp;

    // Return the items in the new order.
    foreach (T item in source)
        yield return item;

    // Restore the collection.
    source[index2] = source[index1];
    source[index1] = temp;
}

Esta solución está sucia porque hace modificar la lista de entrada, incluso si se restaura a su estado original. Esto podría causar varios problemas:

1. La lista podría ser de solo lectura, lo que arrojará una excepción.
2. Si la lista es compartida por varios subprocesos, la lista cambiará para los otros subprocesos durante la duración de esta función.
3. Si ocurre una excepción durante la iteración, la lista no se restaurará. (Esto podría resolverse escribiendo un intento-finalmente dentro de la función Intercambio y poner el código de restauración dentro del bloque finalmente).

Existe una solución mejor (y más breve): simplemente haga una copia de la lista original. (Esto también hace posible usar un IEnumerable como parámetro, en lugar de un IList):

static public IEnumerable<T> Swap2<T>(this IList<T> source, int index1, int index2)
{
    // Parameter checking is skipped in this example.

    // If nothing needs to be swapped, just return the original collection.
    if (index1 == index2)
        return source;

    // Make a copy.
    List<T> copy = source.ToList();

    // Swap the items.
    T temp = copy[index1];
    copy[index1] = copy[index2];
    copy[index2] = temp;

    // Return the copy with the swapped items.
    return copy;
}

Una desventaja de esta solución es que copia la lista completa, lo que consumirá memoria y eso hace que la solución sea bastante lenta.

Podría considerar la siguiente solución:

static public IEnumerable<T> Swap3<T>(this IList<T> source, int index1, int index2)
{
    // Parameter checking is skipped in this example.
    // It is assumed that index1 < index2. Otherwise a check should be build in and both indexes should be swapped.

    using (IEnumerator<T> e = source.GetEnumerator())
    {
        // Iterate to the first index.
        for (int i = 0; i < index1; i++)
            yield return source[i];

        // Return the item at the second index.
        yield return source[index2];

        if (index1 != index2)
        {
            // Return the items between the first and second index.
            for (int i = index1 + 1; i < index2; i++)
                yield return source[i];

            // Return the item at the first index.
            yield return source[index1];
        }

        // Return the remaining items.
        for (int i = index2 + 1; i < source.Count; i++)
            yield return source[i];
    }
}

Y si desea ingresar el parámetro para que sea IEnumerable:

static public IEnumerable<T> Swap4<T>(this IEnumerable<T> source, int index1, int index2)
{
    // Parameter checking is skipped in this example.
    // It is assumed that index1 < index2. Otherwise a check should be build in and both indexes should be swapped.

    using(IEnumerator<T> e = source.GetEnumerator())
    {
        // Iterate to the first index.
        for(int i = 0; i < index1; i++) 
        {
            if (!e.MoveNext())
                yield break;
            yield return e.Current;
        }

        if (index1 != index2)
        {
            // Remember the item at the first position.
            if (!e.MoveNext())
                yield break;
            T rememberedItem = e.Current;

            // Store the items between the first and second index in a temporary list. 
            List<T> subset = new List<T>(index2 - index1 - 1);
            for (int i = index1 + 1; i < index2; i++)
            {
                if (!e.MoveNext())
                    break;
                subset.Add(e.Current);
            }

            // Return the item at the second index.
            if (e.MoveNext())
                yield return e.Current;

            // Return the items in the subset.
            foreach (T item in subset)
                yield return item;

            // Return the first (remembered) item.
            yield return rememberedItem;
        }

        // Return the remaining items in the list.
        while (e.MoveNext())
            yield return e.Current;
    }
}

Swap4 también hace una copia de (un subconjunto de) la fuente. En el peor de los casos, es tan lento y consume memoria como la función Swap2.

Si el orden es importante, debe mantener una propiedad en los objetos "T" en su lista que denote secuencia. Para intercambiarlos, simplemente intercambie el valor de esa propiedad y luego úselo en el .Sort ( comparación con la propiedad de secuencia )