Jak grupować według listy elementów?

Question

W kółko napotykam ten problem: jak pogrupować listę obiektów według listy innych obiektów?

Mam listę obiektów typu A, a każdy z tych obiektów ma właściwość (można nazwać ją ListProp), która również jest listą. ListProp ma elementy typu B. Istnieje wiele elementów typu A o identycznych B -obiektach w ListProp, ale odwołanie do właściwości właściwości różni się od elementu do elementu. Jak pogrupować te A -obiekty w najszybszy sposób, w którym obiekty w ListProp są identyczne?

Przykładowy kod:

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

Można wdrożyć IEqualityComparer<List<B>> i używać go w innym przeciążeniu 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(); 
    } 
} 

Następnie można użyć przeciążenie

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

Answer 2

Spróbuj tego:

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

Będzie grupa przez 0,1; 0,1; 0,1; 0,1,1; 0,1 odpowiednio.

Answer 3

Chciałbym podejść do tego w następujący sposób:

1. Associate każdy element dziecko (w nieruchomości ListProp) z jego rodzica
2. Grupy rodzice przez dzieci
3. Wyświetl wyniki

---

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