C# 如何根据用户输入在LINQ中依次排序？_C#_Linq

C# 如何根据用户输入在LINQ中依次排序？

c# linq

C# 如何根据用户输入在LINQ中依次排序？,c#,linq,C#,Linq,我在一个页面上有一个网格，我想同时对多个列进行排序例如： UserID FirstName LastName ======================================= 1 Bruce Wayne 2 Peter Parker 3 Clark Kent 4 Tony

我在一个页面上有一个网格，我想同时对多个列进行排序

例如：

UserID        FirstName        LastName
=======================================
1             Bruce            Wayne
2             Peter            Parker
3             Clark            Kent
4             Tony             Stark
5             Helena           Wayne

用户可以选择按LastName ASC然后按FirstName DESC订购，这将产生以下结果：

UserID        FirstName        LastName
=======================================
3             Clark            Kent
2             Peter            Parker
4             Tony             Stark
5             Helena           Wayne
1             Bruce            Wayne

用户可以重置订购并决定以其他方式订购

如何在LINQ中实现这一点？据我所知，连锁订购的方式是

superheroes.OrderBy(x => x.LastName).ThenByDescending(x => x.FirstName)

显然，我不想写每一个可能的列顺序组合（我的网格可能有多达10列）。有什么方法可以使排序序列动态化吗？

您需要使用动态LINQ。查看一下

您需要使用动态LINQ。看一看

一种简单的IEnumerable方法（不是完美的，也不是经过测试的，但你已经知道了）。我将开关置于外部，这样比较只进行一次，而不是每次调用选择器。这有点难看，因为你基本上必须依次重复你自己

enum OrderableColumns {UserID, FirstName, ...}

IOrderedEnumerable<SuperHero> OrderBy(SuperHeroes superheroes, OrderableColumns column)
{
    switch(column)
    {
        case UserID:
            return superheroes.OrderBy(x => x.UserID);
        case FirstName:
            return superheroes.OrderBy(x => x.FirstName);
        ...
    }
}

IOrderedEnumerable<SuperHero> ThenBy(IOrderedEnumerable<SuperHero> superheroes, OrderableColumns column)
{
    switch(column)
    {
        case UserID:
            return superheroes.ThenBy(x => x.UserID);
        case FirstName:
            return superheroes.ThenBy(x => x.FirstName);
        ...
    }
}

IOrderedEnumerable<SuperHero> OrderSuperheroes(SuperHeroes superheroes, params OrderableColumns[] columns)
{
     var ordered = OrderBy(superheroes, columns[0]);

     foreach(var col in columns.Skip(1))
         ordered = ThenBy(ordered, col);

     return ordered;
}

enum OrderableColumns{UserID，FirstName，…}
IOrderedEnumerable OrderBy（超级英雄超级英雄，OrderableColumns列）
{
开关（列）
{
案例用户ID：
返回超级英雄.OrderBy（x=>x.UserID）；
案例名：
返回超级英雄.OrderBy（x=>x.FirstName）；
...
}
}
IOrderedEnumerable ThenBy（IOrderedEnumerable超级英雄，OrderableColumns列）
{
开关（列）
{
案例用户ID：
返回超级英雄.ThenBy（x=>x.UserID）；
案例名：
返回超级英雄。然后按（x=>x.FirstName）；
...
}
}
IOrderedEnumerable OrderSuperheroes（SuperHeroes SuperHeroes，params OrderableColumns[]columns）
{
var ordered=OrderBy（超级英雄，列[0]）；
foreach（列中的变量col.Skip（1））
有序=然后由（有序，列）；
订购退货；
}

enum OrderableColumns {UserID, FirstName, ...}

IOrderedEnumerable<SuperHero> OrderBy(SuperHeroes superheroes, OrderableColumns column)
{
    switch(column)
    {
        case UserID:
            return superheroes.OrderBy(x => x.UserID);
        case FirstName:
            return superheroes.OrderBy(x => x.FirstName);
        ...
    }
}

IOrderedEnumerable<SuperHero> ThenBy(IOrderedEnumerable<SuperHero> superheroes, OrderableColumns column)
{
    switch(column)
    {
        case UserID:
            return superheroes.ThenBy(x => x.UserID);
        case FirstName:
            return superheroes.ThenBy(x => x.FirstName);
        ...
    }
}

IOrderedEnumerable<SuperHero> OrderSuperheroes(SuperHeroes superheroes, params OrderableColumns[] columns)
{
     var ordered = OrderBy(superheroes, columns[0]);

     foreach(var col in columns.Skip(1))
         ordered = ThenBy(ordered, col);

     return ordered;
}

