Share via


Procédure pas à pas : Utilisation du service d'authentification avec une application métier Silverlight

Le modèle Application métier Silverlight crée une solution qui active automatiquement l'authentification (selon le mode authentification par formulaire), ainsi que des rôles et des profils. La solution inclut des formulaires de données pour la connexion des utilisateurs existants et des nouveaux utilisateurs en cours d'inscription. Vous pouvez utiliser ces fonctionnalités sans écrire de code supplémentaire. Vous pouvez personnaliser la solution en définissant des rôles et des propriétés de profil.

Dans cette procédure pas à pas, vous allez apprendre comment utiliser l'authentification, les rôles et les profils dans une application métier Silverlight. Vous allez limiter l'accès à certaines opérations de domaine selon les informations d'identification de l'utilisateur et personnaliser l'interface utilisateur selon les préférences de l'utilisateur. Vous allez utiliser l'outil Administration de site Web ASP.NET pour gérer les rôles et les utilisateurs dans le site.

Configuration requise

Ces tâches, ainsi que les autres procédures pas à pas présentées dans la documentation des Services RIA nécessitent au préalable l'installation et la configuration correctes de plusieurs programmes, tels que Visual Studio 2010 et le runtime Developer et le kit de développement logiciel 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 des utilisateurs et des rôles

Vous pouvez utiliser les fonctionnalités fournies dans une application métier Silverlight pour implémenter rapidement l'authentification. Dans la section suivante, vous allez utiliser l'outil Configuration ASP.NET pour créer un utilisateur et un rôle, puis vous connecter à l'aide de cet utilisateur. Vous inscrirez un nouvel utilisateur à travers le formulaire d'inscription fourni dans l'application métier Silverlight.

Pour créer un site, des rôles et des utilisateurs

  1. Dans Visual Studio 2010, sélectionnez Fichier, Nouveau, puis Projet.

    La boîte de dialogue Nouveau projet s'affiche.

  2. Sélectionnez le type de projet Silverlight.

  3. Sélectionnez le modèle Application métier Silverlight et nommez l'application ExampleBusinessApplication.

    RIA_ServicesCreateBizApp

  4. Cliquez sur OK.

    Observez la structure de projet créée. Le projet client Silverlight inclut des pages Silverlight dans le dossier Views. Ces pages permettent la connexion des utilisateurs et l'inscription de nouveaux utilisateurs.

  5. Pour ouvrir l'outil Administration de Site Web ASP.NET, sélectionnez d'abord le projet serveur (ExampleBusinessApplication.Web) dans l'Explorateur de solutions. Ouvrez l'outil Configuration ASP.NET.

  6. Dans le menu Projet, sélectionnez Configuration ASP.NET.

    Si vous ne voyez pas l'option Configuration ASP.NET dans le menu Projet, c'est peut être parce que vous avez sélectionné le projet client.

    RIA_OpenAdminTool

  7. Sélectionnez l'onglet Sécurité dans l'outil Administration de Site Web ASP.NET.

    RIA_WebAdminSecurity

  8. Dans la section Rôles, cliquez sur le lien Créer ou gérer des rôles.

  9. Ajoutez un nouveau rôle nommé Managers et sélectionnez le bouton Ajouter le rôle.

    WebAdmin_CreateRole

  10. Dans l'angle inférieur droit, cliquez sur le bouton Retour.

  11. Dans la section Utilisateurs, cliquez sur le lien Créer un utilisateur.

  12. Créez un utilisateur avec les valeurs suivantes et activez la case à cocher du rôle Managers.

    Nom d'utilisateur : CustomerManager

    Mot de passe : P@ssword

    Adresse de messagerie : someone@example.com

    Question de sécurité : couleur préférée ?

    Réponse de sécurité : bleu

    Rôle Managers : sélectionné

    WebAdmin_CreateUser

  13. Cliquez sur le bouton Créer un utilisateur.

  14. Fermez l'outil Administration de site Web ASP.NET.

  15. Exécutez la solution.

    La page d'accueil de l'application s'affiche dans un navigateur Web.

  16. Dans l'angle supérieur droit de la page, cliquez sur le lien Connexion.

    La boîte de dialogue Connexion s'affiche.

  17. Entrez CustomerManager comme nom d'utilisateur et P@ssword comme mot de passe et cliquez sur le bouton OK.

    RIA_LoginManager

    Vous êtes maintenant connecté en tant que cet utilisateur. Remarquez le texte « Bienvenue, CustomerManager » dans l'angle supérieur droit.

  18. Cliquez sur le lien Déconnexion.

    Vous n'êtes plus connecté en tant que CustomerManager. Dans les étapes suivantes, vous allez créer un utilisateur à l'aide du formulaire d'inscription.

  19. Cliquez à nouveau sur le lien Connexion.

  20. Dans la boîte de dialogue Connexion, cliquez sur le lien S'inscrire maintenant.

    Le formulaire d'inscription s'affiche.

  21. Remplissez le formulaire d'inscription pour créer un nouveau compte d'utilisateur. Utilisez les valeurs suivantes pour ce nouvel utilisateur.

    Nom d'utilisateur : SalesUser

    Nom convivial : SalesUser

    Adresse de messagerie : someone@example.com

    Mot de passe : P@ssword

    Question de sécurité : Quelle était la couleur de votre première voiture ?

    Réponse de sécurité : Verte

    RIA_RegisterUser

  22. Cliquez sur OK pour créer le nouvel utilisateur.

    Remarquez que vous êtes maintenant connecté en tant que SalesUser.

  23. Fermez le navigateur.

  24. Ouvrez à nouveau l'outil Administration de site Web ASP.NET et cliquez sur l'onglet Sécurité.

    Remarquez que 2 utilisateurs existent maintenant dans le site, ainsi que 2 rôles, bien que vous n'ayez créé qu'un seul rôle.

  25. Cliquez sur Créer ou gérer des rôles et observez les rôles Managers et Registered Users.

    Le rôle Registered Users a été créé automatiquement par le modèle Application métier.

    RIA_ManageRoles

  26. Pour les Registered Users, cliquez sur le lien Gérer.

    Remarquez que l'utilisateur nommé SalesUser que vous avez ajouté par le biais de l'application se trouve dans le rôle Registered Users.

  27. Fermez l'outil Administration de site Web ASP.NET.

