Вложенный список LINQ Group для реструктуризации данных

Question

У меня есть вложенный список настраиваемого объекта, переданного из службы в виде JSON, который мне нужен для реструктуризации в новый объект. Вот объект, вложенный список состоит из:

public class Alt 
{ 
    public Member Member { get; set; } 
    public Claim OriginalClaim { get; set; } 
    public Claim AltClaim { get; set; } 
    public double Savings { get; set; } 
} 

Для каждого члена и OriginalClaim, может быть один или более AltClaim. Так что я пытаюсь сделать каждый AltClaim для каждого члена/OriginalClaim. Новый объект, который я буду отображение данных на внешний вид, как это:

public class Alternative 
{ 
    public Member Member { get; set; } 
    public Claim OriginalClaim { get; set; } 
    public List<AlternativeClaim> AlternativeClaims { get; set; } 
} 

public class AlternativeClaim 
{ 
    public Claim AltClaim { get; set; } 
    public double Savings { get; set; } 
} 

Я был в состоянии получить вещи, сгруппированных с помощью LINQ, но производит список Alternative с членом и OriginalClaim дублируется как многие как есть AlternativeClaims. Вот код, который у меня до сих пор:

public void Test(List<List<Alt>> alternatives) 
{ 
    var test = from alts in alternatives 
       from alt in alts 
       group alts by new { alt.Member, alt.OriginalClaim } into a 
       select a; 

    foreach (var a in test) 
    { 
     Console.WriteLine("Auth {0}", a.Key.OriginalClaim.Id); 
     Console.WriteLine("MemberId {0}", a.Key.Member.Id); 

     foreach (var alt in a.SelectMany(x => x)) 
     { 
      [write out alt.AltClaim properties in console here] 
     } 
    } 
} 

Я считаю, что моя проблема связана с запросом LINQ. Я не очень хорошо знаком с LINQ, так есть ли кто-нибудь там, который может помочь мне сформировать это (или, по крайней мере, указать мне в правильном направлении), чтобы я не получал дубликаты? Благодаря!!

EDIT (РАСТВОР):

Решение, которое работало для меня было сочетание двух ответов ниже. The accepted answer - это запрос LINQ, который я использовал, но мне не удалось заставить вещи правильно группироваться без Thomas F's answer. Реализация IEquatable <> в классах, которые я группировал, была ключевой.

Спасибо всем! Вы научили меня многого с вашей помощью по этому вопросу.

Answer 1

 var alts = alternatives.SelectMany(x => x); 

     var res = alts.GroupBy(alt => Tuple.Create(alt.Member, alt.OriginalClaim)) 
      .Select(g => new Alternative 
      { 
       Member = g.Key.Item1, 
       OriginalClaim = g.Key.Item2, 
       AlternativeClaims = g.Select(x => new AlternativeClaim {AltClaim = x.AltClaim, Savings = x.Savings}).ToList() 
      }); 


     foreach (var a in res) 
     { 
      Console.WriteLine("Auth {0}", a.OriginalClaim.Id); 
      Console.WriteLine("MemberId {0}", a.Member.Id); 

      foreach (var alt in a.AlternativeClaims.OrderByDescending(c => c.Savings)) 
      { 
       Console.WriteLine("\tSavings = {0};Id = {1};",alt.Savings, alt.AltClaim.Id); 
      } 
     } 

дает выход:

Auth 51 
MemberId 50 
    Savings = 696969;Id = 513; 
    Savings = 6969;Id = 512; 
    Savings = 69;Id = 511; 
Auth 52 
MemberId 50 
    Savings = 1002;Id = 522; 
    Savings = 100;Id = 521; 
Auth 102 
MemberId 100 
    Savings = 1022;Id = 1022; 
    Savings = 1021;Id = 1021; 

Код испытания

