Динамический LINQ OrderBy для IEnumerable <T> / IQueryable <T>

Слишком легко без каких-либо осложнений:

• Добавьте using System.Linq.Dynamic; вверху.
• Используйте vehicles = vehicles.AsQueryable().OrderBy("Make ASC, Year DESC").ToList();

Я нашел ответ. Я могу использовать метод расширения .AsQueryable<>() для преобразования моего списка в IQueryable, а затем запустить динамический порядок против него.

Просто наткнулся на этот вопрос.

Используя реализацию Marc ApplyOrder сверху, я применил метод расширения, который обрабатывает подобные SQL строки:

list.OrderBy("MyProperty DESC, MyOtherProperty ASC");

Подробности можно найти здесь: http://aonnull.blogspot.com/2010/08/dynamic-sql-like-linq-orderby-extension.html

Я думаю, что было бы полезно использовать отражение, чтобы получить любое свойство, которое вы хотите отсортировать:

IEnumerable<T> myEnumerables
var query=from enumerable in myenumerables
          where some criteria
          orderby GetPropertyValue(enumerable,"SomeProperty")
          select enumerable

private static object GetPropertyValue(object obj, string property)
{
    System.Reflection.PropertyInfo propertyInfo=obj.GetType().GetProperty(property);
    return propertyInfo.GetValue(obj, null);
}

Обратите внимание, что использование отражения значительно медленнее, чем доступ к свойству напрямую, поэтому производительность должна быть исследована.

Просто основываясь на том, что говорили другие. Я обнаружил, что следующее работает достаточно хорошо.

public static IEnumerable<T> OrderBy<T>(this IEnumerable<T> input, string queryString)
{
    if (string.IsNullOrEmpty(queryString))
        return input;

    int i = 0;
    foreach (string propname in queryString.Split(','))
    {
        var subContent = propname.Split('|');
        if (Convert.ToInt32(subContent[1].Trim()) == 0)
        {
            if (i == 0)
                input = input.OrderBy(x => GetPropertyValue(x, subContent[0].Trim()));
            else
                input = ((IOrderedEnumerable<T>)input).ThenBy(x => GetPropertyValue(x, subContent[0].Trim()));
        }
        else
        {
            if (i == 0)
                input = input.OrderByDescending(x => GetPropertyValue(x, subContent[0].Trim()));
            else
                input = ((IOrderedEnumerable<T>)input).ThenByDescending(x => GetPropertyValue(x, subContent[0].Trim()));
        }
        i++;
    }

    return input;
}

Я наткнулся на этот вопрос, ища ряд статей о множественном заказе Linq и, возможно, это то, что автор искал

Вот как это сделать:

var query = pets.OrderBy(pet => pet.Name).ThenByDescending(pet => pet.Age);    

Я пытался это сделать, но имел проблемы с решением Kjetil Watnedal, потому что я не использую встроенный синтаксис linq - я предпочитаю синтаксис стиля метода. Моя особая проблема заключалась в попытке выполнить динамическую сортировку с помощью пользовательского IComparer.

Мое решение получилось так:

Учитывая такой запрос IQueryable:

List<DATA__Security__Team> teams = TeamManager.GetTeams();
var query = teams.Where(team => team.ID < 10).AsQueryable();

И учитывая аргумент поля сортировки во время выполнения:

string SortField; // Set at run-time to "Name"

Динамический OrderBy выглядит так:

query = query.OrderBy(item => item.GetReflectedPropertyValue(SortField));

И это использование небольшого вспомогательного метода под названием GetReflectedPropertyValue():

public static string GetReflectedPropertyValue(this object subject, string field)
{
    object reflectedValue = subject.GetType().GetProperty(field).GetValue(subject, null);
    return reflectedValue != null ? reflectedValue.ToString() : "";
}

Последнее: я упомянул, что хотел, чтобы OrderBy использовал пользовательский IComparer потому что я хотел заниматься естественной сортировкой.

Для этого я просто OrderBy чтобы:

query = query.OrderBy(item => item.GetReflectedPropertyValue(SortField), new NaturalSortComparer<string>());

Смотрите этот пост для кода для NaturalSortComparer().

Вы можете преобразовать IEnumerable в IQueryable.

items = items.AsQueryable().OrderBy("Name ASC");

После многого поиска это сработало для меня:

public static IEnumerable<TEntity> OrderBy<TEntity>(this IEnumerable<TEntity> source, 
                                                    string orderByProperty, bool desc)
{
    string command = desc ? "OrderByDescending" : "OrderBy";
    var type = typeof(TEntity);
    var property = type.GetProperty(orderByProperty);
    var parameter = Expression.Parameter(type, "p");
    var propertyAccess = Expression.MakeMemberAccess(parameter, property);
    var orderByExpression = Expression.Lambda(propertyAccess, parameter);
    var resultExpression = Expression.Call(typeof(Queryable), command, 
                                           new[] { type, property.PropertyType },
                                           source.AsQueryable().Expression, 
                                           Expression.Quote(orderByExpression));
    return source.AsQueryable().Provider.CreateQuery<TEntity>(resultExpression);
}

