强类型动态Linq排序

时间:2009-02-17 17:19:46

标签: c# .net linq

我正在尝试构建一些用于动态排序Linq IQueryable<>的代码。

这里显而易见的方法是使用字符串作为字段名称来对列表进行排序 http://dvanderboom.wordpress.com/2008/12/19/dynamically-composing-linq-orderby-clauses/

但是我想要一个更改 - 编译时检查字段名称,以及使用重构/查找所有引用来支持以后的维护的能力。这意味着我想将字段定义为f => f.Name,而不是字符串。

对于我的特定用途,我想封装一些代码,这些代码将决定应该根据用户输入使用命名的“OrderBy”表达式列表中的哪一个,而不是每次都编写不同的代码。

以下是我写的内容的要点:

var list = from m Movies select m; // Get our list

var sorter = list.GetSorter(...); // Pass in some global user settings object

sorter.AddSort("NAME", m=>m.Name);
sorter.AddSort("YEAR", m=>m.Year).ThenBy(m=>m.Year);

list = sorter.GetSortedList();

...
public class Sorter<TSource>
...
public static Sorter<TSource> GetSorter(this IQueryable<TSource> source, ...)

GetSortedList函数确定要使用哪个命名排序,这会产生一个List对象,其中每个FieldData包含在AddSort中传递的字段的MethodInfo和Type值:

public SorterItem<TSource> AddSort(Func<T, TKey> field)
{
   MethodInfo ... = field.Method;
   Type ... = TypeOf(TKey);
   // Create item, add item to diction, add fields to item's List<>
   // The item has the ThenBy method, which just adds another field to the List<>
}

我不确定是否有办法以一种允许稍后返回的方式存储整个字段对象(由于它是泛型类型,因此无法进行转换)

有没有办法我可以调整示例代码,或者提出全新的代码,以便在之后使用强类型字段名称进行排序,将它们存储在某个容器中并检索(丢失)任何通用类型的铸造)

4 个答案:

答案 0 :(得分:17)

最简单的方法是让你的AddSort()函数采用Expression&lt; Func&lt; Movie&gt;&gt;而不仅仅是一个Func。这允许您的sort方法检查Expression以提取要排序的属性的名称。然后,您可以在内部将此名称存储为字符串,因此存储非常简单,您可以使用链接到的排序算法,但您还可以获得类型安全性和编译时检查有效的属性名称。

static void Main(string[] args)
{
    var query = from m in Movies select m;

    var sorter = new Sorter<Movie>();
    sorter.AddSort("NAME", m => m.Name);
}

class Sorter<T>
{
    public void AddSort(string name, Expression<Func<T, object>> func)
    {
        string fieldName = (func.Body as MemberExpression).Member.Name;
    }
}

在这种情况下,我使用了object作为func的返回类型,因为它很容易自动转换,但如果需要更多功能,可以根据需要使用不同类型或泛型实现。在这种情况下,由于表达式只是在那里进行检查,所以它并不重要。

另一种可能的方法是仍然使用Func,并将其存储在字典本身中。然后,当涉及到排序,并且您需要获取要排序的值时,您可以调用类似的内容:

// assuming a dictionary of fields to sort for, called m_fields
m_fields[fieldName](currentItem)

答案 1 :(得分:8)