Définition des propriétés d'accès et de profil

Vous limitez l'accès à une opération de domaine en appliquant l'attribut RequiresAuthenticationAttribute ou RequiresRoleAttribute à l'opération de domaine. Les opérations de domaine sans attribut sont disponibles pour tous les utilisateurs. L'application d'un attribut à l'opération de domaine n'empêche pas l'utilisateur d'appeler l'opération de domaine ; néanmoins, les utilisateurs qui n'ont pas les informations d'identification requises recevront une exception.

Limiter les données affichées en fonction des rôles

  1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le dossier App_Data dans le projet serveur, sélectionnez Ajouter, puis Élément existant.

  2. Dans la boîte de dialogue Ajouter un élément existant, ajoutez l'exemple de base de données AdventureWorksLT.

  3. Dans le projet serveur, ajoutez un nouvel élément et sélectionnez le modèle ADO.NET Entity Data Model parmi les modèles de Données.

  4. Donnez au modèle le nom AdventureWorksModel.edmx, puis cliquez sur Ajouter.

    L'Assistant EDM s'affiche.

  5. Sélectionnez l'option Générer à partir de la base de données, puis cliquez sur Suivant.

  6. Sélectionnez la base de données AdventureWorksLT, puis cliquez sur Suivant.

  7. Dans la liste des objets de base de données, sélectionnez les tables Customer, Product et SalesOrderHeader, puis cliquez sur Terminer.

    L'Entity Data Model s'affiche dans le concepteur.

  8. Générez la solution.

  9. Dans le projet serveur, ajoutez un nouvel élément et sélectionnez le modèle Classe DomainService parmi les modèles Web.

  10. Nommez le service de domaine AdventureWorksDomainService, puis cliquez sur Ajouter.

  11. Dans la boîte de dialogue Ajouter une nouvelle classe de service de domaine, sélectionnez les entités Customer, Product et SalesOrderHeader.

    RIA_CreateDSForAuth

  12. Cliquez sur OK pour terminer la création du service de domaine.

  13. Dans le fichier de classe AdventureWorksDomainService, ajoutez l'attribut RequiresAuthenticationAttribute à la méthode GetSalesOrderHeader.

    <RequiresAuthentication()> _
    Public Function GetSalesOrderHeaders() As IQueryable(Of SalesOrderHeader)
        Return Me.ObjectContext.SalesOrderHeaders
    End Function
    
    [RequiresAuthentication()]
    public IQueryable<SalesOrderHeader> GetSalesOrderHeaders()
    {
        return this.ObjectContext.SalesOrderHeaders;
    }
    
  14. Ajoutez l'attribut RequiresRoleAttribute à la méthode GetCustomers et nommez le rôle requis « Managers ».

    <RequiresRole("Managers")> _
    Public Function GetCustomers() As IQueryable(Of Customer)
        Return Me.ObjectContext.Customers
    End Function
    
    [RequiresRole("Managers")]
    public IQueryable<Customer> GetCustomers()
    {
        return this.ObjectContext.Customers;
    }
    

    L'opération de domaine GetProducts est disponible à tous les utilisateur ; GetSalesOrderHeaders est disponible aux utilisateurs authentifiés ; et GetCustomers est disponible uniquement aux utilisateurs du rôle Managers.

    Les éléments suivants montrent le service de domaine complet.

    <EnableClientAccess()>  _
    Public Class AdventureWorksDomainService
        Inherits LinqToEntitiesDomainService(Of AdventureWorksLT_DataEntities)
    
        <RequiresRole("Managers")> _
        Public Function GetCustomers() As IQueryable(Of Customer)
            Return Me.ObjectContext.Customers
        End Function
    
        Public Function GetProducts() As IQueryable(Of Product)
            Return Me.ObjectContext.Products
        End Function
    
        <RequiresAuthentication()> _
        Public Function GetSalesOrderHeaders() As IQueryable(Of SalesOrderHeader)
            Return Me.ObjectContext.SalesOrderHeaders
        End Function
    End Class
    
    [EnableClientAccess()]
    public class AdventureWorksDomainService : LinqToEntitiesDomainService<AdventureWorksLT_DataEntities>
    {
        [RequiresRole("Managers")]
        public IQueryable<Customer> GetCustomers()
        {
            return this.ObjectContext.Customers;
        }
    
        public IQueryable<Product> GetProducts()
        {
            return this.ObjectContext.Products;
        }
    
        [RequiresAuthentication()]
        public IQueryable<SalesOrderHeader> GetSalesOrderHeaders()
        {
            return this.ObjectContext.SalesOrderHeaders;
        }
    }
    

