Création et gestion de rôles (C#)

Article
06/29/2023

Notes

Depuis la rédaction de cet article, les fournisseurs d’appartenance ASP.NET ont été remplacés par ASP.NET Identity. Nous vous recommandons vivement de mettre à jour les applications pour utiliser la plateforme d’identité ASP.NET plutôt que les fournisseurs d’appartenance proposés au moment de la rédaction de cet article. ASP.NET Identity présente un certain nombre d’avantages par rapport au système d’appartenance ASP.NET, notamment :

Meilleures performances
Extensibilité et testabilité améliorées
Prise en charge d’OAuth, OpenID Connect et de l’authentification à deux facteurs
Prise en charge des identités basées sur les revendications
Meilleure interopérabilité avec ASP.Net Core

Télécharger le code ou télécharger pdf

Ce tutoriel examine les étapes nécessaires à la configuration de l’infrastructure Rôles. Ensuite, nous allons créer des pages web pour créer et supprimer des rôles.

Introduction

Dans le tutoriel Autorisation basée sur l’utilisateur, nous avons examiné l’utilisation de l’autorisation d’URL pour restreindre certains utilisateurs d’un ensemble de pages et exploré les techniques déclaratives et programmatiques pour ajuster les fonctionnalités d’une page ASP.NET en fonction de l’utilisateur visiteur. Toutefois, l’octroi d’autorisations pour l’accès aux pages ou les fonctionnalités sur une base utilisateur par utilisateur peut devenir un cauchemar de maintenance dans les scénarios où il existe de nombreux comptes d’utilisateur ou lorsque les privilèges des utilisateurs changent souvent. Chaque fois qu’un utilisateur obtient ou perd l’autorisation d’effectuer une tâche particulière, l’administrateur doit mettre à jour les règles d’autorisation d’URL, le balisage déclaratif et le code appropriés.

Il permet généralement de classer les utilisateurs en groupes ou rôles , puis d’appliquer des autorisations sur une base de rôle par rôle. Par exemple, la plupart des applications web ont un certain ensemble de pages ou de tâches qui sont réservées uniquement aux utilisateurs administratifs. À l’aide des techniques apprises dans le tutoriel Autorisation basée sur l’utilisateur , nous ajoutons les règles d’autorisation d’URL, le balisage déclaratif et le code appropriés pour permettre aux comptes d’utilisateur spécifiés d’effectuer des tâches administratives. Toutefois, si un nouvel administrateur a été ajouté ou si un administrateur existant doit faire révoquer ses droits d’administration, nous devons retourner et mettre à jour les fichiers de configuration et les pages web. Toutefois, avec les rôles, nous pouvons créer un rôle appelé Administrateurs et affecter ces utilisateurs approuvés au rôle Administrateurs. Ensuite, nous ajouterons les règles d’autorisation d’URL appropriées, le balisage déclaratif et le code pour permettre au rôle Administrateurs d’effectuer les différentes tâches d’administration. Une fois cette infrastructure en place, l’ajout de nouveaux administrateurs au site ou la suppression d’administrateurs existants est aussi simple que d’inclure ou de supprimer l’utilisateur du rôle Administrateurs. Aucune configuration, balisage déclaratif ou modification du code n’est nécessaire.

ASP.NET propose une infrastructure Rôles pour définir des rôles et les associer à des comptes d’utilisateur. Avec l’infrastructure Rôles, nous pouvons créer et supprimer des rôles, ajouter ou supprimer des utilisateurs à un rôle, déterminer l’ensemble d’utilisateurs qui appartiennent à un rôle particulier et indiquer si un utilisateur appartient à un rôle particulier. Une fois l’infrastructure Rôles configurée, nous pouvons limiter l’accès aux pages sur une base de rôle par rôle via des règles d’autorisation d’URL et afficher ou masquer des informations ou fonctionnalités supplémentaires sur une page en fonction des rôles de l’utilisateur actuellement connecté.

Ce tutoriel examine les étapes nécessaires à la configuration de l’infrastructure Rôles. Ensuite, nous allons créer des pages web pour créer et supprimer des rôles. Dans le tutoriel Attribution de rôles à des utilisateurs, nous allons voir comment ajouter et supprimer des utilisateurs de rôles. Dans le tutoriel Autorisation basée sur le rôle, nous allons voir comment limiter l’accès aux pages sur une base de rôle par rôle, ainsi que comment ajuster la fonctionnalité de page en fonction du rôle de l’utilisateur qui visite. C’est parti !

Étape 1 : Ajout de nouvelles pages ASP.NET

Dans ce tutoriel et les deux suivants, nous allons examiner différentes fonctions et fonctionnalités liées aux rôles. Nous aurons besoin d’une série de pages ASP.NET pour implémenter les rubriques examinées tout au long de ces tutoriels. Créons ces pages et mettons à jour le plan de site.

Commencez par créer un dossier dans le projet nommé Roles. Ensuite, ajoutez quatre nouvelles pages ASP.NET au Roles dossier, en liant chaque page à la Site.master page master. Nommez les pages :

ManageRoles.aspx
UsersAndRoles.aspx
CreateUserWizardWithRoles.aspx
RoleBasedAuthorization.aspx

À ce stade, la Explorateur de solutions de votre projet doit ressembler à la capture d’écran illustrée à la figure 1.

Figure 1 : Quatre nouvelles pages ont été ajoutées au Roles dossier (cliquez pour afficher l’image en taille réelle)

À ce stade, chaque page doit avoir les deux contrôles Content, un pour chacun des ContentPlaceHolders de la page master : MainContent et LoginContent.

<asp:Content ID="Content1" ContentPlaceHolderID="MainContent"Runat="Server">
</asp:Content>
<asp:Content ID="Content2" ContentPlaceHolderID="LoginContent"Runat="Server">
</asp:Content>

Rappelez-vous que le LoginContent balisage par défaut du ContentPlaceHolder affiche un lien pour se connecter ou se déconnecter du site, selon que l’utilisateur est authentifié ou non. Toutefois, la Content2 présence du contrôle Contenu dans la page ASP.NET remplace le balisage par défaut de la page master. Comme nous l’avons vu dans le tutoriel Vue d’ensemble de l’authentification par formulaire , le remplacement du balisage par défaut est utile dans les pages où nous ne voulons pas afficher les options liées à la connexion dans la colonne de gauche.

Toutefois, pour ces quatre pages, nous voulons afficher le balisage par défaut de la page master pour le LoginContent ContentPlaceHolder. Par conséquent, supprimez le balisage déclaratif du Content2 contrôle Content. Après cela, le balisage de chacune des quatre pages ne doit contenir qu’un seul contrôle Content.

Enfin, mettons à jour le plan de site (Web.sitemap) pour inclure ces nouvelles pages web. Ajoutez le code XML suivant après le <siteMapNode> que nous avons ajouté pour les didacticiels d’appartenance.

<siteMapNode title="Roles">
 <siteMapNode url="~/Roles/ManageRoles.aspx" title="Manage Roles"/>
 <siteMapNode url="~/Roles/UsersAndRoles.aspx" title="Users and Roles" />
 <siteMapNode url="~/Roles/CreateUserWizardWithRoles.aspx" title="Create Account (with Roles)" />
 <siteMapNode url="~/Roles/RoleBasedAuthorization.aspx" title="Role-Based Authorization" />
</siteMapNode>

Une fois le plan de site mis à jour, visitez le site via un navigateur. Comme le montre la figure 2, la navigation à gauche inclut désormais des éléments pour les didacticiels Rôles.

Figure 2 : Quatre nouvelles pages ont été ajoutées au Roles dossier (cliquez pour afficher l’image en taille réelle)

Étape 2 : Spécification et configuration du fournisseur d’infrastructure de rôles

Comme l’infrastructure d’appartenance, l’infrastructure Rôles est créée au-dessus du modèle de fournisseur. Comme indiqué dans le tutoriel De base de la sécurité et ASP.NET support , le .NET Framework est fourni avec trois fournisseurs de rôles intégrés : AuthorizationStoreRoleProvider, WindowsTokenRoleProvideret SqlRoleProvider. Cette série de tutoriels se concentre sur , SqlRoleProviderqui utilise une base de données Microsoft SQL Server comme magasin de rôles.

Sous le couvre l’infrastructure Rôles et SqlRoleProvider fonctionne comme l’infrastructure d’appartenance et SqlMembershipProvider. Le .NET Framework contient une Roles classe qui sert d’API à l’infrastructure Roles. La Roles classe a des méthodes statiques telles que CreateRole, DeleteRole, GetAllRolesAddUserToRole, , IsUserInRole, et ainsi de suite. Quand l’une de ces méthodes est appelée, la Roles classe délègue l’appel au fournisseur configuré. Fonctionne SqlRoleProvider avec les tables spécifiques au rôle (aspnet_Roles et aspnet_UsersInRoles) en réponse.

Pour utiliser le SqlRoleProvider fournisseur dans notre application, nous devons spécifier la base de données à utiliser comme magasin. le SqlRoleProvider s’attend à ce que le magasin de rôles spécifié ait certaines tables de base de données, vues et procédures stockées. Ces objets de base de données requis peuvent être ajoutés à l’aide de l’outilaspnet_regsql.exe . À ce stade, nous disposons déjà d’une base de données avec le schéma nécessaire pour .SqlRoleProvider De retour dans le tutoriel Création du schéma d’appartenance dans SQL Server nous avons créé une base de données nommée SecurityTutorials.mdf et utilisée aspnet_regsql.exe pour ajouter les services d’application, qui incluaient les objets de base de données requis par .SqlRoleProvider Par conséquent, nous devons simplement indiquer à l’infrastructure Rôles d’activer la prise en charge des rôles et d’utiliser avec SqlRoleProvider la SecurityTutorials.mdf base de données comme magasin de rôles.

L’infrastructure Rôles est configurée via l’élément <>roleManagerdans le fichier de l’applicationWeb.config. Par défaut, la prise en charge des rôles est désactivée. Pour l’activer, vous devez définir l’attribut de l’élément <roleManager>enabled comme true suit :

<?xml version="1.0"?>
<configuration>
 <system.web>
 ... Additional configuration markup removed for brevity ...

 <roleManager enabled="true" />
 <system.web>
</configuration>

Par défaut, toutes les applications web ont un fournisseur De rôles nommé AspNetSqlRoleProvider de type SqlRoleProvider. Ce fournisseur par défaut est inscrit dans machine.config (situé à l’adresse %WINDIR%\Microsoft.Net\Framework\v2.0.50727\CONFIG: ) :

<roleManager>
 <providers>
 <add name="AspNetSqlRoleProvider"
 connectionStringName="LocalSqlServer"
 applicationName="/"
 type="System.Web.Security.SqlRoleProvider, 
 System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"/>
 </providers>
</roleManager>

L’attribut du connectionStringName fournisseur spécifie le magasin de rôles utilisé. Le AspNetSqlRoleProvider fournisseur définit cet attribut sur LocalSqlServer, qui est également défini dans machine.config et pointe, par défaut, vers une base de données SQL Server 2005 Express Edition dans le App_Data dossier nommé aspnet.mdf.

Par conséquent, si nous activez simplement l’infrastructure Rôles sans spécifier d’informations de fournisseur dans le fichier de Web.config notre application, l’application utilise le fournisseur de rôles inscrits par défaut, AspNetSqlRoleProvider. Si la ~/App_Data/aspnet.mdf base de données n’existe pas, le runtime ASP.NET la crée automatiquement et ajoute le schéma des services d’application. Toutefois, nous ne voulons pas utiliser la aspnet.mdf base de données ; nous voulons plutôt utiliser la SecurityTutorials.mdf base de données que nous avons déjà créée et à laquelle nous avons ajouté le schéma des services d’application. Cette modification peut être effectuée de l’une des deux manières suivantes :

Spécifiez une valeur pour leLocalSqlServernom de chaîne de connexion dansWeb.config. En remplaçant la valeur du LocalSqlServer nom de chaîne de connexion dans Web.config, nous pouvons utiliser le fournisseur de rôles inscrits par défaut (AspNetSqlRoleProvider) et le faire fonctionner correctement avec la SecurityTutorials.mdf base de données. Pour plus d’informations sur cette technique, consultez le billet de blog de Scott Guthrie, Configuration de ASP.NET 2.0 Application Services to Use SQL Server 2000 ou SQL Server 2005.
Ajouter un nouveau fournisseur inscrit de typeSqlRoleProvideret configurer sonconnectionStringNameparamètre pour pointer vers leSecurityTutorials.mdfBase. C’est l’approche que j’ai recommandée et utilisée dans le didacticiel Création du schéma d’appartenance dans SQL Server, et c’est l’approche que je vais utiliser dans ce tutoriel.

Ajoutez le balisage de configuration rôles suivant au Web.config fichier. Ce balisage inscrit un nouveau fournisseur nommé SecurityTutorialsSqlRoleProvider.

<?xml version="1.0"?>    
<configuration>    
 <connectionStrings>    
 <add name="SecurityTutorialsConnectionString"    
 connectionString="..."/>    
 </connectionStrings>

 <system.web>    
 ... Additional configuration markup removed for brevity ...

 <roleManager enabled="true" defaultProvider="SecurityTutorialsSqlRoleProvider">    
 <providers>    
 <add name="SecurityTutorialsSqlRoleProvider"    
 type="System.Web.Security.SqlRoleProvider"    
 applicationName="SecurityTutorials"    
 connectionStringName="SecurityTutorialsConnectionString" />    
 </providers>    
 </roleManager>    
 <system.web>    
</configuration>

Le balisage ci-dessus définit comme SecurityTutorialsSqlRoleProvider fournisseur par défaut (via l’attribut defaultProvider dans l’élément <roleManager> ). Il définit également le SecurityTutorialsSqlRoleProviderparamètre SecurityTutorialsde applicationName sur , qui est le même applicationName paramètre utilisé par le fournisseur d’appartenance (SecurityTutorialsSqlMembershipProvider). Bien qu’il ne soit pas affiché ici, l’élément<add> pour le SqlRoleProvider peut également contenir un commandTimeout attribut pour spécifier la durée du délai d’expiration de la base de données, en secondes. La valeur par défaut est 30.

Une fois ce balisage de configuration en place, nous sommes prêts à commencer à utiliser les fonctionnalités de rôle au sein de notre application.

Notes

Le balisage de configuration ci-dessus illustre l’utilisation <>roleManagerdes attributs et defaultProvider de l’élémentenabled. Il existe un certain nombre d’autres attributs qui affectent la façon dont l’infrastructure Rôles associe les informations de rôle sur une base utilisateur par utilisateur. Nous allons examiner ces paramètres dans le didacticiel Sur l’autorisation basée sur les rôles.

Étape 3 : Examen de l’API rôles

Les fonctionnalités de l’infrastructure Roles sont exposées via la Roles classe , qui contient treize méthodes statiques pour effectuer des opérations basées sur les rôles. Lorsque nous examinons la création et la suppression de rôles aux étapes 4 et 6, nous allons utiliser les CreateRole méthodes et DeleteRole , qui ajoutent ou suppriment un rôle du système.

Pour obtenir la liste de tous les rôles dans le système, utilisez la GetAllRoles méthode (voir Étape 5). La RoleExists méthode retourne une valeur booléenne indiquant s’il existe un rôle spécifié.

Dans le tutoriel suivant, nous allons examiner comment associer des utilisateurs à des rôles. Les Roles méthodes , AddUserToRoles, AddUsersToRoleet AddUsersToRoles de la AddUserToRoleclasse ajoutent un ou plusieurs utilisateurs à un ou plusieurs rôles. Pour supprimer des utilisateurs des rôles, utilisez les RemoveUserFromRoleméthodes , RemoveUserFromRoles, RemoveUsersFromRoleou RemoveUsersFromRoles .

Dans le didacticiel sur l’autorisation basée sur les rôles, nous allons examiner les moyens d’afficher ou de masquer par programmation les fonctionnalités basées sur le rôle d’utilisateur actuellement connecté. Pour ce faire, nous pouvons utiliser les méthodes , GetRolesForUser, GetUsersInRoleou IsUserInRole de FindUsersInRolela Role classe .

Notes

N’oubliez pas qu’à chaque appel de l’une de ces méthodes, la Roles classe délègue l’appel au fournisseur configuré. Dans notre cas, cela signifie que l’appel est envoyé au SqlRoleProvider. Le SqlRoleProvider effectue ensuite l’opération de base de données appropriée en fonction de la méthode appelée. Par exemple, le code Roles.CreateRole("Administrators") entraîne l’exécution SqlRoleProvider de la aspnet_Roles_CreateRole procédure stockée, qui insère un nouvel enregistrement dans la aspnet_Roles table nommée Administrateurs .

Le reste de ce didacticiel examine l’utilisation des méthodes , GetAllRoleset DeleteRole de CreateRolela Roles classe pour gérer les rôles dans le système.

Étape 4 : Création de rôles

Les rôles offrent un moyen de regrouper arbitrairement des utilisateurs, et le plus souvent ce regroupement est utilisé pour un moyen plus pratique d’appliquer des règles d’autorisation. Mais pour utiliser des rôles comme mécanisme d’autorisation, nous devons d’abord définir les rôles qui existent dans l’application. Malheureusement, ASP.NET n’inclut pas de contrôle CreateRoleWizard. Pour ajouter de nouveaux rôles, nous devons créer une interface utilisateur appropriée et appeler l’API Rôles nous-mêmes. La bonne nouvelle, c’est que c’est très facile à réaliser.

Notes

Bien qu’il n’existe aucun contrôle Web CreateRoleWizard, il existe l’outil d’administration de site web ASP.NET, qui est une application ASP.NET locale conçue pour faciliter l’affichage et la gestion de la configuration de votre application web. Cependant, je ne suis pas un grand fan de l’outil d’administration de site web ASP.NET pour deux raisons. Tout d’abord, il est un peu buggy et l’expérience utilisateur laisse beaucoup à désirer. Deuxièmement, l’outil d’administration de site web ASP.NET est conçu pour fonctionner uniquement localement, ce qui signifie que vous devrez créer vos propres pages web de gestion des rôles si vous devez gérer des rôles sur un site actif à distance. Pour ces deux raisons, ce tutoriel et le suivant se concentrent sur la création des outils de gestion des rôles nécessaires dans une page web plutôt que sur l’outil d’administration de site web ASP.NET.

Ouvrez la ManageRoles.aspx page dans le Roles dossier et ajoutez un contrôle TextBox et un contrôle Web Button à la page. Définissez la propriété du ID contrôle TextBox sur RoleName et les propriétés et button IDText sur CreateRoleButton et Créer un rôle, respectivement. À ce stade, le balisage déclaratif de votre page doit ressembler à ce qui suit :

<b>Create a New Role: </b>
<asp:TextBox ID="RoleName" runat="server"></asp:TextBox>
<br />
<asp:Button ID="CreateRoleButton" runat="server" Text="Create Role" />

Ensuite, double-cliquez sur le CreateRoleButton contrôle Button dans le Designer pour créer un gestionnaire d’événementsClick, puis ajoutez le code suivant :

protected void CreateRoleButton_Click(object sender, EventArgs e)
{
    string newRoleName = RoleName.Text.Trim();

    if (!Roles.RoleExists(newRoleName))
        // Create the role
        Roles.CreateRole(newRoleName);

    RoleName.Text = string.Empty;
}

Le code ci-dessus commence par affecter le nom de rôle supprimé entré dans le RoleName TextBox à la newRoleName variable. Ensuite, la méthode de RoleExists la Roles classe est appelée pour déterminer si le rôle newRoleName existe déjà dans le système. Si le rôle n’existe pas, il est créé via un appel à la CreateRole méthode . Si la CreateRole méthode reçoit un nom de rôle qui existe déjà dans le système, une ProviderException exception est levée. C’est pourquoi le code vérifie d’abord que le rôle n’existe pas déjà dans le système avant d’appeler CreateRole. Le Click gestionnaire d’événements se termine en effaçant la RoleName propriété de Text TextBox.

Notes

Vous vous demandez peut-être ce qui se passera si l’utilisateur n’entre aucune valeur dans textBox RoleName . Si la valeur passée à la CreateRole méthode est null ou une chaîne vide, une exception est levée. De même, si le nom du rôle contient une virgule, une exception est levée. Par conséquent, la page doit contenir des contrôles de validation pour s’assurer que l’utilisateur entre dans un rôle et qu’il ne contient pas de virgules. Je pars comme un exercice pour le lecteur.

Créons un rôle nommé Administrateurs. Accédez à la ManageRoles.aspx page via un navigateur, tapez Administrateurs dans la zone de texte (voir figure 3), puis cliquez sur le bouton Créer un rôle.

Figure 3 : Créer un rôle d’administrateur (cliquer pour afficher l’image en taille réelle)

Ce qu’il se passe ? Une publication se produit, mais il n’y a aucun signe visuel indiquant que le rôle a réellement été ajouté au système. Nous allons mettre à jour cette page à l’étape 5 pour inclure des commentaires visuels. Pour l’instant, toutefois, vous pouvez vérifier que le rôle a été créé en accédant à la SecurityTutorials.mdf base de données et en affichant les données de la aspnet_Roles table. Comme le montre la figure 4, le aspnet_Roles tableau contient un enregistrement pour les rôles Administrateurs qui viennent d’être ajoutés.

Figure 4 : La aspnet_Roles table comporte une ligne pour les administrateurs (cliquez pour afficher l’image en taille réelle)

Étape 5 : Affichage des rôles dans le système

Nous allons agrandir la ManageRoles.aspx page pour inclure une liste des rôles actuels dans le système. Pour ce faire, ajoutez un contrôle GridView à la page et définissez sa ID propriété sur RoleList. Ensuite, ajoutez une méthode à la classe code-behind de la page nommée DisplayRolesInGrid à l’aide du code suivant :

private void DisplayRolesInGrid()
{
    RoleList.DataSource = Roles.GetAllRoles();
    RoleList.DataBind();
}

La Roles méthode de la GetAllRoles classe retourne tous les rôles dans le système sous la forme d’un tableau de chaînes. Ce tableau de chaînes est ensuite lié à GridView. Pour lier la liste des rôles à GridView lors du premier chargement de la page, nous devons appeler la DisplayRolesInGrid méthode à partir du gestionnaire d’événements de Page_Load la page. Le code suivant appelle cette méthode lors de la première visite de la page, mais pas lors des publications ultérieures.

protected void Page_Load(object sender, EventArgs e)
{
    if (!Page.IsPostBack)
    DisplayRolesInGrid();
}

Une fois ce code en place, visitez la page via un navigateur. Comme le montre la figure 5, vous devez voir une grille avec une seule colonne intitulée Élément. La grille inclut une ligne pour le rôle Administrateurs que nous avons ajouté à l’étape 4.

Figure 5 : GridView affiche les rôles dans une seule colonne (cliquer pour afficher l’image en taille réelle)

GridView affiche une seule colonne intitulée Item, car la propriété de AutoGenerateColumns GridView est définie sur True (valeur par défaut), ce qui oblige GridView à créer automatiquement une colonne pour chaque propriété dans son DataSource. Un tableau a une propriété unique qui représente les éléments du tableau, d’où la colonne unique dans GridView.

Lorsque vous affichez des données avec un GridView, je préfère définir explicitement mes colonnes plutôt que de les générer implicitement par GridView. En définissant explicitement les colonnes, il est beaucoup plus facile de mettre en forme les données, de réorganiser les colonnes et d’effectuer d’autres tâches courantes. Par conséquent, nous allons mettre à jour le balisage déclaratif de GridView afin que ses colonnes soient explicitement définies.

Commencez par définir la propriété de AutoGenerateColumns GridView sur False. Ensuite, ajoutez un TemplateField à la grille, définissez sa HeaderText propriété sur Rôles et configurez son ItemTemplate pour qu’il affiche le contenu du tableau. Pour ce faire, ajoutez un contrôle Label Web nommé RoleNameLabel à et ItemTemplate liez sa Text propriété à Container.DataItem.

Ces propriétés et le ItemTemplatecontenu de peuvent être définis de manière déclarative ou via la boîte de dialogue Champs de GridView et l’interface Modifier les modèles. Pour accéder à la boîte de dialogue Champs, cliquez sur le lien Modifier les colonnes dans la balise active de GridView. Ensuite, décochez la case Générer automatiquement les champs pour définir la AutoGenerateColumns propriété sur False, puis ajoutez un TemplateField au GridView, en affectant à sa HeaderText propriété la valeur Role. Pour définir le ItemTemplatecontenu de, choisissez l’option Modifier les modèles dans la balise intelligente de GridView. Faites glisser un contrôle Label Web sur , ItemTemplatedéfinissez sa ID propriété RoleNameLabelsur et configurez ses paramètres de liaison de données afin que sa Text propriété soit liée à Container.DataItem.

Quelle que soit l’approche que vous utilisez, le balisage déclaratif résultant de GridView doit ressembler à ce qui suit lorsque vous avez terminé.

<asp:GridView ID="RoleList" runat="server" AutoGenerateColumns="false">    
 <Columns>    
 <asp:TemplateField HeaderText="Role">    
 <ItemTemplate>    
 <asp:Label runat="server" ID="RoleNameLabel" Text='<%# Container.DataItem %>' />    
 </ItemTemplate>    
 </asp:TemplateField>    
 </Columns>    
</asp:GridView>

Notes

Le contenu du tableau est affiché à l’aide de la syntaxe <%# Container.DataItem %>de liaison de données . Une description complète de la raison pour laquelle cette syntaxe est utilisée lors de l’affichage du contenu d’un tableau lié à GridView dépasse le cadre de ce didacticiel. Pour plus d’informations à ce sujet, consultez Liaison d’un tableau scalaire à un contrôle Data Web.

Actuellement, gridView RoleList est uniquement lié à la liste des rôles lors de la première visite de la page. Nous devons actualiser la grille chaque fois qu’un nouveau rôle est ajouté. Pour ce faire, mettez à jour le CreateRoleButton gestionnaire d’événements de Click Button afin qu’il appelle la DisplayRolesInGrid méthode si un nouveau rôle est créé.

protected void CreateRoleButton_Click(object sender, EventArgs e)    
{    
    string newRoleName = RoleName.Text.Trim();

    if (!Roles.RoleExists(newRoleName))    
    {    
        // Create the role    
        Roles.CreateRole(newRoleName);

        // Refresh the RoleList Grid    
        DisplayRolesInGrid();    
    }

    RoleName.Text = string.Empty;    
}

Désormais, lorsque l’utilisateur ajoute un nouveau rôle, GridView RoleList affiche le rôle qui vient d’être ajouté lors de la publication, en fournissant des commentaires visuels indiquant que le rôle a été créé avec succès. Pour illustrer cela, visitez la ManageRoles.aspx page via un navigateur et ajoutez un rôle nommé Superviseurs. Lorsque vous cliquez sur le bouton Créer un rôle, une publication s’affiche et la grille est mise à jour pour inclure administrateurs ainsi que le nouveau rôle, Superviseurs.

Figure 6 : Le rôle Superviseurs a été ajouté (cliquez pour afficher l’image en taille réelle)

Étape 6 : Suppression de rôles

À ce stade, un utilisateur peut créer un rôle et afficher tous les rôles existants à partir de la ManageRoles.aspx page. Nous allons autoriser les utilisateurs à supprimer également des rôles. La Roles.DeleteRole méthode a deux surcharges :

DeleteRole(roleName) - supprime le rôle roleName. Une exception est levée si le rôle contient un ou plusieurs membres.
DeleteRole(roleName, throwOnPopulatedRole) - supprime le rôle roleName. Si throwOnPopulateRole est true, une exception est levée si le rôle contient un ou plusieurs membres. Si throwOnPopulateRole est false, le rôle est supprimé, qu’il contienne ou non des membres. En interne, la DeleteRole(roleName) méthode appelle DeleteRole(roleName, true).

La DeleteRole méthode lève également une exception si roleName est null ou une chaîne vide ou si roleName contient une virgule. Si roleName n’existe pas dans le système, DeleteRole échoue en mode silencieux, sans déclencher d’exception.

Augmentons le GridView dans ManageRoles.aspx pour inclure un bouton Supprimer qui, une fois cliqué, supprime le rôle sélectionné. Commencez par ajouter un bouton Supprimer à GridView en accédant à la boîte de dialogue Champs et en ajoutant un bouton Supprimer, qui se trouve sous l’option Champ de commande. Définissez le bouton Supprimer comme colonne à l’extrême gauche et définissez sa DeleteText propriété sur Rôle de suppression .

Figure 7 : Ajouter un bouton Supprimer à GridView RoleList (cliquer pour afficher l’image en taille réelle)

Après avoir ajouté le bouton Supprimer, le balisage déclaratif de votre GridView doit ressembler à ce qui suit :

<asp:GridView ID="RoleList" runat="server" AutoGenerateColumns="False">
 <Columns>
 <asp:CommandField DeleteText="Delete Role" ShowDeleteButton="True"/>
 <asp:TemplateField HeaderText="Role">
 <ItemTemplate>
 <asp:Label runat="server" ID="RoleNameLabel" Text='<%# Container.DataItem %>' />
 </ItemTemplate>
 </asp:TemplateField>
 </Columns>
</asp:GridView>

Ensuite, créez un gestionnaire d’événements pour l’événement RowDeleting GridView. Il s’agit de l’événement qui est déclenché lors de la publication lorsque vous cliquez sur le bouton Supprimer le rôle. Ajoutez le code suivant au gestionnaire d’événements.

protected void RoleList_RowDeleting(object sender, GridViewDeleteEventArgs e)
{
    // Get the RoleNameLabel
    Label RoleNameLabel = RoleList.Rows[e.RowIndex].FindControl("RoleNameLabel") as Label;

    // Delete the role
    Roles.DeleteRole(RoleNameLabel.Text, false);

    // Rebind the data to the RoleList grid
    DisplayRolesInGrid();
}

Le code commence par référencer par programmation le RoleNameLabel contrôle Web dans la ligne dont le bouton Supprimer le rôle a été cliqué. La Roles.DeleteRole méthode est ensuite appelée, en passant le Text de RoleNameLabel et false, supprimant ainsi le rôle, qu’il y ait ou non des utilisateurs associés au rôle. Enfin, gridView RoleList est actualisé de sorte que le rôle qui vient de supprimer n’apparaît plus dans la grille.

Notes

Le bouton Supprimer le rôle ne nécessite aucune confirmation de la part de l’utilisateur avant de supprimer le rôle. L’un des moyens les plus simples de confirmer une action consiste à utiliser une boîte de dialogue de confirmation côté client. Pour plus d’informations sur cette technique, consultez Ajout de Client-Side confirmation lors de la suppression.

Résumé

De nombreuses applications web ont certaines règles d’autorisation ou des fonctionnalités au niveau de la page qui sont uniquement disponibles pour certaines classes d’utilisateurs. Par exemple, il peut y avoir un ensemble de pages web auxquelles seuls les administrateurs peuvent accéder. Plutôt que de définir ces règles d’autorisation sur une base utilisateur par utilisateur, il est souvent plus utile de définir les règles basées sur un rôle. Autrement dit, plutôt que d’autoriser explicitement les utilisateurs Scott et Jisun à accéder aux pages web d’administration, une approche plus gérable consiste à autoriser les membres du rôle Administrateurs à accéder à ces pages, puis à désigner Scott et Jisun en tant qu’utilisateurs appartenant au rôle Administrateurs.

L’infrastructure Rôles facilite la création et la gestion des rôles. Dans ce tutoriel, nous avons examiné comment configurer l’infrastructure Rôles pour utiliser , SqlRoleProviderqui utilise une base de données Microsoft SQL Server comme magasin de rôles. Nous avons également créé une page web qui répertorie les rôles existants dans le système et permet de créer de nouveaux rôles et de supprimer des rôles existants. Dans les didacticiels suivants, nous verrons comment attribuer des utilisateurs à des rôles et comment appliquer une autorisation basée sur les rôles.

Bonne programmation!

En savoir plus

Pour plus d’informations sur les sujets abordés dans ce tutoriel, reportez-vous aux ressources suivantes :

À propos de l’auteur

Scott Mitchell, auteur de plusieurs livres ASP/ASP.NET et fondateur de 4GuysFromRolla.com, travaille avec les technologies Web Microsoft depuis 1998. Scott travaille comme consultant indépendant, formateur et écrivain. Son dernier livre est Sams Teach Yourself ASP.NET 2.0 in 24 Heures. Scott peut être contacté à mitchell@4guysfromrolla.com ou via son blog à l’adresse http://ScottOnWriting.NET.

Un merci spécial à

Cette série de tutoriels a été examinée par de nombreux réviseurs utiles. Les réviseurs principaux de ce tutoriel incluent Alicja Maziarz, Suchi Banerjee et Teresa Murphy. Vous souhaitez consulter mes prochains articles MSDN ? Si c’est le cas, déposez-moi une ligne à mitchell@4GuysFromRolla.com

Partager via

Création et gestion de rôles (C#)

Introduction

Étape 1 : Ajout de nouvelles pages ASP.NET

Étape 2 : Spécification et configuration du fournisseur d’infrastructure de rôles

Étape 3 : Examen de l’API rôles

Étape 4 : Création de rôles

Étape 5 : Affichage des rôles dans le système

Étape 6 : Suppression de rôles

Résumé

En savoir plus

À propos de l’auteur

Un merci spécial à

Commentaires

Ressources supplémentaires