LINQ - tipos de clases específicos de grupo

Question

Esta pregunta es similar a LINQ group one type of item pero se maneja de una manera más genérica.

Tengo una lista que tiene varias clases derivadas. Puede que tenga algo como esto:

List<BaseClass> list = new List<BaseClass>() { 
    new Class1(1), 
    new Class2(1), 
    new Class1(2), 
    new Class3(1), 
    new Class2(2), 
    new Class4(1), 
    new Class3(2) 
}; 

Estoy tratando de utilizar LINQ a semi-Ordenar la lista por lo que el orden natural se mantiene con excepción de ciertas clases que tienen base.GroupThisType == true. Todas las clases con GroupThisType deben agruparse juntas en el lugar donde se produce la primera clase del mismo tipo. Esto es lo que la salida debería ser como:

List<BaseClass> list = new List<BaseClass>() { 
    new Class1(1), 
    new Class1(2), 
    new Class2(1), 
    new Class3(1), 
    new Class3(2) 
    new Class2(2), 
    new Class4(1), 
}; 

Editar: Vaya, se olvidó de decir que este resultado está asumiendo (Clase 1 y Class3) .GroupThisType == true

Answer 1

De esta manera:

list = list.Select((o, i) => new { Index = i * 10000, Value = o }) 
      .GroupBy(q => q.GetType()) 
      .SelectMany(g => { 
       if (g.First().GroupThisType) 
        return g.Select((q, i) => 
         new { Index = g.First().Index + i, Value = q.Value } 
        ); 
       else 
        return g; 
      }) 
      .OrderBy(q => q.Index) 
      .Select(q => q.Value) 
      .ToList(); 

El i * 10000 permite hasta 10.000 artículos de un grupo para ser insertados entre dos elementos.

Puede reemplazar g.First().GroupThisType con typesToGroup.Contains(g.Key).

Answer 2

El método OrdenarPor LINQ puede aceptar una Interfaz genérica IComparer. Puede usar esto para implementar su algoritmo de clasificación personalizado. No sé si el orden predeterminado puede manejar lo que estás tratando de hacer (dependerá de todas las reglas que necesites implementar). Supongo que sus clases en realidad no se denominan Class1, Class2 con el orden en el nombre del tipo?

HTH.

Answer 3

Aquí hay una solución que usa dos pases: en el primero construyo un diccionario de todos los que deberían agruparse. En el segundo uso SelectMany para reunir los elementos que no se cotejan con las secuencias intercaladas para el primero de los elementos que se cotejan.

// Build a dictionary of the items that group 
var onesToGroup = list.Where(x => x.GroupThisClass) 
          .GroupBy(x => x.GetType()) 
          .ToDictionary(x => x.Key, x => x.AsEnumerable()); 

var results = list.SelectMany(x => x.GroupThisClass ? 
          (onesToGroup[x.GetType()].First() == x ? onesToGroup[x.GetType()] : (new BaseClass[]{})) 
               : (new []{x}));