Dans les versions précédentes d’Entity Framework, faire un calcul de différence entre deux dates avec linq to entities était assez laborieux, les fonctions c# n’étaient pas prise en compte dans les requêtes linq to entities et nous étions obligé soit de passer par une colonne calculée au sein de la Base de données soit modifier les fichiers de mapping pour écrire la requête sql à la main et utiliser la fonction DATEDIFF de SQL Server.

Avec Entity Framework 4 et l’apparition de la classe SqlFunctions, tout ça c’est de l’histoire ancienne. Cette classe contient un bon nombre de fonctions Sql Server qui peuvent être utilisées directement dans nos requêtes Linq To Entities et qui vont être traduites vers les fonctions SQL dans un contexte de requête à la BDD. Ces fonctions sont exposées directement par SQL Server et sont donc propres au Provider Sql Server. Parmis ces fonctions nous trouvons le DateDiff qui va nous permettre de calculer la différence entre 2 dates.

Soit cette requête linq to entites :

var requete = from s in context.Person
            select new { Nom = s.FirstName + " " + s.LastName, 
                                 s.BirthDate, 
                                 Age = System.Data.Objects.SqlClient.SqlFunctions.DateDiff("year", s.BirthDate, DateTime.Now) 
};

Du côté de profiler, voici la requête générée :

Nous remarquons que notre fonction DATEDIFF a été traduite littéralement.

Faisons maintenant un petit tour sur Reflector, voici ce que nous pouvons trouver

En effet, cette fonction est une fonction Sql Server mappée tout simplement. Donc en ce qui concerne les SqlFunctions, il vaut mieux se référer directement à la documentation Transact – SQL.

Le titre de l’article est assez explicite, on va afficher des données provenant d’un service WCF dans un DataGrid. Cet article va servir d’introduction pour la suite des articles autour de Silverlight.

Les données

On va créer une table Task qui va contenir des tâches, voici le script :

create table Task(id int IDENTITY, 
                [name] varchar(255), 
                comment varchar(1000), 
                realizationDate DateTime, 
                termDate DateTime, 
                reminderDate DateTime,
                concerned varchar(100),
                realized bit default 0
                )

Le service WCF

On va créer un service WCF et à l’aide d’entity framework (pour un souci de rapidité) on va chercher la liste des tâches dans la base de données et la renvoyer.

Créer un nouveau projet « WCF Service Project » et nommez le NavigationAppServices. Nommez la solution que vous allez créer « NavigationApp ».

Dans ce projet créez un nouveau « WCF Service » et nommez le « TasksService », et dans ce projet, créez un répertoire DataAccess.

Dans ce répertoire créer un nouveau « ADO.NET entity data model » et nommez le « DbModel ». N’oubliez pas de cocher la table Task qu’on vient de créer. Ceci va vous générer le modèle Entity Framework avec l’entité Task. (Si vous avez besoin de plus de détails sur cette partie je vous recommande ce post)

Revenons maintenant à notre service TasksService et rajoutons le using et la méthode suivante :

using NavigationAppServices.DataAccess;

public List<Task> GetList() 
{
      DbEntities entities = new DbEntities();
      return entities.Task.ToList<Task>();
}

Dans l’interface ITasksService n’oubliez pas de déclarer la méthode comme suit:

[OperationContract]
List<Task> GetList();

Alors juste une petite mise en garde, ce service que nous avons créé en 30 secondes ne respecte aucun best practice du développement N-Tiers mais pour le besoin de cet article ça suffit amplement.

L’application Silverlight

On y est, maintenant qu’on a préparé le terrain, on va pouvoir accéder à ce service WCF et afficher la liste des tâches dans une grille. Pour ce faire, dans la même solution qui contient les services, créez tout d’abord un projet de type « Silverlight navigation application » et nommez le « NavigationApp ». (Pour comprendre la coquille vide que vous génère Visual studio dans ce cas reportez vous à ce post)

Visual studio va alors nous créer une coquille vide. On va ignorer cette coquille et garder uniquement le point d’entrée de notre application qui est App.xaml pour construire notre application Silverlight.

