Exemplarische Vorgehensweise: Verwenden des Authentifizierungsdiensts mit der Silverlight-Geschäftsanwendung

Artikel
03/11/2011

Mit der Vorlage "Silverlight-Geschäftsanwendung" erstellen Sie eine Projektmappe, in der Authentifizierung (mit der Formularauthentifizierung für den Authentifizierungsmodus), Rollen und Profile automatisch aktiviert sind. Die Projektmappe enthält Datenformulare für die Anmeldung vorhandener Benutzer und die Registrierung neuer Benutzer. Diese Funktionen können verwendet werden, ohne zusätzlichen Code zu schreiben. Sie können die Projektmappe anpassen, indem Sie Rollen und Profileigenschaften definieren.

In dieser exemplarischen Vorgehensweise erfahren Sie, wie Authentifizierung, Rollen und Profile in einer Silverlight-Geschäftsanwendung verwendet werden. Sie schränken den Zugriff auf bestimmte Domänenvorgänge anhand der Anmeldeinformationen des Benutzers ein und passen die Benutzeroberfläche basierend auf Benutzereinstellungen an. Zum Verwalten von Rollen und Benutzern in der Website wird das ASP.NET-Websiteverwaltungs-Tool verwendet.

Erforderliche Komponenten

Für diese und die anderen exemplarischen Vorgehensweisen in der RIA Services -Dokumentation müssen zusätzlich zu WCF RIA Services und dem WCF RIA Services-Toolkit mehrere erforderliche Programme installiert und korrekt konfiguriert werden, z. B. Visual Studio 2010, die Silverlight Developer-Laufzeit und das Silverlight-SDK. Zudem müssen Sie SQL Server 2008 R2 Express with Advanced Services installieren und konfigurieren und die AdventureWorks OLTP- und LT-Datenbanken installieren.

Ausführliche Anweisungen für jede dieser erforderlichen Komponenten finden Sie in den Themen unter Erforderliche Komponenten für WCF RIA Services. Folgen Sie den Anweisungen in diesen Themen, bevor Sie mit dieser exemplarischen Vorgehensweise fortfahren, um sicherzustellen, dass beim Ausführen der exemplarischen Vorgehensweisen für RIA Services so wenig Probleme wie möglich auftreten.

Erstellen von Benutzern und Rollen

Mithilfe der Funktionen in einer Silverlight-Geschäftsanwendung kann die Authentifizierung schnell implementiert werden. Im folgenden Abschnitt verwenden Sie das ASP.NET-Konfigurationstool, um einen Benutzer und eine Rolle zu erstellen und sich dann als dieser Benutzer anzumelden. Zudem registrieren Sie über das in der Silverlight-Geschäftsanwendung enthaltene Registrierungsformular einen neuen Benutzer.

So erstellen Sie eine Website, Rollen und Benutzer

Wählen Sie in Visual Studio 2010 Datei, Neu und dann Projekt aus.

Das Dialogfeld Neues Projekt wird angezeigt.
Wählen Sie den Projekttyp Silverlight aus.
Wählen Sie die Vorlage Silverlight-Geschäftsanwendung aus, und geben Sie für die Anwendung den Namen ExampleBusinessApplication ein.
Klicken Sie auf OK.

Beachten Sie die erstellte Projektstruktur. Das Silverlight-Clientprojekt enthält Silverlight-Seiten im Ordner "Views". Diese Seiten ermöglichen das Anmelden von Benutzern und Registrieren von neuen Benutzern.
Wählen Sie zum Öffnen des ASP.NET-Websiteverwaltungs-Tools zuerst das Serverprojekt (ExampleBusinessApplication.Web) im Projektmappen-Explorer aus. Öffnen Sie dann das Tool ASP.NET-Konfiguration.
Wählen Sie im Menü Projekt die Option ASP.NET-Konfiguration aus.