enum OrderableColumns{UserID，FirstName，…}
IOrderedEnumerable OrderBy（超级英雄超级英雄，OrderableColumns列）
{
开关（列）
{
案例用户ID：
返回超级英雄.OrderBy（x=>x.UserID）；
案例名：
返回超级英雄.OrderBy（x=>x.FirstName）；
...
}
}
IOrderedEnumerable ThenBy（IOrderedEnumerable超级英雄，OrderableColumns列）
{
开关（列）
{
案例用户ID：
返回超级英雄.ThenBy（x=>x.UserID）；
案例名：
返回超级英雄。然后按（x=>x.FirstName）；
...
}
}
IOrderedEnumerable OrderSuperheroes（SuperHeroes SuperHeroes，params OrderableColumns[]columns）
{
var orderd=OrderBy（超级英雄，列[0]）；
foreach（列中的变量col.Skip（1））
有序=然后由（有序，列）；
订购退货；
}

您可以构建

函数

动态，如下所示：

public static Func<T,object> GetExp<T>(string preportyName)
{
    var instance = Expression.Parameter(typeof(T));
    var callPreporty = Expression.PropertyOrField(instance, preportyName);
    var lambda = Expression.Lambda<Func<T, object>>(callPreporty,instance);
    return lambda.Compile();
}

var pdotName = GetExp<Person>("Name");  //equals: p=>p.Name
var pdotID = GetExp<Person>("Id");  ////equals: p=>p.Id
var ordered = list.OrderBy(pdotName).ThenBy(pdotID);
//equals: list.OrderBy(p=>p.Name).ThenBy(p=>p.Id)

public static Func GetExp（字符串preprityname）
{
var instance=Expression.Parameter（typeof（T））；
var callpreparty=Expression.PropertyOrField（实例，prepertyname）；
var lambda=Expression.lambda（callpreparty，instance）；
返回lambda.Compile（）；
}

这样使用：

public static Func<T,object> GetExp<T>(string preportyName)
{
    var instance = Expression.Parameter(typeof(T));
    var callPreporty = Expression.PropertyOrField(instance, preportyName);
    var lambda = Expression.Lambda<Func<T, object>>(callPreporty,instance);
    return lambda.Compile();
}

var pdotName = GetExp<Person>("Name");  //equals: p=>p.Name
var pdotID = GetExp<Person>("Id");  ////equals: p=>p.Id
var ordered = list.OrderBy(pdotName).ThenBy(pdotID);
//equals: list.OrderBy(p=>p.Name).ThenBy(p=>p.Id)

var-pdotName=GetExp（“名称”）//等于：p=>p.Name
var pdotID=GetExp（“Id”）////等于：p=>p.Id
var ordered=list.OrderBy（pdotName）.ThenBy（pdotID）；
//等于：list.OrderBy（p=>p.Name）。然后是by（p=>p.Id）

您可以构建

函数

动态，如下所示：

public static Func<T,object> GetExp<T>(string preportyName)
{
    var instance = Expression.Parameter(typeof(T));
    var callPreporty = Expression.PropertyOrField(instance, preportyName);
    var lambda = Expression.Lambda<Func<T, object>>(callPreporty,instance);
    return lambda.Compile();
}

var pdotName = GetExp<Person>("Name");  //equals: p=>p.Name
var pdotID = GetExp<Person>("Id");  ////equals: p=>p.Id
var ordered = list.OrderBy(pdotName).ThenBy(pdotID);
//equals: list.OrderBy(p=>p.Name).ThenBy(p=>p.Id)

public static Func GetExp（字符串preprityname）
{
var instance=Expression.Parameter（typeof（T））；
var callpreparty=Expression.PropertyOrField（实例，prepertyname）；
var lambda=Expression.lambda（callpreparty，instance）；
返回lambda.Compile（）；
}

这样使用：

public static Func<T,object> GetExp<T>(string preportyName)
{
    var instance = Expression.Parameter(typeof(T));
    var callPreporty = Expression.PropertyOrField(instance, preportyName);
    var lambda = Expression.Lambda<Func<T, object>>(callPreporty,instance);
    return lambda.Compile();
}

var pdotName = GetExp<Person>("Name");  //equals: p=>p.Name
var pdotID = GetExp<Person>("Id");  ////equals: p=>p.Id
var ordered = list.OrderBy(pdotName).ThenBy(pdotID);
//equals: list.OrderBy(p=>p.Name).ThenBy(p=>p.Id)

var-pdotName=GetExp（“名称”）//等于：p=>p.Name
var pdotID=GetExp（“Id”）////等于：p=>p.Id
var ordered=list.OrderBy（pdotName）.ThenBy（pdotID）；
//等于：list.OrderBy（p=>p.Name）。然后是by（p=>p.Id）

您使用的是

IEnumerable

还是

IQueryable

？可能会有帮助！为什么不尝试在没有linq的情况下使用编程网格排序？您使用的是

IEnumerable

还是

IQueryable

？可能会有帮助！为什么不尝试在没有linq的情况下使用编程网格排序？作为参考，我在这里使用了动态linq辅助扩展方法：作为参考，我在这里使用了动态linq辅助扩展方法：