Procedura dettagliata: utilizzo del servizio di autenticazione con l'applicazione aziendale di Silverlight

Articolo
03/11/2011

Il modello Applicazione aziendale di Silverlight consente di creare una soluzione che automaticamente abilita l'autenticazione (con la modalità Autenticazione basata su form), i ruoli e i profili. La soluzione include moduli dati per l'accesso degli utenti esistenti e la registrazione dei nuovi utenti. È possibile utilizzare queste funzionalità senza scrivere un codice aggiuntivo. È possibile personalizzare la soluzione definendo i ruoli e le proprietà del profilo.

In questa procedura dettagliata verrà illustrato come si utilizzano l'autenticazione, i ruoli e i profili in un'applicazione aziendale di Silverlight. Si limiterà l'accesso a determinate operazioni di dominio in base alle credenziali dell'utente e si personalizzerà l'interfaccia utente in base alle preferenze dell'utente. Si utilizzerà lo strumento Amministrazione sito Web di ASP.NET per la gestione di ruoli e utenti nel sito.

Prerequisiti

Per l'esecuzione di questa e di altre procedure dettagliate descritte nella documentazione di RIA Services è necessario che siano installati e configurati correttamente alcuni programmi prerequisiti quali Visual Studio 2010 e Silverlight Developer Runtime e SDK, oltre a WCF RIA Services e a WCF RIA Services Toolkit. È inoltre richiesta l'installazione e la configurazione di SQL Server 2008 R2 Express with Advanced Services e l'installazione del database AdventureWorks OLTP e LT.

Le istruzioni dettagliate per soddisfare tali prerequisiti vengono fornite negli argomenti all'interno del nodo Prerequisiti per WCF RIA Services. Seguire tali istruzioni prima di continuare con questa procedura dettagliata in modo da assicurarsi che si verifichi il minor numero possibile di problemi durante l'esecuzione della procedura dettagliata di RIA Services .

Creazione di utenti e ruoli

È possibile utilizzare le funzionalità fornite in un'applicazione aziendale di Silverlight per implementare rapidamente l'autenticazione. Nella sezione seguente, si utilizzerà lo strumento di configurazione ASP.NET per creare un utente e un ruolo, quindi accedere come quell'utente. Si registrerà un nuovo utente tramite il modulo di registrazione fornito nell'applicazione aziendale di Silverlight.

Per creare sito, ruoli e utenti

In Visual Studio 2010, selezionare File, Nuovo e quindi Progetto.

Viene visualizzata la finestra di dialogo Nuovo progetto.
Selezionare il tipo di progetto Silverlight.
Selezionare il modello Applicazione aziendale di Silverlight e denominare l'applicazione ExampleBusinessApplication.
Fare clic su OK.

Notare la struttura del progetto creata. Il progetto client Silverlight include pagine Silverlight nella cartella Views. Queste pagine abilitano l'accesso degli utenti e la registrazione di nuovi utenti.
Per aprire lo strumento Amministrazione sito Web di ASP.NET, selezionare il progetto server (ExampleBusinessApplication.Web) in Esplora soluzioni, quindi aprire lo strumento Configurazione di ASP.NET.
Scegliere Configurazione di ASP.NET dal menu Progetto.

Se l'opzione Configurazione di ASP.NET non è presente nel menu Progetto, è possibile che sia stato selezionato il progetto client.
Selezionare la scheda Sicurezza nello strumento Amministrazione sito Web di ASP.NET.
Nella sezione Ruoli, fare clic sul collegamento Crea o gestisci ruoli.
Aggiungere un nuovo ruolo denominato Managers e selezionare il pulsante Aggiungi ruolo.
Nell'angolo inferiore destro, fare clic sul pulsante Indietro.
Nella sezione Utenti, fare clic sul collegamento Crea utente.
Creare un nuovo utente con i valori seguenti e selezionare la casella di controllo del ruolo Managers.

Nome utente: CustomerManager

Password: P@ssword

Posta elettronica: prova@example.com

Domanda di sicurezza: colore preferito?

Risposta di sicurezza: blu

Ruolo Managers: selezionato
Fare clic sul pulsante Crea utente.
Chiudere lo Strumento di amministrazione sito Web di ASP.NET.
Eseguire la soluzione.

Viene visualizzata la home page dell'applicazione in un Web browser.
Fare clic sul collegamento Accedi nell'angolo in alto a destra della pagina.

