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

Article
03/11/2011

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

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

La boîte de dialogue Nouveau projet s'affiche.
Sélectionnez le type de projet Silverlight.
Sélectionnez le modèle Application métier Silverlight et nommez l'application ExampleBusinessApplication.
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.
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.
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.
Sélectionnez l'onglet Sécurité dans l'outil Administration de Site Web ASP.NET.
Dans la section Rôles, cliquez sur le lien Créer ou gérer des rôles.
Ajoutez un nouveau rôle nommé Managers et sélectionnez le bouton Ajouter le rôle.
Dans l'angle inférieur droit, cliquez sur le bouton Retour.
Dans la section Utilisateurs, cliquez sur le lien Créer un utilisateur.
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é
Cliquez sur le bouton Créer un utilisateur.
Fermez l'outil Administration de site Web ASP.NET.
Exécutez la solution.

La page d'accueil de l'application s'affiche dans un navigateur Web.
Dans l'angle supérieur droit de la page, cliquez sur le lien Connexion.

La boîte de dialogue Connexion s'affiche.
Entrez CustomerManager comme nom d'utilisateur et P@ssword comme mot de passe et cliquez sur le bouton OK.

Vous êtes maintenant connecté en tant que cet utilisateur. Remarquez le texte « Bienvenue, CustomerManager » dans l'angle supérieur droit.
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.
Cliquez à nouveau sur le lien Connexion.
Dans la boîte de dialogue Connexion, cliquez sur le lien S'inscrire maintenant.

Le formulaire d'inscription s'affiche.
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
Cliquez sur OK pour créer le nouvel utilisateur.

Remarquez que vous êtes maintenant connecté en tant que SalesUser.
Fermez le navigateur.
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.
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.
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.
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

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.
Dans la boîte de dialogue Ajouter un élément existant, ajoutez l'exemple de base de données AdventureWorksLT.
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.
Donnez au modèle le nom AdventureWorksModel.edmx, puis cliquez sur Ajouter.

L'Assistant EDM s'affiche.
Sélectionnez l'option Générer à partir de la base de données, puis cliquez sur Suivant.
Sélectionnez la base de données AdventureWorksLT, puis cliquez sur Suivant.
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.
Générez la solution.
Dans le projet serveur, ajoutez un nouvel élément et sélectionnez le modèle Classe DomainService parmi les modèles Web.
Nommez le service de domaine AdventureWorksDomainService, puis cliquez sur Ajouter.
Dans la boîte de dialogue Ajouter une nouvelle classe de service de domaine, sélectionnez les entités Customer, Product et SalesOrderHeader.
Cliquez sur OK pour terminer la création du service de domaine.

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;
}

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

Dans le projet serveur, ouvrez le fichier Web.config.
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>
```
Enregistrez le fichier Web.config.
Dans le projet serveur, développez le dossier Models.

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

Dans le projet client, ajoutez un nouvel élément au dossier Views.
Sélectionnez le modèle Page Silverlight et nommez la nouvelle page Reports.xaml.

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}}"/>

Dans le dossier Assets\Resources, ouvrez le fichier ApplicationStrings.resx.
Ajoutez une ressource de type chaîne nommée ReportsPageTitle avec la valeur Reports.
Enregistrez et fermez le fichier ApplicationStrings.resx.

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>

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.
Nommez les contrôles DataGridProductsGrid, SalesOrdersGrid et CustomersGrid.

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>

Ouvrez le fichier Reports.xaml.cs ou Reports.xaml.vb.
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.

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;

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;
    }
}

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;
}

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();
    }
}

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;
}

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();
            }
        }
    }
}

Exécutez la solution.
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.
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.
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.
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

Dans le projet client, ajoutez un nouvel élément au dossier Views.
Sélectionnez le modèle Fenêtre enfant Silverlight et nommez le fenêtre enfant ProfileWindow.xaml.
Cliquez sur le bouton Ajouter.

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>

Affectez à la propriété Title de ChildWindow la valeur Select Preferences.

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;
    }
}

Pour Visual Basic, ajoutez des instructions Imports pour les espaces de noms System.Windows.Controls et System.Windows.
Développez le dossier Views\Login et ouvrez le fichier LoginStatus.xaml.

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}"/>

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();
}

Exécutez la solution.
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.
Cliquez sur le lien Paramètres et définissez le nombre par défaut de lignes à afficher dans les rapports.
Ouvrez la page Reports et notez que le DataGrid contient maintenant le nombre de lignes que vous avez sélectionné.

Partager via