LINQ - types de classes spécifiques au groupe

Question

Cette question est similaire à LINQ group one type of item mais traitée de manière plus générique.

J'ai une liste qui a diverses classes dérivées. Je peux avoir quelque chose comme ceci:

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

Je suis en train d'utiliser LINQ semi-tri de la liste de sorte que l'ordre naturel est maintenu, sauf pour certaines classes qui ont base.GroupThisType == true. Toutes les classes avec GroupThisType doivent être regroupées à l'endroit où la première classe du même type se produit. Voici ce que la sortie devrait être comme:

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

Edit: Oops, a oublié de dire que ce résultat est en supposant (classes 1 et classe 3) .GroupThisType == true

Answer 1

Comme ceci:

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

Le i * 10000 permet jusqu'à 10.000 articles d'un groupe à insérer entre deux éléments. Vous pouvez remplacer g.First().GroupThisType par typesToGroup.Contains(g.Key).

Answer 2

La méthode OrderBy LINQ peut accepter une IComparer interface générique. Vous pouvez l'utiliser pour implémenter votre algorithme de tri personnalisé. Je ne sais pas si l'ordre par défaut peut gérer ce que vous essayez de faire (cela dépend de toutes les règles que vous devez implémenter). Je suppose que vos classes ne sont pas réellement nommées Class1, Class2 avec la commande dans le nom du type?

HTH.

Answer 3

Voici une solution utilisant deux passages: dans le premier je construis un dictionnaire de tous ceux qui devraient se grouper. Dans la seconde, j'utilise SelectMany pour rassembler les éléments qui ne sont pas assemblés avec les séquences assemblées pour le premier des éléments qui sont assemblés.

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