Vous définissez une propriété de profil dans le fichier Web.config. Lorsque vous ajoutez la propriété à la classe User sur le serveur, la propriété correspondante est générée pour le projet client.

Ajouter des propriétés de profil

  1. Dans le projet serveur, ouvrez le fichier Web.config.

  2. Dans l'élément <profile>, ajoutez une propriété de profil nommée DefaultRows. La propriété contiendra la préférence de l'utilisateur sur le nombre de lignes à afficher.

    L'exemple suivant illustre la section profil du fichier Web.config.

    <profile>
      <properties>
        <add name="FriendlyName" />
        <add type="System.Int32" defaultValue="10" name="DefaultRows"/>
      </properties>
    </profile>
    
  3. Enregistrez le fichier Web.config.

  4. Dans le projet serveur, développez le dossier Models.

  5. Ouvrez le fichier User.cs ou User.vb et ajoutez une propriété nommée DefaultRows.

    Imports System.ServiceModel.DomainServices.Server.ApplicationServices
    Imports System.Runtime.Serialization
    Namespace Web
        Partial Public Class User
            Inherits UserBase
    
            Public Property FriendlyName As String
    
            Public Property DefaultRows As Integer
    
        End Class
    End Namespace
    
    namespace ExampleBusinessApplication.Web
    {
        using System.Runtime.Serialization;
        using System.ServiceModel.DomainServices.Server.ApplicationServices;
    
        public partial class User : UserBase
        {
            public string FriendlyName { get; set; }
    
            public int DefaultRows { get; set; }
        }
    }
    

Utilisation du service d'authentification à partir du client

Avant d'appeler une opération de domaine avec des autorisations limitées, vous devez vérifier que l'utilisateur possède les informations d'identification requises ; sinon, une exception est levée. Dans la section suivante, vous allez vérifier les informations d'identification de l'utilisateur et remplir un à trois contrôles DataGrid en fonction des informations d'identification de l'utilisateur. Vous récupérerez également le nombre d'enregistrements en fonction d'une propriété dans le profil utilisateur. Une valeur par défaut de 10 est utilisée pour les utilisateurs non authentifiés. Cette section n'inclut pas un moyen pour que les utilisateurs puissent définir la propriété de profil DefaultRows, mais vous pourrez l'ajouter dans une section ultérieure.

