Linq to Entity Left Outer Join

Question

J'ai un modèle Entity avec Factures, AffiliateCommissions et AffiliateCommissionPayments.

facture à AffiliateCommission est un à plusieurs, AffiliateCommission à AffiliateCommissionPayment est aussi un à plusieurs

Je suis en train de faire une requête qui renverra toutes les factures qui ont une commission, mais pas nécessairement un commissionPayment connexe. Je veux montrer les factures avec des commissions si elles ont un paiement de commission ou non.

requête ressemble quelque chose comme:

using (var context = new MyEntitities()) 
{ 
    var invoices = from i in context.Invoices 
    from ac in i.AffiliateCommissions 
    join acp in context.AffiliateCommissionPayments on ac.affiliateCommissionID equals acp.AffiliateCommission.affiliateCommissionID 
    where ac.Affiliate.affiliateID == affiliateID 
    select new 
    { 
     companyName = i.User.companyName, 
     userName = i.User.fullName, 
     email = i.User.emailAddress, 
     invoiceEndDate = i.invoicedUntilDate, 
     invoiceNumber = i.invoiceNumber, 
     invoiceAmount = i.netAmount, 
     commissionAmount = ac.amount, 
     datePaid = acp.paymentDate, 
     checkNumber = acp.checkNumber 
    }; 
    return invoices.ToList(); 
} 

Cette requête ci-dessus ne renvoie les éléments avec un AffiliateCommissionPayment.

Answer 1

Je ne sais pas si EF soutient cette (je ne suis pas sûr si vous utilisez EF2 ou EF4), mais c'est la solution dans Linq2Sql de sorte qu'il pourrait être intéressant d'essayer:

using (var context = new MyEntitities()) 
{ 
    var invoices = from i in context.Invoices 
    from ac in i.AffiliateCommissions 
    join acp in context.AffiliateCommissionPayments on ac.affiliateCommissionID equals acp.AffiliateCommission.affiliateCommissionID into acp_join 
    from acp_join_default in acpg.DefaultIfEmpty() 
    where ac.Affiliate.affiliateID == affiliateID 
    select new 
    { 
     companyName = i.User.companyName, 
     userName = i.User.fullName, 
     email = i.User.emailAddress, 
     invoiceEndDate = i.invoicedUntilDate, 
     invoiceNumber = i.invoiceNumber, 
     invoiceAmount = i.netAmount, 
     commissionAmount = ac.amount, 
     datePaid = acp.paymentDate, 
     checkNumber = acp.checkNumber 
    }; 
    return invoices.ToList(); 
} 

La principale changer ici est le into acpg après votre join, et la ligne DefaultIfEmpty.

Answer 2

It's almost always a mistake to use join in LINQ to SQL and LINQ to Entities.

Deviner que l'association AffiliateCommission-AffiliateCommissionPayment est appelé Payment, vous pouvez simplement faire:

using (var context = new MyEntitities()) 
{ 
    var invoices = from i in context.Invoices 
    from ac in i.AffiliateCommissions 
    where ac.Affiliate.affiliateID == affiliateID 
    select new 
    { 
     companyName = i.User.companyName, 
     userName = i.User.fullName, 
     email = i.User.emailAddress, 
     invoiceEndDate = i.invoicedUntilDate, 
     invoiceNumber = i.invoiceNumber, 
     invoiceAmount = i.netAmount, 
     commissionAmount = ac.amount, 
     datePaid = (DateTime?) ac.Payment.paymentDate, 
     checkNumber = (int?) ac.Payment.checkNumber 
    }; 
    return invoices.ToList(); 
} 

LINQ to SQL et LINQ aux entités fusionneront à la fois des valeurs nulles. Les conversions sont nécessaires car le type inféré sera basé sur le type AffiliateCommissionPayment.paymentDate, qui peut ne pas être nullable. Si c'est le cas, vous n'avez pas besoin de la distribution.