Wenn die Option "ASP.NET-Konfiguration" nicht im Menü "Projekt" angezeigt wird, haben Sie möglicherweise das Clientprojekt ausgewählt.
Klicken Sie im ASP.NET-Websiteverwaltungs-Tool auf die Registerkarte Sicherheit.
Klicken Sie im Abschnitt Rollen auf den Link Rollen erstellen oder verwalten.
Fügen Sie eine neue Rolle mit dem Namen "Managers" hinzu, und klicken Sie auf die Schaltfläche Rolle hinzufügen.
Klicken Sie rechts unten auf die Schaltfläche Zurück.
Klicken Sie im Abschnitt Benutzer auf den Link Benutzer erstellen.
Erstellen Sie einen neuen Benutzer mit den folgenden Werten, und aktivieren Sie das Kontrollkästchen für die Rolle "Managers".

Benutzername: CustomerManager

Kennwort: P@ssword

E-Mail: someone@example.com

Sicherheitsfrage: Lieblingsfarbe?

Sicherheitsantwort: Blau

Rolle "Managers": aktiviert
Klicken Sie auf die Schaltfläche Benutzer erstellen.
Schließen Sie das ASP.NET-Websiteverwaltungs-Tool.
Führen Sie die Projektmappe aus.

Die Startseite für die Anwendung wird in einem Webbrowser angezeigt.
Klicken Sie in der oberen rechten Ecke der Seite auf den Link Anmelden.

Ein Dialogfeld "Anmelden" wird angezeigt.
Geben Sie CustomerManager für den Benutzernamen und P@ssword für das Kennwort ein, und klicken Sie auf OK.

Sie werden als dieser Benutzer angemeldet. Beachten Sie den Text "Herzlich Willkommen CustomerManager" in der oberen rechten Ecke.
Klicken Sie auf den Link Abmelden.

Sie sind nicht mehr als CustomerManager angemeldet. In den folgenden Schritten erstellen Sie über das Registrierungsformular einen neuen Benutzer.
Klicken Sie erneut auf den Link Anmelden.
Klicken Sie im Dialogfeld "Anmelden" auf den Link Jetzt registrieren.

Das Registrierungsformular wird angezeigt.
Füllen Sie das Registrierungsformular aus, um ein neues Benutzerkonto zu erstellen. Verwenden Sie für den neuen Benutzer die folgenden Werte.

Benutzername: SalesUser

Anzeigename: SalesUser

E-Mail: someone@example.com

Kennwort: P@ssword

Sicherheitsfrage: Welche Farbe hatte Ihr erstes Auto?

Sicherheitsantwort: Grün
Klicken Sie auf OK, um den neuen Benutzer zu erstellen.

Beachten Sie, dass Sie jetzt als SalesUser angemeldet sind.
Schließen Sie den Browser.
Öffnen Sie erneut das ASP.NET-Websiteverwaltungs-Tool, und klicken Sie auf die Registerkarte Sicherheit.

Beachten Sie, dass die Website jetzt zwei Benutzer enthält und zwei Rollen vorhanden sind, obwohl Sie nur eine Rolle erstellt haben.
Klicken Sie auf Rollen erstellen oder verwalten. Sie sehen die Rollen "Managers" und "Registered Users".

Die Rolle "Registered Users" wurde automatisch durch die Vorlage "Geschäftsanwendung" erstellt.
Klicken Sie für "Registered Users" auf den Link Verwalten.

Der Benutzer mit dem Namen "SalesUser", den Sie über die Anwendung hinzugefügt haben, ist in der Rolle "Registered Users" enthalten.
Schließen Sie das ASP.NET-Websiteverwaltungs-Tool.

Definieren von Zugriffs- und Profileigenschaften

Zum Einschränken des Zugriffs auf einen Domänenvorgang wird das RequiresAuthenticationAttribute-Attribut oder das RequiresRoleAttribute-Attribut auf den Domänenvorgang angewendet. Domänenvorgänge ohne Attribut sind für alle Benutzer verfügbar. Durch das Anwenden eines Attributs auf einen Domänenvorgang wird nicht verhindert, dass der Benutzer den Domänenvorgang aufruft. Bei Benutzern ohne die erforderlichen Anmeldeinformationen führt der Aufruf jedoch zu einem Ausnahmefehler.

