C# LINQ：根据参数对列表进行排序

我有一个LINQ to object查询来选择所有20岁以上的人

IEnumerable<Object> result = null;
result = (from person in AllPersons.ToList()
          where  person.age > 20
                  select new
                  {
                      FirstName= person.FirstName,
                      LastName= person.LastName,
                      Email= person.Email,
                      PhoneNumber= person.PhoneNumber


                  });
return result;

但它不起作用

知道怎么做吗

PS：我不想测试所有的可能性，对每一个都做一个if-else，或者一个case开关。我正在寻找一种有效的方法来做到这一点

---

谢谢

查看动态Linq扩展库

它具有接受

string

s而不是属性的扩展方法

由于您的

SortProperty

已经是一个

字符串

，您可以这样做

var result = (from person in AllPersons.ToList()
              where  person.age > 20
              select new
                     {
                        FirstName= person.FirstName,
                        LastName= person.LastName,
                        Email= person.Email,
                        PhoneNumber= person.PhoneNumber
                     }
              ).OrderBy(SortProperty);

return result;

另外，根据

AllPersons

是什么，在结束之前调用

ToList（）

枚举它可能没有意义。e、 g

var result = (from person in AllPersons
             ...
             ).OrderBy(SortProperty).ToList();

试一试

---

我用的是这样的东西：

var sortExpression = @"A,C";
var expressions = sortExpression.Split(new[] { ',' });

var cmpPredicates = new Dictionary<string, Func<Person, Person, int>>(3);
cmpPredicates.Add(@"A", (x, y) => x.A.CompareTo(y.A));
cmpPredicates.Add(@"B", (x, y) => x.B.CompareTo(y.B));
cmpPredicates.Add(@"C", (x, y) => x.C.CompareTo(y.C));
cmpPredicates.Add(@"Default", (x, y) => x.Id.CompareTo(y.Id));

var currentPredicates = new Func<Person, Person, int>[expressions.Length + 1];
for (int i = 0; i < expressions.Length; i++)
{
    currentPredicates[i] = cmpPredicates[expressions[i]];
}
// Default sort order
currentPredicates[currentPredicates.Length - 1] = cmpPredicates[@"Default"];

persons.Sort((x, y) =>
                {
                    var cmp = 0;

                    var index = 0;
                    while (cmp == 0 && index < currentPredicates.Length)
                    {
                        cmp = currentPredicates[index++](x, y);
                    }

                    return cmp;
                });

---

主要的好处是多属性支持。通过附加检查（重复项、存在项和谓词限制），可以由用户提供。

返回结果如何。OrderBy（x=>x.GetType（）.GetProperty（SortProperty）.GetValue（x，null）.ToString（））；如果这是一个可能的选项，那么可以传递lambda而不是字符串。使用lambda，您可以得到属性的值，然后根据该值进行排序。谢谢您，它成功了。（但是没有ToString（）。因此，移除ToString，我将接受您的回答

return result.OrderBy( x => TypeHelper.GetPropertyValue( x, sortProperty ) )
           .ToList();

return result.OrderBy(x => x.GetType().GetProperty(SortProperty).GetValue(x, null));

var sortExpression = @"A,C";
var expressions = sortExpression.Split(new[] { ',' });

var cmpPredicates = new Dictionary<string, Func<Person, Person, int>>(3);
cmpPredicates.Add(@"A", (x, y) => x.A.CompareTo(y.A));
cmpPredicates.Add(@"B", (x, y) => x.B.CompareTo(y.B));
cmpPredicates.Add(@"C", (x, y) => x.C.CompareTo(y.C));
cmpPredicates.Add(@"Default", (x, y) => x.Id.CompareTo(y.Id));

var currentPredicates = new Func<Person, Person, int>[expressions.Length + 1];
for (int i = 0; i < expressions.Length; i++)
{
    currentPredicates[i] = cmpPredicates[expressions[i]];
}
// Default sort order
currentPredicates[currentPredicates.Length - 1] = cmpPredicates[@"Default"];

persons.Sort((x, y) =>
                {
                    var cmp = 0;

                    var index = 0;
                    while (cmp == 0 && index < currentPredicates.Length)
                    {
                        cmp = currentPredicates[index++](x, y);
                    }

                    return cmp;
                });

public class Person
    {
        public string A { get; set; }
        public string B { get; set; }
        public string C { get; set; }

        public long Id { get; set; }

        public Person()
        {
            this.A = string.Empty;
            this.B = string.Empty;
            this.C = string.Empty;
        }
    }