#Zied

Jai 2 tables en base de données avec une relation n-n, c'est-à-dire qu’elles sont liées avec une troisième table dont la clé primaire est composée des deux clés primaires des 2 tables.

Je génère le modèle .dbml à partir de ces trois tables pour avoir 2 types d'entités ayant chacune comme propriété une EntityCollection<Type> ou Type est l’autre type d'entité. 

Mon but est d’écrire une requête linq permettant de me renvoyer toutes les entités de type x correspondantes à une entité donnée de type y.

Prenons un exemple :

Une Entreprise peut avoir plusieurs Actionnaires et un Actionnaire peut investir dans plusieurs Entreprises.

Voici les types d'entités résultat :

Supposons que ma requête doit me renvoyer tous les actionnaires d'une entreprise 

En sachant que Contains ne marche pas pour linq to entities (domage), voici les deux manières de faire que j'ai trouvé :

1- Utiliser Any<> : on peut l'utiliser pour mettre des conditions sur chaque élément d'une collection(on aura pour résultat tous ceux qui ont satisfait la ou les conditions)

var requete = from actionnaire in entities.Actionnaire

where actionnaire.Entreprise.Any<Entreprise>(e => e.id == idEntreprise)

select actionnaire;

on peut faire par la suite une requete.ToList<Actionnaire>() pour récupérer la liste des actionnaires.

2- Ici on ne va pas se servir d'une fonction particulière sauf qu'on va passer par l'Entreprise pour récupérer ses Actionnaires. La seule chose à savoir est le type de retour de la requête.

using System.Data.Objects.DataClasses;

 IQueryable<EntityCollection<Actionnaire>> requete =

                                                                from entreprise in entities.Entreprise

                                                                where entreprise.id == idEntreprise

                                                                select entreprise.Actionnaire;

EntityCollection<Actionnaire> listeDesActionnaires =  requete.First<EntityCollection<Actionnaire>>();

En fait ici le type de retour n'est pas une  EntityCollection<Actionnaire> mais un  IQueryable<EntityCollection<Actionnaire>> parce que tout simplement il ne sait pas si notre condition dans le where va ramener 1 ou plusieurs Entreprises donc il prévoit d'avoir plusieurs  EntityCollection<Actionnaire> d'ou le IQueryable<EntityCollection<Actionnaire>>.

Donc pour récupérer la liste des actionnaires on doit faire :

requete.First<EntityCollection<Actionnaire>>().ToList<Actionnaire>();

Dans le cadre d'une application n-tiers, on a tous eu besoin de transformer une liste d'éléments d'un certain type vers une liste d'éléments d'un autre type. Ce qu'on faisait avant c'est qu'on faisait un petit foreach() on parcourant la liste de départ, dans la boucle on crée un élément du type de destination on rempli ses propriétés et par la suite on ajoute l'élément à la liste de destination.

Avec linq, on peut éviter cette boucle d'une façon très élégante.

Voici un petit exemple :

supposons que l'on ait les 2 classes suivantes :

public class Personne

{

public Int32 Id { get; set;}

public String Nom { get; set;}

public String Prenom { get; set;}

public Adresse Domicile { get; set;}

}

public class Adresse

{

public Int32 Id { get; set;}

public String Numero { get; set;}

public String Voie { get; set;}

public String CodePostal { get; set;}

public String Ville { get; set;}

public String Pays { get; set;}

}

Dans ma couche d'accès aux données, j'ai une fonction qui me renvoie List<Personne>, et mon objectif est de renvoyer à la couche de présentation qui contient mes page web une liste d'éléments  contenant toutes les propriétés de la classe Personne et une concaténation des propriétés de son adresse. Le but est biensur de binder le résultat directement dans un gridview et ne pas avoir à traiter les données dans le fichier .aspx.cs pour avoir le rendu voulu.

On créé la classe «PersonneVille »  ayant exactement la structure qu'on veut renvoyer

public class PersonneVille

{

public Int32 IdPerson { get; set;}

public String Nom { get; set;}

public String Prenom { get; set;}

public String Domicile { get; set;}

}

Par la suite on fait ce petit code :

//personnes est l'objet de départ de type List<Personne>

var requete = from p in personnes

select new PersonneVille

{

IdPerson = p.Id,

Nom = p.Nom,

Prenom = p.Prenom,

Domicile = p.Domicile.Numero.ToString() + ", " +

p.Domicile.Voie + " " +

p.Domicile.CodePostal + " " +

p.Domicile.Ville + " " +

p.Domicile.Pays

};

return requete.ToList<PersonneVille>();

Et voilà, on a remplacé notre foreach par une petite requête linq :)