Einschränken der angezeigten Daten nach Rollen

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner "App_Data" im Serverprojekt, wählen Sie Hinzufügen aus und dann Vorhandenes Element.
Fügen Sie im Dialogfeld "Vorhandenes Element hinzufügen" die AdventureWorksLT-Beispieldatenbank hinzu.
Fügen Sie im Serverprojekt ein neues Element hinzu, und wählen Sie in den Datenvorlagen die Vorlage ADO.NET Entity Data Model aus.
Geben Sie für das Modell den Namen "AdventureWorksModel.edmx" ein, und klicken Sie auf Hinzufügen.

Der Assistent für Entity Data Model wird angezeigt.
Wählen Sie die Option Aus Datenbank generieren aus, und klicken Sie dann auf Weiter.
Wählen Sie die AdventureWorksLT-Datenbank aus, und klicken Sie anschließend auf Weiter.
Wählen Sie in der Liste der Datenbankobjekte die Tabellen "Customer", "Product" und "SalesOrderHeader" aus, und klicken Sie dann auf Fertig stellen.

Das Entity Data Model wird im Designer angezeigt.
Erstellen Sie die Projektmappe.
Fügen Sie im Serverprojekt ein neues Element hinzu, und wählen Sie in den Webvorlagen die Vorlage Domänendienstklasse aus.
Geben Sie für den Domänendienst den Namen "AdventureWorksDomainService" ein, und klicken Sie dann auf Hinzufügen.
Wählen Sie im Dialogfeld "Neue Domänendienstklasse hinzufügen" die Entitäten "Customer", "Product" und "SalesOrderHeader" aus.
Klicken Sie auf OK, um den Domänendienst zu erstellen.

Fügen Sie in der AdventureWorksDomainService-Klassendatei der GetSalesOrderHeader-Methode das RequiresAuthenticationAttribute-Attribut hinzu.

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

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

Fügen Sie der GetCustomers-Methode das RequiresRoleAttribute-Attribut hinzu, und legen Sie den Namen der erforderlichen Rolle auf "Managers" fest.

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

Der GetProducts-Domänenvorgang steht allen Benutzern zur Verfügung, GetSalesOrderHeaders ist für authentifizierte Benutzer verfügbar und GetCustomers nur für Benutzer in der Rolle "Managers".

Das folgende Beispiel zeigt den vollständigen Domänendienst.

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

Eine Profileigenschaft wird in der Datei "Web.config" definiert. Wenn Sie die Eigenschaft der User-Klasse auf dem Server hinzufügen, wird die entsprechende Eigenschaft für das Clientprojekt generiert.

Hinzufügen von Profileigenschaften

Öffnen Sie im Serverprojekt die Datei "Web.config".
Fügen Sie im <profile>-Element eine Profileigenschaft mit dem Namen "DefaultRows" hinzu. Die Eigenschaft enthält die Einstellung des Benutzers für die Anzahl anzuzeigender Zeilen.

Das folgende Beispiel zeigt den Profilabschnitt der Datei "Web.config".
```
<profile>
  <properties>
    <add name="FriendlyName" />
    <add type="System.Int32" defaultValue="10" name="DefaultRows"/>
  </properties>
</profile>
```
Speichern Sie die Datei "Web.config".
Erweitern Sie im Serverprojekt den Ordner "Models".

Öffnen Sie die Datei "User.cs" bzw. "User.vb", und fügen Sie eine Eigenschaft mit dem Namen "DefaultRows" hinzu.

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

Verwenden des Authentifizierungsdiensts im Clientprojekt

Bevor Sie einen Domänenvorgang mit eingeschränkten Berechtigungen aufrufen, sollten Sie sicherstellen, dass der Benutzer über die erforderlichen Anmeldeinformationen verfügt. Andernfalls wird ein Ausnahmefehler ausgelöst. Im folgenden Abschnitt überprüfen Sie die Anmeldeinformationen des Benutzers, und Sie füllen drei DataGrid-Steuerelemente anhand der Anmeldeinformationen des Benutzers auf. Zudem rufen Sie die Anzahl von Datensätzen basierend auf einer Eigenschaft im Benutzerprofil ab. Für nicht authentifizierte Benutzer wird der Standardwert 10 verwendet. Dieser Abschnitt enthält keine Methode, mit der Benutzer die DefaultRows-Profileigenschaft festlegen können. Eine solche Eigenschaft wird jedoch in einem späteren Abschnitt hinzugefügt.

