Procédure : créer un service de domaine qui utilise des entités définies POCO

Article
03/11/2011

Cette rubrique montre comment utiliser Services RIA WCF pour créer un service de domaine qui utilise des objets POCO (objets CLR traditionnels). L'objectif est de montrer comment construire une application élémentaire Services RIA basée sur des objets POCO qui explique exactement ce qui se passe, entre autres, lorsque les outils Services RIA (assistants et boîtes de dialogue) sont utilisés au cours des différents étapes de la procédure. Les données prises en charge à partir d'objets POCO peuvent permettre de libérer une application de ses dépendances vis-à-vis de bases de données principales à des fins de portabilité ou de sécurité des données, ou encore en vue de tests. Le code client généré automatiquement est entièrement pris en charge par Services RIA avec les entités définies POCO, comme c'est le cas avec Linq to SQL ou Entity Framework. En fait, le service de domaine Services RIA ne dépend pas de la source de données. Par conséquent, cette classe POCO peut faire l'objet d'un remplacement ultérieurement par un composant qui accède à des données à partir d'une autre source, telle qu'une base de données, sans changer le service de domaine proprement dit.

La procédure décrite ici nécessite au préalable l'installation et la configuration correctes de plusieurs programmes, tels que Visual Studio 2010 et Silverlight Developer Runtime et SDK, en plus des Services RIA WCF. Toutefois, le kit de ressources Services RIA WCF Toolkit n'est pas obligatoire. Vous trouverez des instructions détaillées pour satisfaire chacune de ces conditions préalables dans les rubriques du nœud Conditions préalables pour les Services RIA WCF. Suivez ces instructions concernant les programmes requis avant de poursuivre cette procédure, pour être sûr de rencontrer le moins de problèmes possibles.

Créer une solution Services RIA

Créez un projet Services RIA dans Visual Studio 2010 en sélectionnant Fichier, Nouveau, puis Projet.

La boîte de dialogue Nouveau projet s'affiche.
Sélectionnez le modèle Application Silverlight dans le groupe Silverlight des Modèles installés et nommez le nouveau projet RIAServicesPocoExample.
Cliquez sur OK.

La boîte de dialogue Nouvelle application Silverlight s'ouvre.
Activez la case à cocher Activer les services RIA WCF presque au bas de la boîte de dialogue. L'activation de cette case crée un lien Services RIA entre le projet client et le projet serveur. Pour activer cette connexion, cet outil ajoute les références suivantes au projet client :
- System.ComponentModel.DataAnnotations
- System.Runtime.Serialization
- System.ServiceModel.dll
- System.ServiceModel.DomainServices.Client
- System.ServiceModel.DomainServices.Client.Web
- System.ServiceModel.Web.Extensions
- System.Windows.Browser
Cliquez sur OK pour créer la solution.

La solution contient deux projets : un projet client et un projet serveur.
- RIAServicesPocoExample : projet client qui contient le code Silverlight que vous utilisez pour créer la couche de présentation.
- RIAServicesPocoExample.Web : projet serveur qui contient le code de la couche intermédiaire.

Créer un service de domaine

Cliquez avec le bouton droit sur le projet serveur, sélectionnez Ajouter, puis Nouvel élément.
Dans la liste des catégories, sélectionnez Web, puis le modèle Classe DomainService.
Nommez la classe SovereignDomainService.cs (ou SovereignDomainService.vb).
Cliquez sur Ajouter.

La boîte de dialogue Ajouter une nouvelle classe de service de domaine s'ouvre.
Vérifiez que la case Activer l'accès client est activée.
Notez que la seule option disponible dans le menu déroulant pour Classes DataContext/ObjectContext disponibles est l'entité <classe de service de domaine vide> et que vous ne pouvez pas sélectionner la case à cocher Générer des classes associées pour les métadonnées car aucun contexte de données ne peut être associé au service.
Cliquez sur OK.

Cet assistant effectue plusieurs tâches. Il génère une classe SovereignDomainService vide dans un nouveau fichier SovereignDomainService.cs (ou SovereignDomainService.vb) avec des instructions using et des attributs associés. Il ajoute également au fichier Web.config quatre références d'assembly au projet de service et aux éléments de configuration.
Pour observer ce phénomène, ouvrez le fichier SovereignDomainService.cs (ou SovereignDomainService.vb) s'il n'a pas été ouvert automatiquement. Remarquez que le fichier possède les caractéristiques suivantes :
1. Des instructions using ont été ajoutées :
  - using System;
  - using System.Collections.Generic;
  - using System.ComponentModel;
  - using System.ComponentModel.DataAnnotations;
  - using System.Linq;
  - using System.ServiceModel.DomainServices.Hosting;
  - using System.ServiceModel.DomainServices.Server
