Динамический LINQ OrderBy на IEnumerable

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

1. добавить using System.Linq.Dynamic; в верхней части.
2. использовать vehicles = vehicles.AsQueryable().OrderBy("Make ASC, Year DESC").ToList();

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

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

используя реализацию 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 несколько предложений orderby а может быть, именно это и искал автор

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

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

я пытался сделать это, но возникли проблемы с решение Кьетила Ватнедала потому что я не использую встроенный синтаксис 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 использовать custom IComparer - потому что я хотел сделать естественная сортировка.

чтобы сделать это, я просто изменить OrderBy to:

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

посмотреть этот пост код NaturalSortComparer().

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

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's reflection example
}

The

вот еще что мне показалось интересным. Если ваш источник является 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();

спасибо Мартену (запрос коллекции с помощью объекта 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();

(убедитесь, что имена столбцов соответствуют свойствам объекта)

Ура

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

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

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

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

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

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

этот ответ является ответом на комментарии, которые нуждаются в примере для решения, предоставленного @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 in Asp.net и преимущество для сортировки (вы не можете сортировать с помощью IEnumerable версии)

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

Первая Установка Динамическая Инструменты -- > Диспетчер Пакетов NuGet -- > Консоль Диспетчера Пакетов

install-package System.Linq.Dynamic

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

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

преобразовать список в IEnumerable или Iquerable, добавить с помощью System.Линк.Динамическое пространство имен, то u может упомянуть имена свойств в запятую разделенную строку OrderBy метод, который приходит по умолчанию из системы.Линк.Активный.

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