We Keep Coding

Unsupported method Distinct in linq using the Mongodb driver

I need to get the count of the distinct values in a select using the mongodb driver and linq. I made a groupby and then I'm trying to make the distinct but I'm always getting "unsupported method". How can I avoid it? I have no problems when I'm making other operations like average or sum. Is the problem that i'm making a select into another select?
queryGroupby = whereQuery.GroupBy(x => x.CheckinDate.ToString("yyyy MMM"));
var querySelect = queryGroupby
.Select(g => new Statistic()
{
HotelsCount = g.Select(g => g.HoId).Distinct().Count(),
Key = g.Key,
TotalBookingsAmount = g.Sum(g => g.GrossTotal) + g.Sum(g => g.Taxes),
BookingsCount = g.Count(g => true),
TotalBookedDays = g.Sum(g => g.StayDays),
AvgWindowStay = g.Average(g => g.StayDays),
AvgBookingsAmount = g.Average(g => g.GrossTotal) + g.Average(g => g.Taxes)
});

It is always better to use Mongodb aggregate for such complex queries, I am not sure what are you trying to do here, but I will show you how this should be done with c# mongodb driver.
Ideally, you should be using aggregate framework group by function, now if you find the doc hard to read, it is basically defining a extension method to IAggregateFluent, which takes two parameters, the first is an expression to your group key, the second is an expression that takes the group by original result, and return the projection for that result, in your case, the first expression is your queryGroupBy, and the second expression is your querySelect.
I am guessing your object type is Booking, hence the generic Aggregate<Booking> below
var result = await _collection.Aggregate<Booking>()
.Group(e => e.CheckinDate.ToString("yyyy MMM"), // group by date
result => new Statistic() //result is the group result, new Statistic is your projection of the result.
{
HotelsCount = g.Select(g => g.HoId).Distinct().Count(),
Key = g.Key,
TotalBookingsAmount = g.Sum(g => g.GrossTotal) + g.Sum(g => g.Taxes),
BookingsCount = g.Count(g => true),
TotalBookedDays = g.Sum(g => g.StayDays),
AvgWindowStay = g.Average(g => g.StayDays),
AvgBookingsAmount = g.Average(g => g.GrossTotal) + g.Average(g => g.Taxes)
})
.ToListAsync();

How can I reuse a subquery inside a select expression?

In my database I have two tables Organizations and OrganizationMembers, with a 1:N relationship.
I want to express a query that returns each organization with the first and last name of the first organization owner.
My current select expression works, but it's neither efficient nor does it look right to me, since every subquery gets defined multiple times.
await dbContext.Organizations
.AsNoTracking()
.Select(x =>
{
return new OrganizationListItem
{
Id = x.Id,
Name = x.Name,
OwnerFirstName = (x.Members.OrderBy(member => member.CreatedAt).First(member => member.Role == RoleType.Owner)).FirstName,
OwnerLastName = (x.Members.OrderBy(member => member.CreatedAt).First(member => member.Role == RoleType.Owner)).LastName,
OwnerEmailAddress = (x.Members.OrderBy(member => member.CreatedAt).First(member => member.Role == RoleType.Owner)).EmailAddress
};
})
.ToArrayAsync();
Is it somehow possible to summarize or reuse the subqueries, so I don't need to define them multiple times?
Note that I've already tried storing the subquery result in a variable. This doesn't work, because it requires converting the expression into a statement body, which results in a compiler error.

The subquery can be reused by introducing intermediate projection (Select), which is the equivalent of let operator in the query syntax.
For instance:
dbContext.Organizations.AsNoTracking()
// intermediate projection
.Select(x => new
{
Organization = x,
Owner = x.Members
.Where(member => member.Role == RoleType.Owner)
.OrderBy(member => member.CreatedAt)
.FirstOrDefault()
})
// final projection
.Select(x => new OrganizationListItem
{
Id = x.Organization.Id,
Name = x.Organization.Name,
OwnerFirstName = Owner.FirstName,
OwnerLastName = Owner.LastName,
OwnerEmailAddress = Owner.EmailAddress
})
Note that in pre EF Core 3.0 you have to use FirstOrDefault instead of First if you want to avoid client evaluation.
Also this does not make the generated SQL query better/faster - it still contains separate inline subquery for each property included in the final select. Hence will improve readability, but not the efficiency.
That's why it's usually better to project nested object into unflattened DTO property, i.e. instead of OwnerFirstName, OwnerLastName, OwnerEmailAddress have a class with properties FirstName, LastName, EmailAddress and property let say Owner of that type in OrganizationListItem (similar to entity with reference navigation property). This way you will be able to use something like
dbContext.Organizations.AsNoTracking()
.Select(x => new
{
Id = x.Organization.Id,
Name = x.Organization.Name,
Owner = x.Members
.Where(member => member.Role == RoleType.Owner)
.OrderBy(member => member.CreatedAt)
.Select(member => new OwnerInfo // the new class
{
FirstName = member.FirstName,
LastName = member.LastName,
EmailAddress = member.EmailAddress
})
.FirstOrDefault()
})
Unfortunately in pre 3.0 versions EF Core will generate N + 1 SQL queries for this LINQ query, but in 3.0+ it will generate a single and quite efficient SQL query.

How about this:
await dbContext.Organizations
.AsNoTracking()
.Select(x =>
{
var firstMember = x.Members.OrderBy(member => member.CreatedAt).First(member => member.Role == RoleType.Owner);
return new OrganizationListItem
{
Id = x.Id,
Name = x.Name,
OwnerFirstName = firstMember.FirstName,
OwnerLastName = firstMember.LastName,
OwnerEmailAddress = firstMember.EmailAddress
};
})
.ToArrayAsync();