2. La classe SovereignDomainService dérive de la classe DomainService, qui est une classe de base abstraite dans l'infrastructure des Services RIA . Il s'agit de la classe de base pour l'ensemble du service de domaine exposé dans Services RIA .
3. La classe SovereignDomainService est marquée avec l'attribut EnableClientAccessAttribute afin d'indiquer qu'elle est visible pour la couche cliente.
Notez que les références suivantes ont été ajoutées au projet de service par l'assistant :
- System.ComponentModel.DataAnnotations
- System.Runtime.Serialization
- System.ServiceModel.DomainServices.Hosting
- System.ServiceModel.DomainServices.Server
Finalement, ouvrez le fichier Web.config et examinez les nouveaux éléments qui ont été ajoutés par l'assistant.
```
<configuration>
    <system.webServer>
        <modules runAllManagedModulesForAllRequests="true">
            <add name="DomainServiceModule" preCondition="managedHandler"
                type="System.ServiceModel.DomainServices.Hosting.DomainServiceHttpModule, System.ServiceModel.DomainServices.Hosting, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
        </modules>
        <validation validateIntegratedModeConfiguration="false" />
    </system.webServer>
    <system.web>
        <httpModules>
            <add name="DomainServiceModule" type="System.ServiceModel.DomainServices.Hosting.DomainServiceHttpModule, System.ServiceModel.DomainServices.Hosting, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
        </httpModules>
        <compilation debug="true" targetFramework="4.0" />
    </system.web>

    <system.serviceModel>
        <serviceHostingEnvironment aspNetCompatibilityEnabled="true"
            multipleSiteBindingsEnabled="true" />
    </system.serviceModel>
</configuration>
```
À l'exception de l'élément de configuration ciblant le .NET Framework 4.0, chacun de ces éléments a été ajouté par la boîte de dialogue Ajouter une nouvelle classe de service de domaine. Ces éléments activent différentes options ASP.NET et d'hébergement Internet Information Server (IIS).
1. L'assistant ajoute un élément <modules> à la section <system.webserver> requise par l'hébergement IIS 7.
2. L'assistant ajoute un élément <add> de l'élément <httpModules> dans la section system.web requise par l'hébergement IIS 6.
3. Les services de domaine Services RIA sont des services Windows Communication Foundation (WCF) qui, lorsqu'ils sont hébergés avec ASP.NET, doivent l'être en mode de compatibilité ASP.NET. Cette condition ne peut pas être définie dans du code et doit être spécifiée dans le fichier Web.config. Le mode de compatibilité ASP.NET est activé en définissant la propriété aspNetCompatibilityEnabled avec la valeur true dans l'élément <ServiceHostingEnvironment> de la section <system.serviceModel>.

Ajouter la classe POCO

Cette procédure explique comment indiquer à l'infrastructure Services RIA qu'une classe POCO doit être utilisée comme type d'entité. Les types d'entité fournissent des structures de données au modèle de données de l'application et chaque type d'entité doit avoir une clé d'entité unique. La structure des données est spécifiée par l'ensemble de propriétés qu'elle contient. La clé d'entité est fournie en représentant une propriété (ou un ensemble de propriétés) devant fournir un nom unique pour chaque objet entité afin de le distinguer des autres entités du même type. Ce nom est généralement spécifié à l'aide de métadonnées diverses. Cette procédure consiste à appliquer l'attribut [Key] à une propriété. En fait, c'est l'application de cet attribut qui indique à l'infrastructure Services RIA que des instances de la classe POCO correspondent à des objets entités.
Ouvrez le fichier SovereignDomainSevice.cs.

Dans l'étendue de l'espace de noms RIAServicesPocoExample.Web, sous la classe SovereignDomainService générée, ajoutez le code suivant pour la classe Sovereign :


public class Sovereign
    {
        [Key]
        public int UniqueId { get; set; }
        public string Name { get; set; }
        public string House { get; set; }
        public string Dominion { get; set; }
        public int ReignStart { get; set; }
        public int ReignEnd { get; set; }
        public string Sobriquet { get; set; }
    }

