Clasificación de lista basada en otra lista

Tengo dos objetos de lista generics, en los que uno contiene los identificadores y los pedidos, y el otro un conjunto de identificadores con cada identificación en la segunda lista que tiene una referencia de id para la primera lista, por ejemplo;

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; } } 

Obviamente, puedo hacer un tipo simple en una lista de OptionTypes haciendo

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

Sin embargo, la pregunta es, ¿cómo podría hacer un pedido de ‘options_list’ utilizando el ‘Type_ID’ en el objeto que se relacionaría con el orden de los types_list? Como en algo así como (obviamente esto no es válido, ¡pero espero que entiendas la idea!)

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

Debería poder usar un join para producir el resultado deseado. Ejemplo utilizando syntax de consulta.

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

List.FindIndex () es tu amigo:

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

Ejemplo de trabajo: https://dotnetfiddle.net/CpLeFU

Me gusta la syntax de Lambda, así que se me ocurrió este equivalente. Puedo ver cómo la syntax de la consulta es más clara para las uniones.

 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); 

Para una pequeña reducción (de qué, no estoy seguro), esto crea el nuevo objeto con solo la propiedad Ordering, en lugar de la clase Type completa. No es muy diferente aquí, pero tuve una gran clase con los datos de clasificación, y solo necesito la propiedad de clasificación. No sé si importaba, pero era más claro de leer.

 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); 

Parece que la syntax de la consulta le permite realizar un pedido dentro de la consulta inicial, mientras que lambda requiere que se ordene después de que la unión cree el nuevo objeto. Sin embargo, tal vez estén haciendo lo mismo bajo las sábanas: creando el objeto unido, para ser ordenado y luego seleccionado.