Vraag Meerdere "volgorde voor" in LINQ


Ik heb twee tafels, movies en categoriesen ik krijg een geordende lijst van categorie ID eerst en dan door Naam.

De filmtafel heeft drie kolommen, ID, naam en categorie-id. De categorietabel twee heeft kolommen, ID en naam.

Ik probeerde iets als het volgende, maar het werkte niet.

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

1380
2017-11-18 13:34


oorsprong


antwoorden:


Dit zou voor u moeten werken:

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

2524
2017-11-18 13:41



Met behulp van niet-lambda, query-syntax LINQ, kunt u dit doen:

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

[EDIT om commentaar toe te voegen] Gebruik de trefwoorden om de sorteervolgorde te regelen ascending (wat de standaard is en daarom niet erg handig) of descending, zoals zo:

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

550
2017-09-30 14:49



"Nieuw" toevoegen:

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

Dat werkt op mijn doos. Het geeft wel iets terug dat kan worden gebruikt om te sorteren. Het retourneert een object met twee waarden.

Vergelijkbaar met, maar verschillend van sorteren op een gecombineerde kolom, als volgt.

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

67
2018-06-22 14:27



gebruik de volgende regel op uw DataContext om de SQL-activiteit op de DataContext naar de console te loggen - dan kunt u precies zien wat uw linq-instructies uit de database vragen:

_db.Log = Console.Out

De volgende LINQ-instructies:

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

EN

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

produceer de volgende SQL:

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

Terwijl het herhalen van een OrderBy in Linq de resulterende SQL-uitvoer omkeert:

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

EN

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

produceer de volgende SQL (Naam en CategorieId zijn geschakeld):

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

18
2018-02-18 21:03



Er is nog een manier om dit met LINQ te doen, hoewel niet de gemakkelijkste. Je kunt het doen door de OrberBy() methode die een IComparer. Eerst moet je dat doen implementeren van een IComparer voor de Movie klasse als deze:

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

Vervolgens kunt u de films bestellen met de volgende syntaxis:

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

Als je de volgorde moet veranderen naar aflopend voor een van de items, schakel je gewoon de x en y in de Compare()  methode van de MovieComparer overeenkomstig.


12
2018-04-03 14:07



Ik heb een aantal uitbreidingsmethoden (hieronder) gemaakt, zodat u zich geen zorgen hoeft te maken als een IQueryable al is besteld of niet. Als u meerdere objecten wilt bestellen, doet u het gewoon als volgt:

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

Dit is vooral handig als u de volgorde dynamisch creëert, bijv. uit een lijst met eigenschappen om te sorteren.

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

11
2018-06-08 14:49



Gebruik generieke repository

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

anders

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

0
2017-07-17 14:29