[Test] 
    public void Test() 
    { 
     var member1 = new Member {Id = 50}; 
     var member1Claim1 = new Claim {Id = 51}; 
     var member1Claim2 = new Claim {Id = 52}; 

     var member2 = new Member { Id = 100 }; 
     var member2Claim1 = new Claim { Id = 101 }; 
     var member2Claim2 = new Claim { Id = 102 }; 

     var alternatives = new List<List<Alt>>() 
     { 
      new List<Alt> 
      { 
       new Alt 
       { 
        Member = member1, 
        OriginalClaim = member1Claim1, 
        AltClaim = new Claim {Id = 511}, 
        Savings = 69 
       }, 
       new Alt 
       { 
        Member = member1, 
        OriginalClaim = member1Claim1, 
        AltClaim = new Claim {Id = 512}, 
        Savings = 6969 
       }, 
       new Alt 
       { 
        Member = member1, 
        OriginalClaim = member1Claim1, 
        AltClaim = new Claim {Id = 513}, 
        Savings = 696969 
       }, 
       new Alt 
       { 
        Member = member1, 
        OriginalClaim = member1Claim2, 
        AltClaim = new Claim {Id = 521}, 
        Savings = 100 
       }, 
       new Alt 
       { 
        Member = member1, 
        OriginalClaim = member1Claim2, 
        AltClaim = new Claim {Id = 522}, 
        Savings = 1002 
       } 
      }, 
      new List<Alt> 
      { 
       new Alt 
       { 
        Member = member2, 
        OriginalClaim = member2Claim2, 
        AltClaim = new Claim {Id = 1021}, 
        Savings = 1021 
       }, 
       new Alt 
       { 
        Member = member2, 
        OriginalClaim = member2Claim2, 
        AltClaim = new Claim {Id = 1022}, 
        Savings = 1022 
       } 
      } 
     }; 


    } 

И для полноты картины:

public class Alt 
{ 
    public Member Member { get; set; } 
    public Claim OriginalClaim { get; set; } 
    public Claim AltClaim { get; set; } 
    public double Savings { get; set; } 
} 

public class Claim 
{ 
    public int Id { get; set; } 
} 

public class Member 
{ 
    public int Id { get; set; } 
} 

public class Alternative 
{ 
    public Member Member { get; set; } 
    public Claim OriginalClaim { get; set; } 
    public List<AlternativeClaim> AlternativeClaims { get; set; } 
} 

public class AlternativeClaim 
{ 
    public Claim AltClaim { get; set; } 
    public double Savings { get; set; } 
} 

Answer 2

Попробуйте alternatives.SelectMany(alt => new { alt.Member, alt.OriginalClaim })

Answer 3

Выполняют ли классы Member и Claim, реализующие IEquatable?

Если нет, я подозреваю, что группировка не работает, поскольку экземпляры Member и Claim сравниваются по ссылке. И поскольку вы упомянули, что получаете данные из службы в качестве JSON, у всех ваших Alts, скорее всего, есть отдельные экземпляры Member и Claim. Поэтому они никогда не попадают в одну и ту же группу, даже если их свойства имеют одинаковые значения.

Чтобы получить вашу группировку, чтобы работать, вы можете сделать одно из следующих действий:

1. , если оно доступно выбрать уникальный критерий (например, идентификатор или имя) от члена и претензии и группы по ней:

   var test = from alts in alternatives 
         from alt in alts 
         group alts by new { MemberId = alt.Member.Id, OriginalClaimId = alt.OriginalClaim.Id } into a 
         select a; 
   
   foreach (var a in test) 
   { 
       Console.WriteLine("Auth {0}", a.Key.OriginalClaimId); 
       Console.WriteLine("MemberId {0}", a.Key.MemberId); 
   
       foreach (var alt in a.SelectMany(x => x)) 
        [write out alt.AltClaim properties in console here] 
   } 
   

2. Внесите IEquatable и IEquatable для вашего члена и претензии.

   public class Member : IEquatable<Member> 
   { 
       public bool Equals(Member other) 
       { 
        return Id == other.Id; 
       } 
   
       public override bool Equals(object obj) 
       { 
        var other = obj as Member; 
        if (other == null) 
         return false; 
   
        return Equals(other); 
       } 
   
       public override int GetHashCode() 
       { 
        // Whenever IEquatable is implemented, GetHashCode() must also be overridden. 
        return Id.GetHashCode(); 
       } 
   
       // Rest of the class... 
   }