5

グリッドの並べ替えコードの記述をより簡単に操作および保守できるようにし、コードの繰り返しを抑えることができるように、クイッククラスを作成しようとしています。これを行うために、私は次のクラスを思いついた：

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>>あり、その2番目のジェネリックについてより具体的ではないためだと思います。さまざまな並べ替えオプション（文字列以外のプロパティの場合でも）をすべて1つのクラスに保持する方法がわかりません。

問題の1つは、Linq.OrderBy()句がパラメータとして使用されることだと思いますが、どのように推論できるExpression<Func<TSource, TKey>>かについて頭を悩ませていません。したがって、その推論を利用してこれらの式を保存する方法を理解できません。適切な。Linq.OrderBy()TKeyTKey

何か案は？

4

1 に答える 1

5

一般的な引数は次のように推測されます。

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

を持っている場合、コンパイラは、拡張メソッド宣言のために、がこの状況にあるとIEnumerable<T>推測できます。したがって、拡張メソッドは、何であるかを知ることですでに追加されています。例えば：TSourceTTSource

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

で始まるので、拡張子がに影響を与えているためIEnumerable<int>、コンパイラは期待する式がであると推測できます。次に、式が値を返すため、コンパイラは残りの型を推測できます。この状況では、この例ではになります。Func<int, TKey>IEnumerable<int>intFunc<int, int>

さて、あなたの特定の問題に密接に関係しているので、SortConfigオブジェクトを適切に一般化すれば、適切に機能するように式を簡単に設定できます。あなたは今SortConfig、代理人を取っているようです。別のタイプを使用するように一般化すると、特異性が得られますFunc<TSource, object>。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);
    }
于 2012-05-07T18:46:57.213 に答える