Dans cet exemple, la propriété UniqueId correspond à la clé d'entité qui fournit un nom unique pour chaque objet entité de type Sovereign. L'attribut [Key] est défini dans l'assembly System.ComponentModel.DataAnnotations, lequel a déjà été ajouté au projet serveur, de même que l'instruction using pour l'espace de noms correspondants qui le contient. La clé d'entité pourrait également être spécifiée dans un fichier de métadonnées ou selon d'autres méthodes, mais celle-ci est pratique dans la mesure où elle est définie directement dans la classe POCO.

Ajoutez la méthode FetchSovereigns() à la classe Sovereign qui retourne une liste d'instances Sovereign :


public List<Sovereign> FetchSovereigns()
        {
            List<Sovereign> sovereignList = new List<Sovereign>
            {
            new Sovereign()
                {UniqueId = 1, 
                 Name = "John", 
                 House = "Plantagenet", 
                 Dominion = "Angevin Empire", 
                 ReignStart = 1167, 
                 ReignEnd = 1216, 
                 Sobriquet = "Lackland"
                },
            new Sovereign()
                {UniqueId = 2, 
                 Name = "Charles", 
                 House = "Stuart", 
                 Dominion = "England, Scotland, & Ireland", 
                 ReignStart = 1625, 
                 ReignEnd = 1649, 
                 Sobriquet = "The Martyr"
                },
            new Sovereign()
                {UniqueId = 3, 
                 Name = "William", 
                 House = "Dunkeld", 
                 Dominion = "Scotland", 
                 ReignStart = 1165, 
                 ReignEnd = 1249, 
                 Sobriquet = "The Lion"
                },   
            new Sovereign()
                {UniqueId = 4, 
                 Name = "Elizabeth", 
                 House = "Tudor", 
                 Dominion = "England", 
                 ReignStart = 1555, 
                 ReignEnd = 1609, 
                 Sobriquet = "The Virgin Queen"
                },
            new Sovereign()
                {UniqueId = 5, 
                 Name = "Ivan", 
                 House = "Vasilyevich", 
                 Dominion = "Russia", 
                 ReignStart = 1533, 
                 ReignEnd = 1584, 
                 Sobriquet = "The Terrible"
                },
            new Sovereign()
                {UniqueId = 6, 
                 Name = "Charles", 
                 House = "Valois", 
                 Dominion = "France", 
                 ReignStart = 1380, 
                 ReignEnd = 1422, 
                 Sobriquet = "The Mad"
                }
            };
        return sovereignList;
        }

Définir le service de domaine

Cette procédure explique comment créer une requête dans le service de domaine qui sera accessible depuis le client afin de récupérer des données depuis les entités définies POCO. L'infrastructure Services RIA doit savoir lesquelles de ses méthodes doivent être mises à disposition sur le client en tant que requêtes. Une convention de dénomination existe pour y parvenir. Les noms de méthode qui commencent par Get et qui retournent un IEnumerable<EntityType> ou un IQueryable<EntityType> sont reconnus par l'infrastructure Services RIA en tant que requêtes.

Conseil :
IQueryable dérive de IEnumerable. Utilisez IEnumerable pour les collections en mémoire telles que nos entités définies POCO et utilisez IQueryable lors de l'accès à une source de données distante ou sous-jacente telle qu'une base de données SQL.

Ajoutez la méthode GetSovereign() à la classe SovereignDomainService.


        public IEnumerable<Sovereign> GetSovereigns()
        { 
            Sovereign sovereign = new Sovereign();
            return sovereign.FetchSovereigns();
        }

