LINQ按名称选择属性[重复]

Question

我正在尝试在 LINQ 选择语句中使用变量。

这是我现在正在做的一个例子。

using System;
using System.Collections.Generic;
using System.Linq;
using Faker;

namespace ConsoleTesting
{
internal class Program
{
    private static void Main(string[] args)
    {
        List<Person> listOfPersons = new List<Person>
        {
            new Person(),
            new Person(),
            new Person(),
            new Person(),
            new Person(),
            new Person(),
            new Person(),
            new Person(),
            new Person(),
            new Person(),
            new Person()
        };

        var firstNames = Person.GetListOfAFirstNames(listOfPersons);

        foreach (var item in listOfPersons)
        {
            Console.WriteLine(item);
        }

        Console.WriteLine();
        Console.ReadKey();
    }


    public class Person
    {
        public string City { get; set; }
        public string CountryName { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }

        public Person()
        {
            FirstName = NameFaker.Name();
            LastName = NameFaker.LastName();
            City = LocationFaker.City();
            CountryName = LocationFaker.Country();
        }

        public static List<string> GetListOfAFirstNames(IEnumerable<Person> listOfPersons)
        {
            return listOfPersons.Select(x => x.FirstName).Distinct().OrderBy(x => x).ToList();
        }

        public static List<string> GetListOfCities(IEnumerable<Person> listOfPersons)
        {
            return listOfPersons.Select(x => x.FirstName).Distinct().OrderBy(x => x).ToList();
        }

        public static List<string> GetListOfCountries(IEnumerable<Person> listOfPersons)
        {
            return listOfPersons.Select(x => x.FirstName).Distinct().OrderBy(x => x).ToList();
        }

        public static List<string> GetListOfLastNames(IEnumerable<Person> listOfPersons)
        {
            return listOfPersons.Select(x => x.FirstName).Distinct().OrderBy(x => x).ToList();
        }
    }
}
}

我有一些非常不干燥的代码，带有 GetListOf... 方法

我觉得我应该能够做这样的事情

public static List<string> GetListOfProperty(
IEnumerable<Person> listOfPersons, string property)
        {
            return listOfPersons.Select(x =>x.property).Distinct().OrderBy(x=> x).ToList();
        }

但这不是有效的代码。我认为关键可能与创建函数有关

如果这就是答案，我该怎么做？

这是使用反射的第二次尝试但这也是不行的。

        public static List<string> GetListOfProperty(IEnumerable<Person> 
listOfPersons, string property)
        {
            Person person = new Person();
            Type t = person.GetType();
            PropertyInfo prop = t.GetProperty(property);
            return listOfPersons.Select(prop).Distinct().OrderBy(x => 
x).ToList();
}

我认为反射可能是一个死胡同/红鲱鱼，但我想我还是会展示我的作品。

注意示例代码实际上已简化，用于通过 AJAX 填充 datalist 以创建自动完成体验。该对象有 20 多个属性，我可以通过编写 20 多个方法来完成，但我觉得应该有一个 DRY 方法来完成它。也使这种方法也可以清理我的控制器动作。

问题：

鉴于第一部分代码，有没有办法将这些类似的方法抽象为一个方法购买将一些对象传递给 select 语句？？？

感谢您的宝贵时间。

Answer 1

您必须构建选择

.Select(x =>x.property).

手动。幸运的是，这不是一个棘手的问题，因为您希望它始终是同一类型 (string)，所以：

var x = Expression.Parameter(typeof(Person), "x");
var body = Expression.PropertyOrField(x, property);
var lambda = Expression.Lambda<Func<Person,string>>(body, x);

那么上面的Select就变成了：

.Select(lambda).

（对于基于 IQueryable<T> 的 LINQ）或

.Select(lambda.Compile()).

（对于基于IEnumerable<T> 的LINQ）。

请注意，您可以做任何事情来缓存 property 的最终表单。

Answer 2

从您的示例中，我认为您想要的是：

