¿Cómo puedo agrupar por una lista de elementos?

Question

Me encuentro con este problema una y otra vez: ¿cómo puedo agrupar una lista de objetos por una lista que contiene otros objetos?

Tengo una lista de objetos del tipo A y cada uno de estos objetos tiene una propiedad (vamos a llamarlo ListProp) que es una lista también. ListProp tiene elementos del tipo B. Hay varios elementos del tipo A con idéntico B -objetos en ListProp, pero la referencia de propiedad ListProp difiere de un elemento a otro. ¿Cómo puedo agrupar estos objetos A de la manera más rápida, donde los objetos B en ListProp son idénticos?

Código de ejemplo:

class Program 
{ 
    static void Main(string[] args) 
    { 
     var exampleList = new List<A> 
     { 
      // Should be in first group 
      new A { ListProp = new List<B> 
      { 
       new B { Prop = new C { Number = 0 }}, 
       new B { Prop = new C { Number = 1 }} 
      }}, 
      // Should be in first group 
      new A { ListProp = new List<B> 
      { 
       new B { Prop = new C { Number = 0 }}, 
       new B { Prop = new C { Number = 1 }} 
      }}, 
      // Should be in second group 
      new A { ListProp = new List<B> 
      { 
       new B { Prop = new C { Number = 0 }}, 
       new B { Prop = new C { Number = 1 }}, 
       new B { Prop = new C { Number = 1 }} 
      }}, 
      // Should be in third group 
      new A { ListProp = new List<B> 
      { 
       new B { Prop = new C { Number = 0 }}, 
       new B { Prop = new C { Number = 0 }} 
      }} 
     }; 

     // Doesn't work because the reference of ListProp is always different 
     var groupedExampleList = exampleList.GroupBy(x => x.ListProp); 
    } 
} 

class C 
{ 
    public int Number { get; set; } 
    public override bool Equals(object o) 
    { 
     if (o is C) 
      return Number.Equals(((C)o).Number); 
     else 
      return false; 
    } 
} 

class B 
{ 
    public C Prop { get; set; } 
} 

class A 
{ 
    public IList<B> ListProp { get; set; } 
} 

Answer 1

Puede implementar IEqualityComparer<List<B>> y usarlo en la otra sobrecarga de GroupBy.

public class ListOfBEqualityComparer : IEqualityComparer<List<B>> 
{ 
    public bool Equals(List<B> x, List<B> y) 
    { 
     // you can also implement IEqualityComparer<B> and use the overload 
     return x.SequenceEqual(y); 
    } 

    public int GetHashCode(List<B> obj) 
    { 
     //implementation of List<T> may not work for your situation 
     return obj.GetHashCode(); 
    } 
} 

continuación, puede utilizar la sobrecarga de

var groupedExampleList = exampleList.GroupBy(x => x.ListProp, 
              new ListOfBEqualityComparer()); 

Answer 2

Prueba esto:

GroupBy(x => String.Join(",", x.ListProp)); 

Se agrupará por 0,1; 0,1; 0,1; 0,1,1; 0,1 en consecuencia.

Answer 3

que se acercaría a esta de la siguiente manera:

1. asociar cada elemento secundario (en la propiedad ListProp) con su padre
2. Grupo los padres por los niños
3. Proyecta los resultados

---

var data = exampleList.SelectMany(a=>a.ListProp.Select(x=>new{Key = x.Prop.Number, Value = a})) 
      .GroupBy(x=>x.Key) 
      .Select(g=>new {Number = g.Key, Items = g.ToList()});