Ajouter une Page Silverlight pour l'affichage de données

  1. Dans le projet client, ajoutez un nouvel élément au dossier Views.

  2. Sélectionnez le modèle Page Silverlight et nommez la nouvelle page Reports.xaml.

  3. Ouvrez le dossier MainPage.xaml et ajoutez un lien pour la page Reports en ajoutant le XAML suivant après le HyperlinkButton nommé Link2 qui renvoie à la page À propos de.

    <Rectangle x:Name="Divider2" Style="{StaticResource DividerStyle}"/>
    
    <HyperlinkButton x:Name="Link3" Style="{StaticResource LinkStyle}" 
           NavigateUri="/Reports" TargetName="ContentFrame" Content="{Binding Path=ApplicationStrings.ReportsPageTitle, Source={StaticResource ResourceWrapper}}"/>
    
  4. Dans le dossier Assets\Resources, ouvrez le fichier ApplicationStrings.resx.

  5. Ajoutez une ressource de type chaîne nommée ReportsPageTitle avec la valeur Reports.

    RIA_AddReportResource

  6. Enregistrez et fermez le fichier ApplicationStrings.resx.

  7. Ouvrez le fichier Reports.xaml et ajoutez le XAML suivant à l'élément Grid pour qu'il corresponde à la mise en forme des autres pages du site.

    <ScrollViewer x:Name="PageScrollViewer" Style="{StaticResource PageScrollViewerStyle}">
        <StackPanel x:Name="ContentStackPanel" Style="{StaticResource ContentStackPanelStyle}">
            <TextBlock x:Name="HeaderText" Style="{StaticResource HeaderTextStyle}"
                       Text="{Binding Path=ApplicationStrings.ReportsPageTitle, Source={StaticResource ResourceWrapper}}"/>
            <TextBlock x:Name="ContentText" Style="{StaticResource ContentTextStyle}"
                       Text="Display reports based on user permissions"/>
    
        </StackPanel>
    </ScrollViewer>
    
  8. Faites glisser trois contrôles DataGrid depuis la Boîte à outils, juste avant la balise de fin du panneau d'empilement nommé ContentStackPanel.

    Lorsque vous faites glisser les contrôles DataGrid depuis la Boîte à outils, une référence à l'assembly System.Windows.Controls.Data est ajoutée au projet et un préfixe pour l'espace de noms System.Windows.Controls est ajouté à la page.

  9. Nommez les contrôles DataGridProductsGrid, SalesOrdersGrid et CustomersGrid.

  10. Pour chaque contrôle DataGrid, affectez à la propriété Margin la valeur 5.

    L'exemple suivant montre le fichier Reports.xaml complet.

    <navigation:Page x:Class="ExampleBusinessApplication.Views.Reports"
               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"
               xmlns:data="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data"
               mc:Ignorable="d"
               xmlns:navigation="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Navigation"
               d:DesignWidth="640" d:DesignHeight="480"
               Title="Reports Page" >
        <Grid x:Name="LayoutRoot">
            <ScrollViewer x:Name="PageScrollViewer" Style="{StaticResource PageScrollViewerStyle}">
                <StackPanel x:Name="ContentStackPanel" Style="{StaticResource ContentStackPanelStyle}">
                    <TextBlock x:Name="HeaderText" Style="{StaticResource HeaderTextStyle}"
                               Text="{Binding Path=ApplicationStrings.ReportsPageTitle, Source={StaticResource ResourceWrapper}}"/>
                    <TextBlock x:Name="ContentText" Style="{StaticResource ContentTextStyle}"
                               Text="Display reports based on user permissions"/>
                    <data:DataGrid Name="ProductsGrid" Margin="5" />
                    <data:DataGrid Name="SalesOrdersGrid" Margin="5" />
                    <data:DataGrid Name="CustomersGrid" Margin="5" />
                </StackPanel>
            </ScrollViewer>
        </Grid>
    </navigation:Page>
    
  11. Ouvrez le fichier Reports.xaml.cs ou Reports.xaml.vb.

  12. Pour C#, ajoutez des instructions using pour les espaces de noms System.ServiceModel.DomainServices.Client, System.ServiceModel.DomainServices.Client.ApplicationServices et ExampleBusinessApplication.Web. Pour Visual Basic, ajoutez des instructions Imports pour les espaces de noms System.ServiceModel.DomainServices.Client, System.ServiceModel.DomainServices.Client.ApplicationServices, System.Windows.Controls et ExampleBusinessApplication.Web.

  13. Créez une instance du contexte nommé AdventureWorksDomainContext et créez une variable nommée numberOfRows qui contient le nombre de lignes à récupérer.

    Private context As New AdventureWorksDomainContext
    Private numberOfRows As Integer = 10
    
    private AdventureWorksDomainContext context = new AdventureWorksDomainContext();
    int numberOfRows = 10;
    
  14. Ajoutez une méthode nommée LoadRestrictedReports qui appelle la méthode GetSalesOrderHeaderQuery et la méthode GetCustomersQuery, si l'utilisateur appartient au rôle Managers, et qui remplit les grilles de données correspondantes avec les résultats.

    Si vous appelez une opération de domaine alors que l'utilisateur ne possède pas les informations d'identification requises, l'opération de domaine retourne une exception. Vous pouvez éviter cette situation en vérifiant les informations d'identification avant d'appeler l'opération de domaine.

    Private Sub LoadRestrictedReports()
        Dim loadSales = context.Load(context.GetSalesOrderHeadersQuery().Take(numberOfRows))
        SalesOrdersGrid.ItemsSource = loadSales.Entities
        SalesOrdersGrid.Visibility = System.Windows.Visibility.Visible
    
        If (WebContext.Current.User.IsInRole("Managers")) Then
            Dim loadCustomers = context.Load(context.GetCustomersQuery().Take(numberOfRows))
            CustomersGrid.ItemsSource = loadCustomers.Entities
            CustomersGrid.Visibility = System.Windows.Visibility.Visible
        Else
            CustomersGrid.Visibility = System.Windows.Visibility.Collapsed
        End If
    End Sub
    
    private void LoadRestrictedReports()
    {
        LoadOperation<SalesOrderHeader> loadSales = context.Load(context.GetSalesOrderHeadersQuery().Take(numberOfRows));
        SalesOrdersGrid.ItemsSource = loadSales.Entities;
        SalesOrdersGrid.Visibility = System.Windows.Visibility.Visible;
    
        if (WebContext.Current.User.IsInRole("Managers"))
        {
            LoadOperation<Customer> loadCustomers = context.Load(context.GetCustomersQuery().Take(numberOfRows));
            CustomersGrid.ItemsSource = loadCustomers.Entities;
            CustomersGrid.Visibility = System.Windows.Visibility.Visible;
        }
        else
        {
            CustomersGrid.Visibility = System.Windows.Visibility.Collapsed;
        }
    }
    
  15. Ajoutez une méthode nommée LoadReports qui vérifie si l'utilisateur est authentifié et, si c'est le cas, appelle la méthode LoadRestrictedReports. Elle récupère également la propriété de profil nommée DefaultRows et ajoute un gestionnaire d'événements pour l'événement PropertyChanged sur l'objet User. Enfin, elle appelle la méthode GetProductsQuery pour tous les utilisateurs.

    Private Sub LoadReports()
        If (WebContext.Current.User.IsAuthenticated) Then
            numberOfRows = WebContext.Current.User.DefaultRows
            AddHandler WebContext.Current.User.PropertyChanged, AddressOf User_PropertyChanged
            LoadRestrictedReports()
        Else
            CustomersGrid.Visibility = System.Windows.Visibility.Collapsed
            SalesOrdersGrid.Visibility = System.Windows.Visibility.Collapsed
        End If
    
        Dim loadProducts = context.Load(context.GetProductsQuery().Take(numberOfRows))
        ProductsGrid.ItemsSource = loadProducts.Entities
    End Sub
    
    private void LoadReports()
    {
        if (WebContext.Current.User.IsAuthenticated)
        {
            numberOfRows = WebContext.Current.User.DefaultRows;
            WebContext.Current.User.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(User_PropertyChanged);
            LoadRestrictedReports();
        }
        else
        {
            CustomersGrid.Visibility = System.Windows.Visibility.Collapsed;
            SalesOrdersGrid.Visibility = System.Windows.Visibility.Collapsed;
        }
    
        LoadOperation<Product> loadProducts = context.Load(context.GetProductsQuery().Take(numberOfRows));
        ProductsGrid.ItemsSource = loadProducts.Entities;
    }
    
  16. Ajoutez un gestionnaire d'événements pour l'événement PropertyChanged qui appelle LoadReports si la propriété DefaultRows a été modifiée.

    Private Sub User_PropertyChanged(ByVal sender As Object, ByVal e As System.ComponentModel.PropertyChangedEventArgs)
        If (e.PropertyName = "DefaultRows") Then
            LoadReports()
        End If
    End Sub
    
    void User_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
    {
        if (e.PropertyName == "DefaultRows")
        {
            LoadReports();
        }
    }
    
  17. Ajoutez les gestionnaires d'événements pour les événements LoggedIn et LoggedOut qui chargent ou masquent des données selon les modifications apportées aux informations d'identification utilisées pour l'authentification de l'utilisateur.

    Private Sub Authentication_LoggedIn(ByVal sender As Object, ByVal e As ApplicationServices.AuthenticationEventArgs)
        LoadReports()
    End Sub
    
    Private Sub Authentication_LoggedOut(ByVal sender As Object, ByVal e As ApplicationServices.AuthenticationEventArgs)
        CustomersGrid.Visibility = System.Windows.Visibility.Collapsed
        SalesOrdersGrid.Visibility = System.Windows.Visibility.Collapsed
    End Sub
    
    void Authentication_LoggedIn(object sender, AuthenticationEventArgs e)
    {
        LoadReports();
    }
    
    void Authentication_LoggedOut(object sender, AuthenticationEventArgs e)
    {
        CustomersGrid.Visibility = System.Windows.Visibility.Collapsed;
        SalesOrdersGrid.Visibility = System.Windows.Visibility.Collapsed;
    }
    
  18. Ajoutez le code suivant au constructeur. Ce code charge les gestionnaires et appelle LoadReports.

    Public Sub New()
        InitializeComponent()
    
        Me.Title = ApplicationStrings.ReportsPageTitle
    
        AddHandler WebContext.Current.Authentication.LoggedIn, AddressOf Authentication_LoggedIn
        AddHandler WebContext.Current.Authentication.LoggedOut, AddressOf Authentication_LoggedOut
    
        LoadReports()
    End Sub
    
    public Reports()
    {
        InitializeComponent();
    
        this.Title = ApplicationStrings.ReportsPageTitle;
    
        WebContext.Current.Authentication.LoggedIn += new System.EventHandler<AuthenticationEventArgs>(Authentication_LoggedIn);
        WebContext.Current.Authentication.LoggedOut += new System.EventHandler<AuthenticationEventArgs>(Authentication_LoggedOut);
    
        LoadReports();
    }
    

    Le fichier de code complet est illustré ci-dessous.

    Imports System.Windows.Navigation
    Imports System.Windows.Controls
    Imports System.ServiceModel.DomainServices.Client
    Imports System.ServiceModel.DomainServices.Client.ApplicationServices
    Imports ExampleBusinessApplication.Web
    
    Partial Public Class Reports
        Inherits Page
    
        Private context As New AdventureWorksDomainContext
        Private numberOfRows As Integer = 10
    
        Public Sub New()
            InitializeComponent()
    
            Me.Title = ApplicationStrings.ReportsPageTitle
    
            AddHandler WebContext.Current.Authentication.LoggedIn, AddressOf Authentication_LoggedIn
            AddHandler WebContext.Current.Authentication.LoggedOut, AddressOf Authentication_LoggedOut
    
            LoadReports()
        End Sub
    
        Private Sub LoadReports()
            If (WebContext.Current.User.IsAuthenticated) Then
                numberOfRows = WebContext.Current.User.DefaultRows
                AddHandler WebContext.Current.User.PropertyChanged, AddressOf User_PropertyChanged
                LoadRestrictedReports()
            Else
                CustomersGrid.Visibility = System.Windows.Visibility.Collapsed
                SalesOrdersGrid.Visibility = System.Windows.Visibility.Collapsed
            End If
    
            Dim loadProducts = context.Load(context.GetProductsQuery().Take(numberOfRows))
            ProductsGrid.ItemsSource = loadProducts.Entities
        End Sub
    
        Private Sub LoadRestrictedReports()
            Dim loadSales = context.Load(context.GetSalesOrderHeadersQuery().Take(numberOfRows))
            SalesOrdersGrid.ItemsSource = loadSales.Entities
            SalesOrdersGrid.Visibility = System.Windows.Visibility.Visible
    
            If (WebContext.Current.User.IsInRole("Managers")) Then
                Dim loadCustomers = context.Load(context.GetCustomersQuery().Take(numberOfRows))
                CustomersGrid.ItemsSource = loadCustomers.Entities
                CustomersGrid.Visibility = System.Windows.Visibility.Visible
            Else
                CustomersGrid.Visibility = System.Windows.Visibility.Collapsed
            End If
        End Sub
    
        Private Sub User_PropertyChanged(ByVal sender As Object, ByVal e As System.ComponentModel.PropertyChangedEventArgs)
            If (e.PropertyName = "DefaultRows") Then
                LoadReports()
            End If
        End Sub
    
        Private Sub Authentication_LoggedIn(ByVal sender As Object, ByVal e As ApplicationServices.AuthenticationEventArgs)
            LoadReports()
        End Sub
    
        Private Sub Authentication_LoggedOut(ByVal sender As Object, ByVal e As ApplicationServices.AuthenticationEventArgs)
            CustomersGrid.Visibility = System.Windows.Visibility.Collapsed
            SalesOrdersGrid.Visibility = System.Windows.Visibility.Collapsed
        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 System.Windows.Navigation;
    using System.ServiceModel.DomainServices.Client;
    using System.ServiceModel.DomainServices.Client.ApplicationServices;
    using ExampleBusinessApplication.Web;
    
    namespace ExampleBusinessApplication.Views
    {
        public partial class Reports : Page
        {
            private AdventureWorksDomainContext context = new AdventureWorksDomainContext();
            int numberOfRows = 10;
    
            public Reports()
            {
                InitializeComponent();
    
                this.Title = ApplicationStrings.ReportsPageTitle;
    
                WebContext.Current.Authentication.LoggedIn += new System.EventHandler<AuthenticationEventArgs>(Authentication_LoggedIn);
                WebContext.Current.Authentication.LoggedOut += new System.EventHandler<AuthenticationEventArgs>(Authentication_LoggedOut);
    
                LoadReports();
            }
    
            private void LoadReports()
            {
                if (WebContext.Current.User.IsAuthenticated)
                {
                    numberOfRows = WebContext.Current.User.DefaultRows;
                    WebContext.Current.User.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(User_PropertyChanged);
                    LoadRestrictedReports();
                }
                else
                {
                    CustomersGrid.Visibility = System.Windows.Visibility.Collapsed;
                    SalesOrdersGrid.Visibility = System.Windows.Visibility.Collapsed;
                }
    
                LoadOperation<Product> loadProducts = context.Load(context.GetProductsQuery().Take(numberOfRows));
                ProductsGrid.ItemsSource = loadProducts.Entities;
            }
    
            private void LoadRestrictedReports()
            {
                LoadOperation<SalesOrderHeader> loadSales = context.Load(context.GetSalesOrderHeadersQuery().Take(numberOfRows));
                SalesOrdersGrid.ItemsSource = loadSales.Entities;
                SalesOrdersGrid.Visibility = System.Windows.Visibility.Visible;
    
                if (WebContext.Current.User.IsInRole("Managers"))
                {
                    LoadOperation<Customer> loadCustomers = context.Load(context.GetCustomersQuery().Take(numberOfRows));
                    CustomersGrid.ItemsSource = loadCustomers.Entities;
                    CustomersGrid.Visibility = System.Windows.Visibility.Visible;
                }
                else
                {
                    CustomersGrid.Visibility = System.Windows.Visibility.Collapsed;
                }
            }
    
            void Authentication_LoggedIn(object sender, AuthenticationEventArgs e)
            {
                LoadReports();
            }
    
            void Authentication_LoggedOut(object sender, AuthenticationEventArgs e)
            {
                CustomersGrid.Visibility = System.Windows.Visibility.Collapsed;
                SalesOrdersGrid.Visibility = System.Windows.Visibility.Collapsed;
            }
    
            void User_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
            {
                if (e.PropertyName == "DefaultRows")
                {
                    LoadReports();
                }
            }
        }
    }
    
  19. Exécutez la solution.

  20. Cliquez sur le lien Reports.

    Remarquez que quand vous n'êtes pas connecté, seule la table des produits est affichée sur la page Reports.

  21. Cliquez sur le lien Connexion et connectez-vous en tant que SalesUser.

    Remarquez que les tables des produits et des commandes client sont affichées.

    RIA_DisplayReports

  22. Déconnectez-vous et connectez-vous en tant que CustomerManager.

    Remarquez que les tables des produits, des commandes client et des clients sont affichées.

  23. Fermez le navigateur Web.

