Multiple «commander par» dans LINQ

J'ai deux tables, movieset categories, et j'obtiens une liste ordonnée par categoryID d' abord, puis par nom .

La table de film a trois colonnes ID, Name et CategoryID . Le tableau des catégories comporte deux colonnes ID et Nom .

J'ai essayé quelque chose comme ce qui suit, mais cela n'a pas fonctionné.

var movies = _db.Movies.OrderBy( m => { m.CategoryID, m.Name })

Cela devrait fonctionner pour vous:

var movies = _db.Movies.OrderBy(c => c.Category).ThenBy(n => n.Name)

En utilisant LINQ non-lambda, à syntaxe de requête, vous pouvez faire ceci:

var movies = from row in _db.Movies 
             orderby row.Category, row.Name
             select row;

[MODIFIER pour répondre au commentaire] Pour contrôler l'ordre de tri, utilisez les mots-clés ascending(qui sont par défaut et donc pas particulièrement utiles) ou descending, comme ceci:

var movies = from row in _db.Movies 
             orderby row.Category descending, row.Name
             select row;

Ajouter "nouveau":

var movies = _db.Movies.OrderBy( m => new { m.CategoryID, m.Name })

Cela fonctionne sur ma boîte. Il retourne quelque chose qui peut être utilisé pour trier. Il renvoie un objet avec deux valeurs.

Similaire, mais différent du tri par colonne combinée, comme suit.

var movies = _db.Movies.OrderBy( m => (m.CategoryID.ToString() + m.Name))

utilisez la ligne suivante sur votre DataContext pour consigner l'activité SQL sur le DataContext sur la console - vous pouvez alors voir exactement ce que vos instructions linq demandent à la base de données:

_db.Log = Console.Out

Les instructions LINQ suivantes:

var movies = from row in _db.Movies 
             orderby row.CategoryID, row.Name
             select row;

ET

var movies = _db.Movies.OrderBy(m => m.CategoryID).ThenBy(m => m.Name);

produire le SQL suivant:

SELECT [t0].ID, [t0].[Name], [t0].CategoryID
FROM [dbo].[Movies] as [t0]
ORDER BY [t0].CategoryID, [t0].[Name]

Alors que la répétition d'un OrderBy dans Linq semble inverser la sortie SQL résultante:

var movies = from row in _db.Movies 
             orderby row.CategoryID
             orderby row.Name
             select row;

ET

var movies = _db.Movies.OrderBy(m => m.CategoryID).OrderBy(m => m.Name);

produire le SQL suivant (le nom et le CategoryId sont commutés):

SELECT [t0].ID, [t0].[Name], [t0].CategoryID
FROM [dbo].[Movies] as [t0]
ORDER BY [t0].[Name], [t0].CategoryID

J'ai créé quelques méthodes d'extension (ci-dessous) afin que vous n'ayez pas à vous inquiéter si un IQueryable est déjà commandé ou non. Si vous souhaitez classer par plusieurs propriétés, procédez comme suit:

// We do not have to care if the queryable is already sorted or not. 
// The order of the Smart* calls defines the order priority
queryable.SmartOrderBy(i => i.Property1).SmartOrderByDescending(i => i.Property2);

Cela est particulièrement utile si vous créez l'ordre de manière dynamique, par exemple à partir d'une liste de propriétés à trier.

public static class IQueryableExtension
{
    public static bool IsOrdered<T>(this IQueryable<T> queryable) {
        if(queryable == null) {
            throw new ArgumentNullException("queryable");
        }

        return queryable.Expression.Type == typeof(IOrderedQueryable<T>);
    }

    public static IQueryable<T> SmartOrderBy<T, TKey>(this IQueryable<T> queryable, Expression<Func<T, TKey>> keySelector) {
        if(queryable.IsOrdered()) {
            var orderedQuery = queryable as IOrderedQueryable<T>;
            return orderedQuery.ThenBy(keySelector);
        } else {
            return queryable.OrderBy(keySelector);
        }
    }

    public static IQueryable<T> SmartOrderByDescending<T, TKey>(this IQueryable<T> queryable, Expression<Func<T, TKey>> keySelector) {
        if(queryable.IsOrdered()) {
            var orderedQuery = queryable as IOrderedQueryable<T>;
            return orderedQuery.ThenByDescending(keySelector);
        } else {
            return queryable.OrderByDescending(keySelector);
        }
    }
}

Il existe au moins une autre façon de procéder à l'aide de LINQ, mais ce n'est pas la plus simple. Vous pouvez le faire en utilisant la OrberBy()méthode qui utilise un IComparer. Vous devez d'abord implémenter un IComparerpour la Movieclasse comme ceci:

public class MovieComparer : IComparer<Movie>
{
    public int Compare(Movie x, Movie y)
    {
        if (x.CategoryId == y.CategoryId)
        {
            return x.Name.CompareTo(y.Name);
        }
        else
        {
            return x.CategoryId.CompareTo(y.CategoryId);
        }
    }
}

Ensuite, vous pouvez commander les films avec la syntaxe suivante:

var movies = _db.Movies.OrderBy(item => item, new MovieComparer());

Si vous avez besoin de changer l'ordre en descendant pour l'un des éléments, il suffit de changer les x et y à l'intérieur de la Compare() méthode du en MovieComparerconséquence.

Si utiliser un référentiel générique

> lstModule = _ModuleRepository.GetAll().OrderBy(x => new { x.Level,
> x.Rank}).ToList();

autre

> _db.Module.Where(x=> ......).OrderBy(x => new { x.Level, x.Rank}).ToList();