我有一个类名为Product，具有一组属性：
public class Product
{
public string Id { get; set; }
public string Name { get; set; }
public string Categories { get; set; }
}
看起来您想要的东西与我们之前认为的略有不同。您不是在寻找不同值的数量，而是要找到每个不同值的重复次数，这本质上是一种按组分组并计算每个组的计数。
private static Dictionary<string, Dictionary<object, int>>
getDistinctValues<T>(List<T> list)
{
var properties = typeof(T).GetProperties();
var result = properties
//The key of the first dictionary is the property name
.ToDictionary(prop => prop.Name,
//the value is another dictionary
prop => list.GroupBy(item => prop.GetValue(item, null))
//The key of the inner dictionary is the unique property value
//the value if the inner dictionary is the count of that group.
.ToDictionary(group => group.Key, group => group.Count()));
return result;
}
曾经我将这个方法分成了两个，但是我将其压缩到了一个点上，我认为这不是必要的。如果你对这个查询的所有嵌套层次感到困惑，请随时要求进一步的澄清。
private static int DistinctCount<T>(IEnumerable<T> items, string property)
{
var propertyInfo = typeof(T).GetProperty(property);
return items.Select(x => propertyInfo.GetValue(x, null)).Distinct().Count();
}
使用方法：
List<Product> prods = GetProductsFromSomeplace();
int distinctCountById = DistinctCount(prods, "Id");
int distinctCountByName = DistinctCount(prods, "Name");
int distinctCountByCategories = DistinctCount(prods, "Categories");
private static int DistinctCount<TItems, TProperty>(IEnumerable<TItems> items,
string property,
IEqualityComparer<TProperty> propertyComparer)
{
var propertyInfo = typeof(TItems).GetProperty(property);
return items.Select(x => (TProperty)propertyInfo.GetValue(x, null))
.Distinct(propertyComparer).Count();
}
并像这样使用：
List<Product> prods = GetProductsFromSomeplace();
int distinctCountById = DistinctCount(prods, "Id", new MyCustomIdComparer());
在这种情况下，MyCustomIdComparer实现了接口（在本例中为IEC<int>）。
IEnumerable<T> 接口的对象提供一个“可过滤”属性列表和相应的值。这样，无论从数据源返回什么数据，都能够完全知道如何处理。虽然它会将更多的工作推回到数据源/服务/其他地方，但它会使您的UI更加简单。IEnumerable，因为我假设通用解决方案已经不存在——因为您说您需要反射）。如果您有一个类型化的表达式（即您实际上拥有一个 List<Product>），那么通用解决方案会更好，因为它会消除获取第一个项目的需要：public Dictionary<string, IEnumerable<object>>
GetAllPropertyDistincts(IEnumerable unknownValues)
{
//need the first item for the type:
var first = unknownValues.Cast<object>().First(); //obviously must NOT be empty :)
var allDistinct = first.GetType()
.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Select(p => new
{
PropName = p.Name,
Distinct = unknownValues.Cast<object>().Select(
o => property.GetValue(o, null)
).Distinct()
}).ToDictionary(v => v.PropName, v => v.Distinct);
}
Distinct扩展方法使用的默认IEqualityComparer可能存在一些问题 - 因为它是一个泛型方法，目前它将使用EqualityComparer<object>.Default - 这对于某些类型可能不起作用。public Dictionary<string, IEnumerable<object>>
GetAllPropertyDistincts<T>(IEnumerable<T> unknownValues)
{
var allDistinct = typeof(T)
在下面的代码中使用.GetProperties(BindingFlags.Public | BindingFlags.Instance)，然后将内部调用unknownValues.Cast<object>().Select(更改为unknownValues.Select(。
Product 类型，而是使用开放式泛型参数 T，并且该参数没有任何限制（where T : Product），那么可以使用强制转换来解决问题。int count = list
.Cast<Product>()
.Select(p => p.Id)
.Distinct()
.Count();
/// <summary>
/// A distinct value counter, using reflection
/// </summary>
public class DistinctValueCounter<TListItem>
{
/// <summary>
/// Gets or sets the associated list items
/// </summary>
private IEnumerable<TListItem> ListItems { get; set; }
/// <summary>
/// Constructs a new distinct value counter
/// </summary>
/// <param name="listItems">The list items to check</param>
public DistinctValueCounter(IEnumerable<TListItem> listItems)
{
this.ListItems = listItems;
}
/// <summary>
/// Gets the distinct values, and their counts
/// </summary>
/// <typeparam name="TProperty">The type of the property expected</typeparam>
/// <param name="propertyName">The property name</param>
/// <returns>A dictionary containing the distinct counts, and their count</returns>
public Dictionary<TProperty, int> GetDistinctCounts<TProperty>(string propertyName)
{
var result = new Dictionary<TProperty, int>();
// check if there are any list items
if (this.ListItems.Count() == 0)
{
return result;
}
// get the property info, and check it exists
var propertyInfo = this.GetPropertyInfo<TProperty>(this.ListItems.FirstOrDefault(), propertyName);
if (propertyInfo == null)
{
return result;
}
// get the values for the property, from the list of items
return ListItems.Select(item => (TProperty)propertyInfo.GetValue(item, null))
.GroupBy(value => value)
.ToDictionary(value => value.Key, value => value.Count());
}
/// <summary>
/// Gets the property information, for a list item, by its property name
/// </summary>
/// <typeparam name="TProperty">The expected property type</typeparam>
/// <param name="listItem">The list item</param>
/// <param name="propertyName">The property name</param>
/// <returns>The property information</returns>
private PropertyInfo GetPropertyInfo<TProperty>(TListItem listItem, string propertyName)
{
// if the list item is null, return null
if (listItem == null)
{
return null;
}
// get the property information, and check it exits
var propertyInfo = listItem.GetType().GetProperty(propertyName);
if (propertyInfo == null)
{
return null;
}
// return the property info, if it is a match
return propertyInfo.PropertyType == typeof(TProperty) ? propertyInfo : null;
}
}
使用方法：
var counter = new DistinctValueCounter<Person>(people);
var resultOne = counter.GetDistinctCounts<string>("Name");
如果我理解你的目标，你应该只需要使用LINQ：
List<Product> products = /* whatever */
var distinctIds = products.Select(p=>p.Id).Distinct();
var idCount = distinctIds.Count();
...
ToList 获取不同的值，以便只查询一次列表。 - Servy
Product类中有哪些属性呢？这些属性必须在编译时就已知。 - Olivier Jacot-Descombes