Dynamic LINQ OrderBy on IEnumerable

Zbyt łatwe bez żadnych komplikacji:

1. Dodaj using System.Linq.Dynamic; Na górze.
2. Użyj vehicles = vehicles.AsQueryable().OrderBy("Make ASC, Year DESC").ToList();

Znalazłem odpowiedź. Mogę użyć metody rozszerzenia .AsQueryable<>(), Aby przekonwertować moją listę do IQueryable, a następnie uruchomić kolejność dynamiczną przez nią.

Natknąłem się na to pytanie.

Używając implementacji ApplyOrder Marc z góry, połączyłem metodę rozszerzenia obsługującą ciągi podobne do SQL:

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

Szczegóły można znaleźć tutaj: http://aonnull.blogspot.com/2010/08/dynamic-sql-like-linq-orderby-extension.html

Myślę, że byłoby dobrze użyć refleksji, aby uzyskać jakąkolwiek nieruchomość chcesz posortować:

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

Zauważ, że używanie reflection jest znacznie wolniejsze niż bezpośrednie uzyskiwanie dostępu do właściwości, więc wydajność musi być zbadana.

Bazując na tym, co powiedzieli inni. Okazało się, że następujące działa całkiem dobrze.

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

Natknąłem się na to pytanie szukając klauzul Linq multiple orderby a może właśnie tego szukał autor

Oto Jak to zrobić:

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

Próbowałem to zrobić, ale mam problemy z rozwiązaniem Kjetila Watnedala ponieważ nie używam składni inline linq-wolę składnię w stylu metody. Mój szczególny problem polegał na próbie dynamicznego sortowania przy użyciu niestandardowego IComparer.

Moje rozwiązanie skończyło się tak:

Podane zapytanie IQueryable jak tak:

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

I podano argument pola sortowania w czasie wykonywania:

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

Kolejność dynamiczna wygląda tak:

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

I to za pomocą mała metoda pomocnicza o nazwie GetReflectedPropertyValue ():

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

Jeszcze jedno-wspomniałem, że chciałem, aby OrderBy używało custom IComparer - ponieważ chciałem wykonaćnaturalne sortowanie .

Aby to zrobić, zmieniam OrderBy na:

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

Zobacz ten post Po kod dla NaturalSortComparer().

Możesz dodać:

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
}

Funkcja GetPropertyValuepochodzi z odpowiedzi Kjetila Watnedala

Problemem byłoby dlaczego? Każdy taki rodzaj wyrzuca wyjątki w czasie wykonywania, a nie kompilacji (jak odpowiedź D2VIANTA).

Jeśli masz do czynienia z Linq do Sql, a orderby jest drzewem wyrażeń, to i tak zostanie przekonwertowany na SQL do wykonania.

Jest jeszcze coś, co mnie zainteresowało. Jeśli twoje źródło jest DataTable, możesz użyć sortowania dynamicznego bez użycia dynamicznego 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;

Odniesienie: http://msdn.microsoft.com/en-us/library/bb669083.aspx (Using DataSetExtensions)

Jest jeszcze jeden sposób, aby to zrobić, konwertując go do DataView:

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

Dzięki Maarten ( zapytanie kolekcji za pomocą obiektu PropertyInfo w LINQ ) otrzymałem takie rozwiązanie:

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

W moim przypadku pracowałem nad "ColumnHeaderMouseClick" (WindowsForm), więc po prostu znalazłem konkretną kolumnę wciśniętą i jej odpowiedni Właściwośćinfo:

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

Lub

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

(Upewnij się, że nazwy kolumn pasują do Właściwości obiektu)

Cheers

Po wielu poszukiwaniach to mi pomogło:

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

Możesz przekonwertować liczbę mnogą na liczbę mnogą.

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

Alternatywne rozwiązanie używa następującej klasy / interfejsu. Nie jest dynamiczny, ale działa.

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

Ta odpowiedź jest odpowiedzią na komentarze, które wymagają przykładowego rozwiązania dostarczonego przez @ John Sheehan-Runscope

Proszę podać przykład dla reszty z nas.

W DAL (Warstwa dostępu do danych),

Wersja IEnumerable:

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

Wersja IQueryable

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

Teraz możesz użyć wersji IQueryable do wiązania, na przykład GridView w Asp.net i korzyści dla sortowania (nie można sortować za pomocą IEnumerable version)

Użyłem Dapper jako ORM i zbudowałem IQueryable version i wykorzystałem sortowanie w GridView w asp.net to takie proste.

Pierwsza Instalacja Dynamiczna Narzędzia -- > NuGet Package Manager -- > Package Manager Console

install-package System.Linq.Dynamic

Dodaj Przestrzeń Nazw using System.Linq.Dynamic;

Teraz możesz użyć OrderBy("Name, Age DESC")

Konwertuj listę do IEnumerable lub Iquerable, dodaj za pomocą systemu.LINQ.Dynamiczna przestrzeń nazw, następnie można wymienić nazwy właściwości w oddzielonym przecinkiem łańcuchu do metody OrderBy, która domyślnie pochodzi z systemu.LINQ.Dynamiczny.

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