Procédure pas à pas : Ajout de méthodes de requête

  • Article

Cette procédure pas à pas décrit comment ajouter et personnaliser des méthodes dans les Services RIA WCF pour interroger une source de données. Ces méthodes, qui sont appelées des méthodes de requête, doivent être définies avec une signature que l'infrastructure reconnaît comme étant la spécification d'une méthode de requête. Les méthodes de requête satisfont cette exigence en appliquant l'objet QueryAttribute. Les signatures de requête attendues se divisent en deux catégories générales : les requêtes qui retournent toujours un type unique de Entity et les requêtes qui peuvent potentiellement retourner plusieurs types de Entity dans un objet IEnumerable ou IQueryable. Pour plus d'informations sur les signatures de méthode de requête autorisées, consultez Services de domaine.

Lorsque vous créez une classe DomainService et spécifiez ses entités dans la boîte de dialogue Ajouter une nouvelle classe de service de domaine, l'infrastructure des Services RIA crée automatiquement une méthode de requête simple dans cette classe pour chaque entité exposée par le service. Cette méthode de requête récupère simplement tous les enregistrements de l'entité. Cette procédure pas à pas décrit comment ajouter de nouvelles méthodes de requête qui exécutent des scénarios plus complexes tels que le filtrage par une valeur de paramètre. Cette procédure pas à pas indique comment ajouter des requêtes qui retournent une entité unique et également comment ajouter des requêtes qui retournent une collection d'entités.

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 .

Cette procédure pas à pas suppose que vous avez effectué celles décrites dans Procédure pas à pas : Création d'une solution de Services RIA et que vous disposez de la solution ainsi créée, prête à être modifiée par les procédures indiquées ici.

Pour ajouter une méthode de requête qui accepte un paramètre et retourne une entité unique

  1. Ouvrez la solution générée dans la rubrique Procédure pas à pas : Création d'une solution de Services RIA qui expose des données de la table Customer.

  2. Dans le projet serveur, ouvrez la classe DomainService CustomerDomainService qui expose les données de la table Customer.

  3. Ajoutez une méthode de requête qui accepte un paramètre entier et retourne l'entité Customer avec l'ID client correspondant.

    Si une méthode qui retourne une entité unique inclut l'attribut QueryAttribute, vous devez affecter à la propriété IsComposable la valeur false. Les utilisateurs ne peuvent pas spécifier d'opérations de requête supplémentaires à partir du client. Si votre méthode de requête correspond à la signature attendue pour une requête, il est inutile d'appliquer l'attribut QueryAttribute. La valeur de retour doit être une instance unique d'un objet entité.

    <Query(IsComposable:=False)>
Public Function GetCustomersByID(ByVal customerID As Integer) As Customer
    Return Me.ObjectContext.Customers.SingleOrDefault(Function(c) c.CustomerID = customerID)
End Function

    [Query(IsComposable=false)]
public Customer GetCustomersByID(int customerID)
{
    return this.ObjectContext.Customers.SingleOrDefault(c => c.CustomerID == customerID);
}

Pour ajouter une méthode de requête qui accepte un paramètre et retourne une collection d'entités

  1. Ouvrez la classe DomainService qui expose les données de la table Customer.

  2. Dans la classe DomainService CustomerDomainService, ajoutez une méthode de requête qui accepte un paramètre de chaîne et retourne tous les clients dont le nom commence par cette lettre.

    La méthode peut retourner un objet IQueryable, car l'utilisateur peut vouloir fournir une opération de requête supplémentaire à partir du client.

    Public Function GetCustomersByLastNameLetter(ByVal startingLastNameLetter As String) As IQueryable(Of Customer)
    Return Me.ObjectContext.Customers.Where(Function(c) c.LastName.StartsWith(startingLastNameLetter) = True)
End Function

    public IQueryable<Customer> GetCustomersByLastNameLetter(string startingLastNameLetter)
{
    return this.ObjectContext.Customers.Where(c => c.LastName.StartsWith(startingLastNameLetter) == true);
}

