Est-il possible de transformer un IEnumerable en un IOrderedEnumerable sans utiliser OrderBy?

Tout ce que vous devez faire pour le cas par défaut est:

queryRes = values.OrderBy(a => 1);

ce sera effectivement une sorte de noop. Parce que L'OrderBy effectue un tri stable, l'ordre d'origine sera maintenu dans le cas où les objets sélectionnés sont égaux. Notez que puisque c'est un IQueryable et pas IEnumerable il est possible que le fournisseur de requête n'effectue pas un tri stable. Dans ce cas, vous devez savoir s'il est important que l'ordre soit maintenu, ou s'il est approprié de simplement dire "Je ne peu importe l'ordre du résultat, tant que je peux appeler ThenBy sur le résultat).

une Autre option, qui vous permet d'éviter le tri est de créer votre propre IOrderedEnumerable mise en oeuvre:

public class NoopOrder<T> : IOrderedEnumerable<T>
{
    private IQueryable<T> source;
    public NoopOrder(IQueryable<T> source)
    {
        this.source = source;
    }

    public IOrderedEnumerable<T> CreateOrderedEnumerable<TKey>(Func<T, TKey> keySelector, IComparer<TKey> comparer, bool descending)
    {
        if (descending)
        {
            return source.OrderByDescending(keySelector, comparer);
        }
        else
        {
            return source.OrderBy(keySelector, comparer);
        }
    }

    public IEnumerator<T> GetEnumerator()
    {
        return source.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return source.GetEnumerator();
    }
}

Avec votre requête peut être:

queryRes = new NoopOrder<AClass>(values);

Notez que la conséquence de la classe ci-dessus est que si il y a un appel à ThenByThenBy sera effectivement un tri de haut niveau. Il est en effet tourner la suite ThenBy dans un OrderBy appel. (Cela ne devrait pas être surprenant; ThenBy appel CreateOrderedEnumerable méthode, et là ce code appelle OrderBy, EN GROS tourner que ThenBy dans un OrderBy. Du point de vue du tri conceptuel, c'est une façon de dire que "tous les éléments de cette séquence sont égaux aux yeux de ce genre, mais si vous spécifiez que des objets égaux devraient être brisés par quelque chose d'autre, alors faites-le.

une autre façon de penser un "no op sort" est qu'il commande les articles basés dans l'index de la séquence d'entrée. Cela signifie que les articles ne sont pas tous "égaux", cela signifie que l'ordre de la séquence d'entrée être l'ordre final de la séquence de sortie, et comme chaque élément de la séquence d'entrée est toujours plus grand que celui qui le précède, l'ajout de comparaisons supplémentaires ne fera rien, ce qui fait que tout ThenBy appels inutiles. Si ce comportement est désiré, il est encore plus facile à implémenter que le précédent:

public class NoopOrder<T> : IOrderedEnumerable<T>
{
    private IQueryable<T> source;
    public NoopOrder(IQueryable<T> source)
    {
        this.source = source;
    }

    public IOrderedEnumerable<T> CreateOrderedEnumerable<TKey>(Func<T, TKey> keySelector, IComparer<TKey> comparer, bool descending)
    {
        return new NoopOrder<T>(source);
    }

    public IEnumerator<T> GetEnumerator()
    {
        return source.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return source.GetEnumerator();
    }
}