c＃如何使用。包含在通用IEnumerable中<T>

Question

I'm trying to create a generic method that I want to use for mixing a list of objects based off a property. Optionally, you can supply a list of list objects to merge some groups together. This works fine as a non-generic method and when I code the property manually, etc.

Method head:

public static IEnumerable<T> MixObjectsByProperty<T>(
    IEnumerable<T> objects,
    string propertyName,
    IEnumerable<IEnumerable<T>> groupsToMergeByProperty = null)

Snippet of the methods body:

groups =
    (from item in objects
    let propertyInfo = item.GetType().GetProperty(propertyName)
    where propertyInfo != null
    group item by groupsToMergeByProperty
        .FirstOrDefault(ids => ids.Contains(propertyInfo.GetValue(item, null)))
        //.FirstOrDefault(ids => ids.Any(propertyInfo.GetValue(item, null)))
        ?.First()
        ?? propertyInfo.GetValue(item, null)
    into itemGroup
    select itemGroup.ToArray())
    .ToList();

As you can see, I'm having trouble using the contains method on a IEnumerable<T> as propertyInfo.GetValue(item, null) is returning an object. I've tried various casting attempts and using .Any() instead, but I've hit a brick wall :(

Any help will be great, thanks!

Also, let me know if you need any more information but I guess, in essence, all I need to know is how to use .Contains() using <T> .

Set them to the same type? Custom IEqualityComparer ?

Answer 1

I've tried various casting attempts

Have you tried this one?

.FirstOrDefault(ids => ids.Contains((T)propertyInfo.GetValue(item, null)))

Since ids is of type IGrouping<TKey, TElement> where TElement is of type T in your case, casting the value of property to T will allow for the comparison.

Answer 2

Without seeing the whole method (because your type signatures clearly indicate it's not the whole method), here's an example implementation:

public class Ext
{
    public static List<T[]> MixObjectsByProperty<T, TProp, U>(
        IEnumerable<T> source,
        Expression<Func<T, TProp>> property,
        IEnumerable<IEnumerable<U>> groupsToMix = null)
        where T : class
        where U : TProp
    {
        var prop = (PropertyInfo)(property.Body as MemberExpression)?.Member;
        if (prop == null) throw new ArgumentException("Couldn't determine property");

        var accessor = property.Compile();

        var groups = 
            from item in source
            let value = (U)accessor(item)
            group item by
                groupsToMix.FirstOrDefault((ids => ids.Contains(value)))
            into itemGroup
            select itemGroup.ToArray();
        return groups.ToList();
    }
}

For the love of god stop passing property names and using reflection, the rest of Linq makes use of the gorgeous expression system, and you should too!

Answer 3

Ok, so I cracked it in the end. I needed to add more detail in my generic method header/signature.

    public static IEnumerable<T> MixObjectsByProperty<T, U>(
        IEnumerable<T> objects, string propertyName, IEnumerable<IEnumerable<U>> groupsToMergeByProperty = null)
        where T : class
        where U : class
    {
        ...

Note, I added class constraints which allows me to use nullable operators, etc.

And the body became (after adding a propertyValue variable which is casted to the correct type!):

            groups =
                (from item in objects
                 let propertyInfo = item.GetType().GetProperty(propertyName)
                 where propertyInfo != null
                 let propertyValue = (U)propertyInfo.GetValue(item, null)
                 group item by
                     groupsToMergeByProperty
                         .FirstOrDefault(ids => ids.Contains(propertyValue))
                         ?.First()
                     ?? propertyValue
                 into itemGroup
                 select itemGroup.ToArray())
                .ToList();