c# - array - Pedido de LinqPor contra valores específicos

string linq c#

Question

¿Hay alguna manera en Linq de hacer un pedido por un conjunto de valores (cadenas en este caso) sin conocer el orden de los valores?

Considera esta información:

A
B
A
C
B
C
D
E

Y estas variables:

string firstPref, secondPref, thirdPref;

Cuando los valores se establecen así:

firstPref = ''A'';
secondPref = ''B'';
thirdPref = ''C'';

¿Es posible ordenar los datos de esta manera?

A
A
B
B
C
C
D
E

Answer 1

La solución Danbrucs es más elegante, pero aquí hay una solución que usa un IComparer personalizado. Esto podría ser útil si necesita condiciones más avanzadas para su ordenamiento.

 string[] svals = new string[] {"A", "B", "A", "C", "B", "C", "D", "E"};
List<string> list = svals.OrderBy(a => a, new CustomComparer()).ToList();
private class CustomComparer : IComparer<string>
{
private string firstPref = "A";
private string secondPref = "B";
private string thirdPref = "C";
public int Compare(string x, string y)
{
// first pref
if (y == firstPref && x == firstPref)
return 0;
else if (x == firstPref && y != firstPref)
return -1;
else if (y == firstPref && x != firstPref)
return 1;
// second pref
else if (y == secondPref && x == secondPref)
return 0;
else if (x == secondPref && y != secondPref)
return -1;
else if (y == secondPref && x != secondPref)
return 1;
// third pref
else if (y == thirdPref && x == thirdPref)
return 0;
else if (x == thirdPref && y != thirdPref)
return -1;
else
return string.Compare(x, y);
}
}

Answer 2

Pon los valores preferidos en un diccionario. Buscar claves en un diccionario es una operación O (1) en comparación con encontrar valores en una lista que es una operación O (n), por lo que escala mucho mejor.

Cree una cadena de clasificación para cada valor preferido para que se coloquen antes que los otros valores. Para los otros valores, el valor en sí mismo se usará como una cadena de clasificación para que estén realmente ordenados. (El uso de cualquier valor alto arbitrario solo los ubicaría al final de la lista sin clasificar).

List<string> data = new List<string> {
"E", "B", "D", "A", "C", "B", "A", "C"
};
var preferences = new Dictionary<string, string> {
{ "A", " 01" },
{ "B", " 02" },
{ "C", " 03" }
};
string key;
IEnumerable<String> orderedData = data.OrderBy(
item => preferences.TryGetValue(item, out key) ? key : item
);

Answer 3

Sí, debe implementar su propio IComparer<string> y luego pasarlo como el segundo argumento del método OrderBy de LINQ.

Puede encontrar un ejemplo aquí: Ordenar los resultados de LINQ

Answer 4

Si coloca sus preferencias en una lista, podría ser más fácil.

List<String> data = new List<String> { "A","B","A","C","B","C","D","E" };
List<String> preferences = new List<String> { "A","B","C" };
IEnumerable<String> orderedData = data.OrderBy(
item => preferences.IndexOf(item));

Esto colocará todos los elementos que no aparecen en las preferences al frente porque IndexOf() devuelve -1 . Un trabajo ad hoc podría revertir las preferences y ordenar el resultado descendente. Esto se vuelve bastante feo, pero funciona.

IEnumerable<String> orderedData = data.OrderByDescending(
item => Enumerable.Reverse(preferences).ToList().IndexOf(item));

La solución se vuelve un poco más agradable si concat preferences y data .

IEnumerable<String> orderedData = data.OrderBy(
item => preferences.Concat(data).ToList().IndexOf(item));

No me gusta Concat() y ToList() allí. Pero por el momento no tengo una buena manera de evitar eso. Estoy buscando un buen truco para convertir el -1 del primer ejemplo en un gran número.

Answer 5

Combinadas todas las respuestas (y más) en una extensión LINQ genérica que admite el almacenamiento en caché que maneja cualquier tipo de datos, puede diferenciar entre mayúsculas y minúsculas y permite ser encadenado con pre y post orden:

