我试图创建一个快速的类,以便可以更轻松地使用和维护网格的排序代码,并使代码的重复性降低。为此,我提出了以下类(class):
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
。有任何想法吗?
最佳答案
通用参数的推断如下:
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>
。接下来,由于您的表达式返回一个值,因此编译器可以推断剩余的类型,在这种情况下为int
,因此在本示例中,它变为Func<int, int>
。现在,与您的特定问题密切相关,如果适本地泛化了
SortConfig
对象,则可以轻松地设置表达式以使其正常工作。看来您的SortConfig
现在接受了Func<TSource, object>
委托(delegate)。如果您将SortConfig
泛化为使用另一种类型,则会获得特异性。例子: void Add<TSource, TKey>(string name, Func<TSource, TKey> expression)
这里的下一个问题是如何以某种格式存储支持方法。您的类声明如下所示:
public class SortConfig<TSource>
然后,当您调用
OrderBy
扩展名时,所有数据类型都应对齐。编辑:这是我认为您想做的一个工作示例:
static void Main(string[] args)
{
var list = Enumerable.Range(0, 10).Reverse().Select(x => new SampleClass { IntProperty = x, StringProperty = x + "String", DateTimeProperty = DateTime.Now.AddDays(x * -1) });
SortContainer<SampleClass> container = new SortContainer<SampleClass>();
container.Add("Int", x => x.IntProperty);
container.Add("String", x => x.StringProperty);
container.Add("DateTime", x => x.DateTimeProperty);
var sorter = container.GetSorterFor("Int");
sorter.Sort(list).ForEach(x => Console.WriteLine(x.IntProperty));
Console.ReadKey();
}
public class SampleClass
{
public int IntProperty { get; set; }
public string StringProperty { get; set; }
public DateTime DateTimeProperty { get; set; }
}
public class SortContainer<TSource>
{
protected Dictionary<string, ISorter<TSource>> _sortTypes = new Dictionary<string, ISorter<TSource>>();
public void Add<TKey>(string name, Func<TSource, TKey> sortExpression)
{
Sorter<TSource, TKey> sorter = new Sorter<TSource, TKey>(sortExpression);
_sortTypes.Add(name, sorter);
}
public ISorter<TSource> GetSorterFor(string name)
{
return _sortTypes[name];
}
}
public class Sorter<TSource, TKey> : ISorter<TSource>
{
protected Func<TSource, TKey> _sortExpression = null;
public Sorter(Func<TSource, TKey> sortExpression)
{
_sortExpression = sortExpression;
}
public IOrderedEnumerable<TSource> Sort(IEnumerable<TSource> sourceEnumerable)
{
return sourceEnumerable.OrderBy(_sortExpression);
}
}
public interface ISorter<TSource>
{
IOrderedEnumerable<TSource> Sort(IEnumerable<TSource> sourceEnumerable);
}
关于c# - 如何动态存储用于Linq Orderby的表达式?,我们在Stack Overflow上找到一个类似的问题:https://stackoverflow.com/questions/10487248/