Wie lautet die Syntax für eine innere Verknüpfung in LINQ to SQL?

Question

Ich schreibe eine LINQ to SQL-Anweisung, und ich bin nach der Standardsyntax für eine normale innere Verknüpfung mit einer ON Klausel in C#.

Wie stellen Sie das Folgende in LINQ to SQL dar?

select DealerContact.*
from Dealer 
inner join DealerContact on Dealer.DealerID = DealerContact.DealerID

Answer 1

Sie lautet in etwa so:

from t1 in db.Table1
join t2 in db.Table2 on t1.field equals t2.field
select new { t1.field2, t2.field3}

Es wäre schön, wenn Sie sinnvolle Namen und Felder für Ihre Tabellen hätten, um ein besseres Beispiel zu haben :)

Update

Ich denke, dass dies für Ihre Anfrage besser geeignet ist:

var dealercontacts = from contact in DealerContact
                     join dealer in Dealer on contact.DealerId equals dealer.ID
                     select contact;

Denn Sie suchen die Kontakte, nicht die Händler.

Answer 2

Und weil ich die Ausdrucksketten-Syntax bevorzuge, hier ist, wie Sie es mit dieser tun:

var dealerContracts = DealerContact.Join(Dealer, 
                                 contact => contact.DealerId,
                                 dealer => dealer.DealerId,
                                 (contact, dealer) => contact);

Answer 3

So erweitern Sie die Syntax der Ausdruckskette Antwort von Clever Human:

Wenn Sie Dinge (wie Filtern oder Auswählen) an Feldern aus beiden Tabellen, die zusammengefügt werden, tun wollten - statt nur an einer dieser beiden Tabellen - könnten Sie ein neues Objekt im Lambda-Ausdruck des letzten Parameters der Join-Methode erstellen, das beispielsweise beide Tabellen enthält:

var dealerInfo = DealerContact.Join(Dealer, 
                              dc => dc.DealerId,
                              d => d.DealerId,
                              (dc, d) => new { DealerContact = dc, Dealer = d })
                          .Where(dc_d => dc_d.Dealer.FirstName == "Glenn" 
                              && dc_d.DealerContact.City == "Chicago")
                          .Select(dc_d => new {
                              dc_d.Dealer.DealerID,
                              dc_d.Dealer.FirstName,
                              dc_d.Dealer.LastName,
                              dc_d.DealerContact.City,
                              dc_d.DealerContact.State });

Der interessante Teil ist der Lambda-Ausdruck in Zeile 4 des Beispiels:

(dc, d) => new { DealerContact = dc, Dealer = d }

...wo wir ein neues Objekt vom anonymen Typ konstruieren, das als Eigenschaften die Datensätze DealerContact und Dealer mit all ihren Feldern hat.

Wir können dann Felder aus diesen Datensätzen verwenden, um die Ergebnisse zu filtern und auszuwählen, wie im weiteren Verlauf des Beispiels gezeigt wird, in dem dc_d als Name für das anonyme Objekt, das wir erstellt haben und das sowohl den DealerContact- als auch den Dealer-Datensatz als Eigenschaften hat.

Answer 4

var results = from c in db.Companies
              join cn in db.Countries on c.CountryID equals cn.ID
              join ct in db.Cities on c.CityID equals ct.ID
              join sect in db.Sectors on c.SectorID equals sect.ID
              where (c.CountryID == cn.ID) && (c.CityID == ct.ID) && (c.SectorID == company.SectorID) && (company.SectorID == sect.ID)
              select new { country = cn.Name, city = ct.Name, c.ID, c.Name, c.Address1, c.Address2, c.Address3, c.CountryID, c.CityID, c.Region, c.PostCode, c.Telephone, c.Website, c.SectorID, Status = (ContactStatus)c.StatusID, sector = sect.Name };

return results.ToList();

Answer 5

Sie erstellen einen Fremdschlüssel, und LINQ-to-SQL erstellt Navigationseigenschaften für Sie. Jede Dealer hat dann eine Sammlung von DealerContacts die Sie auswählen, filtern und bearbeiten können.

from contact in dealer.DealerContacts select contact

oder

context.Dealers.Select(d => d.DealerContacts)

Wenn Sie keine Navigationseigenschaften verwenden, verpassen Sie einen der wichtigsten Vorteile von LINQ-to-SQL - den Teil, der den Objektgraphen abbildet.