Generic method with dynamically selected parameter in predicate

Question

I have many objects of diffrent type and i need to check few diffrent properties from each of them in the same way. I want to use this method inside object initializer like this:

collection.GroupBy(x => x.Identifier)
.Select(group => new SomeType 
{
    Identifier = group.Key,
    Quantity = group.Sum(i => i.Quantity),
    Type = MY_METHOD_HERE(group),
    Name = MY_METHOD_HERE(group)
})

Strongly typed example for one of the properties:

private ItemType CheckItemTypeConsistency(IGrouping<string, Item> group)
    {
        if (group.Any(x => x.ItemType != group.First().ItemType))
        {
            throw new ArgumentException($"Item with number {group.Key} is inconsistent", nameof(Item.ItemType));
        }
        else
        {
            return group.First().ItemType;
        }
    }

But i also have other property in Item that needs to be checked in the same way with diffrent type, so i have similar method but .ItemType is changed everywhere to .Name and return type is string.

I also have diffrent object type that i need to use it for, so in another method Item is changed to Vehicle.

How to create generic method like that? I tried something like this:

private TElement CheckConsistency<TKey, TElement>(IGrouping<TKey, TElement> group, (maybe something here?))
    {
        if (group.Any(x => x.(what here?) != group.First().(what here?)))
        {
            throw new ArgumentException($"Element with number {group.Key} is inconsistent");
        }
        else
        {
            return group.First();
        }
    }

I solved problem with returning value by returning whole item so i can just CheckConsistency().Property when invoking this method. But i dont know what to do with (what here?).

I thought that maybe i can put something in (maybe something here?) that would be somehow used in place of (what here?)?

Any ideas? I'm not sure about reflection because this method could be called easily more than 1000 times depending on collection size and number of unique entries.

@Edit: Lets say it's something like merging data from two files. For example 2 data sets of items where quantity is added together for items with the same identifier etc. but some properties should be the same like name and if they are diffrent then there's something wrong and i need to throw an error. There are diffrent sets of data with completly diffrent properties like vehicles, but rules are similar, some fields are just added together etc, some must be identical.

Answer 1

Using an accessor function and genericizing the property type and object type, you have:

private TProp CheckConsistency<TClass, TProp>(IGrouping<string, TClass> group, Func<TClass, TProp> propFn) {
    var firstPropValue = propFn(group.First());
    if (group.Any(x => firstPropValue == null ? propFn(x) == null : !propFn(x).Equals(firstPropValue))) {
        throw new ArgumentException($"Item with number {group.Key} is inconsistent");
    }
    else {
        return firstPropValue;
    }
}

Which you can use like:

var ans = collection.GroupBy(x => x.Identifier)
                    .Select(group => new SomeType {
                        Identifier = group.Key,
                        Quantity = group.Sum(i => i.Quantity),
                        Type = CheckConsistency(group, x => x.ItemType),
                        Name = CheckConsistency(group, x => x.Name)
                    });

If it is important to include the proper argument name in the exception, you could pass it in, take in an Expression<Func<>> and pull out the name, then compile the argument to a lambda to use (may be slow), or use reflection instead of a lambda property accessor (also possibly slow).

To use Reflection, I recommend caching the compiled function so you don't constantly re-compile each time the method is called:

// [Expression] => [Func]
Dictionary<LambdaExpression, Delegate> propFnCache = new Dictionary<LambdaExpression, Delegate>();

private TProp CheckConsistency<TClass, TProp>(IGrouping<string, TClass> group, Expression<Func<TClass, TProp>> propExpr) {
    Func<TClass,TProp> propFn;
    if (propFnCache.TryGetValue(propExpr, out var propDel))
        propFn = (Func<TClass, TProp>)propDel;
    else {
        propFn = propExpr.Compile();
        propFnCache.Add(propExpr, propFn);
    }

    var firstPropValue = propFn(group.First());
    if (group.Any(x => !propFn(x).Equals(firstPropValue))) {
        throw new ArgumentException($"Item with number {group.Key} is inconsistent", ((MemberExpression)propExpr.Body).Member.Name);
    }
    else {
        return firstPropValue;
    }
}