public static class SortBySample
{
public static BySampleSorter<TKey> Create<TKey>(IEnumerable<TKey> fixedOrder, IEqualityComparer<TKey> comparer = null)
{
return new BySampleSorter<TKey>(fixedOrder, comparer);
}
public static BySampleSorter<TKey> Create<TKey>(IEqualityComparer<TKey> comparer, params TKey[] fixedOrder)
{
return new BySampleSorter<TKey>(fixedOrder, comparer);
}
public static IOrderedEnumerable<TSource> OrderBySample<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, BySampleSorter<TKey> sample)
{
return sample.OrderBySample(source, keySelector);
}
public static IOrderedEnumerable<TSource> ThenBySample<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector, BySampleSorter<TKey> sample)
{
return sample.ThenBySample(source, keySelector);
}
}
public class BySampleSorter<TKey>
{
private readonly Dictionary<TKey, int> dict;
public BySampleSorter(IEnumerable<TKey> fixedOrder, IEqualityComparer<TKey> comparer = null)
{
this.dict = fixedOrder
.Select((key, index) => new KeyValuePair<TKey, int>(key, index))
.ToDictionary(kv => kv.Key, kv => kv.Value, comparer ?? EqualityComparer<TKey>.Default);
}
public BySampleSorter(IEqualityComparer<TKey> comparer, params TKey[] fixedOrder)
: this(fixedOrder, comparer)
{
}
public IOrderedEnumerable<TSource> OrderBySample<TSource>(IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
{
return source.OrderBy(item => this.GetOrderKey(keySelector(item)));
}
public IOrderedEnumerable<TSource> ThenBySample<TSource>(IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector)
{
return source.CreateOrderedEnumerable(item => this.GetOrderKey(keySelector(item)), Comparer<int>.Default, false);
}
private int GetOrderKey(TKey key)
{
int index;
return dict.TryGetValue(key, out index) ? index : int.MaxValue;
}
}

Uso de muestra utilizando LINQPad-Dump ():

var sample = SortBySample.Create(StringComparer.OrdinalIgnoreCase, "one", "two", "three", "four");
var unsorted = new[] {"seven", "six", "five", "four", "THREE", "tWo", "One", "zero"};
unsorted
.OrderBySample(x => x, sample)
.ThenBy(x => x)
.Dump("sorted by sample then by content");
unsorted
.OrderBy(x => x.Length)
.ThenBySample(x => x, sample)
.Dump("sorted by length then by sample");

Answer 6

Además de @Daniel Brückner respuesta y problema definido al final de la misma:

No me gusta Concat () y ToList () allí. Pero por el momento no tengo una buena> manera de evitarlo. Estoy buscando un buen truco para convertir el -1 del primer> ejemplo en un gran número.

Creo que la solución es usar una declaración lambda en lugar de una expresión lambda.

var data = new List<string> { "corge", "baz", "foo", "bar", "qux", "quux" };
var fixedOrder = new List<string> { "foo", "bar", "baz" };
data.OrderBy(d => {
var index = fixedOrder.IndexOf(d);
return index == -1 ? int.MaxValue : index;
});

La información ordenada es:

foo
bar
baz
corge
qux
quux 

Answer 7

No es realmente eficiente para listas grandes pero bastante fácil de leer:

public class FixedOrderComparer<T> : IComparer<T>
{
private readonly T[] fixedOrderItems;
public FixedOrderComparer(params T[] fixedOrderItems)
{
this.fixedOrderItems = fixedOrderItems;
}
public int Compare(T x, T y)
{
var xIndex = Array.IndexOf(fixedOrderItems, x);
var yIndex = Array.IndexOf(fixedOrderItems, y);
xIndex = xIndex == -1 ? int.MaxValue : xIndex;
yIndex = yIndex == -1 ? int.MaxValue : yIndex;
return xIndex.CompareTo(yIndex);
}
}

Uso:

var orderedData = data.OrderBy(x => x, new FixedOrderComparer<string>("A", "B", "C"));

Nota: Array.IndexOf<T>(....) usa EqualityComparer<T>.Default para encontrar el índice de destino.