Viene visualizzata la finestra di dialogo Accedi.
Immettere CustomerManager per il nome utente e P@ssword per la password, quindi fare clic sul pulsante OK.

Viene eseguito l'accesso come l'utente specificato. Notare il testo "CustomerManager" nell'angolo superiore destro.
Fare clic sul collegamento di disconnessione.

Non si è più collegati come CustomerManager. Nei passaggi seguenti, si creerà un nuovo utente tramite il modulo di registrazione.
Fare nuovamente clic sul collegamento Accedi.
Nella finestra di dialogo Accedi fare clic sul collegamento Registra ora.

Viene visualizzato il modulo di registrazione.
Compilare il modulo di registrazione per creare un nuovo account utente. Utilizzare i valori seguenti per il nuovo utente.

Nome utente: SalesUser

Nome descrittivo: SalesUser

Posta elettronica: prova@example.com

Password: P@ssword

Domanda di sicurezza: specificare il colore della tua prima auto

Risposta di sicurezza: verde
Fare clic su OK per creare il nuovo utente.

Notare che l'accesso è stato eseguito come SalesUser.
Chiudere il browser.
Aprire di nuovo lo strumento Amministrazione sito Web di ASP.NET e fare clic sulla scheda Sicurezza.

Notare che esistono 2 utenti ora nel sito e esistono 2 ruoli anche se è stato creato un solo ruolo.
Fare clic su Crea o gestisci ruoli e notare i ruoli Managers e Registered Users.

Il ruolo Registered Users è stato creato automaticamente dal modello Applicazione aziendale.
Per Registered Users, fare clic sul collegamento Gestisci.

Si noti che l'utente denominato SalesUser aggiunto tramite l'applicazione è nel ruolo Registered Users.
Chiudere lo Strumento di amministrazione sito Web di ASP.NET.

Definizione dell'accesso e delle proprietà del profilo

È possibile limitare l'accesso a un'operazione di dominio applicando l'attributo RequiresAuthenticationAttribute oppure RequiresRoleAttribute all'operazione di dominio. Le operazioni di dominio senza un attributo sono disponibili a tutti gli utenti. L'applicazione di un attributo a un'operazione di dominio non impedisce all'utente di chiamare l'operazione di dominio stessa; tuttavia, gli utenti privi delle credenziali necessarie riceveranno un'eccezione.

Limitare i dati visualizzati in base ai ruoli

In Esplora soluzioni fare clic con il pulsante destro del mouse sulla cartella App_Data nel progetto server, scegliere Aggiungi e quindi Elemento esistente.
Nella finestra di dialogo Aggiungi elemento esistente, aggiungere il database di esempio AdventureWorksLT.
Nel progetto server aggiungere un nuovo elemento e selezionare il modello ADO.NET Entity Data Model dai modelli Dati.
Denominare il modello AdventureWorksModel.edmx, quindi fare clic su Aggiungi.

Viene visualizzata la procedura guidata Entity Data Model.
Selezionare l'opzione Genera da database, quindi fare clic su Avanti.
Selezionare il database AdventureWorksLT e fare clic su Avanti.
Dall'elenco degli oggetti di database, selezionare le tabelle Customer, Product e SalesOrderHeader, quindi fare clic su Fine.

Il modello Entity Data Model verrà visualizzato nella finestra di progettazione.
Compilare la soluzione.
Aggiungere un nuovo elemento al progetto server e selezionare il modello Classe di servizio del dominio dai modelli Web.
Denominare il servizio del dominio AdventureWorksDomainService, quindi fare clic su Aggiungi.
Nella finestra di dialogo Aggiungi una nuova classe di servizio del dominio, selezionare le entità Customer, Product e SalesOrderHeader.
Fare clic su OK per finalizzare la creazione del servizio del dominio.

Nel file di classe AdventureWorksDomainService, aggiungere l'attributo RequiresAuthenticationAttribute al metodo GetSalesOrderHeader.

<RequiresAuthentication()> _
Public Function GetSalesOrderHeaders() As IQueryable(Of SalesOrderHeader)
    Return Me.ObjectContext.SalesOrderHeaders
End Function

[RequiresAuthentication()]
public IQueryable<SalesOrderHeader> GetSalesOrderHeaders()
{
    return this.ObjectContext.SalesOrderHeaders;
}

