7

リストに格納されているオブジェクトのプロパティによって、C# でリストを並べ替えたいと考えています。私はこれを持っています：

if (sortColumn == "Login")
{
    if (sortDir == "ASC")
    {
        filteredList.Sort((x, y) => string.Compare(x.Login, y.Login, true));
    }
    else
    {
        filteredList.Sort((x, y) => string.Compare(y.Login, x.Login, true));
    }
 }

それは正常に動作しますが、ソートするフィールドを知る必要がないように、より一般的にしたいと考えています。私はこのようなことを考えています：

//With sortColumn = "Login";
if (sortDir == "ASC")
{
    filteredList.Sort((x, y) => string.Compare(x.GetType().GetProperty(sortColumn), y.GetType().GetProperty(sortColumn), true));
}
else
{
    filteredList.Sort((x, y) => string.Compare(y.GetType().GetProperty(sortColumn), x.GetType().GetProperty(sortColumn), true));
}

明らかにこれはうまくいきませんが、これが私が望むものです。どういうわけかそれは可能ですか？

ありがとう。

4

4 に答える 4

3

リフレクション コードが正しくありません。これを見てください。

PropertyInfo pi1 = typeof(x).GetProperty(sortColumn);
PropertyInfo pi2 = typeof(y).GetProperty(sortColumn);

//With sortColumn = "Login";
if (sortDir == "ASC")
{
    filteredList.Sort((x, y) => string.Compare(pi1.GetValue(x, null), pi2.GetValue(y, null), true));
}
else
{
    filteredList.Sort((x, y) => string.Compare(pi2.GetValue(y, null), pi1.GetValue(x, null), true));
}

これはあなたのために働くと思います。

于 2012-08-31T07:19:33.760 に答える
1

これは私が同じ問題に使用するものです。

使い方は次のようになります: mySequence.OrderByPropertyName("Login", SortDirection.Descending).

public enum SortDirection
{
    Ascending,
    Descending
}

public static IOrderedEnumerable<T> OrderByPropertyName<T>
(
    this IEnumerable<T> items,
    string propertyName,
    SortDirection sortDirection = SortDirection.Ascending
)
{
    var propInfo = typeof(T).GetProperty(propertyName);
    return items.OrderByDirection(x => propInfo.GetValue(x, null), sortDirection);
}

public static IOrderedEnumerable<T> OrderByDirection<T, TKey>
(
    this IEnumerable<T> items,
    Func<T, TKey> keyExpression,
    SortDirection sortDirection = SortDirection.Ascending
)
{
    switch (sortDirection)
    {
        case SortDirection.Ascending:
            return items.OrderBy(keyExpression);
        case SortDirection.Descending:
            return items.OrderByDescending(keyExpression);
    }
    throw new ArgumentException("Unknown SortDirection: " + sortDirection);
}
于 2012-08-31T07:10:24.940 に答える
0

私はdateTimeと照合して正しく動作しています。

    List<DateTime> list = new List<DateTime>();
    list.Add(DateTime.Now);
    list.Add(DateTime.UtcNow.AddYears(2));

    list.Sort((x, y) => (Convert.ToString(x.GetType().GetProperty("DayOfYear").GetValue(x)).CompareTo(Convert.ToString(y.GetType().GetProperty("DayOfYear").GetValue(y)))));
于 2012-08-31T07:21:51.113 に答える
0

verdesmarald の投稿を拡張して、Ascending と Descending を別々のメソッドに分け、ThenBy メソッドを追加しました。

using System.Collections.Generic;

namespace System.Linq
{
    public static class IEnumerableExtensions
    {
        enum SortDirection
        {
            Ascending,
            Descending
        }

        public static IOrderedEnumerable<T> OrderBy<T>
            (this IEnumerable<T> items,
            string propertyName)
        {
            var propInfo = typeof (T).GetProperty(propertyName);
            return items.OrderByDirection(x => propInfo.GetValue(x, null), SortDirection.Ascending);
        }

        public static IOrderedEnumerable<T> ThenBy<T>
            (this IOrderedEnumerable<T> items,
            string propertyName)
        {
            var propInfo = typeof(T).GetProperty(propertyName);
            return items.ThenByDirection(x => propInfo.GetValue(x, null), SortDirection.Ascending);
        }

        public static IOrderedEnumerable<T> OrderByDescending<T>
            (this IEnumerable<T> items,
            string propertyName)
        {
            var propInfo = typeof(T).GetProperty(propertyName);
            return items.OrderByDirection(x => propInfo.GetValue(x, null), SortDirection.Descending);
        }

        public static IOrderedEnumerable<T> ThenByDescending<T>
            (this IOrderedEnumerable<T> items,
            string propertyName)
        {
            var propInfo = typeof(T).GetProperty(propertyName);
            return items.ThenByDirection(x => propInfo.GetValue(x, null), SortDirection.Descending);
        }

        private static IOrderedEnumerable<T> OrderByDirection<T, TKey>
            (this IEnumerable<T> items,
            Func<T, TKey> keyExpression,
            SortDirection sortDirection)
        {
            switch (sortDirection)
            {
                case SortDirection.Ascending:
                    return items.OrderBy(keyExpression);
                case SortDirection.Descending:
                    return items.OrderByDescending(keyExpression);
            }
            throw new ArgumentException("Unknown SortDirection: " + sortDirection);
        }

        private static IOrderedEnumerable<T> ThenByDirection<T, TKey>
            (this IOrderedEnumerable<T> items,
                Func<T, TKey> keyExpression,
                SortDirection sortDirection)
        {
            switch (sortDirection)
            {
                case SortDirection.Ascending:
                    return items.ThenBy(keyExpression);
                case SortDirection.Descending:
                    return items.ThenByDescending(keyExpression);
            }
            throw new ArgumentException("Unknown SortDirection: " + sortDirection);
        }
    }
}
于 2016-05-31T14:34:54.313 に答える