分组并左加入 linq

Question

There are two tables, one is customers has the fields customerID , GroupID and the other one is CustomerGroup has the fields GroupID , GroupName , I want to get the quantity of customerID in each group, here is the LINQ statement:

var groups = from customerGroups in db.CustomerGroup 
                         join customers in db.Customers on customerGroups.GroupID equals customers.GroupID into gc
                         where customerGroups.MerchantID == merchantID
                         from subCustomerGroups in gc.DefaultIfEmpty()
                         group customerGroups by customerGroups.GroupName into grpCustomerGroups
                         select new { GroupName = grpCustomerGroups.Key, Quantity = customers.Count()};

the problme is that Quantity = customers.Count() is invalid, how to correct the statement? The expected sql steatment is

exec sp_executesql N'SELECT 
    1 AS [C1], 
    [GroupBy1].[K1] AS [GroupName], 
    [GroupBy1].[A1] AS [C2]
    FROM ( SELECT 
        [Extent1].[GroupName] AS [K1], 
        COUNT(CustomerID) AS [A1]
        FROM  [dbo].[CustomerGroup] AS [Extent1]
        LEFT OUTER JOIN [dbo].[Customer] AS [Extent2] ON [Extent1].[GroupID] = [Extent2].[GroupID]
        WHERE [Extent1].[MerchantID] = @p__linq__0
        GROUP BY [Extent1].[GroupName]
    )  AS [GroupBy1]',N'@p__linq__0 bigint',@p__linq__0=9

Answer 1

Usually, if you find yourself doing a left outer join followed by a GroupBy, it is because you want "items with their sub-items", Like "Schools with their Students", "Clients with their Orders", "CustomerGroups with their Customers", etc. If you want this, consider using GroupJoin instead of "Join + DefaultIfEmpty + GroupBy"

I'm more familiar with method syntax, so I'll use that one.

int merchantId = ...
var result = dbContext.CustomerGroups

    // keep only the CustomerGroups from merchantId
    .Where(customerGroup => customerGroup.MerchantId == merchantId)

    .GroupJoin(dbContext.Customers,            // GroupJoin with Customers
    customerGroup => customerGroup.GroupId,    // from every CustomerGroup take the GroupId
    customer => customer.GroupId,              // from every Customer take the GroupId

    // ResultSelector:
    (customerGroup, customersInThisGroup) => new  // from every CustomerGroup with all its
    {                                             // matching customers make one new object
        GroupName = customerGroup.Key,
        Quantity = customersInThisGroup.CustomerId,  // ???
    });

In words:

Take the sequence of CustomerGroups. Keep only those CustomerGroups that have a value for property MerchantId equal to merchantId. From every remaining CustomerGroup, get all its Customers, by comparing the CustomerGroup.GroupId with each Customer.GroupId.

The result is a sequence of CustomerGroups, each with its Customers. From this result (parameter ResultSelector) get the GroupName from the Customer and the Quantity from the Customers in this group.

Your statement was:

Quantity = customers.CustomerID,

This will not work. I'm sure this is not what you want. Alas you forgot to write what you want. I think it is this:

Quantity = customers.Count().

But if you want the CustomerId of all Customers in this CustomerGroup:

// ResultSelector:
(customerGroup, customersInThisGroup) => new
{                                           
    GroupName = customerGroup.Key,
    CustomerIds = customersInThisGroup.Select(customer => customer.CustomerId)
                                      .ToList(),
);

If you want you can use the ResultSelector to get "CustomerGroups with their Customers". Most efficient is to select only the properties you actually plan to use:

// ResultSelector:
(customerGroup, customersInThisGroup) => new
{      
    // select only the CustomerGroup properties that you plan to use:
    Id = CustomerGroup.GroupId,
    Name = CustomerGroup.Name,
    ... // other properties that you plan to use

    Customers = customersInThisGroup.Select(customer => new
    {
         // again, select only the Customer properties that you plan to use
         Id = customer.Id,
         Name = customer.Name,
         ...

         // not needed, you know the value:
         // GroupId = customer.GroupId
    });

The reason not to select the foreign key of the Customers, is efficiency. If CustomerGroup [14] has 1000 Customers, then every Customer in this group will have a value for GroupId equal to [14]. It would be a waste to send this value [14] 1001 times.