Authentification, rôles et profils

Vous ajoutez le DomainService d'authentification à votre solution Services RIA WCF quand vous voulez vérifier les informations d'identification d'un utilisateur, limiter l'accès à certaines opérations ou conserver les propriétés de chaque utilisateur de votre projet client. Dans une application Web ASP.NET traditionnelle, vous pouvez utiliser l'infrastructure de l'appartenance ASP.NET pour effectuer ces fonctions. Les Services RIA reposent sur l'infrastructure de l'appartenance ASP.NET en exposant l'infrastructure de l'appartenance aux clients Internet riches via le DomainService d'authentification. Après avoir ajouté un DomainService d'authentification, vous pouvez activer les fonctions suivantes :

• Authentification : pour vérifier les informations d'identification d'un utilisateur et marquer l'utilisateur comme connecté ou déconnecté.

• Rôles : pour grouper des utilisateurs par responsabilités et accorder des autorisations de ressources aux membres authentifiés d'un groupe.

• Profils : pour conserver des propriétés pour les utilisateurs authentifiés et récupérer ces propriétés dans votre application.

Cette rubrique présente l'utilisation de l'authentification, des rôles et des profils dans une solution de Services RIA.

DomainService d'authentification

Les Services RIA fournissent le modèle DomainService d'authentification pour faciliter l'accès à l'authentification, aux rôles et aux profils sur la couche de présentation. Pour créer un DomainService d'authentification, il suffit de créer un nouvel élément dans le projet serveur et de sélectionner le modèle DomainService d'authentification lors de la création de l'élément.

Quand vous ajoutez un DomainService d'authentification, l'infrastructure des Services RIA ajoute automatiquement deux classes au projet serveur. La classe qui représente le service d'authentification dérive de la classe AuthenticationBase. La classe qui représente l'utilisateur dérive de la classe UserBase. La classe de l'utilisateur contient les propriétés de profil d'un utilisateur authentifié.

Quand vous générez la solution, les Services RIA génèrent automatiquement une classe WebContext dans le projet client. La classe WebContext vous permet d'accéder au DomainService d'authentification et à l'utilisateur dans votre projet client. Vous utilisez la propriété Current pour récupérer l'instance actuelle de WebContext. La classe WebContext dérive de la classe WebContextBase.

Pour obtenir un exemple d'ajout de DomainService d'authentification à une solution de Services RIA, consultez Procédure pas à pas : Utilisation du service d'authentification avec une application de navigation Silverlight.

Application métier Silverlight et authentification

Quand vous sélectionnez le modèle Application métier Silverlight pour créer une solution, la solution inclut automatiquement un DomainService d'authentification et des contrôles pour gérer la connexion et l'inscription des utilisateurs. Par défaut, la solution utilise l'authentification par formulaire, mais vous pouvez facilement la configurer pour l'authentification Windows. Les rôles sont activés et une propriété de profil est définie. Pour obtenir un exemple des fonctions d'authentification incluses par défaut dans une application métier Silverlight et savoir comment modifier la configuration de l'authentification par formulaire en authentification Windows, consultez Procédure pas à pas : Utilisation du modèle Application métier Silverlight. Pour voir un exemple d'aménagement des fonctionnalités par défaut dans une application métier Silverlight, consultez Procédure pas à pas : Utilisation du service d'authentification avec une application métier Silverlight.

L'illustration suivante montre la fenêtre d'inscription, l'une des fonctionnalités par défaut incluse dans l'application métier Silverlight.

Authentification

Les Services RIA fournissent des classes qui vous permettent d'implémenter facilement l'authentification par formulaire ou l'authentification Windows dans votre solution. Pour utiliser l'authentification dans votre solution de Services RIA, vous devez configurer le projet serveur et le projet client pour l'authentification. Pour plus d'informations, consultez Procédure : Activer le service d'authentification des Services RIA.

Après avoir configuré les projets client et serveur, vous connectez de façon asynchrone les utilisateurs de votre application Silverlight en appelant la méthode Login sur l'objet WebContext. Lorsque vous utilisez l'authentification Windows ou quand vous récupérez un utilisateur avec des informations d'identification persistantes, il n'est pas nécessaire d'appeler la méthode Login. Au lieu de cela, vous appelez la méthode LoadUser pour récupérer l'utilisateur authentifié via l'authentification Windows ou pour charger un utilisateur avec des informations d'identification persistantes.

