Tengo una consulta linq que quiero pedir por f.bar, que es una cadena, pero también quiero a fin de que por f.foo, que es un campo booleano, en primer lugar. Como la consulta a continuación.

(from f in foo
orderby f.foo, f.bar
select f)

Aunque esto compila no funciona como se esperaba. Solo pedidos por f.barra de ignorar el campo booleano.

Estoy siendo tonto, lo sé, pero ¿qué tengo que hacer para conseguir este comportamiento?

Gracias

3 Comentarios

  1. 162

    Que debería funcionar bien – se debe ordenar a las entidades con un false foo valor en primer lugar, que aquellos con una true foo valor.

    Que sin duda funciona en LINQ to Objects – que proveedor de LINQ está utilizando?

    Aquí una LINQ to Objects ejemplo que hace trabajo:

    using System;
    using System.Linq;
    
    public static class Test
    {
        public static void Main()
        {
            var data = new[]
            {
                new { x = false, y = "hello" },
                new { x = true, y = "abc" },
                new { x = false, y = "def" },
                new { x = true, y = "world" }
            };
    
            var query = from d in data
                        orderby d.x, d.y
                        select d;
    
            foreach (var result in query)
            {
                Console.WriteLine(result);
            }
        }
    
    }
    • Epic fail… sólo dio cuenta de que era debido a un error que significaba f.foo es siempre falso…. tan ridícula
    • Correcto, false (0) viene antes de true (1) en orden ascendente (por defecto) orden de clasificación.
    • How do I grupo el Column1 por el número de verdadero en la Columna 2?
    • Te sugiero hacer una nueva pregunta con un ejemplo detallado.
    • Yo también!!! y yo upvoted @mat.mcloughlin antes!!! xxD
    • Cómo escribirías esta utilizando lambda?
    • Como data.OrderBy(d => d.x).ThenBy(d => d.y)

  2. 99

    Sólo quería hacer esto y parece que algo sin ordenación implícita. Hice lo siguiente para ser más explícito:

    Something.OrderBy(e=>e.SomeFlag ? 0 : 1) 

    para ordenar algo verdadero a falso.

    • En cierto modo me gusta esto más que el construido en el camino. Principalmente porque incluso si hay una implícita de pedidos de verdadero/falso, que en realidad no es obvio para cualquiera que no haya hecho antes. Por lo tanto, alguien que no sabe mirar el código en el futuro podría pensar que tipo true a false, cuando en realidad se ordena false a true… al menos con esta solución, el código hace dolorosamente evidente que el modo en que desea ordenar.
    • sí me gusta que en el código! Si usted tiene que ir a msdn o stackoverflow para leer la documentación para entender el código, a continuación, no es un gran código, en mi opinión
    • Huele como los números de magia para mí. Me equivoco al suponer que todo programador debería intrínsecamente sabemos muy bien que un booleano true significa a single bit set to 1? A mí, la verdad de true > false es tan obvio como puede ser.
    • Sin embargo, veo cómo .OrderBy(e=>e.SomeFlag) podría llevar a cierta confusión, como SomeFlag se supone para ser un tipo numérico (como es el caso con la mayoría de los tipos vemos «en la naturaleza»). Tal vez .OrderBy(e => e.SomeFlag == true) ayudaría a evitar esa confusión. Seguro que funcionaría mejor que la ramificación en enteros, AFAIK.
    • no los números de magia. Explícitos los valores utilizados para la clasificación y ordenación solo. Los valores podrían ser de 42 y 69, el punto es que el lector del código se sabe que uno de ellos es menor, por lo tanto serán los primeros. El lector del código, probablemente, no sé de qué manera un OrderBy va a poner el bools – le verdadero ser el primero, o false ser el primero. true > false no es universalmente conocida, mientras que 1 > 0 es.
    • en VB6 true tiene un valor de -1: stackoverflow.com/questions/4275800/… Cualquier valor distinto de cero puede ser considerado true.
    • Tenga en cuenta que .OrderBy(e => e.SomeFlag == true) sería el equivalente a .OrderBy(e => e.SomeFlag) mientras que .OrderBy(e => e.SomeFlag ? 0 : 1) es el equivalente de .OrderByDescending(e => e.SomeFlag). Los dos primeros tipos false antes de verdadero, los otros dos tipos verdadero antes de falso.
    • Me gustaría reiterar lo que @EriF89 dijo. Jonny, puede usted por favor, actualice su respuesta para cambiar el 0 y el 1 o el estado que tipo de false a true.
    • Lo EriF89 dice es verdad, pero creo que has interpretado mal de ella. Se pone de relieve el problema de tratamiento de bools como números (puede ser confuso!). La lógica en mi respuesta es que si algunos bandera == true return 0 else return 1′ por lo que hace de ordenación de true a false con un orden ascendente
    • disculpas, tienes razón.
    • ¿Cómo sobre la adición de comentarios? Algo.OrderBy(e=>e.SomeFlag) // pedidos falsos antes de la verdad. Pero ver mi respuesta también para un BooleanComparer..

  3. 0

    Con el fin de ser más explícito sobre el fin de ser utilizados.

    Something.OrderBy(e => e.SomeFlage, new BooleanComparer());
    
    public class BooleanComparer : IComparer<bool>
    {
        public int Compare(bool x, bool y)
        {
            int p = x ? 1 : 0;
            int q = y ? 1 : 0;
            return p - q; 
        }
    }

Dejar respuesta

Please enter your comment!
Please enter your name here