Dynamic LINQ OrderDengan IEnumerable <T> / IQueryable <T>

Saya menemukan contoh dalam VS2008 Contoh untuk Dynamic LINQ yang memungkinkan Anda untuk menggunakan string seperti sql (misalnya OrderBy("Name, Age DESC"))untuk pemesanan. Sayangnya, metode yang disertakan hanya berfungsi IQueryable<T>. Apakah ada cara untuk mengaktifkan fungsi ini IEnumerable<T>?

Baru saja tersandung ke dalam ...

Untuk melakukan ini tanpa pustaka LINQ dinamis, Anda hanya perlu kode seperti di bawah ini. Ini mencakup sebagian besar skenario umum termasuk properti bersarang.

Untuk membuatnya bekerja dengan IEnumerable<T>Anda bisa menambahkan beberapa metode pembungkus yang masuk AsQueryable- tetapi kode di bawah ini adalah Expressionlogika inti yang dibutuhkan.

public static IOrderedQueryable<T> OrderBy<T>(
    this IQueryable<T> source, 
    string property)
{
    return ApplyOrder<T>(source, property, "OrderBy");
}

public static IOrderedQueryable<T> OrderByDescending<T>(
    this IQueryable<T> source, 
    string property)
{
    return ApplyOrder<T>(source, property, "OrderByDescending");
}

public static IOrderedQueryable<T> ThenBy<T>(
    this IOrderedQueryable<T> source, 
    string property)
{
    return ApplyOrder<T>(source, property, "ThenBy");
}

public static IOrderedQueryable<T> ThenByDescending<T>(
    this IOrderedQueryable<T> source, 
    string property)
{
    return ApplyOrder<T>(source, property, "ThenByDescending");
}

static IOrderedQueryable<T> ApplyOrder<T>(
    IQueryable<T> source, 
    string property, 
    string methodName) 
{
    string[] props = property.Split('.');
    Type type = typeof(T);
    ParameterExpression arg = Expression.Parameter(type, "x");
    Expression expr = arg;
    foreach(string prop in props) {
        // use reflection (not ComponentModel) to mirror LINQ
        PropertyInfo pi = type.GetProperty(prop);
        expr = Expression.Property(expr, pi);
        type = pi.PropertyType;
    }
    Type delegateType = typeof(Func<,>).MakeGenericType(typeof(T), type);
    LambdaExpression lambda = Expression.Lambda(delegateType, expr, arg);

    object result = typeof(Queryable).GetMethods().Single(
            method => method.Name == methodName
                    && method.IsGenericMethodDefinition
                    && method.GetGenericArguments().Length == 2
                    && method.GetParameters().Length == 2)
            .MakeGenericMethod(typeof(T), type)
            .Invoke(null, new object[] {source, lambda});
    return (IOrderedQueryable<T>)result;
}

Sunting: semakin menyenangkan jika Anda ingin mencampurnya dengan dynamic- meskipun catatan yang dynamichanya berlaku untuk LINQ-to-Objects (pohon ekspresi untuk ORMs dll tidak dapat benar-benar mewakili dynamickueri - MemberExpressiontidak mendukungnya). Tapi inilah cara untuk melakukannya dengan LINQ-to-Objects. Perhatikan bahwa pilihan Hashtableini karena semantik penguncian yang menguntungkan:

using Microsoft.CSharp.RuntimeBinder;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Dynamic;
using System.Linq;
using System.Runtime.CompilerServices;
static class Program
{
    private static class AccessorCache
    {
        private static readonly Hashtable accessors = new Hashtable();

        private static readonly Hashtable callSites = new Hashtable();

        private static CallSite<Func<CallSite, object, object>> GetCallSiteLocked(
            string name) 
        {
            var callSite = (CallSite<Func<CallSite, object, object>>)callSites[name];
            if(callSite == null)
            {
                callSites[name] = callSite = CallSite<Func<CallSite, object, object>>
                    .Create(Binder.GetMember(
                                CSharpBinderFlags.None, 
                                name, 
                                typeof(AccessorCache),
                                new CSharpArgumentInfo[] { 
                                    CSharpArgumentInfo.Create(
                                        CSharpArgumentInfoFlags.None, 
                                        null) 
                                }));
            }
            return callSite;
        }

