Wie lautet die Syntax für einen inneren Join in LINQ to SQL?

Ich schreibe eine LINQ to SQL-Anweisung und bin nach der Standardsyntax für einen normalen inneren Join mit einer ONKlausel in C #.

Wie stellen Sie Folgendes in LINQ to SQL dar:

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

Es geht ungefähr 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, vernünftige Namen und Felder für Ihre Tabellen zu haben, um ein besseres Beispiel zu erhalten. :) :)

Aktualisieren

Ich denke, für Ihre Anfrage könnte dies angemessener sein:

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

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

Und weil ich die Syntax der Ausdruckskette bevorzuge, machen Sie das folgendermaßen:

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

So erweitern Sie die Antwort der Ausdruckskettensyntax von Clever Human:

Wenn Sie Dinge (wie Filtern oder Auswählen) für Felder aus beiden Tabellen tun möchten, die zusammengefügt werden sollen - statt nur für eine dieser beiden Tabellen -, können Sie ein neues Objekt im Lambda-Ausdruck des letzten Parameters für die Join-Methode erstellen Einbeziehen dieser beiden Tabellen, zum Beispiel:

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 dieses Beispiels:

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

... wo wir ein neues Objekt vom anonymen Typ erstellen, dessen Eigenschaften die DealerContact- und Dealer-Datensätze sowie alle ihre Felder sind.

Wir können dann Felder aus diesen Datensätzen verwenden, während wir die Ergebnisse filtern und auswählen, wie der Rest des Beispiels zeigt, das dc_dals Namen für das von uns erstellte anonyme Objekt verwendet wird, dessen Eigenschaften sowohl die DealerContact- als auch die Dealer-Datensätze enthalten.

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();

Verwenden Sie den Linq Join- Operator:

var q =  from d in Dealer
         join dc in DealerConact on d.DealerID equals dc.DealerID
         select dc;

Sie erstellen einen Fremdschlüssel und LINQ-to-SQL erstellt Navigationseigenschaften für Sie. Jeder Dealerhat dann eine Sammlung, DealerContactsdie 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 Hauptvorteile von LINQ-to-SQL - den Teil, der das Objektdiagramm abbildet.

Grundsätzlich bietet der LINQ- Join- Operator keinen Vorteil für SQL. Dh die folgende Abfrage

var r = from dealer in db.Dealers
   from contact in db.DealerContact
   where dealer.DealerID == contact.DealerID
   select dealerContact;

führt zu INNER JOIN in SQL

join ist nützlich für IEnumerable <>, weil es effizienter ist:

from contact in db.DealerContact  

Die Klausel würde für jeden Händler erneut ausgeführt. Für IQueryable <> ist dies jedoch nicht der Fall. Auch Join ist weniger flexibel.

Tatsächlich ist es oft besser, sich nicht an linq zu beteiligen. Wenn es Navigationseigenschaften gibt, ist eine sehr prägnante Methode zum Schreiben Ihrer linq-Anweisung:

from dealer in db.Dealers
from contact in dealer.DealerContacts
select new { whatever you need from dealer or contact }

Es übersetzt in eine where-Klausel:

SELECT <columns>
FROM Dealer, DealerContact
WHERE Dealer.DealerID = DealerContact.DealerID

Verwenden Sie LINQ-Joins , um Inner Join durchzuführen.

var employeeInfo = from emp in db.Employees
                   join dept in db.Departments
                   on emp.Eid equals dept.Eid 
                   select new
                   {
                    emp.Ename,
                    dept.Dname,
                    emp.Elocation
                   };

Versuche dies :

     var data =(from t1 in dataContext.Table1 join 
                 t2 in dataContext.Table2 on 
                 t1.field equals t2.field 
                 orderby t1.Id select t1).ToList(); 

var q=(from pd in dataContext.tblProducts join od in dataContext.tblOrders on pd.ProductID equals od.ProductID orderby od.OrderID select new { od.OrderID,
 pd.ProductID,
 pd.Name,
 pd.UnitPrice,
 od.Quantity,
 od.Price,
 }).ToList(); 

OperationDataContext odDataContext = new OperationDataContext();    
        var studentInfo = from student in odDataContext.STUDENTs
                          join course in odDataContext.COURSEs
                          on student.course_id equals course.course_id
                          select new { student.student_name, student.student_city, course.course_name, course.course_desc };

Wo Schüler- und Kurstabellen eine Primärschlüssel- und eine Fremdschlüsselbeziehung haben

versuchen Sie stattdessen dies,

var dealer = from d in Dealer
             join dc in DealerContact on d.DealerID equals dc.DealerID
             select d;

var Data= (from dealer in Dealer join dealercontact in DealerContact on dealer.ID equals dealercontact.DealerID
select new{
dealer.Id,
dealercontact.ContactName

}).ToList();

var data=(from t in db.your tableName(t1) 
          join s in db.yourothertablename(t2) on t1.fieldname equals t2.feldname
          (where condtion)).tolist();

var list = (from u in db.Users join c in db.Customers on u.CustomerId equals c.CustomerId where u.Username == username
   select new {u.UserId, u.CustomerId, u.ClientId, u.RoleId, u.Username, u.Email, u.Password, u.Salt, u.Hint1, u.Hint2, u.Hint3, u.Locked, u.Active,c.ProfilePic}).First();

Schreiben Sie die gewünschten Tabellennamen und initialisieren Sie die Auswahl, um das Ergebnis der Felder zu erhalten.

Inner Join zwei Tabellen in Linq C #

var result = from q1 in table1
             join q2 in table2
             on q1.Customer_Id equals q2.Customer_Id
             select new { q1.Name, q1.Mobile, q2.Purchase, q2.Dates }

von d1 in DealerContrac Join d2 in DealerContrac auf d1.dealearid entspricht d2.dealerid select new {dealercontract. *}

Ein bestes Beispiel

Tabellennamen: TBL_EmpundTBL_Dep

var result = from emp in TBL_Emp join dep in TBL_Dep on emp.id=dep.id
select new
{
 emp.Name;
 emp.Address
 dep.Department_Name
}


foreach(char item in result)
 { // to do}