Positionnez vous au niveau du projet NavigationApp et créez un nouveau « Silverlight User Control » en le nommant MasterPage.xaml ( Nous l’avons nommé comme cela juste parce que ça sera le conteneur de notre application Silverlight mais le fonctionnement n’est pas du tout pareil)

Dans le fichier App.xaml.cs remplacez la ligne suivante :

this.RootVisual = new MainPage();

par celle la :

this.RootVisual = new MasterPage();

L’application va donc au démarrage charger notre conteneur au lieu de charger le conteneur généré par Visual Studio. Si vous lancez l’application à ce stage vous aurez une page blanche puisque MasterPage ne contient rien.

Nous allons maintenant travailler sur l’aspect général de l’application, pour cela nous allons définir une grille qui nous permettra d’organiser un peu l’interface et positionner nos différents éléments graphique. Ouvrez MasterPage.xaml et en dessous de cette ligne :

<Grid x:Name="LayoutRoot" Background="White">

Placez ces quelques lignes qui permettent de définir la grille

<Grid.RowDefinitions>
      <RowDefinition Height="50"></RowDefinition>
      <RowDefinition Height="*"></RowDefinition>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
      <ColumnDefinition Width="100"></ColumnDefinition>
      <ColumnDefinition Width="*"></ColumnDefinition>
</Grid.ColumnDefinitions>

Rien de sorcier, nous avons définit une grille avec 2 lignes et 2 colonnes.

Nous allons maintenant remplir les cases de la grille avec des éléments graphiques.

<Border Style="{StaticResource MyBannerStyle}">
      <TextBlock Text="Mon application de la mort"></TextBlock>
</Border>
<Border Style="{StaticResource MyToolboxStyle}">
</Border>
<Border Style="{StaticResource MyBodyPageStyle}">
</Border>

Border est un conteneur graphique permettant de regrouper d’autres éléments. Donc on a définit 3 éléments de type border :

- Le premier sera notre bannière et occupera toute la première ligne de la grille

- Le deuxième sera un panel à gauche de l’écran qui restera vide jusqu’à la fin de cet article mais qui est destiné à accueillir une boite à outils ou un menu.

- Le troisième et dernier va accueillir notre application Silverlight

Les styles qui sont appliqués à ces éléments graphiques sont les suivants :

<Style x:Key="MyBannerStyle" TargetType="Border">
        <Setter Property="Background" Value="#C0C0C0"></Setter>
        <Setter Property="Grid.Row" Value="0"></Setter>
        <Setter Property="Grid.Column" Value="0"></Setter>
        <Setter Property="Grid.ColumnSpan" Value="2"></Setter>
</Style>
<Style x:Key="MyToolboxStyle" TargetType="Border">
     <Setter Property="Background" Value="#C0C0C0"></Setter>
     <Setter Property="Grid.Row" Value="1"></Setter>
     <Setter Property="Grid.Column" Value="0"></Setter>
</Style>

<Style x:Key="MyBodyPageStyle" TargetType="Border">
     <Setter Property="Grid.Row" Value="1"></Setter>
     <Setter Property="Grid.Column" Value="1"></Setter>
</Style>

Il faut les rajouter dans /Assets/Styles.xaml.

Dans MasterPage.xaml , positionnez vous maintenant en dessous de cette ligne.

<Border Style="{StaticResource MyBodyPageStyle}">

et rajoutez le code suivant :

<navigation:Frame x:Name="ContentFrame" Style="{StaticResource ContentFrameStyle}" Source="/Tasks">                          
                <navigation:Frame.UriMapper>
                    <uriMapper:UriMapper>
                        <uriMapper:UriMapping Uri="" MappedUri="/Views/Tasks.xaml"/>
                        <uriMapper:UriMapping Uri="/{pageName}" MappedUri="/Views/{pageName}.xaml"/>
                    </uriMapper:UriMapper>
                </navigation:Frame.UriMapper>
</navigation:Frame>

Pas de panique, il vous manque des briques, positionnez vous en dessous de cette ligne

xmlns:x=http://schemas.microsoft.com/winfx/2006/xaml

et rajoutez les 2 lignes suivantes :

xmlns:uriMapper="clr-namespace:System.Windows.Navigation;assembly=System.Windows.Controls.Navigation"
xmlns:navigation="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Navigation"