public static List<string> GetListOfProperty(IEnumerable<Person> 
    listOfPersons, string property)
{
    Type t = typeof(Person);         
    PropertyInfo prop = t.GetProperty(property);
    return listOfPersons
        .Select(person => (string)prop.GetValue(person))
        .Distinct()
        .OrderBy(x => x)
        .ToList();

}

typeof 是 C# 中的内置运算符，您可以将类型的名称“传递”给它，它将返回 Type 的相应实例。它在编译时工作，而不是运行时，所以它不像普通函数那样工作。

PropertyInfo 有一个采用对象参数的GetValue 方法。对象是要从中获取属性值的类型实例。如果您尝试定位 static 属性，请使用 null 作为该参数。

GetValue 返回一个object，您必须将其转换为实际类型。

person => (string)prop.GetValue(person) 是一个带有如下签名的 Lamba 表达式：

string Foo(Person person) { ... }

如果您希望它适用于任何类型的属性，请将其设为通用而不是硬编码 string。

public static List<T> GetListOfProperty<T>(IEnumerable<Person> 
    listOfPersons, string property)
{
    Type t = typeof(Person);         
    PropertyInfo prop = t.GetProperty(property);
    return listOfPersons
        .Select(person => (T)prop.GetValue(person))
        .Distinct()
        .OrderBy(x => x)
        .ToList();
}

Answer 3

我会尽可能远离反射和硬编码字符串...

如何定义一个接受 T 的函数选择器的扩展方法，以便您可以处理字符串属性之外的其他类型

public static List<T> Query<T>(this IEnumerable<Person> instance, Func<Person, T> selector)
{
    return instance
        .Select(selector)
        .Distinct()
        .OrderBy(x => x)
        .ToList();
}

假设你有一个 person 类，除了你已经公开的之外，还有一个 int 类型的 id 属性

public class Person
{
    public int Id { get; set; }
    public string City { get; set; }
    public string CountryName { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

您需要做的就是使用类型安全的 lambda 选择器获取结果

var ids = listOfPersons.Query(p => p.Id);
var firstNames = listOfPersons.Query(p => p.FirstName);
var lastNames = listOfPersons.Query(p => p.LastName);
var cityNames = listOfPersons.Query(p => p.City);
var countryNames = listOfPersons.Query(p => p.CountryName);

编辑

您似乎确实需要硬编码字符串作为属性输入，那么如何省略一些动态性并使用一些确定性

public static List<string> Query(this IEnumerable<Person> instance, string property)
{
    switch (property)
    {
        case "ids": return instance.Query(p => p.Id.ToString());
        case "firstName": return instance.Query(p => p.FirstName);
        case "lastName": return instance.Query(p => p.LastName);
        case "countryName": return instance.Query(p => p.CountryName);
        case "cityName": return instance.Query(p => p.City);
        default: throw new Exception($"{property} is not supported");
    }
}

并访问所需的结果

var cityNames = listOfPersons.Query("cityName");

Answer 4

你应该可以用反射来做到这一点。我使用它类似的东西。

只要改变你的想法试试这个：

public static List<string> GetListOfValues(IEnumerable<Person> listOfPersons, string propertyName)
{
    var ret = new List<string>();

    PropertyInfo prop = typeof(Person).GetProperty(propertyName);
    if (prop != null)
        ret = listOfPersons.Select(p => prop.GetValue(p).ToString()).Distinct().OrderBy(x => x).ToList();

    return ret;
}

希望对你有帮助。

它基于 C# 6

Answer 5

您也可以使用它。对我有用。

public static class ObjectReflectionExtensions
{
    public static  object GetValueByName<T>(this T thisObject,  string propertyName)
    {
        PropertyInfo prop = typeof(T).GetProperty(propertyName);
        return prop.GetValue(thisObject);

    }
}

然后像这样调用。

public static List<string> GetListOfProperty(IEnumerable<Person> listOfPersons, string propertyName)
    {
        return listOfPersons.Select(x =>(string)x.GetValueByName(propertyName)).Distinct().OrderBy(x=> x).ToList();
    }

Answer 6

如果要选择所有值：

object[] foos = objects.Select(o => o.GetType().GetProperty("PropertyName").GetValue(o)).ToArray();