LINQ 查询 - 如何参数化选择不同的查询

Question

I'm having a hard time figuring out what I am missing when trying to parameterize a "Select" with "Distinct" query.

This is a sample of the code I have repeated multiple times with different items to select.

    private void getCustomerCodeList(ObservableCollection<Model> FilteredData)
    {
        var distCustomerCode = FilteredData.Select(i => new { i.CustomerCode, i.FamilyName }).Distinct().OrderBy(x => x.FamilyName).ToList();

        DistinctCustomerCodeList.Clear();

        foreach (var item in distCustomerCode)
        {
            DistinctCustomerCodeList.Add(new Model() { CustomerCode = item.CustomerCode, FamilyName = item.FamilyName });

        }

    }

I am trying to convert this into one method where I can pass in the "Select" and the "Orderby" as parameters. The code below is as far as I was able to get, and it works fine if I pass in a lambda with one property, but errors as soon as I try to add a second.

        public void getDistinct<TKey>(ObservableCollection<Model> FilteredData, Func<Model, TKey> myDistinctProperty, Func<TKey, TKey> mySortingProperty)
    {


        var distinct = FilteredData.Select(myDistinctProperty).Distinct().OrderBy(mySortingProperty).ToList();

        DistinctCustomerCodeList.Clear();

        foreach (var item in distinct )
        {

            DistinctCustomerCodeList.Add(new Model() { CustomerCode = item.ToString() });
        }
    }

If I call this method:

getDistinct<string>(FilteredData, x => x.CustomerCode, x => x);

it works fine but if I try:

getDistinct<string>(FilteredData, i => new { i.CustomerCode, i.FamilyName }, x => x.FamilyName)

it errors.

Can anyone shed some light on this for me.

Thanks.

Update-

Here is the error message I am receiving.

'IEnumerable' does not contain a definition for 'OrderBy' and the best extension method overload 'ParallelEnumerable.OrderBy<Model, string>(ParallelQuery, Func<Model, string>)' requires a receiver of type 'ParallelQuery'

I made the changes based on the clarification that nalpnir provided and here is what my updated code looks like.

       public void getDistinct<TKey>(ObservableCollection<Model> FilteredData, Func<Model, TKey> myDistinctProperty, Func<Model, string> mySortingProperty)
    {


        var distinct= FilteredData.Select(myDistinctProperty).Distinct().OrderBy(mySortingProperty).ToList();
        DistinctCustomerCodeList.Clear();
        foreach (var item in distinct)
        {

            DistinctCustomerCodeList.Add(new Model() { CustomerCode = item.ToString() });
        }
    }

This portion has the error provided above (FilteredData.Select(myDistinctProperty).Distinct())

and here is the updated method call:

getDistinct<Model>(FilteredData, i => new Model { FamilyName = i.FamilyName, CustomerCode = i.CustomerCode }, x => x.CustomerCode);

Update 2 -

Thank you all for your feedback. I ended up using the answer from JeremyLakeman , as it fit best in the project I am working on.

The answer from nalpnir is awesome and I will try to implement it in the future.

Answer 1

The reason is simple, the LINQ you are doing is wrong, for 2 reasons but the same reason itself:

• Your TKey is set as a string, so when you say new { i.CustomerCode, i.FamilyName } it doesnt know how to go from that expression to a string.

• The same occurs in the case of the sorting, x is of type String, and x doesnt know what x.CustomerName is.

What you should use is the Model as TKey, like this:

getDistinct<Model>(list, i => new Model { FamilyName = i.FamilyName, CustomerCode = i.CustomerCode }, x => x.CustomerCode);

UPDATE: Since i noticed it didnt do what you wanted to do, which is to be able to get it without repetitions, I changed a bit the idea so you can get around it, and even made it more generic so you can implement it with any class you want, as long as you make a few changes which i ll explain

public static List<T> getDistinct<T, TKey>(ObservableCollection<T> FilteredData, Func<T, TKey> myDistinctProperty, Func<T, string> mySortingProperty)
    where T:Model, new()
{
    var DistinctCustomerCodeList = new List<T>();

    var distinct = FilteredData.GroupBy(myDistinctProperty).Select(x => x.First()).OrderBy(mySortingProperty).ToList();

    foreach (var item in distinct)
    {
        DistinctCustomerCodeList.Add(new T() { CustomerCode = item.CustomerCode, FamilyName = item.FamilyName });
    }

    return DistinctCustomerCodeList;
}

As you see now you have 2 Generics, One is T which i restricted to be of type Model, and the other one is another type whichever you want in this particular case it will accept new { x.CustomerCode, x.FamilyName } . I ll give you a link to a .Net fiddle so you know can see a demo

Demo: demo

You can toy with it. Basically whichever class you replace model for will work as long as you change the output of the type T, and change the Add inside the foreach. Inherited members of Model will also work so lets say for example you implement the following:

public class ModelExtended:Model
{
    public int NewProp { get; set; }
}

And also changed the ObservableCollection To ObservableCollection will also work because they share some properties

Answer 2

The OrderBy() is expecting a generic type TKey but the parameter mySortingProperty is explicitly referencing Model . Update the parameter in your method definition as follows:

public void getDistinct<TKey>(ObservableCollection<Model> FilteredData, Func<Model, TKey> myDistinctProperty, Func<TKey, string> mySortingProperty)

Answer 3

Your first example turned each instance of Model into an anonymous type, then later back into a Model again. Instead, the generic distinct method should create a new Model with only the requested fields.

public void getDistinct<TOrder>(ObservableCollection<Model> FilteredData, Func<Model, Model> distinct, Func<Model, TOrder> sort)
    {
        var distinct = FilteredData.Select(distinct).Distinct().OrderBy(sort).ToList();

        DistinctCustomerCodeList.Clear();
        DistinctCustomerCodeList.AddRange(distinct);
    }

Then this should work, with the compiler able to infer the generic types;

getDistinct(FilteredData, i => new Model{ i.CustomerCode, i.FamilyName }, x => x.FamilyName);