Quelle est la syntaxe pour une jointure interne dans LINQ to SQL?

J’écris une instruction LINQ to SQL et je suis après la syntaxe standard pour une jointure interne normale avec une clause ON dans C #.

Comment représentez-vous les éléments suivants dans LINQ to SQL:

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

Ça va quelque chose comme:

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

Il serait bien d’avoir des noms et des champs sensibles pour vos tableaux pour un meilleur exemple. 🙂

Mettre à jour

Je pense que pour votre requête, cela pourrait être plus approprié:

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

Puisque vous recherchez les contacts, pas les revendeurs.

Et parce que je préfère la syntaxe de la chaîne d’expression, voici comment procéder:

 var dealerContracts = DealerContact.Join(Dealer, contact => contact.DealerId, dealer => dealer.DealerId, (contact, dealer) => contact); 
 var results = from c in db.Companies join cn in db.Counsortinges 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(); 

Pour étendre la réponse à la syntaxe de la chaîne d’expression par Clever Human:

Si vous vouliez faire des choses (comme filtrer ou sélectionner) sur les champs des deux tables en les reliant – à la place sur une seule de ces deux tables – vous pourriez créer un nouvel object dans l’expression lambda du paramètre final de la méthode Join incorporant ces deux tables, par exemple:

 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 partie intéressante est l’expression lambda à la ligne 4 de cet exemple:

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

… où nous construisons un nouvel object de type anonyme qui a pour propriétés les enregistrements DealerContact et Dealer, ainsi que tous leurs champs.

Nous pouvons alors utiliser les champs de ces enregistrements lorsque nous filtrons et sélectionnons les résultats, comme le montre le rest de l’exemple, qui utilise dc_d comme nom pour l’object anonyme que nous avons créé et qui contient à la fois les enregistrements DealerContact et Dealer.

Utilisez l’opérateur Linq Join :

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

essentiellement, LINQ join operator ne fournit aucun avantage pour SQL. Ie la requête suivante

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

entraînera INNER JOIN en SQL

join est utile pour IEnumerable <> car il est plus efficace:

 from contact in db.DealerContact 

la clause serait ré-exécutée pour chaque revendeur Mais pour IQueryable <> ce n’est pas le cas. Aussi rejoindre est moins flexible.

Vous créez une clé étrangère et LINQ-to-SQL crée des propriétés de navigation pour vous. Chaque Dealer disposera alors d’une collection de DealerContacts que vous pourrez sélectionner, filtrer et manipuler.

 from contact in dealer.DealerContacts select contact 

ou

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

Si vous n’utilisez pas les propriétés de navigation, vous manquez l’un des principaux avantages de LINQ-to-SQL – la partie qui mappe le graphe d’object.

En fait, il est souvent préférable de ne pas adhérer, c’est-à-dire en linq. Quand il y a des propriétés de navigation, une manière très succincte d’écrire votre instruction linq est la suivante:

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

Cela se traduit par une clause where:

 SELECT  FROM Dealer, DealerContact WHERE Dealer.DealerID = DealerContact.DealerID 

Utilisez les jointures LINQ pour effectuer une jointure interne.

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

Essaye ça :

  var data =(from t1 in dataContext.Table1 join t2 in dataContext.Table2 on t1.field equals t2.field orderby t1.Id select t1).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 }; 

Où les tables d’étudiants et de cours ont une relation de clé primaire et de clé étrangère

essayez plutôt ceci,

 var dealer = from d in Dealer join dc in DealerContact on d.DealerID equals dc.DealerID select d; 
 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(); 
 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(); 

Ecrivez les noms de tables souhaités et initialisez la sélection pour obtenir le résultat des champs.

Inner joint deux tables dans 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 } 

Un meilleur exemple

Noms de table: TBL_Emp et 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}