Pour afficher les résultats de ces méthodes de requête dans le projet client

  1. Dans le projet client, ouvrez MainPage.xaml.

  2. Ajoutez deux contrôles TextBox et deux contrôles Button afin que l'utilisateur puisse filtrer des enregistrements client soit par l'ID, soit par la première lettre du nom.

    Le XAML suivant montre une disposition complète ainsi que le DataGrid existant.

    <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">
        <Grid.ColumnDefinitions>
            <ColumnDefinition></ColumnDefinition>
            <ColumnDefinition></ColumnDefinition>
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition Height="25"></RowDefinition>
            <RowDefinition></RowDefinition>
        </Grid.RowDefinitions>
        <StackPanel Orientation="Horizontal" Grid.Row="0" Grid.Column="0">
            <TextBlock Text="search by id: " ></TextBlock>
            <TextBox Name="IDValue" Width="50" ></TextBox>
            <Button Name="IDButton" Click="IDButton_Click" Content="Submit"></Button>
        </StackPanel>
        <StackPanel Orientation="Horizontal" Grid.Row="0" Grid.Column="1">
            <TextBlock Text="search by name: "></TextBlock>
            <TextBox Name="LetterValue" Width="30"></TextBox>
            <Button Name="LetterButton" Click="LetterButton_Click" Content="Submit"></Button>
        </StackPanel>

      <data:DataGrid Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2" Name="CustomerGrid"></data:DataGrid>
    </Grid>
</UserControl>

  3. Ouvrez la page code-behind de MainPage.xaml (MainPage.xaml.cs ou MainPage.xaml.vb).

  4. Ajoutez le code pour récupérer les résultats de la requête basés sur l'entrée utilisateur.

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

Partial Public Class MainPage
    Inherits UserControl
    Dim _customerContext As New CustomerDomainContext

    Public Sub New()
        InitializeComponent()
    End Sub

    Private Sub LetterButton_Click(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs)
        IDButton.IsEnabled = False
        LetterButton.IsEnabled = False
        Dim loadOp = Me._customerContext.Load(Me._customerContext.GetCustomersByLastNameLetterQuery(LetterValue.Text), AddressOf CustomerLoadedCallback, Nothing)
        CustomerGrid.ItemsSource = loadOp.Entities
    End Sub

    Private Sub IDButton_Click(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs)
        IDButton.IsEnabled = False
        LetterButton.IsEnabled = False
        Dim loadOp = Me._customerContext.Load(Me._customerContext.GetCustomersByIDQuery(IDValue.Text), AddressOf CustomerLoadedCallback, Nothing)
        CustomerGrid.ItemsSource = loadOp.Entities
    End Sub

    Public Sub CustomerLoadedCallback(ByVal loadOperation As LoadOperation(Of Customer))
        IDButton.IsEnabled = True
        LetterButton.IsEnabled = True
    End Sub
End Class

    using System;
using System.Windows;
using System.Windows.Controls;
using RIAServicesExample.Web;
using System.ServiceModel.DomainServices.Client;

namespace RIAServicesExample
{

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

        public MainPage()
        {
            InitializeComponent();
        }

        private void LetterButton_Click(object sender, RoutedEventArgs e)
        {
            IDButton.IsEnabled = false;
            LetterButton.IsEnabled = false;
            LoadOperation<Customer> loadOp = this._customerContext.Load(this._customerContext.GetCustomersByLastNameLetterQuery(LetterValue.Text), CustomerLoadedCallback, null);
            CustomerGrid.ItemsSource = loadOp.Entities;
        }

        private void IDButton_Click(object sender, RoutedEventArgs e)
        {
            IDButton.IsEnabled = false;
            LetterButton.IsEnabled = false;
            LoadOperation<Customer> loadOp = this._customerContext.Load(this._customerContext.GetCustomersByIDQuery(int.Parse(IDValue.Text)), CustomerLoadedCallback, null);
            CustomerGrid.ItemsSource = loadOp.Entities;
        }

        void CustomerLoadedCallback(LoadOperation<Customer> loadOperation)
        {
            IDButton.IsEnabled = true;
            LetterButton.IsEnabled = true;
        }
    }
}

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

    L'illustration suivante montre une liste de clients filtrée par nom qui s'affiche lors de l'exécution de l'application.

    RIA_QueryMethods