Спасибо Maarten (Запросить коллекцию с использованием объекта PropertyInfo в LINQ) Я получил это решение:

myList.OrderByDescending(x => myPropertyInfo.GetValue(x, null)).ToList();

В моем случае я работал над "ColumnHeaderMouseClick" (WindowsForm), поэтому просто нашел конкретный столбец и его корреспондент PropertyInfo:

foreach (PropertyInfo column in (new Process()).GetType().GetProperties())
{
    if (column.Name == dgvProcessList.Columns[e.ColumnIndex].Name)
    {}
}

ИЛИ

PropertyInfo column = (new Process()).GetType().GetProperties().Where(x => x.Name == dgvProcessList.Columns[e.ColumnIndex].Name).First();

(обязательно, чтобы имена столбцов соответствовали объекту Properties)

Приветствия

Здесь что-то еще я нашел интересным. Если ваш источник является DataTable, вы можете использовать динамическую сортировку без использования Dynamic Linq

DataTable orders = dataSet.Tables["SalesOrderHeader"];
EnumerableRowCollection<DataRow> query = from order in orders.AsEnumerable()
                                         orderby order.Field<DateTime>("OrderDate")
                                         select order;
DataView view = query.AsDataView();
bindingSource1.DataSource = view;

ссылка: http://msdn.microsoft.com/en-us/library/bb669083.aspx (с использованием DataSetExtensions)

Вот еще один способ сделать это, переведя его в DataView:

DataTable contacts = dataSet.Tables["Contact"];    
DataView view = contacts.AsDataView();    
view.Sort = "LastName desc, FirstName asc";    
bindingSource1.DataSource = view;
dataGridView1.AutoResizeColumns();

Вы можете добавить его:

public static IEnumerable<T> OrderBy( this IEnumerable<T> input, string queryString) {
    //parse the string into property names
    //Use reflection to get and sort by properties
    //something like

    foreach( string propname in queryString.Split(','))
        input.OrderBy( x => GetPropertyValue( x, propname ) );

    // I used Kjetil Watnedal reflection example
}

Функция GetPropertyValue находится из ответ Kjetil Watnedal

Проблема в том, почему? Любой такой тип будет генерировать исключения во время выполнения, а не компилировать время (например, ответ D2VIANT).

Если вы имеете дело с Linq to Sql, а orderby - это дерево выражений, оно все равно будет преобразовано в SQL.

Альтернативное решение использует следующий класс/интерфейс. Это не очень динамично, но оно работает.

public interface IID
{
    int ID
    {
        get; set;
    }
}

public static class Utils
{
    public static int GetID<T>(ObjectQuery<T> items) where T:EntityObject, IID
    {
        if (items.Count() == 0) return 1;
        return items.OrderByDescending(u => u.ID).FirstOrDefault().ID + 1;
    }
}

Первая установка динамического Инструменты → Диспетчер пакетов NuGet → Консоль диспетчера пакетов

install-package System.Linq.Dynamic

Добавить Пространство имен using System.Linq.Dynamic;

Теперь вы можете использовать OrderBy("Name, Age DESC")

Этот ответ является ответом на комментарии, которым нужен пример для решения, предоставленного @John Sheehan - Runscope

Просьба привести пример для всех нас.

в DAL (уровень доступа к данным),

Версия IEnumerable:

  public  IEnumerable<Order> GetOrders()
    {
      // i use Dapper to return IEnumerable<T> using Query<T>
      //.. do stuff
      return  orders  // IEnumerable<Order>
  }

Версия IQueryable

  public IQueryable<Order> GetOrdersAsQuerable()
    {
        IEnumerable<Order> qry= GetOrders();
        //use the built-in extension method  AsQueryable in  System.Linq namespace
        return qry.AsQueryable();            
    }

Теперь вы можете использовать версию IQueryable для привязки, например GridView в Asp.net, и использовать ее для сортировки (вы не можете сортировать с помощью версии IEnumerable)

Я использовал Dapper как ORM и строю версию IQueryable и использовал сортировку в GridView в asp.net так просто.

Преобразуйте список в IEnumerable или Iquerable, добавьте с использованием пространства имен System.LINQ.Dynamic, затем вы можете указать имена свойств в разделенной запятой строке на метод OrderBy, который по умолчанию запускается из System.LINQ.Dynamic.

var result1 = lst.OrderBy(a=>a.Name);// for ascending order. 
 var result1 = lst.OrderByDescending(a=>a.Name);// for desc order.