Les méthodes et les propriétés suivantes sont généralement utilisées dans le projet client lorsque vous avez implémenté l'authentification.

Membre	Code à utiliser	Tâche
Authentication	WebContext.Current.Authentication	Pour accéder au service d'authentification.
User	WebContext.Current.User	Pour accéder à l'objet qui contient l'état de l'utilisateur.
Login ou Login ou Login	WebContext.Current.Authentication.Login(string, string) ou WebContext.Current.Authentication.Login(LoginParameters) ou WebContext.Current.Authentication.Login(LoginParameters, LoginOperation, object)	Pour vérifier les informations d'identification de l'utilisateur de façon asynchrone.
Logout ou Logout	WebContext.Current.Authentication.Logout(boolean) ou WebContext.Current.Authentication.Logout(LogoutOperation, object)	Pour déconnecter de façon asynchrone un utilisateur authentifié.
LoadUser ou LoadUser	WebContext.Current.Authentication.LoadUser() ou WebContext.Current.Authentication.LoadUser(LoadUserOperation, object)	Pour charger un utilisateur authentifié, actualisez l'état de l'utilisateur, chargez l'authentification de l'utilisateur persistant ou récupérez l'objet user principal si vous utilisez l'authentification Windows.

L'exemple suivant indique comment appeler la méthode Login à partir d'un gestionnaire d'événements pour un bouton de connexion. Une méthode de rappel est incluse pour répondre aux résultats de l'opération de connexion.

Private Sub LoginButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
    Dim lp As LoginParameters = New LoginParameters(UserName.Text, Password.Password)
    WebContext.Current.Authentication.Login(lp, AddressOf Me.LoginOperation_Completed, Nothing)
    LoginButton.IsEnabled = False
    LoginResult.Text = ""
End Sub

Private Sub LoginOperation_Completed(ByVal lo As LoginOperation)
    If (lo.HasError) Then
        LoginResult.Text = lo.Error.Message
        LoginResult.Visibility = System.Windows.Visibility.Visible
        lo.MarkErrorAsHandled()
    ElseIf (lo.LoginSuccess = False) Then
        LoginResult.Text = "Login failed. Please check user name and password."
        LoginResult.Visibility = System.Windows.Visibility.Visible
    ElseIf (lo.LoginSuccess = True) Then
        SetControlVisibility(True)
    End If
    LoginButton.IsEnabled = True
End Sub

private void LoginButton_Click(object sender, RoutedEventArgs e)
{
    LoginParameters lp = new LoginParameters(UserName.Text, Password.Password);
    WebContext.Current.Authentication.Login(lp, this.LoginOperation_Completed, null);
    LoginButton.IsEnabled = false;
    LoginResult.Text = "";
}

private void LoginOperation_Completed(LoginOperation lo)
{
    if (lo.HasError)
    {
        LoginResult.Text = lo.Error.Message;
        LoginResult.Visibility = System.Windows.Visibility.Visible;
        lo.MarkErrorAsHandled();
    }
    else if (lo.LoginSuccess == false)
    {
        LoginResult.Text = "Login failed. Please check user name and password.";
        LoginResult.Visibility = System.Windows.Visibility.Visible;
    }
    else if (lo.LoginSuccess == true)
    {
        SetControlVisibility(true);
    }
    LoginButton.IsEnabled = true;
}

Rôles

Après avoir implémenté l'authentification, vous pouvez configurer votre solution pour utiliser des rôles. Grâce aux rôles, vous pouvez affecter des utilisateurs à des groupes. Vous pouvez alors spécifier qu'une opération de domaine particulière est disponible uniquement aux membres de ce rôle. Vous limitez l'accès à une opération de domaine en appliquant l'objet RequiresRoleAttribute à l'opération de domaine. Pour plus d'informations, consultez Procédure : Activer les rôles dans les Services RIA.

