sql-order-by - LINQ में एकाधिक "ऑर्डर"




(6)

मेरे पास दो टेबल, movies और categories , और मुझे श्रेणी आईडी द्वारा पहले और फिर नाम से ऑर्डर की गई सूची मिलती है।

फिल्म तालिका में तीन कॉलम, आईडी, नाम और श्रेणी आईडी है । श्रेणी तालिका दो में कॉलम, आईडी और नाम हैं

मैंने निम्नलिखित की तरह कुछ करने की कोशिश की, लेकिन यह काम नहीं किया।

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

Answers

गैर-लैम्ब्डा, क्वेरी-सिंटैक्स LINQ का उपयोग करके, आप यह कर सकते हैं:

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;

LINQ का उपयोग करके ऐसा करने के लिए कम से कम एक और तरीका है, हालांकि सबसे आसान नहीं है। आप OrberBy() विधि का उपयोग कर ऐसा कर सकते हैं जो IComparer का उपयोग करता है। सबसे पहले आपको Movie क्लास के लिए IComparer लागू करने की आवश्यकता है:

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

यदि आपको वस्तुओं में से किसी एक के लिए उतरने के क्रम को स्विच करने की आवश्यकता है तो केवल x और y को MovieComparer के Compare() विधि के अंदर स्विच Compare()


यह आपके लिए काम करना चाहिए:

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

कंसोल पर DataContext पर SQL गतिविधि लॉग करने के लिए अपने DataContext पर निम्न पंक्ति का उपयोग करें - फिर आप देख सकते हैं कि आपके linq कथन डेटाबेस से क्या अनुरोध कर रहे हैं:

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

निम्नलिखित एसक्यूएल का उत्पादन करें:

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

जबकि, लिंक में ऑर्डरबी को दोहराना, परिणामस्वरूप 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);

निम्नलिखित एसक्यूएल का उत्पादन (नाम और श्रेणी आईडी स्विच कर रहे हैं):

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

मैंने कुछ एक्सटेंशन विधियां (नीचे) बनाई हैं, इसलिए यदि आपको 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);
        }
    }
}

आप यह भी कोशिश कर सकते हैं।

var results= persons.GroupBy(n => new { n.PersonId, n.car})
                .Select(g => new {
                               g.Key.PersonId,
                               g.Key.car)}).ToList();




linq sql-order-by