LINQ'da birden fazla "sıralama ölçütü"

İki tablo var, moviesve categories, ve ben tarafından sıralı bir listesini almak KategoriNo tarafından birinci ve daha sonra adı .

Film tablosunda üç sütun Kimliği, Ad ve Kategori Kimliği vardır . Kategori tablosunun iki sütun kimliği ve adı vardır .

Aşağıdaki gibi bir şey denedim, ama işe yaramadı.

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

Bunun sizin için çalışması gerekir:

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

Lambda olmayan, sorgu-sözdizimi LINQ kullanarak şunları yapabilirsiniz:

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

[Yorumu adreslemek için DÜZENLE] Sıralama düzenini kontrol etmek için ascending(varsayılan olan ve bu nedenle özellikle kullanışlı olmayan) anahtar kelimeleri kullanın veya descendingşu şekilde:

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

Yeni ekle":

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

Bu benim kutumda çalışıyor. Sıralamak için kullanılabilecek bir şey döndürür. İki değerli bir nesne döndürür.

Benzer, ancak aşağıdaki gibi birleştirilmiş bir sütuna göre sıralamadan farklıdır.

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

DataContext üzerindeki SQL etkinliğini konsola kaydetmek için DataContext'inizde aşağıdaki satırı kullanın - o zaman linq deyimlerinizin veritabanından ne istediğini tam olarak görebilirsiniz:

_db.Log = Console.Out

Aşağıdaki LINQ ifadeleri:

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

VE

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

aşağıdaki SQL'i üretin:

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

Linq içinde bir OrderBy tekrarlamak sonuçta ortaya çıkan SQL çıktısını tersine çevirir gibi görünüyor:

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

VE

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

aşağıdaki SQL'i üretin (Name ve CategoryId anahtarlamalı):

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

Bazı uzantı yöntemleri (aşağıda) oluşturdum, bu yüzden bir IQueryable zaten sipariş edilip edilmediğini düşünmenize gerek yok. Birden fazla mülke göre sipariş vermek istiyorsanız, aşağıdaki gibi yapın:

// 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);

Bu, sıralamayı dinamik olarak, fe listelemek için özellikler listesinden oluşturursanız özellikle yararlıdır.

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);
        }
    }
}

En kolay olmasa da, LINQ kullanarak bunu yapmanın en az bir yolu daha var. Bunu OrberBy()bir IComparer. Yöntemini kullanarak yapabilirsiniz . İlk olarak, bir uygulamaya gerek ICompareriçin Movieböyle sınıfa:

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);
        }
    }
}

Ardından filmleri aşağıdaki sözdizimiyle sipariş edebilirsiniz:

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

Eğer öğelerinden biri için inen için sipariş geçmek gerekirse sadece iç x ve y geçiş Compare() yöntemiMovieComparer buna göre.

Genel depo kullanılıyorsa

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

Başka

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