Join in Linq query not working - linq

Question

Now I have to sum the results by grouping the customers.
I have made a query but It is not working at all. Can anybody help me? Here is my query:
![var query=from p in context.Delivery
join o in
(from o1 in context.OrderTables select o1)
on p.OrderID equals o.OrderID
into go from po in go.DefaultIfEmpty()
join d in (from d1 in context.Diagram select d1)
on po.DiagramID equals d.DiagramID into gd
from pd in gd.Distinct()
group pd by pd.CustomerID into groupCustomer
join cu in context.CustomerCompanyTables
on groupCustomer.Key equals cu.CustomerID
select new { cu.CompanyName, SumNoTax = p.Sum(t => t.OrderID!=0 ? p.Price:d.Price)};][2]

Answer 1

As I noted in the comments your query seems massively over complicated:
The use of
…
join x in (from z in context.Xx select z) on …
rather than just:
…
join x in context.Xx on …
Those checks for non-exitant data (go.DefaultIfEmpty()): the form
of join you are using is an inner join: data will be returned
only when matching objects exist for both sides of the condition.
But in the end, your problem is refering back to the original collections
in the final select clause rather than to the result of the group by.
And of course there is no SellingPrice in PdtDeliveryTable also
used in that final select clause.
My approach with queries like this is to build things up incrementally,
ensuring I understand what I am doing with each step.
So the first step is to do the join. For this purpose I've defined
a slightly simpler structure to try and keep things clear (see the
bottom of this answer for definitions) and some test data. I'm using
LINQ to Objects, but the synatax and semantics of the LINQ operators
is the same (and it saves creating a more complex project & database).
A customer has multiple orders, each with a single Sku (stock control
unit—a product). The order can optionally override the default price
of the sku (hence using a Nullable<decimal>). There is also some
test data.
The first step is to check I'm doing the join right, and check
I'm handling that price override:
var ctx = GetTestData();
var query = from c in ctx.Customers
join o in ctx.Orders on c.CustomerId equals o.CustomerId
join s in ctx.Skus on o.SkuId equals s.SkuId
select new { Customer = c, Order = o, Sku = s };
Console.WriteLine("CustId\tCust\t\tOrder\tSku\tPaid");
foreach (var v in query) {
Console.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}",
v.Customer.CustomerId,
v.Customer.Name,
v.Order.OrderId,
v.Sku.SkuId,
v.Order.SpecificPrice ?? v.Sku.DefaultPrice);
}
which results in
CustId Cust Order Sku Paid
1 Acme Corp 1 1 10.0
1 Acme Corp 2 2 15.0
1 Acme Corp 3 3 30.0
2 Beta Corp 4 1 9.99
Note the only data is where there are matching objects of each type, so
there is nothing from the third customer (has no orders) and only one row
from the second customer (doesn't have any orders for other SKUs): there
are no null objects to remove.
The second step is to perform the grouping. This will result in
a rather different data structure something like:
class AnonOfGroup : IEnumerable<AnonOfRow> {
KeyType Key;
}
where AnonOfRow is the type of whatever you are grouping.
Thus:
var query = from c in ctx.Customers
join o in ctx.Orders on c.CustomerId equals o.CustomerId
join s in ctx.Skus on o.SkuId equals s.SkuId
select new { Customer = c, Order = o, Sku = s } into joinRes
group joinRes by joinRes.Customer.CustomerId into g
select g;
has, using the above terms the type of Key being the type of CustomerId and
AnonOfRow being the type of joinRes which is the type of the first
select clause.
This can be shown with a double loop:
Outer over the each different group (with the same key)
Inner over each object in each group (created by the first select
clause)
so:
Console.WriteLine("Customer");
Console.WriteLine("\tOrder\tSku\tPrice");
foreach (var grp in query) {
Console.WriteLine("{0}: {1}", grp.Key, grp.First().Customer.Name);
foreach (var row in grp) {
Console.WriteLine("\t{0}\t{1}\t{2}",
row.Order.OrderId,
row.Sku.SkuId,
row.Order.SpecificPrice ?? row.Sku.DefaultPrice);
}
}
gives:
Customer
Order Sku Price
1: Acme Corp
1 1 10.0
2 2 15.0
3 3 30.0
2: Beta Corp
4 1 9.99
Note also that I'm alble to access the "inner data" from the outer loop
by performing some enumeration (in this case I know the customer is
the same in each inner object so I'll use the first). This is safe
because the underlying join is an inner join.
The Final Step is to sum over each order within the group. This can
be done for each group in the final select cluase. This will be processed
once for each group, but within that clause we can aggregate
over the rows in that group:
var query = from c in ctx.Customers
join o in ctx.Orders on c.CustomerId equals o.CustomerId
join s in ctx.Skus on o.SkuId equals s.SkuId
select new { Customer = c, Order = o, Sku = s } into joinRes
group joinRes by joinRes.Customer.CustomerId into g
select new {
CustomerId = g.Key,
CustomerName = g.First().Customer.Name,
TotalPrice = g.Sum(r => r.Order.SpecificPrice ?? r.Sku.DefaultPrice)
};
Console.WriteLine("Cust\tName\t\tTotal");
foreach (var row in query) {
Console.WriteLine("{0}\t{1}\t{2}", row.CustomerId, row.CustomerName, row.TotalPrice);
}
In this case the aggregation changes the list of lists into a (flat)
list, so only needing a single loop to see all the data. The use of
the null check within the summation means that there are no nulls:
Cust Name Total
1 Acme Corp 55.0
2 Beta Corp 9.99
which is clearly correct for the input data.
Your Solution should just be a matter of substituting your types, adding the fourth
as an extra join, and adjusting to the slightly different types.
class Customer {
public int CustomerId;
public string Name;
}
class Sku {
public int SkuId;
public decimal DefaultPrice;
}
class Order {
public int OrderId;
public int CustomerId;
public int SkuId;
public decimal? SpecificPrice;
}
class Context {
public List<Customer> Customers;
public List<Sku> Skus;
public List<Order> Orders;
}
static Context GetTestData() {
var customers = new List<Customer> {
new Customer { CustomerId = 1, Name = "Acme Corp" },
new Customer { CustomerId = 2, Name = "Beta Corp" },
new Customer { CustomerId = 3, Name = "Gamma Corp" }
};
var skus = new List<Sku> {
new Sku { SkuId = 1, DefaultPrice = 10.0m },
new Sku { SkuId = 2, DefaultPrice = 20.0m },
new Sku { SkuId = 3, DefaultPrice = 30.0m }
};
var orders = new List<Order> {
new Order { OrderId = 1, CustomerId = 1, SkuId = 1 },
new Order { OrderId = 2, CustomerId = 1, SkuId = 2, SpecificPrice = 15.0m },
new Order { OrderId = 3, CustomerId = 1, SkuId = 3 },
new Order { OrderId = 4, CustomerId = 2, SkuId = 1, SpecificPrice = 9.99m }
};
return new Context {
Customers = customers,
Skus = skus,
Orders = orders
};
}