How about doing this like
await dbContext.Organizations
.AsNoTracking()
.Select(x => new OrganizationListItem
{
Id = x.Id,
Name = x.Name,
OwnerFirstName = x.Members.FirstOrDefault(member => member.Role == RoleType.Owner).FirstName,
OwnerLastName = x.Members.FirstOrDefault(member => member.Role == RoleType.Owner)).LastName,
OwnerEmailAddress = x.Members.FirstOrDefault(member => member.Role == RoleType.Owner)).EmailAddress
})
.ToArrayAsync();

Multiple fields in GroupBy clause in LINQ (where one is computed field)

I have a LINQ query upon which I need to add two fields as group by clauses. While I can easily group by with as many column fields but the problem is occurring when one of the fields is a calculated field. I can't seem to be able to get my head around on how to add the second attribute in this case
var values = intermediateValues
//.GroupBy(x => new {x.Rate, x.ExpiryDate })
.GroupBy(r => new { Rate = ((int)(r.Rate / BucketSize)) * BucketSize })
.Select(y => new FXOptionScatterplotValue
{
Volume = y.Sum(z => z.TransactionType == "TERMINATION" ? -z.Volume : z.Volume),
Rate = y.Key.Rate,
ExpiryDate = y.Key.ExpiryDate,
Count = y.Count()
}).ToArray();
In the above code sample I would like to have ExpiryDate added to my existing GroupBy clause which has a computed field of Rate already there. The code looks like this in VS editor

So just include it as you have in the commented-out code:
.GroupBy(r => new { Rate = ((int)(r.Rate / BucketSize)) * BucketSize,
r.ExpiryDate })

This might help you
var values = intermediateValues
//.GroupBy(x => new {x.Rate, x.ExpiryDate })
.GroupBy(r => new { Rate = ((int)(r.Rate / BucketSize) ) * BucketSize,ExpiryDate1 = r.ExpiryDate })
.Select(y => new FXOptionScatterplotValue
{
Volume = y.Sum(z => z.TransactionType == "TERMINATION" ? -z.Volume : z.Volume),
Rate = y.Key.Rate,
ExpiryDate = y.Key.ExpiryDate1,
Count = y.Count()
}).ToArray();
Just use ExpiryDate1 as anonymous type and use this as key name....

GroupBy of Anonymous Object strange result

I am getting an unexpected result from GroupBy in this case, I expect a Dictionary<string,List<object>> from GroupBy. But the browser receives something like: [{playdate, experiencetype...}, { ... }, { }], [{playdate, experiencetype,... }, { } ],...
So there are no Keys even though the objects are grouped into arrays, but I want Keys to be there. I put up a breakpoint and checked packagedAjax, and there seems to be a GroupedEnumerable there containing Lookups. Any thoughts?
var packagedAjax = showtimesByMovieAndLocation
.Select(x =>
new
{
playdate = x.PlayDate,
experiencetype = x.FFCode,
vistasessionid = x.SessionID,
areacode = x.AreaCode
})
.GroupBy(x => x.experiencetype);
return new JsonpResult(packagedAjax, Request.QueryString["callback"]);

GroupBy returns an IGrouping, not a Dictionary. If you want a Dictionary, convert it using .ToDictionary():
var packagedAjax = showtimesByMovieAndLocation
.Select(x =>
new
{
playdate = x.PlayDate,
experiencetype = x.FFCode,
vistasessionid = x.SessionID,
areacode = x.AreaCode
})
.GroupBy(x => x.experiencetype)
.ToDictionary(g => g.Key, g => g.ToList());

The type of the arguments cannot be inferred usage Linq GroupJoin

I'm trying to make a linq GroupJoin, and I receive the fore mentioned error. This is the code
public Dictionary<string, List<QuoteOrderline>> GetOrderlines(List<string> quoteNrs)
{
var quoteHeadersIds = portalDb.nquote_orderheaders
.Where(f => quoteNrs.Contains(f.QuoteOrderNumber))
.Select(f => f.ID).ToList();
List<nquote_orderlines> orderlines = portalDb.nquote_orderlines
.Where(f => quoteHeadersIds.Contains(f.QuoteHeaderID))
.ToList();
var toRet = quoteNrs
.GroupJoin(orderlines, q => q, o => o.QuoteHeaderID, (q => o) => new
{
quoteId = q,
orderlines = o.Select(g => new QuoteOrderline()
{
Description = g.Description,
ExtPrice = g.UnitPrice * g.Qty,
IsInOrder = g.IsInOrder,
PartNumber = g.PartNo,
Price = g.UnitPrice,
ProgramId = g.ProgramId,
Quantity = (int)g.Qty,
SKU = g.SKU
}).ToList()
});
}

I suspect this is the immediate problem:
(q => o) => new { ... }
I suspect you meant:
(q, o) => new { ... }
In other words, "here's a function taking a query and an order, and returning an anonymous type". The first syntax simply doesn't make sense - even thinking about higher ordered functions, you'd normally have q => o => ... rather than (q => o) => ....
Now that won't be enough on its own... because GroupJoin doesn't return a dictionary. (Indeed, you don't even have a return statement yet.) You'll need a ToDictionary call after that. Alternatively, it may well be more appropriate to return an ILookup<string, QuoteOrderLine> via ToLookup.