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

Question

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

Comment vous représentez ce qui suit dans LINQ to SQL:

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

Answer 1

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

Ce serait bien d'avoir des noms sensibles et les champs pour vos tables pour une meilleure Exemple. :)

Mise à 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 êtes à la recherche des contacts, et non les revendeurs.

Answer 2

Utilisez Linq Join opérateur:

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

Answer 3

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 4

Et parce que je préfère la syntaxe de la chaîne d'expression, voici comment vous le faites avec que:

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

Answer 5

essentiellement LINQ rejoindre l'opérateur fournit aucun avantage pour SQL. C'est à dire. la requête suivante

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

se traduira par INNER JOIN dans SQL

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

from contact in db.DealerContact 

clause serait exécutée à nouveau pour chaque revendeur Mais pour IQueryable <> ce n'est pas le cas. Aussi rejoindre est moins flexible.

Answer 6

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

from contact in dealer.DealerContacts select contact 

ou

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

Si vous n'êtes pas en utilisant les propriétés de navigation, vous manquez à l'un des principaux avantages sur LINQ to SQL - la partie qui mappe le graphe d'objet.

Answer 7

En fait, il est souvent préférable de ne pas joindre, c'est-à-dire linq.Quand il y a des propriétés de navigation d'une manière très succincte d'écrire votre déclaration LINQ est:

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

Il se traduit par une clause where:

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

Answer 8

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

Lorsque des tables d'étudiants et des cours ont clé primaire et étrangère relation clé

Answer 9

Un meilleur exemple

Tableau noms: 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} 

Answer 10

Utilisez LINQ joins pour effectuer Inner Join.

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 11

plutôt essayer cela,

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

Answer 12

Essayez ceci:

 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 13

Pour étendre la syntaxe de la chaîne d'expression answer par Clever humaine:

Si vous voulez faire des choses (comme filtre ou select) sur les champs des deux tables jointes ensemble - à la place sur un seul de ces deux tables - vous pouvez créer un nouvel objet dans l'expression lambda du dernier paramètre à la méthode join intégrant ces deux tableaux, 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 dans la ligne 4 de cette exemple:

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

... où nous construisons un nouvel objet de type anonyme qui a comme propriétés et les concessionnaireContact dossiers des courtiers, ainsi que tous leurs champs. Nous pouvons ensuite utiliser des champs de ces enregistrements comme nous filtrons et sélectionnons les résultats, comme démontré par le reste de l'exemple, qui utilise dc_d comme nom pour l'objet anonyme que nous avons construit qui a les deux DealerContact et Dealer enregistrements comme ses propriétés.

Answer 14

jointure interne Deux tables de Linq C#

var result =
de q1 dans le tableau 1
rejoindre q2 dans table2
sur q1.Customer_Id égal q2.Customer_Id
sélectionnez Nouveau {q1.Name, q1. mobile, q2.Purchase, q2.Dates}

Answer 15

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

}).ToList(); 

Answer 16

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 17

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

Écrivez les noms de table que vous voulez, et initialisez la sélection pour obtenir le résultat des champs.

Answer 18

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