Jointure externe gauche dans Linq-To-Entities

Question

Existe-t-il un moyen de faire une jointure externe gauche dans linq-to-entities SANS avoir des tables mappées avec des clés étrangères?

En outre, si notre société décide d'utiliser linq-to-entities malgré toutes ses failles actuelles, pensez-vous qu'il est important d'avoir Visual Studio 2010? En d'autres termes, qu'est-ce qui dans Visual Studio 2010 pourrait aider à développer avec des entités qui ne sont pas dans Visual Studio 2008?

Merci.

Answer 1

Microsoft dispose de deux équipes de données qui visent toutes les deux le même objectif: l'entité LINQ-to-SQL et ADO.NET. Le support est maintenant disponible avec ADO.NET for Entities, ce qui signifie que LINQ-to-SQL ne sera pas aussi prioritaire que l'offre ADO.NET.

Visual Studio 2010 prend en charge .NET 4 qui à son tour prend en charge ADO.NET pour les entités et LINQ-to-SQL. Mis à part le nombre de fonctionnalités de productivité présentes dans VS2010, je n'ai pas vu grand-chose en termes de support de données qui soit différent de VS2008.

En termes de jointure externe gauche:

var dc = new DataContext(); 

var query = (
    from t1 in dc.MyTable 
    join a in MyJoinedTable on p.Id equals a.Id into tempTable 
    from t2 in tempTable.DefaultIfEmpty() 
    select new { p.Column1, p.Column2, t2.Column1} 
    ); 

Answer 2

Cela peut ne pas vous satisfaire parce que les objets ne sont pas correctement aplaties, mais vous pouvez effectuer une jointure externe et retourner une collection de types anonymes.

Une jointure externe gauche est identique à l'union de la jointure interne et de l'ensemble except (la partie du premier ensemble qui ne se joint pas au second ensemble).

Ici, je simplement

• calculer la jointure interne
• l'exception Calculons ensemble (création d'une entité vide B pour assurer les types sont compatibles)
• combinons les deux ensembles.

Le LINQ n'est pas beau, mais il est mignon.

class A 
{ 
    public int Id { get; set; } 
    public string PropertyA { get; set; }   
} 

class B 
{ 
    public int Id { get; set; } 
    public string PropertyB { get; set; } 
} 

var aThings = new List<A>(); 
var bThings = new List<B>(); 

var innerJoin = aThings.SelectMany(a => 
    bThings.Where(b => a.Id == b.Id).Select(b => new { a, b })).ToList(); 

var exceptSet = aThings.Where(a => 
    !bThings.Select(b => b.Id).Contains(a.Id)).Select(a => 
    { 
     B b = new B(); 
     return new { a, b }; 
    }); 

var outerJoin = innerJoin; 
outerJoin.AddRange(exceptSet); 

Le résultat est une liste de types anonymes {a, b}