Vous pouvez permettre aux utilisateurs de modifier la propriété de profil DefaultRows en ajoutant une fenêtre enfant. Lorsque la valeur est modifiée, vous appelez la méthode SaveUser pour enregistrer la valeur dans la source de données. Vous récupérez la valeur actuelle via les propriétés de l'objet User de l'instance actuelle WebContext.

Ajouter une fenêtre pour la définition de propriété de profil

  1. Dans le projet client, ajoutez un nouvel élément au dossier Views.

  2. Sélectionnez le modèle Fenêtre enfant Silverlight et nommez le fenêtre enfant ProfileWindow.xaml.

    Ajouter une fenêtre enfant

  3. Cliquez sur le bouton Ajouter.

  4. Dans le dossier ProfileWindow.xaml, ajoutez le XAML suivant après l'élément Grid.RowDefinitions pour inclure une ComboBox de sélection du nombre de lignes à afficher dans les rapports.

    <StackPanel Orientation="Horizontal" Grid.Row="0">
        <TextBlock Text="Number of rows to display for reports: "></TextBlock>
        <ComboBox x:Name="defaultRows" Height="20" VerticalAlignment="Top">
            <ComboBoxItem Content="1"></ComboBoxItem>
            <ComboBoxItem Content="2"></ComboBoxItem>
            <ComboBoxItem Content="3"></ComboBoxItem>
            <ComboBoxItem Content="4"></ComboBoxItem>
            <ComboBoxItem Content="5"></ComboBoxItem>
            <ComboBoxItem Content="6"></ComboBoxItem>
            <ComboBoxItem Content="7"></ComboBoxItem>
            <ComboBoxItem Content="8"></ComboBoxItem>
            <ComboBoxItem Content="9"></ComboBoxItem>
            <ComboBoxItem Content="10"></ComboBoxItem>
            <ComboBoxItem Content="15"></ComboBoxItem>
            <ComboBoxItem Content="20"></ComboBoxItem>
        </ComboBox>
    </StackPanel>
    
  5. Affectez à la propriété Title de ChildWindow la valeur Select Preferences.

  6. Dans le fichier ProfileWindow.xaml.cs ou ProfileWindow.xaml.vb, ajoutez le code suivant pour récupérer et définir la propriété de profil.

    Imports System.Windows.Controls
    Imports System.Windows
    
    Partial Public Class ProfileWindow
        Inherits ChildWindow
    
        Public Sub New()
            InitializeComponent()
    
            Dim userDefaultRows = WebContext.Current.User.DefaultRows.ToString()
            For Each cbi As ComboBoxItem In defaultRows.Items
                If (cbi.Content.ToString() = userDefaultRows) Then
                    defaultRows.SelectedItem = cbi
                    Exit For
                End If
            Next
        End Sub
    
        Private Sub OKButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs) Handles OKButton.Click
            Dim newSelection = Integer.Parse(defaultRows.SelectionBoxItem.ToString())
            If (newSelection <> WebContext.Current.User.DefaultRows) Then
                WebContext.Current.User.DefaultRows = newSelection
                WebContext.Current.Authentication.SaveUser(True)
            End If
            Me.DialogResult = True
        End Sub
    
        Private Sub CancelButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs) Handles CancelButton.Click
            Me.DialogResult = False
        End Sub
    
    End Class
    
    public partial class ProfileWindow : ChildWindow
    {
        public ProfileWindow()
        {
            InitializeComponent();
    
            string userDefaultRows = WebContext.Current.User.DefaultRows.ToString();
            foreach (ComboBoxItem cbi in defaultRows.Items)
            {
                if (cbi.Content.ToString() == userDefaultRows)
                {
                    defaultRows.SelectedItem = cbi;
                    break;
                }
            }
        }
    
        private void OKButton_Click(object sender, RoutedEventArgs e)
        {
            int newSelection = int.Parse(defaultRows.SelectionBoxItem.ToString());
            if (newSelection != WebContext.Current.User.DefaultRows)
            {
                WebContext.Current.User.DefaultRows = newSelection;
                WebContext.Current.Authentication.SaveUser(true);
            }
            this.DialogResult = true;
        }
    
        private void CancelButton_Click(object sender, RoutedEventArgs e)
        {
            this.DialogResult = false;
        }
    }
    
  7. Pour Visual Basic, ajoutez des instructions Imports pour les espaces de noms System.Windows.Controls et System.Windows.

  8. Développez le dossier Views\Login et ouvrez le fichier LoginStatus.xaml.

  9. Pour ajouter un lien Paramètres à la fenêtre de profil, ajoutez le XAML suivant avant le bouton de déconnexion.

    <Button x:Name="SettingsButton" Click="SettingsButton_Click" Content="settings" Style="{StaticResource LoginRegisterLinkStyle}" Margin="0,0,0,0"></Button>
    <TextBlock Text="  |  " Style="{StaticResource SpacerStyle}"/>
    
  10. Dans le fichier LoginStatus.xaml.cs ou LoginStatus.xaml.vb, ajoutez le gestionnaire d'événements de type clic suivant pour le lien Paramètres.

    Private Sub SettingsButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
        Dim settingsWindow As New ProfileWindow
        settingsWindow.Show()
    End Sub
    
    private void SettingsButton_Click(object sender, RoutedEventArgs e)
    {
        ExampleBusinessApplication.Views.ProfileWindow settingsWindow = new ExampleBusinessApplication.Views.ProfileWindow();
        settingsWindow.Show();
    }
    
  11. Exécutez la solution.

  12. Connectez-vous en tant que CustomerManager ou SalesUser et remarquez que la barre d'état de connexion inclut maintenant un lien pour les paramètres.

    RIA_NewLoginStatusBar

  13. Cliquez sur le lien Paramètres et définissez le nombre par défaut de lignes à afficher dans les rapports.

    RIA_ShowProfileSettings

  14. Ouvrez la page Reports et notez que le DataGrid contient maintenant le nombre de lignes que vous avez sélectionné.