Vorgehensweise Join zwischen mehreren Tabellen in LINQ Lambda

Ich versuche, führen Sie eine Verknüpfung zwischen mehreren Tabellen in LINQ. Ich habe die folgenden Klassen:

Product {Id, ProdName, ProdQty}

Category {Id, CatName}

ProductCategory{ProdId, CatId} //association table

Und ich den folgenden code verwenden (wo productcategory und productcategory sind Instanzen der oben genannten Klassen):

var query = product.Join(productcategory, p => p.Id, pc => pc.ProdID, (p, pc) => new {product = p, productcategory = pc})
                   .Join(category, ppc => ppc.productcategory.CatId, c => c.Id, (ppc, c) => new { productproductcategory = ppc, category = c});

Mit diesem code habe ich erhalten, ein Objekt der folgenden Klasse:

QueryClass { productproductcategory, category}

Wo producproductcategory Typ:

ProductProductCategoryClass {product, productcategory}

Verstehe ich nicht, wo die verknüpften "Tabelle" ist, erwartete ich eine einzelne Klasse enthält alle Eigenschaften, die von den beteiligten Klassen.

Mein Ziel ist, füllen Sie ein anderes Objekt mit einigen Eigenschaften ergeben sich aus der Abfrage:

CategorizedProducts catProducts = query.Select(m => new { m.ProdId = ???, m.CatId = ???, //other assignments });

wie kann ich dieses Ziel erreichen?

InformationsquelleAutor der Frage CiccioMiami | 2012-03-15

c#join lambda linq multiple-tables

139

Für joins, die ich stark bevorzugen, query-syntax für alle details, die gerne ausgeblendet wird (nicht zuletzt von denen sind die transparente IDS beteiligt sich mit der intermediate-Projektionen entlang des Weges, die offensichtlich in der dot-syntax äquivalent). Aber, fragte Sie über Lambdas, die ich denke, Sie haben alles was Sie brauchen - Sie müssen nur um es alle zusammen.
```
var categorizedProducts = product
    .Join(productcategory, p => p.Id, pc => pc.ProdId, (p, pc) => new { p, pc })
    .Join(category, ppc => ppc.pc.CatId, c => c.Id, (ppc, c) => new { ppc, c })
    .Select(m => new { 
        ProdId = m.ppc.p.Id, //or m.ppc.pc.ProdId
        CatId = m.c.CatId
        //other assignments
    });
```
Wenn Sie müssen, können Sie speichern Sie die Verknüpfung in eine lokale variable und die Wiederverwendung zu einem späteren Zeitpunkt, jedoch fehlen weitere Angaben, im Gegenteil, ich sehe keinen Grund für die Einführung der lokalen Variablen.

Außerdem könnten Sie werfen die Select in die Letzte lambda des zweiten Join (wieder, vorausgesetzt, es sind keine anderen Operationen, die abhängig von der join-Ergebnisse), die geben würde:
```
var categorizedProducts = product
    .Join(productcategory, p => p.Id, pc => pc.ProdId, (p, pc) => new { p, pc })
    .Join(category, ppc => ppc.pc.CatId, c => c.Id, (ppc, c) => new {
        ProdId = ppc.p.Id, //or ppc.pc.ProdId
        CatId = c.CatId
        //other assignments
    });
```
...und machen einen letzten Versuch, Sie zu verkaufen Abfrage-syntax würde dies wie folgt Aussehen:
```
var categorizedProducts =
    from p in product
    join pc in productcategory on p.Id equals pc.ProdId
    join c in category on pc.CatId equals c.Id
    select new {
        ProdId = p.Id, //or pc.ProdId
        CatId = c.CatId
        //other assignments
    };
```
Ihre Hände werden gebunden auf, ob die Abfrage-syntax verfügbar ist. Ich kenne einige Läden haben solche Mandate - basiert oft auf der Vorstellung, dass die Abfrage-syntax ist etwas mehr begrenzt als die dot-syntax. Es gibt andere Gründe, wie "warum soll ich lernen eine zweite syntax, wenn ich kann alles tun und mehr in der dot-syntax?" Wie dieser Letzte Teil zeigt - es sind details, die Abfrage-syntax versteckt, die machen können, es lohnt sich umarmt mit der Verbesserung der Lesbarkeit es bringt: alle diejenigen, intermediate Projektionen und Kennungen, die Sie haben, um zu Kochen-gerne auch nicht-front-und-center-Bühne in der Abfrage-syntax-version - Sie sind hintergrund-fluff. Aus meiner soap-box-jetzt - jedenfalls, vielen Dank für die Frage. 🙂

InformationsquelleAutor der Antwort devgeezer

Was Sie gesehen haben, ist was Sie bekommen - und es ist genau das, was Sie gefragt haben, hier:

(ppc, c) => new { productproductcategory = ppc, category = c}

Das ist ein lambda-Ausdruck, der die Rückkehr eines anonymen Typs mit den beiden Eigenschaften.

In Ihrem CategorizedProducts, man muss nur über diejenigen Eigenschaften:

CategorizedProducts catProducts = query.Select(
      m => new { 
             ProdId = m.productproductcategory.product.Id, 
             CatId = m.category.CatId, 
             //other assignments 
           });

InformationsquelleAutor der Antwort Jon Skeet

schauen Sie auf dieses Beispiel-code von meinem Projekt

public static IList<Letter> GetDepartmentLettersLinq(int departmentId)
{
    IEnumerable<Letter> allDepartmentLetters =
        from allLetter in LetterService.GetAllLetters()
        join allUser in UserService.GetAllUsers() on allLetter.EmployeeID equals allUser.ID into usersGroup
        from user in usersGroup.DefaultIfEmpty()//here is the tricky part
        join allDepartment in DepartmentService.GetAllDepartments() on user.DepartmentID equals allDepartment.ID
        where allDepartment.ID == departmentId
        select allLetter;

    return allDepartmentLetters.ToArray();
}

in diesem code kam ich 3 Tabellen und ich spited join-Bedingung aus der where-Klausel

Hinweis: das Services-Klassen sind nur verzogen(Kapseln), die Datenbank-Operationen

InformationsquelleAutor der Antwort Basheer AL-MOMANI

 public ActionResult Index()
    {
        List<CustomerOrder_Result> obj = new List<CustomerOrder_Result>();

       var  orderlist = (from a in db.OrderMasters
                         join b in db.Customers on a.CustomerId equals b.Id
                         join c in db.CustomerAddresses on b.Id equals c.CustomerId
                         where a.Status == "Pending"
                         select new
                         {
                             Customername = b.Customername,
                             Phone = b.Phone,
                             OrderId = a.OrderId,
                             OrderDate = a.OrderDate,
                             NoOfItems = a.NoOfItems,
                             Order_amt = a.Order_amt,
                             dis_amt = a.Dis_amt,
                             net_amt = a.Net_amt,
                             status=a.Status,  
                             address = c.address,
                             City = c.City,
                             State = c.State,
                             Pin = c.Pin

                         }) ;
       foreach (var item in orderlist)
       {

           CustomerOrder_Result clr = new CustomerOrder_Result();
           clr.Customername=item.Customername;
           clr.Phone = item.Phone;
           clr.OrderId = item.OrderId;
           clr.OrderDate = item.OrderDate;
           clr.NoOfItems = item.NoOfItems;
           clr.Order_amt = item.Order_amt;
           clr.net_amt = item.net_amt;
           clr.address = item.address;
           clr.City = item.City;
           clr.State = item.State;
           clr.Pin = item.Pin;
           clr.status = item.status;

           obj.Add(clr);



       }

InformationsquelleAutor der Antwort saktiprasad swain

var query = from a in d.tbl_Usuarios
                    from b in d.tblComidaPreferidas
                    from c in d.tblLugarNacimientoes
                    select new
                    {
                        _nombre = a.Nombre,
                        _comida = b.ComidaPreferida,
                        _lNacimiento = c.Ciudad
                    };
        foreach (var i in query)
        {
            Console.WriteLine($"{i._nombre } le gusta {i._comida} y nació en {i._lNacimiento}");
        }

InformationsquelleAutor der Antwort Alex Martinez

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.