Question

我正在尝试创建一个快速类，这样我就可以更轻松地为网格编写排序代码，并保持代码重复。为此，我提出了以下课程：

public class SortConfig<TSource, TRelatedObject> where TSource : class where TRelatedObject : class
{
    public IList<SortOption> Options { get; protected set; }
    public SortOption DefaultOption { get; set; }

    public SortConfig()
    {
        Options = new List<SortOption>();
    }

    public void Add(string name, Expression<Func<TSource, object>> sortExpression, TRelatedObject relatedObject, bool isDefault = false)
    {
        var option = new SortOption
        {
            FriendlyName = name,
            SortExpression = sortExpression,
            RelatedObject = relatedObject
        };

        Options.Add(option);

        if (isDefault)
            DefaultOption = option;
    }

    public SortOption GetSortOption(string sortName)
    {
        if (sortName.EndsWith("asc", StringComparison.OrdinalIgnoreCase))
            sortName = sortName.Substring(0, sortName.LastIndexOf("asc", StringComparison.OrdinalIgnoreCase));
        else if (sortName.EndsWith("desc", StringComparison.OrdinalIgnoreCase))
            sortName = sortName.Substring(0, sortName.LastIndexOf("desc", StringComparison.OrdinalIgnoreCase));

        sortName = sortName.Trim();

        var option = Options.Where(x => x.FriendlyName.Trim().Equals(sortName, StringComparison.OrdinalIgnoreCase))
                            .FirstOrDefault();
        if (option == null)
        {
            if (DefaultOption == null)
                throw new InvalidOperationException(
                    string.Format("No configuration found for sort type of '{0}', and no default sort configuration exists", sortName));

            option = DefaultOption;
        }

        return option;
    }

    public class SortOption
    {
        public string FriendlyName { get; set; }
        public Expression<Func<TSource, object>> SortExpression { get; set; }
        public TRelatedObject RelatedObject { get; set; }
    }
}

您的想法是创建不同排序选项的快速配置，OrderBy表达式用于该选项，以及可选的与该排序选项相关的对象。这允许我的代码看起来像：

    protected void InitSortConfig()
    {
        _sortConfig = new SortConfig<xosPodOptimizedSearch, HtmlAnchor>();
        _sortConfig.Add("name", (x => x.LastName), lnkSortName, true);
        _sortConfig.Add("team", (x => x.SchoolName), lnkSortTeam);
        _sortConfig.Add("rate", (x => x.XosRating), lnkSortRate);
        _sortConfig.Add("pos", (x => x.ProjectedPositions), null);
        _sortConfig.Add("height", (x => x.Height), lnkSortHeight);
        _sortConfig.Add("weight", (x => x.Weight), lnkSortWeight);
        _sortConfig.Add("city", (x => x.SchoolCity), lnkSortCity);
        _sortConfig.Add("state", (x => x.SchoolState), lnkSortState);
    }

然后我可以按照

进行排序

        // Get desired sorting configuration
        InitSortConfig();
        var sortOption = _sortConfig.GetSortOption(sort);
        bool isDescendingSort = sort.EndsWith("desc", StringComparison.OrdinalIgnoreCase);

        // Setup columns
        InitSortLinks();
        if (sortOption.RelatedObject != null)
        {
            // Make modifications to html anchor
        }

        // Form query
        var query = PodDataContext.xosPodOptimizedSearches.AsQueryable();

        if (isDescendingSort)
            query = query.OrderByDescending(sortOption.SortExpression);
        else
            query = query.OrderBy(sortOption.SortExpression);

当排序变量是一个字符串时，这很有用，但是当它不是一个字符串时，我得到以下异常：Cannot order by type 'System.Object'.

我假设这是因为我将表达式存储为Expression<Func<TSource, object>>而不是更具体地说明第二个通用。我不明白如何在一个类中保留所有不同的排序选项（即使对于非字符串属性）。

我猜其中一个问题是Linq.OrderBy()子句将Expression<Func<TSource, TKey>>作为参数，但我并没有围绕Linq.OrderBy()如何推断TKey应该是什么，因此我无法理解如何利用该推断将这些表达式与正确的TKey一起存储。

有什么想法吗？

Answer 1

通用参数推断如下：

IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> enumerable, Func<TSource, TKey> expression)

当你有IEnumerable<T>时，由于扩展方法声明，编译器能够在这种情况下推断TSource是T;因此，在知道TSource是什么时，已经添加了扩展方法。例如：

Enumerable.Range(0, 10).OrderBy(x => x)

由于我们从IEnumerable<int>开始，编译器可以推断它所期望的表达式为Func<int, TKey>，因为扩展正在影响IEnumerable<int>。接下来，因为表达式返回一个值，编译器可以在这种情况{（1}}）中推断出剩余的类型，因此在这个例子中它变为int。

现在，与您的特定问题密切相关，如果您对Func<int, int>对象进行适当的通用化，则可以轻松地将表达式设置为正常工作。您的SortConfig现在看起来像是SortConfig代表。如果您将Func<TSource, object>一般化为使用其他类型，则会获得特异性。例如：

SortConfig

这里的下一个问题是如何以某种格式存储您的支持方法。你的类声明如下：

 void Add<TSource, TKey>(string name, Func<TSource, TKey> expression)

然后，当您调用public class SortConfig<TSource>扩展名时，所有数据类型都应该排成一行。

编辑：这是我认为你想做的一个有效例子：

OrderBy

如何动态存储用于Linq Orderby的表达式？

1 个答案: