LINQ හි ​​“ඇණවුම් කරන්න”

මට වගු දෙකක් ඇති moviesඅතර categories, මම මුලින්ම කාණ්ඩ අංකයෙන් සහ පසුව නම අනුව ඇණවුම් ලැයිස්තුවක් ලබා ගනිමි .

චිත්‍රපට වගුවේ තීරු ID, නම සහ CategoryID යන තීරු තුනක් ඇත . කාණ්ඩ වගුවේ ID සහ නම යන තීරු දෙකක් ඇත .

මම පහත සඳහන් දේ වැනි දෙයක් උත්සාහ කළ නමුත් එය සාර්ථක වූයේ නැත.

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

මෙය ඔබ වෙනුවෙන් වැඩ කළ යුතුය:

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

ලැම්බඩා නොවන, විමසුම්-සින්ටැක්ස් ලින්ක් භාවිතා කරමින් ඔබට මෙය කළ හැකිය:

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

[අදහස් දැක්වීම සඳහා සංස්කරණය කරන්න] වර්ග කිරීමේ අනුපිළිවෙල පාලනය කිරීම සඳහා, මූලික වචන භාවිතා කරන්න ascending(එය පෙරනිමිය වන අතර එබැවින් විශේෂයෙන් ප්‍රයෝජනවත් නොවේ) හෝ descending, එසේ ය:

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

අලුතින් එකතු කරන්න":

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

ඒක මගේ පෙට්ටියේ වැඩ කරනවා. එය වර්ග කිරීම සඳහා භාවිතා කළ හැකි යමක් ආපසු ලබා දෙයි. එය අගයන් දෙකක් සහිත වස්තුවක් ආපසු ලබා දෙයි.

පහත දැක්වෙන පරිදි ඒකාබද්ධ තීරුවකින් වර්ග කිරීමට සමාන, නමුත් වෙනස් වේ.

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

ඩේටාකොන්ටෙක්ස්ට් හි SQL ක්‍රියාකාරකම් කොන්සෝලය වෙත ලොග් කිරීම සඳහා ඔබේ ඩේටාකොන්ටෙක්ස්ට් හි පහත දැක්වෙන රේඛාව භාවිතා කරන්න - එවිට ඔබේ ලින්ක් ප්‍රකාශයන් දත්ත ගබඩාවෙන් ඉල්ලා සිටින්නේ හරියටම ඔබට දැක ගත හැකිය:

_db.Log = Console.Out

පහත දැක්වෙන LINQ ප්‍රකාශ:

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

සහ

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

පහත SQL නිෂ්පාදනය කරන්න:

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

ෙකෙසේෙවතත්, ලින්ක් හි ඕඩර්බයි එකක් පුනරාවර්තනය කිරීම, එහි ප්‍රති ing ලයක් ෙලස SQL නිමැවුම ආපසු හැරවීමට පෙනේ:

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

සහ

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

පහත SQL නිපදවන්න (නම සහ CategoryId මාරු කර ඇත):

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

මම දීර් extension කිරීමේ ක්‍රම කිහිපයක් (පහළ) නිර්මාණය කර ඇති බැවින් IQueryable එකක් දැනටමත් ඇණවුම් කර තිබේද නැද්ද යන්න ගැන කරදර විය යුතු නැත. ඔබට බහු ගුණාංග අනුව ඇණවුම් කිරීමට අවශ්‍ය නම් එය පහත පරිදි කරන්න:

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

ඔබ ඇණවුම ගතිකව නිර්මාණය කරන්නේ නම් මෙය විශේෂයෙන් උපකාරී වේ, වර්ග කිරීම සඳහා දේපල ලැයිස්තුවකින් fe.

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

පහසුම නොවන නමුත් LINQ භාවිතයෙන් මෙය කිරීමට අවම වශයෙන් තවත් ක්‍රමයක් තිබේ. A භාවිතා කරන OrberBy()ක්‍රමය භාවිතා කිරීමෙන් ඔබට එය කළ හැකිය IComparer. මුලින්ම ඔබ මේ වගේ පන්තියක් IComparerසඳහා ක්‍රියාත්මක කළ යුතුයි Movie:

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

එවිට ඔබට පහත දැක්වෙන වාක්‍ය ඛණ්ඩය සමඟ චිත්‍රපට ඇණවුම් කළ හැකිය:

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

ඔබට එක් අයිතමයක් සඳහා ඇණවුම බැසයාමට අවශ්‍ය නම් Compare() ඒ MovieComparerඅනුව ක්‍රමවේදය තුළ x සහ y මාරු කරන්න .

සාමාන්‍ය නිධිය භාවිතා කරන්නේ නම්

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

නැතිනම්

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