Qual è la sintassi per un inner join in LINQ to SQL?

Question

Sto scrivendo un'istruzione LINQ to SQL e sto cercando la sintassi standard per un normale inner join con un ON clausola in C#.

Come si rappresenta quanto segue in LINQ to SQL:

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

Answer 1

Funziona più o meno così:

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

Sarebbe bello avere nomi e campi sensati per le tue tabelle per un esempio migliore.:)

Aggiornamento

Penso che per la tua domanda questo potrebbe essere più appropriato:

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

Poiché stai cercando i contatti, non i rivenditori.

Answer 2

E poiché preferisco la sintassi della catena di espressioni, ecco come farlo:

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

Answer 3

Per estendere la sintassi della catena di espressioni risposta di Clever Human:

Se volessi fare qualcosa (come filtrare o selezionare) sui campi di entrambe le tabelle unite insieme, invece che solo su una di queste due tabelle, potresti creare un nuovo oggetto nell'espressione lambda del parametro finale del metodo Join incorporando entrambe le tabelle, ad esempio:

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

La parte interessante è l'espressione lambda nella riga 4 di quell'esempio:

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

...dove costruiamo un nuovo oggetto di tipo anonimo che ha come proprietà i record DealerContact e Dealer, insieme a tutti i loro campi.

Possiamo quindi utilizzare i campi di tali record mentre filtriamo e selezioniamo i risultati, come dimostrato dal resto dell'esempio, che utilizza dc_d come nome per l'oggetto anonimo che abbiamo creato che ha come proprietà sia i record DealerContact che Dealer.

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

Utilizzo Linq Partecipa operatore:

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

Answer 6

Crei una chiave esterna e LINQ-to-SQL crea le proprietà di navigazione per te.Ogni Dealer avrà quindi una raccolta di DealerContacts che puoi selezionare, filtrare e manipolare.

from contact in dealer.DealerContacts select contact

O

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

Se non utilizzi le proprietà di navigazione, stai perdendo uno dei principali vantaggi di LINQ-to-SQL: la parte che mappa il grafico dell'oggetto.

Answer 7

fondamentalmente LINQ giuntura L'operatore non offre alcun vantaggio per SQL.Cioè.la seguente interrogazione

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

risulterà in INNER JOIN in SQL

giuntura è utile per IEnumerable<> perché è più efficiente:

from contact in db.DealerContact  

la clausola verrebbe rieseguita per ogni rivenditoreMa per IQueryable<> non è così.Anche giuntura è meno flessibile.

Answer 8

In realtà spesso è meglio non aderire, in linq s'intende.Quando sono presenti proprietà di navigazione, un modo molto conciso per scrivere l'istruzione linq è:

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

Si traduce in una clausola where:

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

Answer 9

Utilizzo LINQ si unisce per eseguire l'unione interna.

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
                   };

Answer 10

Prova questo :

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

Answer 11

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

Answer 12

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 };

Dove le tabelle degli studenti e del corso hanno una relazione tra chiave primaria e chiave esterna

Answer 13

prova invece questo,

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

Answer 14

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

}).ToList();

Answer 15

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

Answer 16

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

Scrivi i nomi delle tabelle che desideri e inizializza la selezione per ottenere il risultato dei campi.

Answer 17

Unione interna di due tabelle 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 }

Answer 18

Un miglior esempio

Nomi delle tabelle: TBL_Emp E TBL_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}