        internal static Func<dynamic,object> GetAccessor(string name)
        {
            Func<dynamic, object> accessor = (Func<dynamic, object>)accessors[name];
            if (accessor == null)
            {
                lock (accessors )
                {
                    accessor = (Func<dynamic, object>)accessors[name];
                    if (accessor == null)
                    {
                        if(name.IndexOf('.') >= 0) {
                            string[] props = name.Split('.');
                            CallSite<Func<CallSite, object, object>>[] arr 
                                = Array.ConvertAll(props, GetCallSiteLocked);
                            accessor = target =>
                            {
                                object val = (object)target;
                                for (int i = 0; i < arr.Length; i++)
                                {
                                    var cs = arr[i];
                                    val = cs.Target(cs, val);
                                }
                                return val;
                            };
                        } else {
                            var callSite = GetCallSiteLocked(name);
                            accessor = target =>
                            {
                                return callSite.Target(callSite, (object)target);
                            };
                        }
                        accessors[name] = accessor;
                    }
                }
            }
            return accessor;
        }
    }

    public static IOrderedEnumerable<dynamic> OrderBy(
        this IEnumerable<dynamic> source, 
        string property)
    {
        return Enumerable.OrderBy<dynamic, object>(
            source, 
            AccessorCache.GetAccessor(property), 
            Comparer<object>.Default);
    }

    public static IOrderedEnumerable<dynamic> OrderByDescending(
        this IEnumerable<dynamic> source, 
        string property)
    {
        return Enumerable.OrderByDescending<dynamic, object>(
            source, 
            AccessorCache.GetAccessor(property), 
            Comparer<object>.Default);
    }

    public static IOrderedEnumerable<dynamic> ThenBy(
        this IOrderedEnumerable<dynamic> source, 
        string property)
    {
        return Enumerable.ThenBy<dynamic, object>(
            source, 
            AccessorCache.GetAccessor(property), 
            Comparer<object>.Default);
    }

    public static IOrderedEnumerable<dynamic> ThenByDescending(
        this IOrderedEnumerable<dynamic> source, 
        string property)
    {
        return Enumerable.ThenByDescending<dynamic, object>(
            source, 
            AccessorCache.GetAccessor(property), 
            Comparer<object>.Default);
    }

    static void Main()
    {
        dynamic a = new ExpandoObject(), 
                b = new ExpandoObject(), 
                c = new ExpandoObject();
        a.X = "abc";
        b.X = "ghi";
        c.X = "def";
        dynamic[] data = new[] { 
            new { Y = a },
            new { Y = b }, 
            new { Y = c } 
        };

        var ordered = data.OrderByDescending("Y.X").ToArray();
        foreach (var obj in ordered)
        {
            Console.WriteLine(obj.Y.X);
        }
    }
}

Terlalu mudah tanpa komplikasi:

1. Tambahkan using System.Linq.Dynamic;di atas.
2. Menggunakan vehicles = vehicles.AsQueryable().OrderBy("Make ASC, Year DESC").ToList();

Saya menemukan jawabannya. Saya dapat menggunakan .AsQueryable<>()metode ekstensi untuk mengubah daftar saya menjadi IQueryable, kemudian menjalankan urutan dinamis dengan menentangnya.

Baru saja menemukan pertanyaan ini.

Menggunakan implementasi ApplyOrder Marc dari atas, saya menampar bersama metode Extension yang menangani string seperti-SQL seperti:

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

Detail dapat ditemukan di sini: http://aonnull.blogspot.com/2010/08/dynamic-sql-like-linq-orderby-extension.html

Saya kira itu akan berhasil menggunakan refleksi untuk mendapatkan properti apa pun yang ingin Anda urutkan:

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

Perhatikan bahwa menggunakan refleksi jauh lebih lambat daripada mengakses properti secara langsung, sehingga kinerjanya harus diselidiki.

Hanya membangun apa yang dikatakan orang lain. Saya menemukan bahwa berikut ini bekerja dengan cukup baik.

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

Saya telah menemukan pertanyaan ini untuk mencari beberapa klausa orderby Linq dan mungkin inilah yang dicari penulis

Berikut cara melakukannya:

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

Saya mencoba melakukan ini tetapi mengalami masalah dengan solusi Kjetil Watnedal karena saya tidak menggunakan sintaks LINQ inline - Saya lebih memilih sintaks metode-gaya. Masalah khusus saya adalah mencoba melakukan penyortiran dinamis menggunakan custom IComparer.

