Procédure pas à pas : Création d'une solution de Services RIA

  • Article

Dans cette procédure pas à pas, vous allez créer une application Services RIA WCF qui extrait des données de la base de données AdventureWorksLT pour les mettre ensuite à la disposition d'un client Silverlight auquel elles sont présentés. Vous accèderez aux données de la source de données en créant des classes d'entité qui représentent différentes tables de base de données sur le serveur de la couche intermédiaire, puis vous les présenterez en créant un service de domaine qui rend ces entités de couche intermédiaire accessibles au client Silverlight. Cette procédure pas à pas sert de point de départ à beaucoup d'autres du même type dans la documentation des Services RIA .

Configuration requise

Cette procédure pas à pas, ainsi que les autres procédures du même type présentées dans la documentation des Services RIA nécessite au préalable l'installation et la configuration correctes de plusieurs programmes, tels que Visual Studio 2010 et le Developer Runtime et SDK Silverlight, en plus des Services RIA WCF et du kit de ressources des Services RIA WCF. Ces procédures nécessitent également l'installation et la configuration de SQL Server 2008 R2 Express with Advanced Services et l'installation de la base de données AdventureWorks OLTP et LT.

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 avant de poursuivre, pour être sûr de rencontrer le moins de problèmes possibles en effectuant ces procédures pas à pas des Services RIA .

Création d'une solution avec un lien des services RIA entre les projets

Pour installer une solution de Services RIA

  1. 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.

  2. Sélectionnez le modèle Application Silverlight dans le groupe Silverlight des Modèles installés et nommez le nouveau projet RIAServicesExample.

    RIA_StartProject

  3. Cliquez sur OK.

    La boîte de dialogue Nouvelle application Silverlight s'ouvre.

  4. 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 des Services RIA entre le projet client et le projet serveur.

    RIA_CreateProjectwithLink

  5. Cliquez sur OK pour créer la solution.

    La solution contient deux projets : un projet client et un projet serveur. Le projet client est nommé RIAServicesExample et il contient le code Silverlight que vous utiliserez pour créer la couche de présentation. Le projet serveur est nommé RIAServicesExample.Web et il contient le code de la couche intermédiaire.

    RIA_ProjectsCreated

Création de modèles de données

Dans cette section, vous créerez les classes d'entité ADO.NET qui représentent des données de la base de données AdventureWorksLT. Les Services RIA fonctionnent avec diverses classes de modélisation des données et sources de données. Pour en savoir plus sur les options d'accès aux données avec les Services RIA , consultez la rubrique Données.

CautionAttention :
Quand vous utilisez un Entity Data Model (EMD) avec Visual Studio 2010, vous devez sélectionner l'option Inclure les colonnes clés étrangères dans le modèle. Par défaut, cette option est sélectionnée lorsque vous utilisez l'Assistant Entity Data Model. Vous devez aussi utiliser le comportement par défaut qui consiste à intégrer les informations de mappage EMD dans l'assembly.

