多个组成单个linq查询

Question

I believe I need to have multiple "Group into" statements in a single linq query. Here is what I am trying to do:

var queryNew = from a in ICDUnitOfWork.AlphaGroups.Find()
               join e in ICDUnitOfWork.Alphas.Find()
                      on a.AlphaGroupID equals e.AlphaGroupID into g
               join c in ICDUnitOfWork.Codes.Find()
                      on a.CodeID equals c.CodeID into co
               join cod in ICDUnitOfWork.Codes.Find()
                        on g.CodeID equals cod.CodeID
               select new HomeSearchViewModel
               {
                   Alphas = g,
                   AlphaGroups = a,
                   AlphaGroupCode = co,
                   AlphasCodes = cod
               };

An alpha group has an collection of Alphas. Each AlphaGroup has a corresponding AlphaGroup.CodeId, an each Alpha has an Alpha.CodeId that needs to join with the 'Codes" class. I'm not sure how to adjust my query to accomplish this.

Edit: the final result should look something like:

AlphaGroup -> contains Multiple "Alphas"

Each AlphaGroup has a corresponding CodeId from the "Codes" class, and each Alpha also has a corresponding CodeID.

So the ViewModel looks like:

public class HomeSearchViewModel
{
    public IEnumerable<Alpha> Alphas { get; set; }
    public AlphaGroup AlphaGroups { get; set; }
    public IEnumerable<Code> AlphasCodes { get; set; }
    public Code AlphaGroupCode { get; set; }
    public string SearchTerm { get; set; }
}

Answer 1

Completly untested, but try something similar to:

select new
    {
      Alphas = g
      AlphaGroups = a,
      AlphaGroupCode = co,
      AlphasCodes = cod
    }
 .GroupBy(grp => grp.AlphaGroups)
 .Select(grp => new HomeSearchViewModel
    {
       AlphaGroups = grp.Key,
       AlphaGroupCode = grp.Key.Code,
       Alphas = grp.ToList(),
       AlaCodes = grp.Select(alp => alp.Code)
    });

Answer 2

In this case putting it in fluid syntax may make it a lot easier, if I get your gist you are trying to do the following:

var result = ICDUnitOfWork.AlphaGroups.Find()
                          .GroupJoin( ICDUnitOfWork.Alphas.Find()
                                                   .Join( ICDUnitOfWork.Codes.Find(),
                                                          alpha => alpha.CodeID,
                                                          code => codeID,
                                                          (alpha,code) => new
                                                                    {
                                                                      Alpha = alpha,
                                                                      AlphaCode = code
                                                                    }),
                                       alphaG => alphaG.AlphaGroupID,
                                       anon => anon.Alpha.AlphaGroupID,
                                       (alphaG, anonG) => new
                                                       {
                                                        AlphaGroup = alphaG,
                                                        AnonG = anonG
                                                       })
                          .Join( ICDUnitOfWork.Codes.Find(),
                                 anon => anon.AlphaGroup.CodeID,
                                 code => code.CodeID,
                                 (anon, g) => new HomeSearchViewModel()
                                              {
                                                     AlphaGroups = anon.AlphaGroup,
                                                     AlphaGroupCode = g,
                                                     Alphas = anon.AnonG
                                                                  .Select(anonG => anonG.Alpha),
                                                     AlphaCodes = anon.AnonG
                                                                      .Select(anonG => anonG.AlphaCode)
                                                   });

So this works under the assumption that code to alpha is one-to-one, or that you don't want nested groups of them (which is what you seem to be saying form your view structure but not your query...).

Similarly putting it in static syntax would be something like so:

var result = from ag in (from AlphaG in ICDUnitOfWork.AlphaGroups.Find()
                                 join AlphaGCode in ICdUnitOfWork.Codes.Find()
                                 on AlphaG.CodeID = AlphaGCode.CodeID)
             join a in (from Alpha in ICDUnitOfWork.Alphas.Find()
                                 join AlphaCode in ICdUnitOfWork.Codes.Find()
                                 on Alpha.CodeID = AlphaCode.CodeID)
             into Alphas
             select new HomeSearchViewModel
                    {
                     AlphaGroups = ag.AlphaG,
                     AlphaGroupCode = ag.AlphaGCode,
                     Alphas = Alphas.Select(anon => anon.Alpha),
                     AlphasCodes = Alphas.Select(anon => anon.AlphaCode)
                    };

Though this might need some tweaking as don't have access to vs ATM.