Ce code définit la zone qui va accueillir les pages Silverlight. (Pour en savoir plus à propos de l’uri mapping je vous recommande ce post

Créons maintenant notre page Tasks, positionnez vous au niveau du répertoire Views et ajouter une nouvelle « Silverlight page » et nommez la Tasks.xaml.

Dans Tasks.xaml, on va tout d’abord définir une Grille pour placer la DataGrid et un petit bouton de rafraîchissement. La grille aura 1 ligne et 2 colonnes, voici son code :

<Grid.RowDefinitions>
    <RowDefinition Height="*"></RowDefinition>
    <RowDefinition Height="30"></RowDefinition>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
     <ColumnDefinition Width="*"></ColumnDefinition>
</Grid.ColumnDefinitions>

Avant de créer la DataGrid qui va contenir la liste des tâches, allons déjà récupérer la liste des tâches à partir de notre service web, on va essayer de faire les choses à peu près proprement avec le pattern MVVM, on ne va pas s’attarder sur ce pattern qui fera l’objet d’un prochain post mais sachez juste que si vous vous intéressez à Silverlight ou wpf, le pattern MVVM est incontournable.

Dans le projet NavigationApp créez 2 nouveaux répertoires et nommez les « Model » et « ViewModel ».

Dans le répertoire Model, créez une nouvelle classe et nommez la « Task.cs », voici son contenu :

public class Task
{
        public int Id { get; set; }

        public string Name { get; set; }

        public bool Realized { get; set; }
}

Donc on a dans notre Model une classe Task qui représente une petite partie de la classe Task exposée par le service.

Dans le répertoire ViewModel, créez une nouvelle classe et nommez-la « TasksViewModel.cs ». Cette classe va contenir les propriétés sur les quels on va lier les composants graphiques de l’interface TasksViewModel. Pour pouvoir notifier les composants graphiques que le contenu des propriétés a changé il faut que notre classe implémente l’interface INotifyPropertyChanged. Pour cela il faut déclarer dans la classe le delegate PropertyChanged de cette manière :

public event PropertyChangedEventHandler PropertyChanged;

On a rajouté la méthode RaisePropertyChanged permettant de déclancher l’évènement PropertyChanged sur une propriété.

Notre grille va se lier à une liste de tâches, donc on va rajouter cette propriété :

private List<Task> tasks;
public List<Task> Tasks 
{
       get { return tasks; }
       set 
       {
            tasks = value;
            RaisePropertyChanged("Tasks");
       }
}

Nous remarquons bien que dans le set on déclanche l’évènement PropertyChanged dès qu’on a modifié le contenu de la propriété.

Et enfin on va aussi rajouter la méthode qui va contacter le service pour ramener les données (FillTasks) et le délégé (taskServiceClient_GetListCompleted) qui va traîter la réponse asynchrone du service et qui va modifier le contenu de la liste Tasks.

Au final voici le code de la classe TasksViewModel :

    public class TasksViewModel : INotifyPropertyChanged
    {
        #region INotifyPropertyChanged Members

        public event PropertyChangedEventHandler PropertyChanged;

        #endregion

        private void RaisePropertyChanged(string propertyName)
        {
            if (this.PropertyChanged != null)
            {
                this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }

        public void FillTasks() 
        {
            Services.Tasks.TasksServiceClient taskServiceClient = new NavigationApp.Services.Tasks.TasksServiceClient();
            taskServiceClient.GetListCompleted += new EventHandler<NavigationApp.Services.Tasks.GetListCompletedEventArgs>(taskServiceClient_GetListCompleted);
            taskServiceClient.GetListAsync();
        }

        void taskServiceClient_GetListCompleted(object sender, NavigationApp.Services.Tasks.GetListCompletedEventArgs e)
        {
            List<Task> resultTasks = new List<Task>();

            foreach(NavigationApp.Services.Tasks.Task t in e.Result)
            {
                Task mt = new Task();
                mt.Id = t.id;
                mt.Name = t.name;
                if (t.realized.HasValue)
                    mt.Realized = t.realized.Value;
                resultTasks.Add(mt);
            }

            this.Tasks = resultTasks;
        }

        private List<Task> tasks;

        public List<Task> Tasks 
        {
            get { return tasks; }
            set 
            {
                tasks = value;
                RaisePropertyChanged("Tasks");
            }
        }
    }

Il ne nous reste qu’à ajouter la grille et le bouton à l’interface dans Tasks.xaml

<Data:DataGrid x:Name="TasksGrid" Style="{StaticResource MyGridStyle}" ItemsSource="{Binding Tasks}">
</Data:DataGrid>
<Button x:Name="btnRefreshGrid" Click="btnRefreshGrid_Click" Style="{StaticResource MyButtonStyle}" Content="Refresh">
</Button>

Concentrons nous un peu sur le bout de code de la grille et plus particulièrement sur la valeur de l’attribut ItemSource {Binding Tasks}. Cette valeur permet de lier notre grille à l’attribut Tasks de l’objet du DataContext courant. Le DataContext est une propriété de type à la quelle on peut lier (Binding) des composants graphiques, qui contient en général une instance de l’objet qui va peupler nos composants graphiques et qui est hérité par tous les composants graphiques enfants tant qu’il n’est pas redéfini au niveau du composant en lui-même. Nous aurons l’occasion de revenir dessus plus en détail dans un prochain post.

Ajouter les styles suivants au niveau de Styles.xaml :

<Style x:Key="MyGridStyle" TargetType="Data:DataGrid">
        <Setter Property="Grid.Row" Value="0"></Setter>
        <Setter Property="Grid.Column" Value="0"></Setter>
</Style>
<Style x:Key="MyButtonStyle" TargetType="Button">
        <Setter Property="HorizontalAlignment" Value="Left"></Setter>
        <Setter Property="MaxWidth" Value="100"></Setter>
        <Setter Property="Grid.Row" Value="1"></Setter>
        <Setter Property="Grid.Column" Value="0"></Setter>
</Style>

Ajouter l’espace de noms System.Windows.Controls au niveau de Styles.xaml et Tasks.xaml

xmlns:Data="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data"

Dans Tasks.xaml.cs, positionnez vous dans le constructeur et ajouter le code suivant :

TasksViewModel tasksvm = new TasksViewModel();
this.DataContext = tasksvm;
tasksvm.FillTasks();

Tout ce qu’on fait ici c’est dire que le DataContext de la classe Tasks est une nouvelle instance de notre ViewModel et on rempli la propriété Tasks. Vu qu’on a lié notre grille à la proprété Task, lorsque cette dernière sera remplie et donc modifiée elle déclanchera l’évènement PropertyChanged et le moteur de binding va rafraîchir le contenu de la grille.

Et enfin, rajouter cette méthode dans la classe Tasks dans Tasks.xaml.cs qui va s’exécuter lors du click du bouton pour rafraîchir le contenu de la grille.

private void btnRefreshGrid_Click(object sender, RoutedEventArgs e)
{
        ((TasksViewModel)this.DataContext).FillTasks();
}

Vous pouvez maintenant éxecuter, vous devriez avoir quelque chose qui ressemble à ça (n’oubliez pas de remplir la base J)

Vous pouvez aussi modifier le contenu de la table et cliquer sur le bouton rafraîchir qui va mettre à jour la propriété Tasks, cette mise à jour va être notifiée au moteur de binding qui va redessiner la grille.

Une dernière explication par rapport à la grille, vous avez certainement remarqué qu’il y a bien 3 colonnes qui correspondent bien aux 3 proriétés de la classe Task. Mais ce qu’il faut surtout remarquer c’est que la colonnes « Realized » a été automatiquement dessinée sous forme de checkbox. En effet, par défaut le DataGrid s’adapte au type de la donnée qu’il affiche et ceci en associant à chaque type un DataTemplate par défaut.

Conclusion

A travers cet exemple basqiue on a introduit plusieurs notions sur les quels on va revenir plus en détail dans de prochains postes :

- Le DataContext et le databinding

- Le pattern MVVM

- Le DataGrid

- Les styles

A très bientôt ;)

L'ADO.NET Entity Framework est un outil de mapping OR. Il nous permet d'avoir une transposition de notre base de données en modèle objet et de manipuler directement ce modèle au lieu de la base de données.

 

Intérêts

-         L'ADO.NET Entity Framework va nous générer automatiquement la couche d'accès aux données sans aucun effort ce qui nous permettra de nous concentrer sur les autres couches.

-         Cette couche va nous épargner toute la partie : j’ouvre une connexion à la base de données, je fais une requête sql, j’exécute la requête…

-         On a une transposition objet de notre base de données, on peut donc manipuler ces données avec du c# et surtout avec linq et tous les avantages de l’utilisation de linq (requête compilée, intellicence, …).

Générer le modèle à partir du wizard

Pour commencer il faut créer un projet de type ClassLibrary et le nommer.

 

Positionner vous sur le projet et click droit -> Add -> New Item. Dans « Visual C# Items », cliquer sur l'élément « ADO.NET Entity Data Model », renommez le en ce que vous voulez (eviter les caractères spéciaux et les tirets bas). Cliquer sur « Add ».

 

 

Cliquer sur l'élément « Generate from database »et cliquer sur « Next »

 

 

Choisir la connexion à la base de données qu'on veut utiliser, nommer la ConnectionString (toujours éviter les caractères spéciaux, ...) et cliquer sur Next.

 

Choisir les tables qu'on veut utiliser en cochant les checkbox correspondants, nommer le Model Namespace et cliquer sur finish.

 

 

Voici le résultat de la génération

Une fois qu'on a généré le modèle, il faut le préparer pour qu'on puisse l'utiliser.

Configuration du modèle

La première chose à faire c'est de compiler le projet contenant le .dbml.

 

Pour pouvoir utiliser le modèle il faut exporter les fichiers .csdl .msl .ssdl vers le projet qui voudra instancier le modèle. La façon la plus simple de les exporter de couche en couche est de les inclure dans la dll du projet contenant. Mais avant de le faire ouvrez le App.config et regardez la connectionString.

 

Pour inclure ces fichiers dans la dll il faut aller ouvrir le .dbml, click droit n'importe sur l'espace de travail -> Propiétés. Dans la propriété « Metadata Artifact Processing » séléctionner « Embed in output assembly ». Au passage vous remarquerez que la connectionString a changé de forme.

Compiler le projet. Voilà maintenant votre modèle est prêt à être utilisé.

 

Utilisation

Pour utiliser le modèle, il faut tout d'abord ajouter une référence au projet contenant le modèle et aussi à l'assembly System.Data.Entity. Ensuite, si on est dans le projet utilisateur final (Projet application web, projet de test, ...) on doit copier / coller la ConnectionString dans le App.Config ou Web.Config. Enfin écrire un using du namespace du modèle et using System.Data.Entity

 

Pour mon exemple ci-dessus :

 

using ActionnaireEntrepriseModele;

using System.Data.Entity;

 

Et c'est tout. On peut maintenant charger le modèle en écrivant :

 

Entities entities = new Entities();

 

on peut après ecrire des requête linq comme celle-ci :

 

var requete = from actionnaire in entities.Actionnaire

                        where actionnaire.id == id

                        select actionnaire;

 

Voici un petit problème auquel je me suis confronté dernièrement, je voulais tout simplement faire une requête linq contenant une jointure avec plusieurs conditions.

 

Prenons comme exemple les types d'entités suivants :

Je voudrais ecrire une requête linq qui me renvoie tous les employés de l'entreprise “NetGame”.

Pour ce faire je vais ecrire une jointure entre les 2 types d'entité “Entreprise” et “Employe”, cette jointure aura deux conditions :

-         la première est  employe.Entreprise.id doit correspondre à Entreprise.id

-         la deuxième est que entreprise.raisonSociale doit être égal à "NetGame"

 

Pour pouvoir mettre deux conditions dans une jointure, on doit créer dynamiquement 2 objets anonymes (new) chacun ayant comme propriétés les opérandes qui doivent composer les conditions séparés par une virgule, la comparaison va donc se faire sur les objets.

 

Soit “entities” est une instance de ObjectContext, voici la requête :

 

 var requete = from employe in entities.Employe

                       join entreprise in entities.Entreprise on

                                 new { idEntreprise = employe.Entreprise.id, raisonSociale = "NetGame" }

                      equals new { idEntreprise = entreprise.id, raisonSociale = entreprise.raisonSociale }

                      select employe;            

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 :)