Hinzufügen einer Silverlight-Seite zum Anzeigen von Daten

Fügen Sie im Clientprojekt dem Ordner "Views" ein neues Element hinzu.
Wählen Sie die Vorlage Silverlight-Seite aus, und geben Sie für die neue Seite den Namen "Reports.xaml" ein.

Öffnen Sie die Datei "MainPage.xaml", und fügen Sie einen Link für die Seite "Reports" hinzu, indem Sie nach dem HyperlinkButton mit dem Namen Link2 für die Infoseite (About) den folgenden XAML-Code hinzufügen.

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

Öffnen Sie im Ordner "Assets\Resources" die Datei "ApplicationStrings.resx".
Fügen Sie eine neue Zeichenfolgenressource "ReportsPageTitle" mit dem Wert "Reports" hinzu.
Speichern und schließen Sie die Datei "ApplicationStrings.resx".

Öffnen Sie die Datei "Reports.xaml", und fügen Sie dem Grid-Element den folgenden XAML-Code hinzu, um die Seite entsprechend den anderen Seiten der Website zu formatieren.

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

Ziehen Sie drei DataGrid-Steuerelemente aus der Toolbox direkt vor das Endtag des Stapelbereichs mit dem Namen ContentStackPanel.

Wenn Sie die DataGrid-Steuerelemente aus der Toolbox ziehen, wird dem Projekt ein Verweis auf die System.Windows.Controls.Data-Assembly hinzugefügt, und der Seite wird ein Präfix für den System.Windows.Controls-Namespace hinzugefügt.
Geben Sie für die DataGrid-Steuerelemente die Namen ProductsGrid, SalesOrdersGrid und CustomersGrid ein.

Legen Sie für jedes DataGrid-Steuerelement die Margin-Eigenschaft auf 5 fest.

Das folgende Beispiel zeigt die vollständige Datei "Reports.xaml".

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

Öffnen Sie die Datei "Reports.xaml.cs" bzw. "Reports.xaml.vb".
Fügen Sie für C# using-Anweisungen für die Namespaces System.ServiceModel.DomainServices.Client, System.ServiceModel.DomainServices.Client.ApplicationServices und ExampleBusinessApplication.Web hinzu. Fügen Sie für Visual Basic Imports-Anweisungen für die Namespaces System.ServiceModel.DomainServices.Client, System.ServiceModel.DomainServices.Client.ApplicationServices, System.Windows.Controls und ExampleBusinessApplication.Web hinzu.

Erstellen Sie eine Instanz des AdventureWorksDomainContext-Kontexts und eine Variable mit dem Namen "numberOfRows", die die Anzahl abzurufender Zeilen enthält.

Private context As New AdventureWorksDomainContext
Private numberOfRows As Integer = 10

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

Fügen Sie eine Methode mit dem Namen LoadRestrictedReports hinzu, durch die die GetSalesOrderHeaderQuery- und die GetCustomersQuery-Methode aufgerufen und die entsprechenden Datenraster mit den Ergebnissen aufgefüllt werden, wenn der Benutzer der Rolle "Managers" angehört.

Wenn Sie einen Domänenvorgang aufrufen und der Benutzer nicht über die erforderlichen Anmeldeinformationen verfügt, gibt der Domänenvorgang eine Ausnahme zurück. Sie können diese Situation vermeiden, indem Sie die Anmeldeinformationen vor dem Aufrufen des Domänenvorgangs überprüfen.

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

