List sort based on another list

问题:

I have two generic list objects, in which one contains ids and ordering, and the other a bunch of ids with each id in the second list having an id reference to the first list, for example;

public class OptionType
{
    public int ID { get; set; }
    public int Ordering { get; set; }
}

public class Option
{
    public int ID { get; set; }
    public int Type_ID { get; set; }
}   

Obviously I can do a simple sort on a list of OptionTypes by doing

types_list.OrderBy(x => x.Ordering);

Question is though, how could I go about ordering an 'options_list' by utilising the 'Type_ID' on the object which would relate to the ordering of the types_list. As in something like (obviously this isn't valid - but hopefully you will get the idea!)

options_list.OrderBy(x => x.Type_ID == types_list.OrderBy(e => e.Ordering));

回答1:

You should be able to use a join to produce your desired output. Example using query syntax.

var orderedOptions = from option in options_list
                     join type in types_list
                     on option.Type_ID equals type.ID
                     orderby type.Ordering
                     select option;

回答2:

List.FindIndex() is your friend:

var orderedB = listB.OrderBy(b => listA.FindIndex(a => a.id == b.id));

Working example: https://dotnetfiddle.net/CpLeFU

回答3:

I like Lambda syntax, so I came up with this equivalent. I can see how query syntax is cleaner for joins.

var orderedOptions = options_list
    .Join(
        types_list,
        option => option.Type_ID,
        type => type.ID,
        (option, type) => new { Option = option, Type = type })
    .OrderBy(x => x.Type.Ordering)
    .Select(x => x.Option);

For a slight reduction (of what, I'm not sure), this creates the new object with just the Ordering property, instead of the entire Type class. Not much different here, but I had a large class with the sort data, and only need the sorting property. Don't know if it mattered, but it was clearer to read.

var orderedOptions = options_list
    .Join(
        types_list,
        option => option.Type_ID,
        type => type.ID,
        (option, type) => new { Option = option, Ordering = type.Ordering })
    .OrderBy(x => x.Ordering)
    .Select(x => x.Option);

It looks like the query syntax lets you order within the initial query, while lambda requires ordering after the join creates the new object. Maybe they're really doing the same thing under the covers though: creating the joined object, to be sorted then selected.