Les méthodes et les propriétés suivantes sont en général utilisées lorsque vous avez implémenté des rôles.

Membre	Code à utiliser	Tâche
Roles	WebContext.Current.User.Roles	Pour accéder aux rôles auxquels l'utilisateur est affecté.
IsInRole	WebContext.Current.User.IsInRole(string)	Pour déterminer si l'utilisateur authentifié est un membre d'un rôle spécifié.

L'exemple suivant montre une opération de domaine avec un accès limité aux membres d'un rôle nommé 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;
}

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. L'exemple suivant indique comment vérifier si l'utilisateur est un membre du rôle requis avant de charger les données.

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

Profils

Les propriétés de profil vous permettent d'enregistrer des informations au sujet de l'utilisateur. Vous pouvez utiliser ces propriétés pour personnaliser votre application pour chaque utilisateur. Pour utiliser des profils dans votre solution, vous devez configurer votre solution pour les profils. Pour plus d'informations, consultez Procédure : Activer les profils dans les services RIA.

Les méthodes et les propriétés suivantes sont en général utilisées lorsque vous avez implémenté des profils.

Membre	Code à utiliser	Tâche
User	WebContext.Current.User	Pour accéder à l'objet qui contient toutes les propriétés que vous avez ajoutées à la classe User ; par exemple, User.PhoneNumber.
LoadUser ou LoadUser	WebContext.Current.Authentication.LoadUser() ou WebContext.Current.Authentication.LoadUser(LoadUserOperation, object)	Pour actualiser l'état de l'utilisateur.
SaveUser ou SaveUser	WebContext.Current.Authentication.SaveUser(boolean) ou WebContext.Current.Authentication.SaveUser(SaveUserOperation, object)	Pour enregistrer toutes les modifications de l'état de l'utilisateur ; par ex., après avoir défini une valeur de propriété de profil.

L'exemple suivant montre comment définir une propriété d'utilisateur en fonction de la valeur sélectionnée par l'utilisateur.

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

Gestion des erreurs d'authentification sur le client

Vous pouvez gérer des erreurs qui surviennent lors de la connexion, la déconnexion, le chargement ou l'enregistrement des utilisateurs, en fournissant une méthode de rappel comme paramètre lorsque vous appelez ces méthodes. Dans la méthode de rappel, vous ajoutez un code pour gérer l'erreur et appelez la méthode MarkErrorAsHandled pour spécifier que l'infrastructure ne lèvera pas d'exception. La classe AuthenticationService vous permet de fournir une méthode de rappel lorsque vous appelez les méthodes suivantes :

• LoadUser

• Login

• Logout

• SaveUser

L'exemple de la section « Authentification » précédente montre une méthode de rappel qui gère les erreurs pour l'opération Login.

Pour plus d'informations, consultez Gestion des erreurs sur le client.

Limitation de l'accès à un service de domaine

Après avoir implémenté l'authentification et les rôles, vous pouvez limiter l'accès à un service de domaine uniquement pour des utilisateurs particuliers. Vous appliquez les attributs suivants au service de domaine entier ou aux opérations individuelles sur le service. Lorsque vous appliquez un attribut au service entier, il s'applique à toutes les opérations.

• RequiresAuthenticationAttribute : spécifie que seuls les utilisateurs avec des informations d'authentification valides peuvent accéder à l'opération.

• RequiresRoleAttribute : spécifie que seuls des utilisateurs authentifiés qui appartiennent à des rôles spécifiés peuvent accéder à l'opération.

Vous pouvez aussi créer votre propre attribut d'autorisation personnalisé. Pour plus d'informations, consultez Procédure : Créer un attribut d'autorisation personnalisé.

L'exemple suivant montre un service de domaine avec trois opérations de domaine. Les attributs RequiresAuthenticationAttribute et RequiresRoleAttribute sont utilisés pour limiter l'accès. L'opération de domaine GetProducts est disponible pour tous les utilisateurs ; GetSalesOrderHeaders est disponible pour les utilisateurs authentifiés ; et GetCustomers n'est disponible que pour les utilisateurs du rôle Managers.

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

Voir aussi

Tâches

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

Concepts

Sécurité des Services RIA WCF