Cela permet de retourner l'ensemble des entités de souverain à partir de la collection. Mais, en général, nous ne souhaitons retourner qu'un sous-ensemble des entités. Pour illustrer cet exemple, modifiez cette requête afin de ne retourner que les souverains de la liste qui ont régné pendant le Moyen-Âge, autrement dit où sovereign.ReignEnd <= 1500. Le code suivant permet d'y parvenir :
```
        public IEnumerable<Sovereign> GetSovereignsByReignEnd(int ReignedBefore)
        {
            Sovereign sovereign = new Sovereign();
            return sovereign.FetchSovereigns().Where<Sovereign>(p => p.ReignEnd <= 1500);
        }
```
Générez (Ctrl+Maj+B) la solution afin de créer le code proxy client auto-généré.
Dans l'Explorateur de solutions, sélectionnez le projet client RIAServicesPocoExample et cliquez sur l'icône Afficher tous les fichiers en haut de la fenêtre, puis examinez le fichier RIAServicesPocoExample.Web.g.cs dans le dossier Generated_Code. Examinez le code auto-généré dans ce fichier et notez les éléments suivants :
- Une classe WebContext qui dérive de la classe WebContextBase est générée et utilisée pour gérer le contexte d'application.
- Une classe Sovereign qui dérive de la classe Entity est générée pour l'entité exposée par le service de domaine. La classe d'entité Sovereign du projet client correspond à l'entité Sovereign du serveur.
- Une classe SovereignDomainContext qui dérive de la classe DomainContext est générée. Cette classe possède une méthode nommée GetSovereignsByReignEndQuery qui correspond à la méthode de requête créée dans le service de domaine.
Pour plus d'informations sur la génération automatique de code, consultez la rubrique Génération de code client. Pour plus d'informations sur la personnalisation de la génération de code, consultez les rubriques Personnalisation du code généré.

Afficher le résultat de la requête dans le client Silverlight

Ouvrez MainPage.xaml.

Depuis la Boîte à outils à gauche, faites glisser un contrôle DataGrid dans l'élément Grid, dans la vue XAML.

Si vous faites glisser le contrôle Grille de données depuis la Boîte à outils, une instruction using System.Windows.Controls d'espace de noms est ajoutée au fichier MainPage.xaml.cs et les références aux assemblys System.Windows.Controls.Data et System.Windows.Controls.Data.Input sont ajoutées automatiquement au projet client.

Attention :
Si vous ajoutez DataGrid sans le faire glisser depuis la Boîte à outils, vous devez ajouter manuellement les références aux assemblys dans le projet client et l'instruction using dans le fichier code-behind.

Modifiez la valeur de AutoGeneratedColums par True, donnez à l'élément DataGrid le nom SovereignGrid et ajustez les Height et Width comme indiqué dans le XAML suivant.


<Grid x:Name="LayoutRoot" Background="White">
     <sdk:DataGrid AutoGenerateColumns="True" 
                   Height="200" 
                   HorizontalAlignment="Left" 
                   Margin="157,86,0,0" 
                   Name="SovereignGrid" 
                   VerticalAlignment="Top"
                   Width="600" />
</Grid>

Ouvrez le fichier MainPage.xaml.cs.
Ajoutez les deux instructions using (C#) ou Imports (Visual Basic) : using RIAServicesPocoExample.Web; et using System.ServiceModel.DomainServices.Client;.

L'espace de noms RIAServicesPocoExample.Web est l'espace de noms qui contient le code généré pour le projet client dans RIAServicesPocoExample.Web.g.cs (ou RIAServicesPocoExample.Web.g.vb).
Pour créer le SovereignDomainContext, ajoutez la ligne de code private SovereignDomainContext _sovereignContext = new SovereignDomainContext(); à la classe MainPage.
Récupérez des entités client en appelant la méthode GetSovereignsQuery avec LoadOperation: LoadOperation<Sovereign> loadOp = this._sovereignContext.Load(this._sovereignContext.GetSovereignsByReignEndQuery(1500));.

Liez les entités chargées au DataGrid avec SovereignGrid.ItemsSource = loadOp.Entities;.

Pour résumer, le fichier MainPage.xaml.cs doit maintenant contenir le code suivant :

//Namespaces added
using RIAServicesPocoExample.Web;
using System.ServiceModel.DomainServices.Client;

namespace RIAServicesPocoExample
{
    public partial class MainPage : UserControl

    {
        private SovereignDomainContext _sovereignContext = new SovereignDomainContext();

        public MainPage()
        {

            InitializeComponent();

              LoadOperation<Sovereign> loadOp = this._sovereignContext.Load(this._sovereignContext.GetSovereignsByReignEndQuery(1500));
              SovereignGrid.ItemsSource = loadOp.Entities;
        }
    }
}

Exécutez l'application (F5).

Vous devez voir la table dans le navigateur qui affiche les propriétés des souverains du Moyen-Âge uniquement (dont le règne s'est terminé avant 1500 de l'ère chrétienne) (par ordre alphabétique).

Sécurité

Voir aussi

Tâches

Procédure pas à pas : Récupération et affichage des données d'un service de domaine

Concepts

Génération de code client

Partager via