无赖!我必须学习如何从头到尾阅读规范: - (

然而,既然我花了太多时间而不是工作,我会发布我的结果,希望这会激发人们阅读,思考,理解(重要)然后行动。或者如何使用泛型,lambdas和有趣的Linq东西过于聪明。

  

我在此期间发现了一个巧妙的技巧   运动,是那些私人内心   派生自Dictionary的类。   他们的全部目的是删除所有   那些尖括号以便   提高可读性。

哦,差点忘了代码:

更新:使代码具有通用性并使用IQueryable代替IEnumerable

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using NUnit.Framework;
using NUnit.Framework.SyntaxHelpers;


namespace StackOverflow.StrongTypedLinqSort
{
    [TestFixture]
    public class SpecifyUserDefinedSorting
    {
        private Sorter<Movie> sorter;

        [SetUp]
        public void Setup()
        {
            var unsorted = from m in Movies select m;
            sorter = new Sorter<Movie>(unsorted);

            sorter.Define("NAME", m1 => m1.Name);
            sorter.Define("YEAR", m2 => m2.Year);
        }

        [Test]
        public void SortByNameThenYear()
        {
            var sorted = sorter.SortBy("NAME", "YEAR");
            var movies = sorted.ToArray();

            Assert.That(movies[0].Name, Is.EqualTo("A"));
            Assert.That(movies[0].Year, Is.EqualTo(2000));
            Assert.That(movies[1].Year, Is.EqualTo(2001));
            Assert.That(movies[2].Name, Is.EqualTo("B"));
        }

        [Test]
        public void SortByYearThenName()
        {
            var sorted = sorter.SortBy("YEAR", "NAME");
            var movies = sorted.ToArray();

            Assert.That(movies[0].Name, Is.EqualTo("B"));
            Assert.That(movies[1].Year, Is.EqualTo(2000));
        }

        [Test]
        public void SortByYearOnly()
        {
            var sorted = sorter.SortBy("YEAR");
            var movies = sorted.ToArray();

            Assert.That(movies[0].Name, Is.EqualTo("B"));
        }

        private static IQueryable<Movie> Movies
        {
            get { return CreateMovies().AsQueryable(); }
        }

        private static IEnumerable<Movie> CreateMovies()
        {
            yield return new Movie {Name = "B", Year = 1990};
            yield return new Movie {Name = "A", Year = 2001};
            yield return new Movie {Name = "A", Year = 2000};
        }
    }


    internal class Sorter<E>
    {
        public Sorter(IQueryable<E> unsorted)
        {
            this.unsorted = unsorted;
        }

        public void Define<P>(string name, Expression<Func<E, P>> selector)
        {
            firstPasses.Add(name, s => s.OrderBy(selector));
            nextPasses.Add(name, s => s.ThenBy(selector));
        }

        public IOrderedQueryable<E> SortBy(params string[] names)
        {
            IOrderedQueryable<E> result = null;

            foreach (var name in names)
            {
                result = result == null
                             ? SortFirst(name, unsorted)
                             : SortNext(name, result);
            }

            return result;
        }

        private IOrderedQueryable<E> SortFirst(string name, IQueryable<E> source)
        {
            return firstPasses[name].Invoke(source);
        }

        private IOrderedQueryable<E> SortNext(string name, IOrderedQueryable<E> source)
        {
            return nextPasses[name].Invoke(source);
        }

        private readonly IQueryable<E> unsorted;
        private readonly FirstPasses firstPasses = new FirstPasses();
        private readonly NextPasses nextPasses = new NextPasses();


        private class FirstPasses : Dictionary<string, Func<IQueryable<E>, IOrderedQueryable<E>>> {}


        private class NextPasses : Dictionary<string, Func<IOrderedQueryable<E>, IOrderedQueryable<E>>> {}
    }


    internal class Movie
    {
        public string Name { get; set; }
        public int Year { get; set; }
    }
}

答案 2 :(得分:8)

根据每个人的贡献,我提出了以下建议。

它提供双向排序以及彻底解决问题。这意味着我不需要为每个给定类型的未排序列表创建新的Sorter。为什么不能将未排序的列表传递给分拣机。这意味着我们可以为不同的类型创建一个分类器的signelton实例......

只是一个想法:

[TestClass]
public class SpecifyUserDefinedSorting
{
    private Sorter<Movie> sorter;
    private IQueryable<Movie> unsorted;

    [TestInitialize]
    public void Setup()
    {
        unsorted = from m in Movies select m;
        sorter = new Sorter<Movie>();
        sorter.Register("Name", m1 => m1.Name);
        sorter.Register("Year", m2 => m2.Year);
    }

    [TestMethod]
    public void SortByNameThenYear()
    {
        var instructions = new List<SortInstrcution>()
                               {
                                   new SortInstrcution() {Name = "Name"},
                                   new SortInstrcution() {Name = "Year"}
                               };
        var sorted = sorter.SortBy(unsorted, instructions);
        var movies = sorted.ToArray();

        Assert.AreEqual(movies[0].Name, "A");
        Assert.AreEqual(movies[0].Year, 2000);
        Assert.AreEqual(movies[1].Year, 2001);
        Assert.AreEqual(movies[2].Name, "B");
    }

    [TestMethod]
    public void SortByNameThenYearDesc()
    {
        var instructions = new List<SortInstrcution>()
                               {
                                   new SortInstrcution() {Name = "Name", Direction = SortDirection.Descending},
                                   new SortInstrcution() {Name = "Year", Direction = SortDirection.Descending}
                               };
        var sorted = sorter.SortBy(unsorted, instructions);
        var movies = sorted.ToArray();

        Assert.AreEqual(movies[0].Name, "B");
        Assert.AreEqual(movies[0].Year, 1990);
        Assert.AreEqual(movies[1].Name, "A");
        Assert.AreEqual(movies[1].Year, 2001);
        Assert.AreEqual(movies[2].Name, "A");
        Assert.AreEqual(movies[2].Year, 2000);
    }

    [TestMethod]
    public void SortByNameThenYearDescAlt()
    {
        var instructions = new List<SortInstrcution>()
                               {
                                   new SortInstrcution() {Name = "Name", Direction = SortDirection.Descending},
                                   new SortInstrcution() {Name = "Year"}
                               };
        var sorted = sorter.SortBy(unsorted, instructions);
        var movies = sorted.ToArray();

        Assert.AreEqual(movies[0].Name, "B");
        Assert.AreEqual(movies[0].Year, 1990);
        Assert.AreEqual(movies[1].Name, "A");
        Assert.AreEqual(movies[1].Year, 2000);
        Assert.AreEqual(movies[2].Name, "A");
        Assert.AreEqual(movies[2].Year, 2001);
    }

    [TestMethod]
    public void SortByYearThenName()
    {
        var instructions = new List<SortInstrcution>()
                               {
                                   new SortInstrcution() {Name = "Year"},
                                   new SortInstrcution() {Name = "Name"}
                               };
        var sorted = sorter.SortBy(unsorted, instructions); 
        var movies = sorted.ToArray();

        Assert.AreEqual(movies[0].Name, "B");
        Assert.AreEqual(movies[1].Year, 2000);
    }

    [TestMethod]
    public void SortByYearOnly()
    {
        var instructions = new List<SortInstrcution>()
                               {
                                   new SortInstrcution() {Name = "Year"} 
                               };
        var sorted = sorter.SortBy(unsorted, instructions); 
        var movies = sorted.ToArray();

        Assert.AreEqual(movies[0].Name, "B");
    }

    private static IQueryable<Movie> Movies
    {
        get { return CreateMovies().AsQueryable(); }
    }

    private static IEnumerable<Movie> CreateMovies()
    {
        yield return new Movie { Name = "B", Year = 1990 };
        yield return new Movie { Name = "A", Year = 2001 };
        yield return new Movie { Name = "A", Year = 2000 };
    }
}


public static class SorterExtension
{
    public static IOrderedQueryable<T> SortBy<T>(this IQueryable<T> source, Sorter<T> sorter, IEnumerable<SortInstrcution> instrcutions)
    {
        return sorter.SortBy(source, instrcutions);
    }
}

public class Sorter<TSource>
{
    private readonly FirstPasses _FirstPasses;
    private readonly FirstPasses _FirstDescendingPasses;
    private readonly NextPasses _NextPasses;
    private readonly NextPasses _NextDescendingPasses; 

    public Sorter()
    {
        this._FirstPasses = new FirstPasses();
        this._FirstDescendingPasses = new FirstPasses();
        this._NextPasses = new NextPasses();
        this._NextDescendingPasses = new NextPasses();
    }


    public void Register<TKey>(string name, Expression<Func<TSource, TKey>> selector)
    {
        this._FirstPasses.Add(name, s => s.OrderBy(selector));
        this._FirstDescendingPasses.Add(name, s => s.OrderByDescending(selector));
        this._NextPasses.Add(name, s => s.ThenBy(selector));
        this._NextDescendingPasses.Add(name, s => s.ThenByDescending(selector));
    }


    public IOrderedQueryable<TSource> SortBy(IQueryable<TSource> source, IEnumerable<SortInstrcution> instrcutions)
    {
        IOrderedQueryable<TSource> result = null;

        foreach (var instrcution in instrcutions) 
            result = result == null ? this.SortFirst(instrcution, source) : this.SortNext(instrcution, result); 

        return result;
    }

    private IOrderedQueryable<TSource> SortFirst(SortInstrcution instrcution, IQueryable<TSource> source)
    {
        if (instrcution.Direction == SortDirection.Ascending)
            return this._FirstPasses[instrcution.Name].Invoke(source);
        return this._FirstDescendingPasses[instrcution.Name].Invoke(source);
    }

    private IOrderedQueryable<TSource> SortNext(SortInstrcution instrcution, IOrderedQueryable<TSource> source)
    {
        if (instrcution.Direction == SortDirection.Ascending)
            return this._NextPasses[instrcution.Name].Invoke(source);
        return this._NextDescendingPasses[instrcution.Name].Invoke(source);
    }

    private class FirstPasses : Dictionary<string, Func<IQueryable<TSource>, IOrderedQueryable<TSource>>> { }

    private class NextPasses : Dictionary<string, Func<IOrderedQueryable<TSource>, IOrderedQueryable<TSource>>> { } 
}


internal class Movie
{
    public string Name { get; set; }
    public int Year { get; set; }
}

public class SortInstrcution
{
    public string Name { get; set; }

    public SortDirection Direction { get; set; }
}

public enum SortDirection   
{
    //Note I have created this enum because the one that exists in the .net 
    // framework is in the web namespace...
    Ascending,
    Descending
}

请注意,如果您不想对SortInstrcution有依赖,那么就不会那么难以改变。

希望这有助于某人。

答案 3 :(得分:3)

我喜欢上面的工作 - 非常感谢你!我冒昧地添加了一些东西:

  1. 添加了排序方向。

  2. 注册并调用两个不同的问题。

  3. 用法:

    var censusSorter = new Sorter<CensusEntryVM>();
    censusSorter.AddSortExpression("SubscriberId", e=>e.SubscriberId);
    censusSorter.AddSortExpression("LastName", e => e.SubscriberId);
    
    View.CensusEntryDataSource = censusSorter.Sort(q.AsQueryable(), 
        new Tuple<string, SorterSortDirection>("SubscriberId", SorterSortDirection.Descending),
        new Tuple<string, SorterSortDirection>("LastName", SorterSortDirection.Ascending))
        .ToList();
    
    
    
    internal class Sorter<E>
    {
        public Sorter()
        {
        }
        public void AddSortExpression<P>(string name, Expression<Func<E, P>> selector)
        {
            // Register all possible types of sorting for each parameter
            firstPasses.Add(name, s => s.OrderBy(selector));
            nextPasses.Add(name, s => s.ThenBy(selector));
            firstPassesDesc.Add(name, s => s.OrderByDescending(selector));
            nextPassesDesc.Add(name, s => s.OrderByDescending(selector));
        } 
    
        public IOrderedQueryable<E> Sort(IQueryable<E> list, 
                                         params Tuple<string, SorterSortDirection>[] names) 
        { 
            IOrderedQueryable<E> result = null; 
            foreach (var entry in names)
            {
                result = result == null 
                       ? SortFirst(entry.Item1, entry.Item2, list) 
                       : SortNext(entry.Item1, entry.Item2, result); 
            } 
            return result; 
        } 
        private IOrderedQueryable<E> SortFirst(string name, SorterSortDirection direction, 
                                               IQueryable<E> source) 
        { 
            return direction == SorterSortDirection.Descending
                 ? firstPassesDesc[name].Invoke(source) 
                 : firstPasses[name].Invoke(source);
        } 
    
        private IOrderedQueryable<E> SortNext(string name, SorterSortDirection direction, 
                                              IOrderedQueryable<E> source) 
        {
            return direction == SorterSortDirection.Descending
                 ? nextPassesDesc[name].Invoke(source) 
                 : nextPasses[name].Invoke(source); 
        }
    
        private readonly FirstPasses firstPasses = new FirstPasses(); 
        private readonly NextPasses nextPasses = new NextPasses();
        private readonly FirstPasses firstPassesDesc = new FirstPasses();
        private readonly NextPasses nextPassesDesc = new NextPasses();
    
        private class FirstPasses : Dictionary<string, Func<IQueryable<E>, IOrderedQueryable<E>>> { }
        private class NextPasses : Dictionary<string, Func<IOrderedQueryable<E>, IOrderedQueryable<E>>> { }
    }