Creazione e gestione di ruoli (C#)

di Scott Mitchell

Nota

Poiché questo articolo è stato scritto, i provider di appartenenza ASP.NET sono stati sostituiti da ASP.NET Identity. È consigliabile aggiornare le app per usare la ASP.NET Identity Platform anziché i provider di appartenenza in primo piano al momento della scrittura di questo articolo. ASP.NET Identity offre numerosi vantaggi rispetto al sistema di appartenenza ASP.NET, tra cui :

• Prestazioni migliori
• Miglioramento dell'estendibilità e della testability
• Supporto per OAuth, OpenID Connect e autenticazione a due fattori
• Supporto delle identità basate sulle attestazioni
• Interoperabilità migliore con ASP.Net Core

Scaricare codice o scaricare pdf

Questa esercitazione esamina i passaggi necessari per configurare il framework Ruoli. In seguito, verranno create pagine Web per creare ed eliminare ruoli.

Introduzione

Nell'esercitazione Sull'autorizzazione basata sull'utente è stata esaminata l'uso dell'autorizzazione URL per limitare determinati utenti da un set di pagine ed è stata esaminata una tecnica dichiarativa e programmatica per modificare la funzionalità di una pagina ASP.NET in base all'utente che visita. La concessione dell'autorizzazione per l'accesso alla pagina o la funzionalità su base utente, tuttavia, può diventare un incubo di manutenzione negli scenari in cui sono presenti molti account utente o quando i privilegi degli utenti cambiano spesso. Ogni volta che un utente ottiene o perde l'autorizzazione per eseguire un'attività specifica, l'amministratore deve aggiornare le regole di autorizzazione url appropriate, il markup dichiarativo e il codice.

In genere consente di classificare gli utenti in gruppi o ruoli e quindi di applicare le autorizzazioni in base al ruolo. La maggior parte delle applicazioni Web, ad esempio, dispone di un determinato set di pagine o attività riservate solo agli utenti amministrativi. Usando le tecniche apprese nell'esercitazione Sull'autorizzazione basata sull'utente , aggiungeremo le regole di autorizzazione url appropriate, il markup dichiarativo e il codice per consentire agli account utente specificati di eseguire attività amministrative. Tuttavia, se un nuovo amministratore è stato aggiunto o se un amministratore esistente deve avere revocato i diritti di amministrazione, è necessario restituire e aggiornare i file di configurazione e le pagine Web. Con i ruoli, tuttavia, è possibile creare un ruolo denominato Amministratori e assegnare tali utenti attendibili al ruolo Administrators. Aggiungeremo quindi le regole di autorizzazione url appropriate, il markup dichiarativo e il codice per consentire al ruolo Amministratori di eseguire le varie attività amministrative. Con questa infrastruttura sul posto, l'aggiunta di nuovi amministratori al sito o la rimozione di quelli esistenti è semplice come l'inclusione o la rimozione dell'utente dal ruolo Administrators. Non sono necessarie modifiche di configurazione, markup dichiarativo o codice.

ASP.NET offre un framework Ruoli per definire i ruoli e associarli agli account utente. Con il framework Ruoli è possibile creare ed eliminare ruoli, aggiungere utenti a o rimuovere utenti da un ruolo, determinare il set di utenti che appartengono a un ruolo specifico e stabilire se un utente appartiene a un determinato ruolo. Dopo aver configurato il framework Ruoli, è possibile limitare l'accesso alle pagine in base al ruolo tramite le regole di autorizzazione url e mostrare o nascondere informazioni o funzionalità aggiuntive in una pagina in base ai ruoli dell'utente attualmente connessi.

Questa esercitazione esamina i passaggi necessari per configurare il framework Ruoli. In seguito, verranno create pagine Web per creare ed eliminare ruoli. Nell'esercitazione Assegna ruoli agli utenti verrà illustrato come aggiungere e rimuovere utenti dai ruoli. E nell'esercitazione sull'autorizzazione basata su ruoli verrà illustrato come limitare l'accesso alle pagine in base al ruolo insieme a come modificare la funzionalità della pagina a seconda del ruolo dell'utente in visita. È possibile iniziare subito.

Passaggio 1: Aggiunta di nuove pagine ASP.NET

In questa esercitazione e i due successivi verranno esaminate diverse funzioni e funzionalità correlate ai ruoli. È necessaria una serie di pagine di ASP.NET per implementare gli argomenti esaminati in queste esercitazioni. Creare queste pagine e aggiornare la mappa del sito.

Iniziare creando una nuova cartella nel progetto denominato Roles. Aggiungere quindi quattro nuove pagine ASP.NET alla Roles cartella, collegando ogni pagina alla Site.master pagina master. Assegnare un nome alle pagine:

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

A questo punto la Esplora soluzioni del progetto dovrebbe essere simile alla schermata visualizzata nella figura 1.

Figura 1: sono state aggiunte quattro nuove pagine alla cartella (fare clic per visualizzare l'immagineRoles a dimensioni complete)

Ogni pagina deve, a questo punto, avere i due controlli Contenuto, uno per ognuno dei ContentPlaceHolder della pagina master: MainContent e LoginContent.

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

Tenere presente che il LoginContent markup predefinito di ContentPlaceHolder visualizza un collegamento per accedere o disconnettersi dal sito, a seconda che l'utente sia autenticato. La presenza del Content2 controllo Contenuto nella pagina ASP.NET, tuttavia, esegue l'override del markup predefinito della pagina master. Come illustrato in Un'esercitazione Panoramica dell'autenticazione dei moduli , l'override del markup predefinito è utile nelle pagine in cui non si desidera visualizzare le opzioni correlate all'account di accesso nella colonna sinistra.

Per queste quattro pagine, tuttavia, si vuole visualizzare il markup predefinito della pagina master per LoginContent ContentPlaceHolder. Rimuovere pertanto il markup dichiarativo per il Content2 controllo Contenuto. Dopo aver eseguito questa operazione, ogni markup della quattro pagina deve contenere un solo controllo Contenuto.

Infine, aggiorniamo la mappa del sito (Web.sitemap) per includere queste nuove pagine Web. Aggiungere il codice XML seguente dopo l'aggiunta per le esercitazioni sull'appartenenza <siteMapNode> .

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

Con la mappa del sito aggiornata, visitare il sito tramite un browser. Come illustrato nella figura 2, lo spostamento a sinistra include ora elementi per le esercitazioni sui ruoli.

Figura 2: Sono state aggiunte quattro nuove pagine alla cartella (fare clic per visualizzare l'immagineRoles a dimensioni complete)

Passaggio 2: Specificare e configurare il provider del framework ruoli

Analogamente al framework Di appartenenza, il framework Ruoli viene compilato in base al modello del provider. Come illustrato nell'esercitazione Informazioni di base sulla sicurezza e ASP.NET supporto , .NET Framework viene fornito con tre provider di ruoli predefiniti: AuthorizationStoreRoleProvider, WindowsTokenRoleProvidere SqlRoleProvider. Questa serie di esercitazioni è incentrata su SqlRoleProvider, che usa un database microsoft SQL Server come archivio ruoli.

Sotto il framework Ruoli e SqlRoleProvider funziona esattamente come il framework di appartenenza e SqlMembershipProvider. .NET Framework contiene una Roles classe che funge da API nel framework Ruoli. La Roles classe include metodi statici come CreateRole, GetAllRolesDeleteRoleAddUserToRoleIsUserInRole, e così via. Quando viene richiamato uno di questi metodi, la Roles classe delega la chiamata al provider configurato. Funziona SqlRoleProvider con le tabelle specifiche del ruolo (aspnet_Roles e aspnet_UsersInRoles) in risposta.

Per usare il SqlRoleProvider provider nell'applicazione, è necessario specificare il database da usare come archivio. Si SqlRoleProvider prevede che l'archivio ruoli specificato disponga di determinate tabelle, viste e stored procedure di database. Questi oggetti di database necessari possono essere aggiunti usando lo aspnet_regsql.exe strumento. A questo punto è già disponibile un database con lo schema necessario per .SqlRoleProvider Nell'esercitazione Creazione dello schema di appartenenza in SQL Server è stato creato un database denominato SecurityTutorials.mdf e usato aspnet_regsql.exe per aggiungere i servizi dell'applicazione, che includevano gli oggetti di database richiesti da SqlRoleProvider. Di conseguenza, è sufficiente indicare al framework Ruoli di abilitare il supporto del ruolo e l'uso SqlRoleProvider con il SecurityTutorials.mdf database come archivio ruoli.

Il framework Ruoli viene configurato tramite l'elemento <roleManager> nel file dell'applicazione Web.config . Per impostazione predefinita, il supporto del ruolo è disabilitato. Per abilitarlo, è necessario impostare l'attributo <roleManager> dell'elemento enabled su true come segue:

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

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

Per impostazione predefinita, tutte le applicazioni Web hanno un provider Ruoli denominato AspNetSqlRoleProvider di tipo SqlRoleProvider. Questo provider predefinito è registrato in (disponibile in machine.config%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'attributo del connectionStringName provider specifica l'archivio ruoli usato. Il AspNetSqlRoleProvider provider imposta questo attributo su LocalSqlServer, definito anche in machine.config e punti, per impostazione predefinita, su un database SQL Server 2005 Express Edition nella App_Data cartella denominata aspnet.mdf.

Di conseguenza, se si abilita semplicemente il framework Ruoli senza specificare informazioni sul provider nel file dell'applicazione Web.config , l'applicazione usa il provider di ruoli registrati predefinito, AspNetSqlRoleProvider. Se il ~/App_Data/aspnet.mdf database non esiste, il runtime di ASP.NET lo creerà automaticamente e aggiungerà lo schema dei servizi applicazioni. Tuttavia, non si vuole usare il aspnet.mdf database; invece, si vuole usare il SecurityTutorials.mdf database già creato e aggiunto lo schema dei servizi applicazione a. Questa modifica può essere eseguita in uno dei due modi seguenti:

• Specificare un valore per l'oggettoLocalSqlServernome della stringa di connessione inWeb.config. Sovrascrivendo il valore del nome della stringa di connessione in Web.config, è possibile usare il LocalSqlServer provider di ruoli registrati predefinito (AspNetSqlRoleProvider) e usarlo correttamente con il SecurityTutorials.mdf database. Per altre informazioni su questa tecnica, vedere il post di blog di Scott Guthrie, Configurazione di servizi applicazioni ASP.NET 2.0 per usare SQL Server 2000 o SQL Server 2005.
• Aggiungere un nuovo provider registrato di tipoSqlRoleProvidere configurare il relativoconnectionStringNameimpostazione per puntare all'oggettoSecurityTutorials.mdfDatabase. Questo è l'approccio consigliato e usato nell'esercitazione Creazione dello schema di appartenenza in SQL Server ed è anche l'approccio che userò in questa esercitazione.

Aggiungere il markup di configurazione ruoli seguente al Web.config file. Questo markup registra un nuovo provider denominato 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>

Il markup precedente definisce come SecurityTutorialsSqlRoleProvider provider predefinito (tramite l'attributo nell'elemento <roleManager>defaultProvider). Imposta anche l'impostazione SecurityTutorialsSqlRoleProvidersu applicationName , che corrisponde alla stessa applicationName impostazione SecurityTutorialsutilizzata dal provider di appartenenza (SecurityTutorialsSqlMembershipProvider). Anche se non illustrato qui, l'elemento per l'oggetto<add>SqlRoleProvider può contenere anche un commandTimeout attributo per specificare la durata del timeout del database, in secondi. Il valore predefinito è 30.

Con questo markup di configurazione, è possibile iniziare a usare la funzionalità del ruolo all'interno dell'applicazione.

Nota

Il markup di configurazione precedente illustra l'uso <>roleManagerdegli attributi e defaultProvider dell'elementoenabled. Esistono diversi altri attributi che influiscono sul modo in cui il framework ruoli associa le informazioni sui ruoli in base all'utente. Queste impostazioni verranno esaminate nell'esercitazione sull'autorizzazione basata su ruoli .

Passaggio 3: Esame dell'API ruoli

La funzionalità del framework Roles viene esposta tramite la Roles classe , che contiene tredici metodi statici per l'esecuzione di operazioni basate sui ruoli. Quando si esaminano la creazione e l'eliminazione di ruoli nei passaggi 4 e 6 verranno usati i CreateRole metodi e DeleteRole , che aggiungono o rimuovono un ruolo dal sistema.

Per ottenere un elenco di tutti i ruoli nel sistema, usare il GetAllRoles metodo (vedere Passaggio 5). Il RoleExists metodo restituisce un valore booleano che indica se esiste un ruolo specificato.

Nell'esercitazione successiva verrà illustrato come associare gli utenti ai ruoli. I Roles metodi , AddUserToRoles, AddUsersToRolee AddUsersToRoles della AddUserToRoleclasse aggiungono uno o più utenti a uno o più ruoli. Per rimuovere gli utenti dai ruoli, usare i RemoveUserFromRolemetodi , RemoveUserFromRoles, RemoveUsersFromRoleo RemoveUsersFromRoles .

Nell'esercitazione sull'autorizzazione basata sui ruoli verranno esaminati i modi per visualizzare o nascondere a livello di codice le funzionalità in base al ruolo dell'utente attualmente connesso. A tale scopo, è possibile usare i Role metodi , GetRolesForUser, GetUsersInRoleo IsUserInRole della FindUsersInRoleclasse .

Nota

Tenere presente che ogni volta che viene richiamato uno di questi metodi, la Roles classe delega la chiamata al provider configurato. In questo caso, significa che la chiamata viene inviata a SqlRoleProvider. Esegue SqlRoleProvider quindi l'operazione di database appropriata in base al metodo richiamato. Ad esempio, il codice Roles.CreateRole("Administrators") genera l'esecuzione SqlRoleProvider della aspnet_Roles_CreateRole stored procedure, che inserisce un nuovo record nella aspnet_Roles tabella denominata Administrators .

Nella parte restante di questa esercitazione viene esaminato l'uso Roles dei metodi , GetAllRolese DeleteRole della CreateRoleclasse per gestire i ruoli nel sistema.

Passaggio 4: Creazione di nuovi ruoli

I ruoli offrono un modo per raggruppare arbitrariamente gli utenti e in genere questo raggruppamento viene usato per un modo più pratico per applicare le regole di autorizzazione. Tuttavia, per usare i ruoli come meccanismo di autorizzazione, è prima necessario definire quali ruoli esistono nell'applicazione. Sfortunatamente, ASP.NET non include un controllo CreateRoleWizard. Per aggiungere nuovi ruoli, è necessario creare un'interfaccia utente appropriata e richiamare l'API Roles. La buona notizia è che questo è molto facile da realizzare.

Nota

Anche se non è presente alcun controllo Web CreateRoleWizard, è disponibile lo strumento di amministrazione del sito Web ASP.NET, un'applicazione ASP.NET locale progettata per facilitare la visualizzazione e la gestione della configurazione dell'applicazione Web. Tuttavia, non sono un grande fan del ASP.NET strumento di amministrazione del sito Web per due motivi. In primo luogo, è un po 'buggy e l'esperienza utente lascia molto da desiderare. In secondo luogo, lo strumento di amministrazione del sito Web ASP.NET è progettato per funzionare solo in locale, ovvero sarà necessario creare pagine Web di gestione dei ruoli personalizzate se è necessario gestire i ruoli in un sito live in remoto. Per questi due motivi, questa esercitazione e la successiva si concentrerà sulla creazione degli strumenti di gestione dei ruoli necessari in una pagina Web anziché basarsi sullo strumento di amministrazione del sito Web ASP.NET.

Aprire la ManageRoles.aspx pagina nella Roles cartella e aggiungere un controllo TextBox e un controllo Web Button alla pagina. Impostare la proprietà del ID controllo TextBox su e le proprietà e Text button ID rispettivamente su CreateRoleButton e Crea RoleName ruolo. A questo punto, il markup dichiarativo della pagina dovrebbe essere simile al seguente:

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

Fare quindi doppio clic sul CreateRoleButton controllo Pulsante nel Designer per creare un Click gestore eventi e quindi aggiungere il codice seguente:

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

Il codice precedente inizia assegnando il nome del ruolo tagliato immesso nella RoleName casella di testo alla newRoleName variabile . Viene quindi chiamato il Roles metodo della RoleExists classe per determinare se il ruolo newRoleName esiste già nel sistema. Se il ruolo non esiste, viene creato tramite una chiamata al CreateRole metodo . Se al CreateRole metodo viene passato un nome di ruolo già esistente nel sistema, viene generata un'eccezione ProviderException . Questo è il motivo per cui il codice verifica innanzitutto che il ruolo non esista già nel sistema prima di chiamare CreateRole. Il Click gestore eventi termina cancellando la RoleName proprietà di Text TextBox.

Nota

Ci si potrebbe chiedere cosa accadrà se l'utente non immette alcun valore in RoleName TextBox. Se il valore passato al CreateRole metodo è null o una stringa vuota, viene generata un'eccezione. Analogamente, se il nome del ruolo contiene una virgola viene generata un'eccezione. Di conseguenza, la pagina deve contenere controlli di convalida per garantire che l'utente entri in un ruolo e che non contenga virgole. Lascio come esercizio per il lettore.

Verrà ora creato un ruolo denominato Administrators. Visitare la ManageRoles.aspx pagina tramite un browser, digitare Amministratori nella casella di testo (vedere la figura 3) e quindi fare clic sul pulsante Crea ruolo.

Figura 3: Creare un ruolo Amministratori (fare clic per visualizzare l'immagine a dimensione intera)

Che cosa succede? Si verifica un postback, ma non è presente alcun segnale visivo che il ruolo è stato effettivamente aggiunto al sistema. Questa pagina verrà aggiornata nel passaggio 5 per includere commenti e suggerimenti visivi. Per il momento, tuttavia, è possibile verificare che il ruolo sia stato creato passando al SecurityTutorials.mdf database e visualizzando i dati dalla aspnet_Roles tabella. Come illustrato nella figura 4, la aspnet_Roles tabella contiene un record per i ruoli Administrators appena aggiunti.

Figura 4: La aspnet_Roles tabella include una riga per gli amministratori (fare clic per visualizzare l'immagine a dimensione intera)

Passaggio 5: Visualizzazione dei ruoli nel sistema

È ora possibile aumentare la ManageRoles.aspx pagina per includere un elenco dei ruoli correnti nel sistema. A tale scopo, aggiungere un controllo GridView alla pagina e impostarne la ID proprietà su RoleList. Aggiungere quindi un metodo alla classe code-behind della pagina denominata DisplayRolesInGrid usando il codice seguente:

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

Il Roles metodo della GetAllRoles classe restituisce tutti i ruoli nel sistema come matrice di stringhe. Questa matrice di stringhe viene quindi associata a GridView. Per associare l'elenco dei ruoli a GridView al primo caricamento della pagina, è necessario chiamare il DisplayRolesInGrid metodo dal gestore eventi della Page_Load pagina. Il codice seguente chiama questo metodo quando la pagina viene visitata per la prima volta, ma non nei postback successivi.

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

Con questo codice sul posto, visitare la pagina tramite un browser. Come illustrato nella figura 5, dovrebbe essere visualizzata una griglia con una singola colonna con etichetta Item. La griglia include una riga per il ruolo Administrators aggiunta nel passaggio 4.

Figura 5: GridView visualizza i ruoli in una singola colonna (fare clic per visualizzare l'immagine a dimensione intera)

GridView visualizza una colonna solitaria con etichetta Item perché la proprietà di AutoGenerateColumns GridView è impostata su True (impostazione predefinita), che fa sì che GridView crei automaticamente una colonna per ogni proprietà nel relativo DataSource. Una matrice ha una singola proprietà che rappresenta gli elementi nella matrice, quindi la singola colonna in GridView.

Quando si visualizzano dati con un controllo GridView, si preferisce definire in modo esplicito le colonne anziché generarle in modo implicito da GridView. Definendo in modo esplicito le colonne, è molto più semplice formattare i dati, riorganizzare le colonne ed eseguire altre attività comuni. Di conseguenza, aggiorniamo il markup dichiarativo di GridView in modo che le relative colonne siano definite in modo esplicito.

Per iniziare, impostare la proprietà di AutoGenerateColumns GridView su False. Aggiungere quindi un oggetto TemplateField alla griglia, impostarne la HeaderText proprietà su Roles e configurarne ItemTemplate il contenuto in modo che visualizzi il contenuto della matrice. A tale scopo, aggiungere un controllo Web Label denominato RoleNameLabel a e associarne la TextItemTemplate proprietà a Container.DataItem.

Queste proprietà e il ItemTemplatecontenuto del controllo possono essere impostati in modo dichiarativo o tramite la finestra di dialogo Campi di GridView e l'interfaccia Modifica modelli. Per raggiungere la finestra di dialogo Campi, fare clic sul collegamento Modifica colonne nello smart tag di GridView. Deselezionare quindi la casella di controllo Genera automaticamente campi per impostare la AutoGenerateColumns proprietà su False e aggiungere un oggetto TemplateField a GridView, impostandone la HeaderText proprietà su Role. Per definire il ItemTemplatecontenuto, scegliere l'opzione Modifica modelli dallo Smart Tag di GridView. Trascinare un controllo Web Label in ItemTemplate, impostarne la ID proprietà RoleNameLabelsu e configurare le impostazioni di associazione dati in modo che la relativa Text proprietà sia associata a Container.DataItem.

Indipendentemente dall'approccio usato, il markup dichiarativo risultante di GridView dovrebbe essere simile al seguente al termine dell'operazione.

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

Nota

Il contenuto della matrice viene visualizzato usando la sintassi <%# Container.DataItem %>databinding . Una descrizione completa del motivo per cui questa sintassi viene usata quando si visualizza il contenuto di una matrice associata a GridView esula dall'ambito di questa esercitazione. Per altre informazioni su questo argomento, vedere Associazione di una matrice scalare a un controllo Web dati.

Attualmente, RoleList GridView è associato solo all'elenco dei ruoli quando la pagina viene visitata per la prima volta. È necessario aggiornare la griglia ogni volta che viene aggiunto un nuovo ruolo. A tale scopo, aggiornare il CreateRoleButton gestore eventi di Click Button in modo che chiami il DisplayRolesInGrid metodo se viene creato un nuovo ruolo.

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

Ora quando l'utente aggiunge un nuovo ruolo, RoleList GridView mostra il ruolo appena aggiunto al postback, fornendo un feedback visivo che il ruolo è stato creato correttamente. Per illustrare questo problema, visitare la ManageRoles.aspx pagina tramite un browser e aggiungere un ruolo denominato Supervisori. Quando si fa clic sul pulsante Crea ruolo, viene visualizzato un postback e la griglia verrà aggiornata per includere amministratori, nonché il nuovo ruolo Supervisori.

Figura 6: Il ruolo Supervisori è stato aggiunto (fare clic per visualizzare l'immagine a dimensione intera)

Passaggio 6: Eliminazione dei ruoli

A questo punto un utente può creare un nuovo ruolo e visualizzare tutti i ruoli esistenti dalla ManageRoles.aspx pagina. Consentire agli utenti di eliminare anche i ruoli. Il Roles.DeleteRole metodo ha due overload:

• DeleteRole(roleName) - elimina il role roleName. Viene generata un'eccezione se il ruolo contiene uno o più membri.
• DeleteRole(roleName, throwOnPopulatedRole) - elimina il role roleName. Se throwOnPopulateRole è true, viene generata un'eccezione se il ruolo contiene uno o più membri. Se throwOnPopulateRole è false, il ruolo viene eliminato se contiene membri o meno. Internamente, il DeleteRole(roleName) metodo chiama DeleteRole(roleName, true).

Il DeleteRole metodo genererà anche un'eccezione se roleName è null o una stringa vuota o se roleName contiene una virgola. Se roleName non esiste nel sistema, DeleteRole non riesce in modo invisibile all'utente, senza generare un'eccezione.

È possibile aumentare GridView in ManageRoles.aspx per includere un pulsante Elimina che, quando si fa clic, elimina il ruolo selezionato. Iniziare aggiungendo un pulsante Elimina a GridView passando alla finestra di dialogo Campi e aggiungendo un pulsante Elimina, che si trova nell'opzione CommandField. Impostare il pulsante Delete sulla colonna a sinistra e impostarne la DeleteText proprietà su Elimina ruolo.

Figura 7: Aggiungere un pulsante Elimina a GridView (Fare clic per visualizzare l'immagineRoleList a dimensioni complete)

Dopo aver aggiunto il pulsante Elimina, il markup dichiarativo di GridView dovrebbe essere simile al seguente:

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

Creare quindi un gestore eventi per l'evento RowDeleting GridView. Questo è l'evento generato al postback quando viene fatto clic sul pulsante Elimina ruolo. Aggiungere il codice seguente al gestore eventi.

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

Il codice inizia facendo riferimento a livello di codice al RoleNameLabel controllo Web nella riga il cui pulsante Elimina ruolo è stato fatto clic. Il Roles.DeleteRole metodo viene quindi richiamato, passando l'oggetto Text e RoleNameLabelfalse, eliminando così il ruolo indipendentemente dal fatto che siano presenti utenti associati al ruolo. Infine, RoleList GridView viene aggiornato in modo che il ruolo appena eliminato non venga più visualizzato nella griglia.

Nota

Il pulsante Elimina ruolo non richiede alcuna conferma dall'utente prima di eliminare il ruolo. Uno dei modi più semplici per confermare un'azione è tramite una finestra di dialogo di conferma lato client. Per altre informazioni su questa tecnica, vedere Aggiunta di Client-Side conferma durante l'eliminazione.

Riepilogo

Molte applicazioni Web dispongono di determinate regole di autorizzazione o funzionalità a livello di pagina disponibili solo per determinate classi di utenti. Ad esempio, potrebbe esserci un set di pagine Web a cui possono accedere solo gli amministratori. Anziché definire queste regole di autorizzazione su base utente, spesso è più utile definire le regole in base a un ruolo. Invece di consentire agli utenti Scott e Jisun di accedere alle pagine Web amministrative, un approccio più gestibile consiste nel consentire ai membri del ruolo Administrators di accedere a queste pagine e quindi di denotare Scott e Jisun come utenti appartenenti al ruolo Administrators.

Il framework Ruoli semplifica la creazione e la gestione dei ruoli. In questa esercitazione è stato illustrato come configurare il framework Ruoli per l'uso di SqlRoleProvider, che usa un database microsoft SQL Server come archivio ruoli. È stata creata anche una pagina Web che elenca i ruoli esistenti nel sistema e consente la creazione di nuovi ruoli e quelli esistenti da eliminare. Nelle esercitazioni successive verrà illustrato come assegnare utenti ai ruoli e come applicare l'autorizzazione basata sul ruolo.

Programmazione felice!

Altre informazioni

Per altre informazioni sugli argomenti illustrati in questa esercitazione, vedere le risorse seguenti:

• Esame dell'appartenenza, dei ruoli e del profilo di ASP.NET 2.0
• Procedura: Usare Gestione ruoli in ASP.NET 2.0
• Provider di ruoli
• Documentazione tecnica per l'elemento <roleManager>
• Uso delle API Di appartenenza e Gestione ruoli

Informazioni sull'autore

Scott Mitchell, autore di più libri ASP/ASP.NET e fondatore di 4GuysFromRolla.com, ha lavorato con le tecnologie Web Microsoft dal 1998. Scott lavora come consulente indipendente, allenatore e scrittore. Il suo ultimo libro è Sams Teach Yourself ASP.NET 2,0 in 24 Ore. Scott può essere raggiunto all'indirizzo mitchell@4guysfromrolla.com o tramite il suo blog all'indirizzo http://ScottOnWriting.NET.

Grazie speciali

Questa serie di esercitazioni è stata esaminata da molti revisori utili. I revisori principali per questa esercitazione includono Alicja Maziarz, Suchi Banerjee e Teresa Murphy. Interessati a esaminare i prossimi articoli MSDN? In tal caso, lasciami una riga in mitchell@4GuysFromRolla.com

Avanti