Pour rendre des données disponibles dans la couche intermédiaire

  1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet serveur, RIAServicesExample.Web, sélectionnez Ajouter, puis Nouvel élément.

    La boîte de dialogue Ajouter un nouvel élément s'affiche.

  2. Dans la liste des catégories, sélectionnez Données, puis le modèle ADO.NET Entity Data Model.

  3. Nommez le nouveau fichier AdventureWorksModel.edmx, puis cliquez sur Ajouter.

    L'Assistant EDM s'affiche.

  4. Sur l'écran Choisir le contenu du modèle, sélectionnez l'option Générer à partir de la base de données et cliquez sur Suivant.

  5. Sur l'écran Choisir votre connexion de données, créez une connection de données à la base de données et cliquez sur Suivant.

  6. Sur l'écran Choisir vos objets de base de données, sélectionnez l'Adresse, le Client et les tables CustomerAddress.

  7. Confirmez que la case à cocher Inclure les colonnes clés étrangères dans le modèle est activée et cliquez sur Terminer.

    Les modèles d'entité sont créés pour les tables.

  8. Construisez la solution (à l'aide de la combinaison de touches Ctrl+Shift+B).

Création d'un service de domaine

Dans cette section, vous ajouterez un service de domaine au projet de couche intermédiaire. Un service de domaine expose au projet client les entités de données et les opérations figurant dans le projet serveur. Vous pouvez ajouter la logique métier au service de domaine pour gérer la façon dont le client interagit avec les données.

Pour créer le service de domaine

  1. Cliquez avec le bouton droit sur le projet serveur, sélectionnez Ajouter, puis Nouvel élément.

  2. Dans la liste des catégories, sélectionnez Web, puis sélectionnez le modèle Classe DomainService.

  3. Nommez la classe CustomerDomainService.cs (ou CustomerDomainService.vb).

    RIA_AddDomainService

  4. Cliquez sur Ajouter.

    La boîte de dialogue Ajouter une nouvelle classe de service de domaine s'ouvre.

  5. Vérifiez que la case Activer l'accès client est activée.

  6. Sélectionnez l'entité Client, puis activez la case Activer la modification pour cette entité.

    RIA_AddEntity

  7. Cliquez sur OK.

    La classe CustomerDomainService est générée dans un nouveau fichier CustomerDomainService.cs (ou CustomerDomainService.vb).

  8. Ouvrez ce fichier. Remarquez que le fichier possède les caractéristiques suivantes :

    • La classe CustomerDomainService dérive de la classe LinqToEntitiesDomainService, qui est une classe de base abstraite dans l'infrastructure des Services RIA . Cette classe de base a été automatiquement utilisée parce que le service de domaine expose une classe de données d'entité ADO.NET.

    • La classe de base générique est liée à la classe d'entité créée dans les étapes précédentes par les AdventureWorksLTEntities de type ObjectContext dans son paramètre générique.

    • La classe CustomerDomainService est marquée avec l'attribut EnableClientAccessAttribute afin d'indiquer qu'elle est visible pour la couche cliente.

    • Une méthode de requête nommée GetCustomers est générée. Cette méthode retourne chaque élément sans filtrage ni tri.

    • Des méthodes permettant d'insérer des clients dans les enregistrements, de les mettre à jour et de les supprimer ont été générées.

Création du client Silverlight

Dans d'autres procédures pas à pas, vous pourrez voir comment ajouter une logique métier au service de domaine. Pour la procédure en cours, vous utiliserez simplement la méthode GetCustomers générée par défaut.

Des classes de proxy client sont générées lorsque vous construisez la solution. Le lien des Services RIA établi entre le projet client et le projet serveur rend possible la génération de ce code. Ces classes de proxy client permettent d'accéder aux données du client.

Pour consulter les classes de proxy client générées

  1. Générez la solution.

    Lorsque vous construisez la solution, du code est généré dans le projet client.

  2. Dans l'Explorateur de solutions, sélectionnez le projet client RIAServicesExample et cliquez sur l'icône Afficher tous les fichiers en haut de la fenêtre.

    Remarquez que le dossier Generated_Code contient un fichier RIAServicesExample.Web.g.cs (ou RIAServicesExample.Web.g.vb).

    RIA_GeneratedCode

  3. Ouvrez le fichier de code dans le dossier Generated_Code.

    Remarquez que le fichier possède les caractéristiques suivantes :

    • Une classe WebContext qui dérive de la classe WebContextBase est générée.

    • Une classe CustomerDomainContext qui dérive de la classe DomainContext est générée. Cette classe possède une méthode nommée GetCustomersQuery qui correspond à la méthode de requête créée dans le service de domaine.

    • Une classe Customer 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é Customer du projet client correspond à l'entité Customer du serveur.

Pour afficher les données dans le client Silverlight

  1. Ouvrez MainPage.xaml.

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

    Ce glisser-déposer du contrôle DataGrid depuis la Boîte à outils entraîne l'ajout automatique d'une instruction d'espace de noms using System.Windows.Controls et d'une référence à un assembly System.Windows.Controls.Data.

    CautionAttention :
    Si vous ajoutez le DataGrid sans le faire glisser depuis la Boîte à outils, vous devez ajouter manuellement la référence à l'assembly System.Windows.Controls.Data au projet client et l'instruction using au fichier code-behind.

  3. Modifiez la valeur de l'objet AutoGeneratedColums en True, donnez à l'élément DataGrid le nom CustomerGrid et ajustez les attributs de largeur et hauteur comme indiqué dans le XAML suivant.

    <UserControl 
    xmlns:data="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data"  
    x:Class="RIAServicesExample.MainPage"
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="https://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="https://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400">

    <Grid x:Name="LayoutRoot" Background="White">
      <data:DataGrid Name="CustomerGrid"></data:DataGrid>
    </Grid>
</UserControl>

  4. Ouvrez le code-behind de MainPage.xaml.

  5. Ajoutez les deux instructions using (C#) ou Imports (Visual Basic) : using RIAServicesExample.Web; et using System.ServiceModel.DomainServices.Client;.

    L'espace de noms RIAServicesExample.Web est l'espace de noms qui contient le code généré pour le projet client dans le RIAServicesExample.Web.g.cs (ou RIAServicesExample.Web.g.vb).

  6. Pour créer le CustomerDomainContext, ajoutez la ligne de code private CustomerDomainContext _customerContext = new CustomerDomainContext(); à la classe MainPage.

    Imports System.ServiceModel.DomainServices.Client
Imports RIAServicesExample.Web

Partial Public Class MainPage
    Inherits UserControl

    Private _customerContext As New CustomerDomainContext

    Public Sub New()
        InitializeComponent()

        Dim loadOp = Me._customerContext.Load(Me._customerContext.GetCustomersQuery())
        CustomerGrid.ItemsSource = loadOp.Entities
    End Sub

End Class

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using RIAServicesExample.Web;
using System.ServiceModel.DomainServices.Client;

namespace RIAServicesExample
{
    public partial class MainPage : UserControl
    {
        private CustomerDomainContext _customerContext = new CustomerDomainContext();

        public MainPage()
        {
            InitializeComponent();

            LoadOperation<Customer> loadOp = this._customerContext.Load(this._customerContext.GetCustomersQuery());
            CustomerGrid.ItemsSource = loadOp.Entities;
        }
    }
}

  7. Récupérez des entités client en appelant la méthode GetCustomersQuery avec LoadOperation: LoadOperation<Customer> loadOp = this._customerContext.Load(this._customerContext.GetCustomersQuery());.

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

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

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


namespace RIAServicesExample
{
    public partial class MainPage : UserControl
    {
        private CustomerDomainContext _customerContext = new CustomerDomainContext();
        public MainPage()
        {
            InitializeComponent();

            LoadOperation<Customer> loadOp = this._customerContext.Load(this._customerContext.GetCustomersQuery());
            CustomerGrid.ItemsSource = loadOp.Entities;
        }
    }
}

  9. Exécutez l'application (F5).

    Vous devez voir une grille de données semblable à la suivante.

    RIA_ResultsGrid

Étapes suivantes

Cette procédure pas à pas n'indiquait que les étapes de base pour créer un projet et récupérer des données non filtrées depuis un service de domaine. Voici quelques suggestions pour découvrir certaines fonctionnalités supplémentaires :