Solusi saya berakhir seperti ini:

Diberi permintaan IQueryable seperti:

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

Dan diberi argumen semacam lapangan run-time:

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

OrderBy dinamis terlihat seperti ini:

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

Dan itu menggunakan metode pembantu kecil yang disebut GetReflectedPropertyValue ():

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

Satu hal terakhir - saya menyebutkan bahwa saya ingin OrderBymenggunakan kebiasaan IComparer- karena saya ingin melakukan penyortiran alami .

Untuk melakukan itu, saya hanya mengubah OrderByke:

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

Lihat posting ini untuk mengetahui kodenya NaturalSortComparer().

Gunakan dinamis linq

tambahkan saja using System.Linq.Dynamic;

Dan gunakan seperti ini untuk memesan semua kolom Anda:

string sortTypeStr = "ASC"; // or DESC
string SortColumnName = "Age"; // Your column name
query = query.OrderBy($"{SortColumnName} {sortTypeStr}");

Anda bisa menambahkannya:

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 GetPropertyValuefungsi dari jawaban Kjetil Watnedal ini

Masalahnya adalah mengapa? Jenis apa pun akan membuang pengecualian pada waktu berjalan, daripada mengkompilasi waktu (seperti jawaban D2VIANT).

Jika Anda berurusan dengan Linq ke Sql dan orderby adalah pohon ekspresi itu akan dikonversi menjadi SQL untuk eksekusi.

Inilah sesuatu yang menurut saya menarik. Jika sumber Anda adalah DataTable, Anda dapat menggunakan penyortiran dinamis tanpa menggunakan Linq Dinamis

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;

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

Berikut ini satu cara lagi untuk melakukannya dengan mengubahnya menjadi DataView:

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

Terima kasih kepada Maarten ( Permintaan koleksi menggunakan objek PropertyInfo di LINQ ) saya mendapat solusi ini:

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

Dalam kasus saya, saya sedang mengerjakan "ColumnHeaderMouseClick" (WindowsForm) jadi baru saja menemukan Kolom khusus ditekan dan PropertyInfo korespondennya:

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

ATAU

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

(pastikan memiliki Nama kolom Anda yang cocok dengan properti Objek)

Bersulang

Setelah banyak pencarian, ini berhasil bagi saya:

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

Anda dapat mengonversi IEnumerable ke IQueryable.

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

Solusi alternatif menggunakan kelas / antarmuka berikut. Itu tidak benar-benar dinamis, tetapi berhasil.

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

Jawaban ini merupakan tanggapan terhadap komentar yang membutuhkan contoh untuk solusi yang disediakan oleh @John Sheehan - Runscope

Tolong berikan contoh untuk kita semua.

dalam DAL (Lapisan Akses Data),

Versi IEnumerable:

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

Versi IQueryable

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

Sekarang Anda dapat menggunakan versi IQueryable untuk mengikat, misalnya GridView di Asp.net dan manfaat untuk menyortir (Anda tidak dapat menyortir menggunakan versi IEnumerable)

Saya menggunakan Dapper sebagai ORM dan membangun versi IQueryable dan menggunakan sorting di GridView di asp.net dengan sangat mudah.

Pertama Instal Alat Dinamis -> NuGet Package Manager -> Package Manager Console

install-package System.Linq.Dynamic

Tambahkan Namespace using System.Linq.Dynamic;

Sekarang kamu bisa menggunakannya OrderBy("Name, Age DESC")

Anda bisa menggunakan ini:

        public List<Book> Books(string orderField, bool desc, int skip, int take)
{
    var propertyInfo = typeof(Book).GetProperty(orderField);

    return _context.Books
        .Where(...)
        .OrderBy(p => !desc ? propertyInfo.GetValue(p, null) : 0)
        .ThenByDescending(p => desc ? propertyInfo.GetValue(p, null) : 0)
        .Skip(skip)
        .Take(take)
        .ToList();
}

Konversi Daftar ke IEnumerable atau Iquerable, tambahkan menggunakan namespace System.LINQ.Dynamic, maka Anda dapat menyebutkan nama properti dalam string yang dipisah koma ke Metode OrderBy yang datang secara default dari System.LINQ.Dynamic.

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