Fügen Sie eine Methode mit dem Namen LoadReports hinzu, durch die überprüft wird, ob der Benutzer authentifiziert ist, und ob die LoadRestrictedReports-Methode aufgerufen wird, wenn dies der Fall ist. Diese Methode ruft auch die DefaultRows-Profileigenschaft ab und fügt dem User-Objekt einen Ereignishandler für das PropertyChanged-Ereignis hinzu. Zum Schluss ruft sie die GetProductsQuery-Methode für alle Benutzer auf.

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

Fügen Sie einen Ereignishandler für das PropertyChanged-Ereignis hinzu, durch den LoadReports aufgerufen wird, wenn sich die DefaultRows-Eigenschaft geändert hat.

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

Fügen Sie Ereignishandler für die LoggedIn- und LoggedOut-Ereignisse hinzu, durch die Daten basierend auf der Änderung der Anmeldeinformationen für die Benutzerauthentifizierung geladen oder ausgeblendet werden.

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

Fügen Sie dem Konstruktor den folgenden Code hinzu. Dieser Code lädt die Handler und ruft LoadReports auf.

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

Das folgende Beispiel zeigt die vollständige Codedatei.

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

Führen Sie die Projektmappe aus.
Klicken Sie auf den Link Reports.

Wenn Sie nicht angemeldet sind, wird nur die Tabelle "Products" auf der Seite "Reports" angezeigt.
Klicken Sie auf den Link "Anmelden", und melden Sie sich als SalesUser an.

Die Tabellen für Produkte und Verkaufsaufträge werden angezeigt.
Melden Sie sich ab, und melden Sie sich als CustomerManager an.

Die Tabellen für Produkte, Verkaufsaufträge und Kunden werden angezeigt.
Schließen Sie den Webbrowser.

Sie können ein untergeordnetes Fenster hinzufügen, um Benutzern das Bearbeiten der DefaultRows-Profileigenschaft zu ermöglichen. Wenn der Wert geändert wird, rufen Sie die SaveUser-Methode auf, um den Wert in der Datenquelle zu speichern. Der aktuelle Wert wird über die Eigenschaften des User-Objekts der aktuellen WebContext-Instanz abgerufen.

Hinzufügen eines Fensters zum Festlegen der Profileigenschaft

Fügen Sie im Clientprojekt dem Ordner "Views" ein neues Element hinzu.
Wählen Sie die Vorlage Untergeordnetes Silverlight-Fenster aus, und geben Sie für das untergeordnete Fenster den Namen "ProfileWindow.xaml" ein.
Klicken Sie auf die Schaltfläche Hinzufügen.

Fügen Sie in der Datei "ProfileWindow.xaml" nach dem Grid.RowDefinitions-Element den folgenden XAML-Code hinzu, um eine ComboBox zum Auswählen der in den Berichten anzuzeigenden Anzahl von Zeilen hinzuzufügen.

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

Legen Sie die Title-Eigenschaft für das ChildWindow auf Select Preferences fest.

Fügen Sie in der Datei "ProfileWindow.xaml.cs" bzw. "ProfileWindow.xaml.vb" den folgenden Code hinzu, um die Profileigenschaft abzurufen und festzulegen.

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

Fügen Sie für Visual Basic Imports-Anweisungen für die Namespaces System.Windows.Controls und System.Windows hinzu.
Erweitern Sie den Ordner "Views\Login", und öffnen Sie die Datei "LoginStatus.xaml".

Fügen Sie vor der Abmeldeschaltfläche den folgenden XAML-Code hinzu, um dem Profilfenster einen Einstellungslink hinzuzufügen.

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

Fügen Sie in der Datei "LoginStatus.xaml.cs" bzw. "LoginStatus.xaml.vb" den folgenden Click-Ereignishandler für den Einstellungslink hinzu.

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

Führen Sie die Projektmappe aus.
Melden Sie sich als CustomerManager oder SalesUser an. Sie werden feststellen, dass die Anmeldestatusleiste jetzt einen Link für Einstellungen enthält.
Klicken Sie auf den Einstellungslink, und legen Sie die Standardanzahl von Zeilen fest, die für die Berichte angezeigt werden soll.
Öffnen Sie die Seite "Reports". Das DataGrid enthält jetzt die von Ihnen ausgewählte Anzahl von Zeilen.

Share via