Aggiungere l'attributo RequiresRoleAttribute al metodo GetCustomers e denominare il ruolo richiesto "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'operazione di dominio GetProducts è disponibile a qualsiasi utente, GetSalesOrderHeaders è disponibile agli utenti autenticati e GetCustomers è disponibile solo agli utenti nel ruolo Managers.

Nell'esempio riportato di seguito viene illustrato il servizio del dominio completo.

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

La proprietà del profilo viene definita nel file Web.config. Quando si aggiunge la proprietà alla classe User sul server, viene generata la proprietà corrispondente per il progetto client.

Aggiungere proprietà profilo

Aprire il file Web.config nel progetto server.
Nell'elemento <profile>, aggiungere una proprietà del profilo denominata DefaultRows. La proprietà conterrà la preferenza dell'utente per il numero di righe da visualizzare.

Di seguito viene illustrata la sezione del profilo del file Web.config.
```
<profile>
  <properties>
    <add name="FriendlyName" />
    <add type="System.Int32" defaultValue="10" name="DefaultRows"/>
  </properties>
</profile>
```
Salvare il file Web.config.
Nel progetto server, espandere la cartella Models.

Aprire il file User.cs o User.vb e aggiungere una proprietà denominata 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; }
    }
}

Utilizzo del servizio di autenticazione dal client

Prima di chiamare un'operazione di dominio con autorizzazioni limitate, è necessario controllare che l'utente disponga delle credenziali necessarie; in caso contrario, viene generata un'eccezione. Nella seguente sezione, verranno verificate le credenziali dell'utente e verranno popolati i dati da uno a tre controlli DataGrid in base alle credenziali dell'utente. Verrà inoltre recuperato il numero di record in base a una proprietà nel profilo utente. Un valore predefinito di 10 viene utilizzato per gli utenti non autenticati. In questa sezione non è incluso alcun metodo per consentire agli utenti di impostare la proprietà del profilo DefaultRows, ma tale opzione verrà aggiunta in una sezione successiva.

Aggiungere una pagina Silverlight per la visualizzazione dei dati

Nel progetto client aggiungere un nuovo elemento alla cartella Views.
Selezionare il modello Pagina Silverlight e denominare la nuova pagina Reports.xaml.

Aprire il file MainPage.xaml e aggiungere un collegamento alla pagina Reports aggiungendo il seguente codice XAML dopo l'elemento HyperlinkButton denominato Link2 che collega alla pagina Informazioni su.

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

Nella cartella Assets\Resources, aprire il file ApplicationStrings.resx.
Aggiungere una nuova risorsa di tipo stringa denominata ReportsPageTitle con il valore Reports.
Salvare e chiudere il file ApplicationStrings.resx.

Aprire il file Reports.xaml e aggiungere il seguente codice XAML all'elemento Grid per corrispondere alla formattazione delle altre pagine nel sito.

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

Trascinare tre controlli DataGrid dalla casella degli strumenti inserendoli subito prima del tag di fine del pannello Stack denominato ContentStackPanel.

Quando si trascinano i controlli DataGrid dalla casella degli strumenti, viene aggiunto al progetto un riferimento all'assembly System.Windows.Controls.Data e viene aggiunto alla pagina un prefisso per lo spazio dei nomi System.Windows.Controls.
Assegnare ai controlli DataGrid i nomi ProductsGrid, SalesOrdersGrid e CustomersGrid.

Per ogni controllo DataGrid, impostare la proprietà Margin su 5.

Nell'esempio seguente viene illustrato il file Reports.xaml completo.

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

Aprire il file Reports.xaml.cs o Reports.xaml.vb.
Per C#, aggiungere un'istruzione using per gli spazi dei nomi System.ServiceModel.DomainServices.Client, System.ServiceModel.DomainServices.Client.ApplicationServices e ExampleBusinessApplication.Web. Per Visual Basic, aggiungere un'istruzione Imports per gli spazi dei nomi System.ServiceModel.DomainServices.Client, System.ServiceModel.DomainServices.Client.ApplicationServices, System.Windows.Controls e ExampleBusinessApplication.Web.

Creare un'istanza di AdventureWorksDomainContext denominata context, quindi creare una variabile denominata numberOfRows che contiene il numero di righe da recuperare.

Private context As New AdventureWorksDomainContext
Private numberOfRows As Integer = 10

