如何在LINQ查询中构建动态order by子句 [英] How to build dynamic order by clause in LINQ query

问题描述

我有以下

公共类瞳孔
 {
  public   string 名称{获取;  set ;} 
  public  字符串性别{获取; 设置;} 
  public   string 标准{获取; 设置;} 
} 

姓名性别标准
 ---------------------------------- 
 phani男性首先
亚伯拉罕男性第二个

如何根据您点击的列标题编写优化的linq查询

 db.Pup il.OrderBy（x = >  x.Name）.Select（x = >  x）; 

解决方案

  public   static  IQueryable< t> OrderByDynamic< t>（此 IQueryable< t>查询，字符串 sortColumn， bool  降序）
 {
  //  < span class =code-comment>动态创建如下调用：query.OrderBy（p =& gt; p.SortColumn） 
  var  parameter = Expression.Parameter（ typeof （T），  p）; 
 
  string  command =  排序依据; 
 
  if （降序）
 {
命令=   OrderByDescending; 
} 
 
表达式resultExpression =  null ; 
 
  var  property =  typeof （T）.GetProperty（sortColumn）; 
  //  这是p.SortColumn的一部分 
  var  propertyAccess = Expression.MakeMemberAccess（parameter，property）; 
 
  //  这是p =& gt;部分p.SortColumn  
  var  orderByExpression = Expression.Lambda（propertyAccess，parameter）; 
 
  //  最后，按顺序调用OrderBy/OrderByDescending方法lamba表达式 
 resultExpression = Expression.Call（ typeof （可查询），命令， new 类型[] { typeof （T），property.PropertyType}，
 query.Expression，Expression.Quote（orderByExpression））; 
 
  return  query.Provider.CreateQuery< t>（resultExpression）; 
} 

调用上述方法

  var  Pupil = 来自 s   db.Pupil 选择; 
 Pupil = SortExtension.OrderByDynamic（Pupil，sortfield， false ）; 

这里Pupil是Iqueryable

添加 System.Linq.Dynamic.cs [ ^ ]文件到您的解决方案并使用以下代码执行动态订单

引用： dynamic-query-library [ ^ ]





< pre lang =cs> static void Main（ string [] args）
{

List< Pupil> list = new List< Pupil>（）;
list.Add（ new Pupil（）{Name = b}）;
list.Add（ new Pupil（）{Name = c}）;
list.Add（ new Pupil（）{Name = a}）;


var data = OrderByQuery（list， 名称， false ）;


}

public static List< Pupil> OrderByQuery（List< Pupil> data， string columnName， bool isAscending）
{
string sort = isAscending？ 升序： 降序;
var source = data.AsQueryable（）;
return source.OrderBy（columnName + + sort）.ToList（）;
}

参考 Maciej Los 解决方案，简单而且更好

这与解决方案3的解决方案基本相同，但有点美化。



必需使用：

< pre lang =c＃> 使用系统;
使用 System.Linq;
使用 System.Linq.Expressions;

扩展类：

  public   static  类 QueryableExtensions 
 {
  public   enum 订单
 {
 Asc，
 
 $ b} 
 
  public   static  IQueryable< T> OrderByDynamic< T>（
 此 IQueryable< T>查询，
 字符串 orderByMember ，
订单方向）
 {
  var  queryElementTypeParam = Expression.Parameter（ typeof < /跨度>（T））; 
 
  var  memberAccess = Expression.PropertyOrField（queryElementTypeParam，orderByMember）; 
 
  var  keySelector = Expression.Lambda（memberAccess，queryElementTypeParam）; 
 
  var  orderBy = Expression.Call（
  typeof （可查询） ），
 direction == Order.Asc？  OrderBy：  OrderByDescending，
  new 类型[] {  typeof （T），memberAccess.Type}，
 query.Expression，
 Expression.Quote（keySelector））; 
 
  return  query.Provider.CreateQuery< T>（orderBy）; 
} 
} 

样品使用：

  var  pupils = db.Pupil.OrderByDynamic（ 名称，QueryableExtensions.Order.Asc）; 

I have the following

Public class Pupil
{
public string Name {get;set;}
public string Gender {get;set;}
public string Standard {get;set;}
}

Name        Gender        Standard
----------------------------------
phani        Male          First
Abraham      Male         Second

How to write optimized linq query based on the column heading which you had clicked

db.Pupil.OrderBy(x => x.Name).Select(x => x);

解决方案

public static IQueryable<t> OrderByDynamic<t>(this IQueryable<t> query, string sortColumn, bool descending)
{
    // Dynamically creates a call like this: query.OrderBy(p =&gt; p.SortColumn)
    var parameter = Expression.Parameter(typeof(T), "p");

    string command = "OrderBy";

    if (descending)
    {
        command = "OrderByDescending";
    }

    Expression resultExpression = null;

    var property = typeof(T).GetProperty(sortColumn);
    // this is the part p.SortColumn
    var propertyAccess = Expression.MakeMemberAccess(parameter, property);

    // this is the part p =&gt; p.SortColumn
    var orderByExpression = Expression.Lambda(propertyAccess, parameter);

    // finally, call the "OrderBy" / "OrderByDescending" method with the order by lamba expression
    resultExpression = Expression.Call(typeof(Queryable), command, new Type[] { typeof(T), property.PropertyType },
       query.Expression, Expression.Quote(orderByExpression));

    return query.Provider.CreateQuery<t>(resultExpression);
}

call the above method

var Pupil = from s in db.Pupil select s;
Pupil = SortExtension.OrderByDynamic(Pupil, sortfield,false);

here Pupil is Iqueryable

add System.Linq.Dynamic.cs [^] file to your solution and use the below code to do dynamic order by
references : dynamic-query-library[^]

static void Main(string[] args)
        {

            List<Pupil> list = new List<Pupil>();
            list.Add(new Pupil() { Name = "b" });
            list.Add(new Pupil() { Name = "c" });
            list.Add(new Pupil() { Name = "a" });


            var data = OrderByQuery(list, "Name", false);


         }

        public static List<Pupil> OrderByQuery(List<Pupil> data, string columnName, bool isAscending )
        {
            string sort = isAscending ? "ascending" : "descending";
            var source = data.AsQueryable();
            return source.OrderBy(columnName + " " + sort).ToList();
        }

refer Maciej Los solution, its simple and better

This is basically the same solution as solution 3, but a bit beautified.

Required "usings":

using System;
using System.Linq;
using System.Linq.Expressions;

Extension class:

public static class QueryableExtensions
{
    public enum Order
    {
        Asc,
        Desc
    }

    public static IQueryable<T> OrderByDynamic<T>(
        this IQueryable<T> query,
        string orderByMember,
        Order direction)
    {
        var queryElementTypeParam = Expression.Parameter(typeof(T));

        var memberAccess = Expression.PropertyOrField(queryElementTypeParam, orderByMember);

        var keySelector = Expression.Lambda(memberAccess, queryElementTypeParam);

        var orderBy = Expression.Call(
            typeof(Queryable),
            direction == Order.Asc ? "OrderBy" : "OrderByDescending",
            new Type[] { typeof(T), memberAccess.Type },
            query.Expression,
            Expression.Quote(keySelector));

        return query.Provider.CreateQuery<T>(orderBy);
    }
}

Sample use:

var pupils = db.Pupil.OrderByDynamic("Name", QueryableExtensions.Order.Asc);

这篇关于如何在LINQ查询中构建动态order by子句的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！