Erstellen und Verwalten von Rollen (C#)

von Scott Mitchell

Code herunterladen oder PDF herunterladen

In diesem Tutorial werden die erforderlichen Schritte zum Konfigurieren des Rollenframeworks untersucht. Danach erstellen wir Webseiten, um Rollen zu erstellen und zu löschen.

Einführung

Im Tutorial zur benutzerbasierten Autorisierung haben wir die Verwendung der URL-Autorisierung untersucht, um bestimmte Benutzer auf eine Reihe von Seiten einzuschränken, und deklarative und programmgesteuerte Techniken zum Anpassen der Funktionalität einer ASP.NET Seite basierend auf dem besuchenden Benutzer untersucht. Das Erteilen von Berechtigungen für Seitenzugriff oder -funktionen auf Benutzerbasis kann jedoch zu einem Wartungsaltraum in Szenarien werden, in denen viele Benutzerkonten vorhanden sind oder sich die Berechtigungen von Benutzern häufig ändern. Jedes Mal, wenn ein Benutzer die Autorisierung erhält oder verliert, um eine bestimmte Aufgabe auszuführen, muss der Administrator die entsprechenden URL-Autorisierungsregeln, deklaratives Markup und Code aktualisieren.

In der Regel hilft es, Benutzer in Gruppen oder Rollen zu klassifizieren und dann Berechtigungen rollenweise anzuwenden. Beispielsweise verfügen die meisten Webanwendungen über einen bestimmten Satz von Seiten oder Aufgaben, die nur für Administratoren reserviert sind. Mithilfe der im Tutorial zur benutzerbasierten Autorisierung erlernten Techniken fügen wir die entsprechenden URL-Autorisierungsregeln, deklaratives Markup und Code hinzu, damit die angegebenen Benutzerkonten administrative Aufgaben ausführen können. Wenn jedoch ein neuer Administrator hinzugefügt wurde oder ein vorhandener Administrator ihre Administratorrechte widerrufen muss, müssten wir die Konfigurationsdateien und Webseiten zurückgeben und aktualisieren. Mit Rollen könnten wir jedoch eine Rolle namens Administratoren erstellen und diese vertrauenswürdigen Benutzer der Rolle "Administratoren" zuweisen. Als Nächstes fügen wir die entsprechenden URL-Autorisierungsregeln, deklaratives Markup und Code hinzu, damit die Rolle "Administratoren" die verschiedenen administrativen Aufgaben ausführen kann. Wenn diese Infrastruktur eingerichtet ist, ist das Hinzufügen neuer Administratoren zur Website oder das Entfernen vorhandener Administratoren so einfach wie das Einschließen oder Entfernen des Benutzers aus der Rolle "Administratoren". Es sind keine Konfigurations-, deklarative Markup- oder Codeänderungen erforderlich.

ASP.NET bietet ein Rollenframework zum Definieren von Rollen und Zuordnen dieser Rollen zu Benutzerkonten. Mit dem Rollenframework können wir Rollen erstellen und löschen, Benutzer zu einer Rolle hinzufügen oder daraus entfernen, die Gruppe von Benutzern bestimmen, die zu einer bestimmten Rolle gehören, und angeben, ob ein Benutzer zu einer bestimmten Rolle gehört. Nachdem das Rollenframework konfiguriert wurde, können wir den Zugriff auf Seiten auf Rollenbasis über URL-Autorisierungsregeln einschränken und zusätzliche Informationen oder Funktionen auf einer Seite basierend auf den aktuell angemeldeten Benutzerrollen ein- oder ausblenden.

In diesem Tutorial werden die erforderlichen Schritte zum Konfigurieren des Rollenframeworks untersucht. Danach erstellen wir Webseiten, um Rollen zu erstellen und zu löschen. Im Tutorial Zuweisen von Rollen zu Benutzern wird erläutert, wie Sie Benutzer hinzufügen und daraus entfernen. Im Tutorial zur rollenbasierten Autorisierung erfahren Sie, wie Sie den Zugriff auf Seiten auf Rollenbasis einschränken und die Seitenfunktionalität abhängig von der Rolle des Gastbenutzers anpassen. Jetzt geht‘s los!

Schritt 1: Hinzufügen neuer ASP.NET Pages

In diesem Und den nächsten beiden Lernprogramm werden verschiedene rollenbezogene Funktionen und Funktionen untersucht. Wir benötigen eine Reihe von ASP.NET Seiten, um die in diesen Tutorials behandelten Themen zu implementieren. Wir erstellen diese Seiten und aktualisieren die Siteübersicht.

Erstellen Sie zunächst einen neuen Ordner im Projekt mit dem Namen Roles. Fügen Sie dem Roles Ordner als Nächstes vier neue ASP.NET Seiten hinzu, wobei jede Seite mit der Site.master master Seite verknüpft wird. Nennen Sie die Seiten:

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

An diesem Punkt sollte die Projektmappen-Explorer Ihres Projekts ähnlich dem Screenshot in Abbildung 1 aussehen.

Abbildung 1: Vier neue Seiten wurden zum Roles Ordner hinzugefügt (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Jede Seite sollte an diesem Punkt über die beiden Content-Steuerelemente verfügen, eines für jedes der ContentPlaceHolders der master Seite: MainContent und LoginContent.

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

Denken Sie daran, dass das LoginContent Standardmarkup von ContentPlaceHolder einen Link zum Anmelden oder Abmelden der Website anzeigt, je nachdem, ob der Benutzer authentifiziert ist. Das Vorhandensein des Content2 Inhaltssteuerelements auf der seite ASP.NET überschreibt jedoch das Standardmarkup der master Seite. Wie im Tutorial Eine Übersicht über die Formularauthentifizierung erläutert, ist das Überschreiben des Standardmarkups auf Seiten nützlich, auf denen keine anmeldebezogenen Optionen in der linken Spalte angezeigt werden sollen.

Für diese vier Seiten möchten wir jedoch das Standardmarkup der master Seite für den LoginContent ContentPlaceHolder anzeigen. Entfernen Sie daher das deklarative Markup für das Content2 Content-Steuerelement. Danach sollte jedes der vier Seiten-Markup nur ein Content-Steuerelement enthalten.

Schließlich aktualisieren wir die Websiteübersicht (Web.sitemap), um diese neuen Webseiten einzuschließen. Fügen Sie den folgenden XML-Code nach dem hinzu, den <siteMapNode> wir für die Tutorials zur Mitgliedschaft hinzugefügt haben.

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

Nachdem die Websitekarte aktualisiert wurde, besuchen Sie die Website über einen Browser. Wie in Abbildung 2 dargestellt, enthält die Navigation auf der linken Seite nun Elemente für die Rollen-Tutorials.

Abbildung 2: Vier neue Seiten wurden zum Ordner hinzugefügt (Klicken Sie hier, um dasRoles Bild in voller Größe anzuzeigen)

Schritt 2: Angeben und Konfigurieren des Rollenframeworkanbieters

Wie das Mitgliedschaftsframework wird das Rollenframework auf der Grundlage des Anbietermodells erstellt. Wie im Tutorial Sicherheitsgrundlagen und ASP.NET Support erläutert, wird die .NET Framework mit drei integrierten Rollenanbietern ausgeliefert: AuthorizationStoreRoleProvider, WindowsTokenRoleProviderund SqlRoleProvider. Diese Tutorialreihe konzentriert sich auf die SqlRoleProvider, die eine Microsoft SQL Server-Datenbank als Rollenspeicher verwendet.

Unterhalb des Hintergrunds funktionieren das Rollenframework und SqlRoleProvider genau wie das Mitgliedschaftsframework und SqlMembershipProvider. Die .NET Framework enthält eine Roles Klasse, die als API für das Rollenframework dient. Die Roles -Klasse verfügt über statische Methoden wie CreateRole, DeleteRole, GetAllRolesAddUserToRole, , IsUserInRoleusw. Wenn eine dieser Methoden aufgerufen wird, delegiert die Roles -Klasse den Aufruf an den konfigurierten Anbieter. Funktioniert SqlRoleProvider mit den rollenspezifischen Tabellen (aspnet_Roles und aspnet_UsersInRoles) als Antwort.

Um den SqlRoleProvider Anbieter in unserer Anwendung verwenden zu können, müssen wir angeben, welche Datenbank als Speicher verwendet werden soll. Erwartet SqlRoleProvider , dass der angegebene Rollenspeicher über bestimmte Datenbanktabellen, Sichten und gespeicherte Prozeduren verfügt. Diese erforderlichen Datenbankobjekte können mit dem aspnet_regsql.exe Tool hinzugefügt werden. An diesem Punkt verfügen wir bereits über eine Datenbank mit dem Schema, das für erforderlich SqlRoleProviderist. Zurück im Tutorial Erstellen des Mitgliedschaftsschemas in SQL Server haben wir eine Datenbank mit dem Namen SecurityTutorials.mdf erstellt und zum Hinzufügen der Anwendungsdienste verwendetaspnet_regsql.exe, die die für SqlRoleProviderdie erforderlichen Datenbankobjekte enthalten. Aus diesem Grund müssen wir das Rollenframework anweisen, die Rollenunterstützung zu aktivieren und mit SqlRoleProvider der SecurityTutorials.mdf Datenbank als Rollenspeicher zu verwenden.

Das Rollenframework wird über das <roleManager> -Element in der Datei der Anwendung Web.config konfiguriert. Standardmäßig ist die Rollenunterstützung deaktiviert. Um dies zu aktivieren, müssen Sie das <roleManager> Attribut des enabled Elements wie folgt true festlegen:

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

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

Standardmäßig verfügen alle Webanwendungen über einen Rollenanbieter mit dem Namen AspNetSqlRoleProviderSqlRoleProvider. Dieser Standardanbieter ist in machine.config registriert (befindet sich unter %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>

Das Attribut des Anbieters connectionStringName gibt den verwendeten Rollenspeicher an. Der AspNetSqlRoleProvider Anbieter legt dieses Attribut auf LocalSqlServerfest, das ebenfalls in machine.config definiert ist und standardmäßig auf eine SQL Server 2005 Express Edition-Datenbank im Ordner mit dem App_Data Namen verweistaspnet.mdf.

Wenn wir also einfach das Rollenframework ohne Angabe von Anbieterinformationen in der Datei unserer Anwendung Web.config aktivieren, verwendet die Anwendung den standardmäßig registrierten Rollenanbieter. AspNetSqlRoleProvider Wenn die ~/App_Data/aspnet.mdf Datenbank nicht vorhanden ist, erstellt die ASP.NET Runtime sie automatisch und fügt das Anwendungsdienstschema hinzu. Wir möchten jedoch nicht die aspnet.mdf Datenbank verwenden, sondern die Datenbank verwenden, die SecurityTutorials.mdf wir bereits erstellt und das Anwendungsdienstschema hinzugefügt haben. Diese Änderung kann auf eine von zwei Arten erfolgen:

• Geben Sie einen Wert für dieLocalSqlServerName der Verbindungszeichenfolge inWeb.config. Durch Überschreiben des Namenswerts der LocalSqlServer Verbindungszeichenfolge in Web.configkönnen wir den standardmäßig registrierten Rollenanbieter (AspNetSqlRoleProvider) verwenden und ihn ordnungsgemäß mit der SecurityTutorials.mdf Datenbank verwenden. Weitere Informationen zu dieser Technik finden Sie im Blogbeitrag von Scott Guthrie, Configuring ASP.NET 2.0 Application Services to Use SQL Server 2000 or SQL Server 2005.
• Hinzufügen eines neuen registrierten Anbieters vom TypSqlRoleProviderund konfigurierenconnectionStringNamefestlegen, um auf dieSecurityTutorials.mdfDatenbank. Dies ist der Ansatz, den ich im Tutorial Erstellen des Mitgliedschaftsschemas in SQL Server empfohlen und verwendet habe, und es ist der Ansatz, den ich auch in diesem Tutorial verwenden werde.

Fügen Sie der Datei das folgende Rollenkonfigurationsmarkup Web.config hinzu. Dieses Markup registriert einen neuen Anbieter namens 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>

Das obige Markup definiert den SecurityTutorialsSqlRoleProvider als Standardanbieter (über das defaultProvider -Attribut im <roleManager> -Element). Außerdem wird die SecurityTutorialsSqlRoleProvider-Einstellung von applicationName auf SecurityTutorialsfestgelegt. Dies ist die gleiche applicationName Einstellung, die vom Mitgliedschaftsanbieter (SecurityTutorialsSqlMembershipProvider) verwendet wird. Das -Element für das <add> -Element für kann SqlRoleProvider auch ein commandTimeout -Attribut enthalten, um die Dauer des Datenbanktimeouts in Sekunden anzugeben. Der Standardwert ist 30.

Nachdem dieses Konfigurationsmarkup eingerichtet wurde, können wir mit der Verwendung von Rollenfunktionen in unserer Anwendung beginnen.

Schritt 3: Untersuchen der Rollen-API

Die Funktionalität des Rollenframeworks wird über die -Klasse verfügbar gemacht, die Rolesdreizehn statische Methoden zum Ausführen rollenbasierter Vorgänge enthält. Wenn wir uns das Erstellen und Löschen von Rollen in den Schritten 4 und 6 ansehen, verwenden wir die CreateRole Methoden und DeleteRole , mit denen eine Rolle hinzugefügt oder aus dem System entfernt wird.

Um eine Liste aller Rollen im System abzurufen, verwenden Sie die GetAllRoles -Methode (siehe Schritt 5). Die RoleExists Methode gibt einen booleschen Wert zurück, der angibt, ob eine angegebene Rolle vorhanden ist.

Im nächsten Tutorial wird untersucht, wie Benutzer Rollen zugeordnet werden. Die Roles Methoden , AddUserToRoles, AddUsersToRoleund AddUsersToRoles der Klasse AddUserToRolefügen mindestens einer Rolle einen oder mehrere Benutzer hinzu. Um Benutzer aus Rollen zu entfernen, verwenden Sie die RemoveUserFromRoleMethoden , RemoveUserFromRoles, RemoveUsersFromRoleoder RemoveUsersFromRoles .

Im Tutorial Zur rollenbasierten Autorisierung untersuchen wir Möglichkeiten zum programmgesteuerten Anzeigen oder Ausblenden von Funktionen basierend auf der Rolle des aktuell angemeldeten Benutzers. Um dies zu erreichen, können wir die Methoden , , GetRolesForUserGetUsersInRoleoder IsUserInRole der Role -Klasse FindUsersInRoleverwenden.

Im weiteren Verlauf dieses Tutorials wird die Verwendung der Methoden , GetAllRolesund DeleteRole der Roles Klasse CreateRolezum Verwalten der Rollen im System untersucht.

Schritt 4: Erstellen neuer Rollen

Rollen bieten eine Möglichkeit, Benutzer willkürlich zu gruppieren, und in der Regel wird diese Gruppierung für eine bequemere Möglichkeit zum Anwenden von Autorisierungsregeln verwendet. Um Rollen jedoch als Autorisierungsmechanismus verwenden zu können, müssen wir zuerst definieren, welche Rollen in der Anwendung vorhanden sind. Leider enthält ASP.NET kein CreateRoleWizard-Steuerelement. Um neue Rollen hinzuzufügen, müssen wir eine geeignete Benutzeroberfläche erstellen und die Rollen-API selbst aufrufen. Die gute Nachricht ist, dass dies sehr einfach zu erreichen ist.

Öffnen Sie die ManageRoles.aspx Seite im Roles Ordner, und fügen Sie der Seite ein TextBox- und ein Button-Websteuerelement hinzu. Legen Sie die Eigenschaft des TextBox-Steuerelements ID auf RoleName und die Eigenschaften von Button ID und Text auf CreateRoleButton bzw. Rolle erstellen fest. An diesem Punkt sollte das deklarative Markup Ihrer Seite wie folgt aussehen:

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

Doppelklicken Sie als Nächstes auf das CreateRoleButton Button-Steuerelement im Designer, um einen Click Ereignishandler zu erstellen, und fügen Sie dann den folgenden Code hinzu:

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

Der obige Code beginnt mit dem Zuweisen des gekürzten Rollennamens, der in das RoleName Textfeld eingegeben wurde, der newRoleName Variablen. Als Nächstes wird die -Methode der RolesRoleExists -Klasse aufgerufen, um zu ermitteln, ob die Rolle newRoleName bereits im System vorhanden ist. Wenn die Rolle nicht vorhanden ist, wird sie über einen Aufruf der CreateRole -Methode erstellt. Wenn der CreateRole Methode ein Rollenname übergeben wird, der bereits im System vorhanden ist, wird eine ProviderException Ausnahme ausgelöst. Aus diesem Grund überprüft der Code zuerst, um sicherzustellen, dass die Rolle nicht bereits im System vorhanden ist, bevor er aufruft CreateRole. Der Click Ereignishandler beschließt, indem die RoleName TextBox-Eigenschaft Text entfernt wird.

Erstellen Wir nun eine Rolle mit dem Namen Administratoren. Besuchen Sie die ManageRoles.aspx Seite über einen Browser, geben Sie Administratoren in das Textfeld ein (siehe Abbildung 3), und klicken Sie dann auf die Schaltfläche Rolle erstellen.

Abbildung 3: Erstellen einer Administratorrolle (Klicken Sie hier, um das bild in voller Größe anzuzeigen)

Was passiert? Es wird ein Postback durchgeführt, aber es gibt keinen visuellen Hinweis, dass die Rolle tatsächlich zum System hinzugefügt wurde. Wir werden diese Seite in Schritt 5 so aktualisieren, dass sie visuelles Feedback enthält. Derzeit können Sie jedoch überprüfen, ob die Rolle erstellt wurde, indem Sie zur SecurityTutorials.mdf Datenbank wechseln und die Daten aus der aspnet_Roles Tabelle anzeigen. Wie Abbildung 4 zeigt, enthält die aspnet_Roles Tabelle einen Datensatz für die gerade hinzugefügten Administratorrollen.

Abbildung 4: Die aspnet_Roles Tabelle enthält eine Zeile für die Administratoren (Klicken Sie hier, um das bild in voller Größe anzuzeigen)

Schritt 5: Anzeigen der Rollen im System

Erweitern wir die ManageRoles.aspx Seite, um eine Liste der aktuellen Rollen im System einzuschließen. Um dies zu erreichen, fügen Sie der Seite ein GridView-Steuerelement hinzu, und legen Sie dessen ID Eigenschaft auf fest RoleList. Fügen Sie als Nächstes der CodeBehind-Klasse der Seite mithilfe des folgenden Codes eine Methode hinzu DisplayRolesInGrid :

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

Die Roles -Methode der GetAllRoles -Klasse gibt alle Rollen im System als Array von Zeichenfolgen zurück. Dieses Zeichenfolgenarray wird dann an die GridView gebunden. Um die Liste der Rollen beim ersten Laden der Seite an gridView zu binden, müssen wir die DisplayRolesInGrid -Methode aus dem Ereignishandler der Seite Page_Load aufrufen. Der folgende Code ruft diese Methode auf, wenn die Seite zum ersten Mal besucht wird, aber nicht bei nachfolgenden Postbacks.

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

Wenn dieser Code vorhanden ist, besuchen Sie die Seite über einen Browser. Wie Abbildung 5 zeigt, sollte ein Raster mit einer einzelnen Spalte mit der Bezeichnung Element angezeigt werden. Das Raster enthält eine Zeile für die Rolle "Administratoren", die wir in Schritt 4 hinzugefügt haben.

Abbildung 5: Die GridView zeigt die Rollen in einer einzelnen Spalte an (Klicken Sie, um das bild in voller Größe anzuzeigen)

GridView zeigt eine einzelne Spalte mit der Bezeichnung Item an, da die GridView-Eigenschaft AutoGenerateColumns auf True (Standard) festgelegt ist, wodurch GridView automatisch eine Spalte für jede Eigenschaft in ihrem DataSourceerstellt. Ein Array verfügt über eine einzelne Eigenschaft, die die Elemente im Array darstellt, daher die einzelne Spalte in gridView.

Beim Anzeigen von Daten mit einer GridView ziehe ich es vor, meine Spalten explizit zu definieren, anstatt sie implizit von GridView generieren zu lassen. Durch explizites Definieren der Spalten ist es viel einfacher, die Daten zu formatieren, die Spalten neu anzuordnen und andere gängige Aufgaben auszuführen. Aus diesem Grund aktualisieren wir das deklarative Markup von GridView, sodass seine Spalten explizit definiert sind.

Legen Sie zunächst die GridView-Eigenschaft AutoGenerateColumns auf False fest. Fügen Sie als Nächstes dem Raster ein TemplateField hinzu, legen Sie dessen HeaderText Eigenschaft auf Rollen fest, und konfigurieren Sie es ItemTemplate so, dass der Inhalt des Arrays angezeigt wird. Um dies zu erreichen, fügen Sie ein Label-Websteuerelement mit dem namen hinzu RoleNameLabelItemTemplate , und binden Sie seine Text Eigenschaft an Container.DataItem.

Diese Eigenschaften und der ItemTemplateInhalt können deklarativ oder über das Dialogfeld Felder von GridView und die Schnittstelle Vorlagen bearbeiten festgelegt werden. Um das Dialogfeld Felder zu erreichen, klicken Sie im Smarttag von GridView auf den Link Spalten bearbeiten. Deaktivieren Sie als Nächstes das Kontrollkästchen Felder automatisch generieren, um die AutoGenerateColumns Eigenschaft auf False festzulegen, und fügen Sie der GridView ein TemplateField-Element hinzu, und legen Sie dessen HeaderText Eigenschaft auf Role fest. Um den ItemTemplateInhalt zu definieren, wählen Sie im Smarttag von GridView die Option Vorlagen bearbeiten aus. Ziehen Sie ein Label Web-Steuerelement auf , ItemTemplatelegen Sie seine ID Eigenschaft auf fest RoleNameLabel, und konfigurieren Sie die Datenbindungseinstellungen, sodass seine Text Eigenschaft an Container.DataItemgebunden ist.

Unabhängig davon, welchen Ansatz Sie verwenden, sollte das resultierende deklarative Markup von GridView wie folgt aussehen, wenn Sie fertig sind.

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

Derzeit ist gridView RoleList nur an die Liste der Rollen gebunden, wenn die Seite zum ersten Mal besucht wird. Wir müssen das Raster aktualisieren, wenn eine neue Rolle hinzugefügt wird. Aktualisieren Sie dazu den Ereignishandler der CreateRoleButtonClick Schaltfläche so, dass er die DisplayRolesInGrid -Methode aufruft, wenn eine neue Rolle erstellt wird.

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

Wenn der Benutzer nun eine neue Rolle hinzufügt, zeigt GridView RoleList die gerade hinzugefügte Rolle beim Postback an und gibt visuelles Feedback, dass die Rolle erfolgreich erstellt wurde. Um dies zu veranschaulichen, besuchen Sie die ManageRoles.aspx Seite über einen Browser, und fügen Sie eine Rolle namens Supervisors hinzu. Wenn Sie auf die Schaltfläche Rolle erstellen klicken, wird ein Postback erstellt, und das Raster wird aktualisiert, um Administratoren sowie die neue Rolle "Supervisors" einzubeziehen.

Abbildung 6: Die Rolle "Supervisors" wurde hinzugefügt (Klicken Sie hier, um das bild in voller Größe anzuzeigen)

Schritt 6: Löschen von Rollen

An diesem Punkt kann ein Benutzer eine neue Rolle erstellen und alle vorhandenen Rollen auf der ManageRoles.aspx Seite anzeigen. Lassen Sie uns Benutzern erlauben, auch Rollen zu löschen. Die Roles.DeleteRole Methode verfügt über zwei Überladungen:

• DeleteRole(roleName) – löscht die rolle roleName. Eine Ausnahme wird ausgelöst, wenn die Rolle mindestens ein Element enthält.
• DeleteRole(roleName, throwOnPopulatedRole) – löscht die rolle roleName. Wenn throwOnPopulateRole ist true, wird eine Ausnahme ausgelöst, wenn die Rolle mindestens ein Element enthält. Wenn throwOnPopulateRole ist false, wird die Rolle gelöscht, unabhängig davon, ob sie Elemente enthält oder nicht. Intern ruft die DeleteRole(roleName) -Methode auf DeleteRole(roleName, true).

Die DeleteRole -Methode löst auch eine Ausnahme aus, wenn roleName oder eine leere Zeichenfolge ist null oder wenn roleName ein Komma enthält. Wenn roleName im System nicht vorhanden ist, DeleteRole schlägt ohne Ausnahme automatisch fehl.

Erweitern wir die GridView in ManageRoles.aspx , um eine Schaltfläche Löschen einzuschließen, mit der die ausgewählte Rolle gelöscht wird, wenn sie darauf geklickt wird. Beginnen Sie mit dem Hinzufügen einer Schaltfläche Löschen zur GridView, indem Sie zum Dialogfeld Felder wechseln und eine Schaltfläche Löschen hinzufügen, die sich unter der Option CommandField befindet. Legen Sie die Schaltfläche Löschen ganz links fest, und legen Sie ihre DeleteText Eigenschaft auf Rolle löschen fest.

Abbildung 7: Hinzufügen einer Schaltfläche zum Löschen zur RoleList GridView (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Nach dem Hinzufügen der Schaltfläche Löschen sollte das deklarative Markup Ihres GridView wie folgt aussehen:

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

Erstellen Sie als Nächstes einen Ereignishandler für das GridView-Ereignis RowDeleting . Dies ist das Ereignis, das beim Postback ausgelöst wird, wenn auf die Schaltfläche Rolle löschen geklickt wird. Fügen Sie dem Ereignishandler folgenden Code hinzu.

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

Der Code verweist zunächst programmgesteuert auf das RoleNameLabel Websteuerelement in der Zeile, auf deren Schaltfläche "Rolle löschen" geklickt wurde. Die Roles.DeleteRole -Methode wird dann aufgerufen und übergeben, TextRoleNameLabelfalsewodurch die Rolle gelöscht wird, unabhängig davon, ob der Rolle Benutzer zugeordnet sind. Schließlich wird gridView RoleList aktualisiert, sodass die gerade gelöschte Rolle nicht mehr im Raster angezeigt wird.

Zusammenfassung

Viele Webanwendungen verfügen über bestimmte Autorisierungsregeln oder Funktionen auf Seitenebene, die nur für bestimmte Benutzerklassen verfügbar sind. Beispielsweise kann es eine Reihe von Webseiten geben, auf die nur Administratoren zugreifen können. Anstatt diese Autorisierungsregeln auf Benutzerbasis zu definieren, ist es häufig nützlicher, die Regeln basierend auf einer Rolle zu definieren. Das heißt, anstatt Benutzern Scott und Jisun explizit den Zugriff auf die Administrativen Webseiten zu gestatten, besteht ein besser verwaltbarerEr Ansatz darin, Mitgliedern der Rolle "Administratoren" den Zugriff auf diese Seiten zu ermöglichen und dann Scott und Jisun als Benutzer zu bezeichnen, die der Rolle "Administratoren" angehören.

Das Rollenframework erleichtert das Erstellen und Verwalten von Rollen. In diesem Tutorial haben wir untersucht, wie Sie das Rollenframework für die Verwendung von SqlRoleProviderkonfigurieren, das eine Microsoft SQL Server-Datenbank als Rollenspeicher verwendet. Außerdem haben wir eine Webseite erstellt, die die vorhandenen Rollen im System auflistet und das Erstellen neuer und des Löschens vorhandener Rollen ermöglicht. In den nachfolgenden Tutorials erfahren Sie, wie Sie Benutzer Rollen zuweisen und die rollenbasierte Autorisierung anwenden.

Viel Spaß beim Programmieren!

Weitere Informationen

Weitere Informationen zu den in diesem Tutorial erläuterten Themen finden Sie in den folgenden Ressourcen:

• Untersuchen von Mitgliedschaft, Rollen und Profil von ASP.NET 2.0
• Vorgehensweise: Verwenden des Rollen-Managers in ASP.NET 2.0
• Rollenanbieter
• Technische Dokumentation für das <roleManager> Element
• Verwenden der Mitgliedschafts- und Rollen-Manager-APIs

Zum Autor

Scott Mitchell, Autor mehrerer ASP/ASP.NET-Bücher und Gründer von 4GuysFromRolla.com, arbeitet seit 1998 mit Microsoft-Webtechnologien. Scott arbeitet als unabhängiger Berater, Trainer und Autor. Sein neuestes Buch ist Sams Teach Yourself ASP.NET 2.0 in 24 Stunden. Scott kann unter mitchell@4guysfromrolla.com oder über seinen Blog unter http://ScottOnWriting.NETerreicht werden.

Besonderen Dank an

Diese Tutorialreihe wurde von vielen hilfreichen Prüfern überprüft. Zu den leitenden Prüfern für dieses Tutorial gehören Alicja Maziarz, Suchi Banerjee und Teresa Murphy. Möchten Sie meine anstehenden MSDN-Artikel lesen? Wenn dies der Fall ist, legen Sie mir eine Zeile unter mitchell@4GuysFromRolla.com