private AdventureWorksDomainContext context = new AdventureWorksDomainContext();
int numberOfRows = 10;

Aggiungere un metodo denominato LoadRestrictedReports che chiama il metodo GetSalesOrderHeaderQuery e il metodo GetCustomersQuery se l'utente appartiene al ruolo Managers e popola le griglie dei dati corrispondenti con i risultati.

Se si chiama un'operazione di dominio quando l'utente non dispone delle credenziali necessarie, l'operazione di dominio restituisce un'eccezione. È possibile evitare questa situazione controllando le credenziali prima di chiamare l'operazione di dominio.

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

Aggiungere un metodo denominato LoadReports che controlla se l'utente è autenticato e, in tal caso, chiama il metodo LoadRestrictedReports. Viene inoltre recuperata la proprietà del profilo denominata DefaultRows e viene aggiunto un gestore eventi per l'evento PropertyChanged sull'oggetto utente. Infine, viene chiamato il metodo GetProductsQuery per tutti gli utenti.

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

Aggiungere un gestore eventi per l'evento PropertyChanged che chiama LoadReports se la proprietà DefaultRows è stata modificata.

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

Aggiungere i gestori eventi per gli eventi LoggedIn e LoggedOut che caricano o nascondono i dati sulla base della modifica nelle credenziali di autenticazione dell'utente.

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

Aggiungere il codice seguente al costruttore. Questo codice carica i gestori e chiama 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();
}

Di seguito viene riportato il file di codice completo.

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

Eseguire la soluzione.
Fare clic sul collegamento Reports.

Notare che quando l'utente non ha effettuato l'accesso, nella pagina Reports viene visualizzata soltanto la tabella dei prodotti.
Fare clic sul collegamento Accedi e accedere come SalesUser.

Notare che vengono visualizzate le tabelle per prodotti e ordini di vendita.
Disconnettersi e riaccedere come CustomerManager.

Notare che vengono visualizzate le tabelle per prodotti, ordini di vendita e clienti.
Chiudere il browser Web.

È possibile consentire agli utenti di modificare la proprietà del profilo DefaultRows aggiungendo una finestra figlio. Quando il valore viene modificato, è possibile chiamare il metodo SaveUser per salvare il valore nell'origine dati. Viene recuperato il valore corrente tramite le proprietà nell'oggetto utente dell'istanza WebContext corrente.

Aggiungere una finestra per l'impostazione della proprietà del profilo

Nel progetto client aggiungere un nuovo elemento alla cartella Views.
Selezionare il modello Finestra secondaria Silverlight e denominare la finestra secondaria ProfileWindow.xaml.
Fare clic sul pulsante Aggiungi.

Nel file ProfileWindow.xaml, aggiungere il seguente codice XAML dopo l'elemento Grid.RowDefinitions per includere un oggetto ComboBox per la selezione del numero di righe da visualizzare nei rapporti.

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

Impostare la proprietà Title dell'oggetto ChildWindow su Select Preferences.

Nel file ProfileWindow.xaml.cs o ProfileWindow.xaml.vb, aggiungere il codice seguente per recuperare e impostare la proprietà del profilo.

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

Per Visual Basic, aggiungere istruzioni Imports per gli spazi dei nomi System.Windows.Controls e System.Windows.
Espandere la cartella Views\Login e aprire il file LoginStatus.xaml.

Per aggiungere un collegamento alle impostazioni nella finestra del profilo, aggiungere il seguente codice XAML prima del pulsante di disconnessione.

<Button x:Name="SettingsButton" Click="SettingsButton_Click" Content="settings" Style="{StaticResource LoginRegisterLinkStyle}" Margin="0,0,0,0"></Button>
<TextBlock Text="  |  " Style="{StaticResource SpacerStyle}"/>

Nel file LoginStatus.xaml.cs o LoginStatus.xaml.vb, aggiungere il gestore eventi clic seguente per il collegamento alle impostazioni.

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

Eseguire la soluzione.
Accedere come CustomerManager o SalesUser e notare che la barra di stato dell'accesso ora include un collegamento per le impostazioni.
Fare clic sul collegamento delle impostazioni e impostare il numero predefinito di righe da visualizzare nei rapporti.
Aprire la pagina Reports e notare che l'elemento DataGrid ora contiene il numero di righe che è stato selezionato.

Condividi tramite