Linq: преобразование плоской структуры в иерархическую

Каков самый простой и несколько эффективный способ преобразования плоской структуры:

object[][] rawData = new object[][] 
{ 
  { "A1", "B1", "C1" }, 
  { "A1", "B1", "C2" },
  { "A2", "B2", "C3" }, 
  { "A2", "B2", "C4" }
  // .. more 
};

в иерархическую структуру:

class X
{
  public X () 
  {
    Cs = new List<string>();
  }
  public string A { get; set; }
  public string B { get; set; }
  public List<string> Cs { get; private set; }
}

результат должен выглядеть так:

// pseudo code which describes structure:
result =
{
  new X() { A = "A1", B = "B1", Cs = { "C1", "C2" } },
  new X() { A = "A2", B = "B2", Cs = { "C3", "C4" } }
}

Предпочтительно использовать методы расширения Linq. Целевой класс X может быть изменен (например, публичный сеттер для Списка), только если это невозможно/полезно, как сейчас.

Ответ 1

для данного частного случая:

   .GroupBy( x => new { a = x[0], b = x[1] } )
   .Select( x => new { A = x.Key.a, B = x.Key.b, C = x.Select( c => c[2] ) })

Ответ 2

Что-то вроде этого должно работать, если глубина вашей иерархии ограничена (как в вашем примере, когда у вас есть только три уровня A, B и C). Я немного упростил ваш X:

class X {
    public string A { get; set; }
    public string B { get; set; }
    public List<string> Cs { get; set; }
}

Затем вы можете использовать вложенные GroupBy столько раз, сколько вам нужно (в зависимости от глубины иерархии). Было бы также относительно легко переписать это в рекурсивный метод (который будет работать для произвольно глубоких иерархий):

// Group by 'A'
rawData.GroupBy(aels => aels[0]).Select(a => 
  // Group by 'B'
  a.GroupBy(bels => bels[1]).Select(b =>
    // Generate result of type 'X' for the current grouping
    new X { A = a.Key, B = b.Key, 
            // Take the third element 
            Cs = b.Select(c => c[2]).ToList() }));

Это более явное, чем другие решения здесь, но, возможно, это будет более читаемым, поскольку это более простая кодировка идеи...

Ответ 3

Поскольку члены X являются строками и Cs являются частным набором, а rawData - массивом массивов объектов, я бы добавил конструктор в X public X(string a, string b, List<string> cs), а затем выполнил этот код

var query = from row in rawData
            group row by new { A = row[0], B = row[1] } into rowgroup
            select new X((string)rowgroup.Key.A, (string)rowgroup.Key.B, rowgroup.Select(r => (string)r[2]).ToList());

Это следующие необработанные данные

object[][] rawData = new object[][]  
    {  
        new object[] { "A1", "B1", "C1" },  
        new object[] { "A1", "B1", "C2" }, 
        new object[] { "A2", "B2", "C3" },  
        new object[] { "A2", "B2", "C4" } 
        // .. more  
    };

Ответ 4

Я хотел посмотреть, могу ли я написать это без анонимных экземпляров. Это не так уж плохо:

IEnumerable<X> myList =
  from raw0 in rawData
  group raw0 by raw0[0] into g0
  let g1s =
  (
    from raw1 in g0
    group raw1 by raw1[1]
  )
  from g1 in g1s
  select new X()
  {
    A = g0.Key,
    B = g1.Key,
    C = g1.Select(raw2 => raw2[2]).ToList()
  }