Erstellen und Verwalten von Rollen (C#)

von Scott Mitchell

Code herunterladen oder PDF herunterladen

In diesem Lernprogramm werden die Schritte untersucht, die zum Konfigurieren des Rollenframeworks erforderlich sind. Danach erstellen wir Webseiten zum Erstellen und Löschen von Rollen.

Einführung

ImUser-Based Autorisierungslernprogramm haben wir uns mit der URL-Autorisierung befasst, um bestimmte Benutzer von einer Reihe von Seiten einzuschränken und deklarative und programmgesteuerte Techniken zum Anpassen der Funktionalität einer ASP.NET Seite basierend auf dem besuchten Benutzer untersucht. Die Gewährung von Berechtigungen für den Seitenzugriff oder die Funktionalität auf Benutzerbasis kann jedoch zu einem Wartungsaltraum in Szenarien werden, in denen viele Benutzerkonten vorhanden sind oder sich die Rechte der Benutzer häufig ändern. Jedes Mal, wenn ein Benutzer die Autorisierung zum Ausführen einer bestimmten Aufgabe erhält oder verliert, muss der Administrator die entsprechenden URL-Autorisierungsregeln, deklaratives Markup und Code aktualisieren.

Normalerweise hilft es, Benutzer in Gruppen oder Rollen zu klassifizieren und dann Berechtigungen auf Rollenbasis anzuwenden. Die meisten Webanwendungen verfügen beispielsweise über einen bestimmten Satz von Seiten oder Aufgaben, die nur für Administrative Benutzer reserviert sind. Mithilfe der im User-Based Autorisierungslernprogramm gelernten Techniken würden wir die entsprechenden URL-Autorisierungsregeln, deklaratives Markup und Code hinzufügen, 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önnen 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 vorhanden 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 zum 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 der Benutzer bestimmen, die zu einer bestimmten Rolle gehören, und bestimmen, 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 Rollen des aktuell angemeldeten Benutzers ein- oder ausblenden.

In diesem Lernprogramm werden die Schritte untersucht, die zum Konfigurieren des Rollenframeworks erforderlich sind. Danach erstellen wir Webseiten zum Erstellen und Löschen von Rollen. Im Lernprogramm zum Zuweisen von Rollen zu Benutzern sehen wir uns an, wie Benutzer aus Rollen hinzugefügt und entfernt werden. Und im Role-Based Autorisierungs-Lernprogramm erfahren Sie, wie Sie den Zugriff auf Seiten auf Rollenbasis beschränken und wie Sie die Seitenfunktionalität je nach Rolle des Gastbenutzers anpassen. Fangen wir an!

Schritt 1: Hinzufügen neuer ASP.NET Seiten

In dieser Anleitung und den nächsten beiden Tutorials werden wir verschiedene rollenbezogene Funktionen und Fähigkeiten untersuchen. Wir benötigen eine Reihe von ASP.NET Seiten, um die in diesen Lernprogrammen untersuchten Themen zu implementieren. Lassen Sie uns diese Seiten erstellen und die Sitemap aktualisieren.

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

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

An diesem Punkt sollte der Projektmappen-Explorer dem screenshot in Abbildung 1 ähneln.

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

Jede Seite sollte an diesem Punkt über die beiden Inhaltssteuerelemente verfügen, eines für jeden der ContentPlaceHolders der Masterseite: MainContent und LoginContent.

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

Erinnern Sie sich daran, dass das LoginContent Standardmarkup von ContentPlaceHolder einen Link zum Anmelden oder Abmelden der Website anzeigt, je nachdem, ob der Benutzer authentifiziert ist. Jedoch überschreibt das Vorhandensein des Content2 Inhaltssteuerelements auf der ASP.NET-Seite das Standardmarkup der Masterseite. Wie im " beschrieben, ist das Überschreiben des Standardmarkups auf Seiten hilfreich, 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 Inhaltssteuerelement. Danach sollte das Markup jeder der vier Seiten nur ein Inhaltssteuerelement enthalten.

Abschließend aktualisieren wir die Websitekarte (Web.sitemap), um diese neuen Webseiten einzuschließen. Fügen Sie den folgenden XML-Code nach dem <siteMapNode>, das wir für die Mitgliedschaftstutorials hinzugefügt haben, hinzu.

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

Sobald die Sitemap aktualisiert ist, besuchen Sie die Website über einen Browser. Wie in Abbildung 2 dargestellt, enthält die Navigation auf der linken Seite jetzt Elemente für die Rollenlernprogramme.

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

Schritt 2: Angeben und Konfigurieren des Rollenframeworkanbieters

Wie das Mitgliedschaftsframework wird das Rollenframework auf dem Anbietermodell erstellt. Wie im Lernprogramm „Security Basics“ und „ASP.NET Support“ erläutert, wird das .NET Framework mit drei integrierten Rollenanbietern ausgeliefert: AuthorizationStoreRoleProvider, WindowsTokenRoleProvider, und SqlRoleProvider. Diese Tutorialreihe konzentriert sich auf den SqlRoleProvider, der eine Microsoft SQL Server-Datenbank als Rollenspeicher verwendet.

Hinter den Kulissen funktioniert das Rollenframework und SqlRoleProvider genauso wie das Mitgliedschaftsframework und SqlMembershipProvider. Das .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, GetAllRoles, AddUserToRole, IsUserInRoleusw. Wenn eine dieser Methoden aufgerufen wird, delegiert die Roles Klasse den Aufruf an den konfigurierten Anbieter. Dieses SqlRoleProvider funktioniert als Antwort mit den rollenspezifischen Tabellen (aspnet_Roles und aspnet_UsersInRoles).

Um den SqlRoleProvider Anbieter in unserer Anwendung zu verwenden, müssen wir angeben, welche Datenbank als Speicher verwendet werden soll. Der SqlRoleProvider angegebene Rollenspeicher erwartet, dass bestimmte Datenbanktabellen, Ansichten und gespeicherte Prozeduren vorhanden sind. Diese erforderlichen Datenbankobjekte können mithilfe des aspnet_regsql.exe Tools hinzugefügt werden. An diesem Punkt verfügen wir bereits über eine Datenbank mit dem Schema, das für die SqlRoleProvider erforderlich ist. Im vorherigen Lernprogramm Erstellen des Mitgliedschaftsschemas in SQL Server haben wir eine Datenbank mit dem Namen SecurityTutorials.mdf erstellt und aspnet_regsql.exe verwendet, um die Anwendungsdienste hinzuzufügen, die die für SqlRoleProvider erforderlichen Datenbankobjekte enthielten. Daher müssen wir dem Rollenframework lediglich mitteilen, dass die Rollenunterstützung aktiviert und die SqlRoleProviderSecurityTutorials.mdf Datenbank als Rollenspeicher verwendet werden kann.

Das Rollenframework wird über das <roleManager> Element in der Datei der Anwendung Web.config konfiguriert. Standardmäßig ist die Rollenunterstützung deaktiviert. Um es zu aktivieren, müssen Sie das Attribut des <roleManager>enabled Elements folgendermaßen auf 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 AspNetSqlRoleProvider des Typs SqlRoleProvider. 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 setzt dieses Attribut auf LocalSqlServer, das ebenfalls in machine.config definiert ist und standardmäßig auf eine SQL Server 2005 Express Edition-Datenbank im Ordner App_Data mit dem Namen aspnet.mdf verweist.

Wenn wir also einfach das Rollenframework aktivieren, ohne Anbieterinformationen in der Datei unserer Anwendung Web.config anzugeben, verwendet die Anwendung den standardmäßigen registrierten Rollenanbieter. AspNetSqlRoleProvider Wenn die ~/App_Data/aspnet.mdf-Datenbank nicht vorhanden ist, wird sie von der ASP.NET-Laufzeit automatisch erstellt und das Schema für Anwendungsdienste hinzugefügt. Wir möchten jedoch nicht die aspnet.mdf Datenbank verwenden, sondern die SecurityTutorials.mdf Datenbank, die wir bereits erstellt und dem Anwendungsdienstschema hinzugefügt haben. Diese Änderung kann auf eine von zwei Arten durchgeführt werden:

• Angeben eines Werts für denLocalSqlServerVerbindungszeichenfolgenname inWeb.config. Durch das Überschreiben des Namenswerts der LocalSqlServer Verbindungszeichenfolge in Web.configkönnen wir den standard registrierten Rollenanbieter (AspNetSqlRoleProvider) verwenden und ordnungsgemäß mit der SecurityTutorials.mdf Datenbank arbeiten lassen. 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.
• Fügen Sie einen neuen registrierten Anbieter vom Typ hinzu und konfigurieren Sie dessen Einstellungen, sodass sie auf dieDatenbank verweisen. Dies ist der Ansatz, den ich in dem Lernprogramm 'Erstellen des Mitgliedschaftsschemas in SQL Server' empfohlen und verwendet habe, und es ist auch der Ansatz, den ich in diesem Tutorial verwenden werde.

Fügen Sie der Datei Web.config das folgende Konfigurationsmarkup für Rollen hinzu. Dieses Markup registriert einen neuen Anbieter mit dem Namen 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 Standardanbieter (über das defaultProvider Attribut im <roleManager> Element). Außerdem wird die Einstellung von SecurityTutorialsSqlRoleProvider auf applicationName festgelegt, was die gleiche SecurityTutorials-Einstellung ist, die vom Mitgliedschaftsanbieter applicationName verwendet wird (SecurityTutorialsSqlMembershipProvider). Für das Element <add> kann auch ein commandTimeout Attribut enthalten sein, um die Dauer des Datenbank-Timeouts in Sekunden festzulegen. Der Standardwert ist 30.

Mit diesem Konfigurationsmarkup können wir mit der Verwendung von Rollenfunktionen in unserer Anwendung beginnen.

Schritt 3: Untersuchen der Rollen-API

Die Funktionen des Rollenframeworks werden über die Roles Klasse verfügbar gemacht, die dreizehn 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 Methoden, die eine Rolle aus dem System hinzufügen oder entfernen.

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 Lernprogramm untersuchen wir, wie Benutzer Rollen zugeordnet werden. Die Methoden AddUserToRole, AddUserToRoles, AddUsersToRole und AddUsersToRoles der Roles-Klasse fügen mindestens einen Benutzer zu einer oder mehreren Rollen hinzu. Um Benutzer aus Rollen zu entfernen, verwenden Sie die RemoveUserFromRoleMethoden , RemoveUserFromRoles, , RemoveUsersFromRoleoder RemoveUsersFromRoles

ImRole-Based Autorisierungslernprogramm werden wir Möglichkeiten zum programmgesteuerten Ein- oder Ausblenden von Funktionen basierend auf der Rolle des aktuell angemeldeten Benutzers betrachten. Dazu können wir die Methoden Role, FindUsersInRole, GetRolesForUser, GetUsersInRole oder IsUserInRole der Role-Klasse verwenden.

In dem restlichen Teil dieses Lernprogramms wird die Verwendung der Methoden der Roles Klasse sowie der CreateRole, GetAllRoles und DeleteRole zur Verwaltung der Rollen im System erläutert.

Schritt 4: Erstellen neuer Rollen

Rollen bieten eine Möglichkeit, Benutzer willkürlich zu gruppieren, und diese Gruppierung wird am häufigsten für eine bequemere Möglichkeit zum Anwenden von Autorisierungsregeln verwendet. Um rollen jedoch als Autorisierungsmechanismus zu verwenden, 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 ID TextBox-Steuerelements auf RoleName und die Eigenschaften der Schaltfläche ID und Text auf CreateRoleButton und 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 im Designer auf das CreateRoleButton Schaltflächensteuerelement, 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, indem der gekürzte Rollenname, der in das RoleName-Textfeld eingegeben wurde, der Variablen newRoleName zugewiesen wird. Als Nächstes wird die Methode der Roles Klasse aufgerufen, um festzustellen, ob die Rolle newRoleName bereits im System existiert. Wenn die Rolle nicht vorhanden ist, wird sie über einen Aufruf der CreateRole Methode erstellt. Wenn der CreateRole-Methode ein Rollenname übergeben wird, der im System bereits vorhanden ist, wird eine ProviderException-Ausnahme ausgelöst. Aus diesem Grund prüft der Code zuerst, um sicherzustellen, dass die Rolle vor dem Aufrufen CreateRolenicht bereits im System vorhanden ist. Der Click Ereignishandler wird beendet, indem die Eigenschaft des RoleNameText TextBox-Objekts gelöscht wird.

Erstellen wir eine Rolle namens "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 ist los? Ein Postback tritt auf, aber es gibt keinen visuellen Hinweis, dass die Rolle tatsächlich dem System hinzugefügt wurde. Wir aktualisieren diese Seite in Schritt 5, um visuelles Feedback einzuschließen. Jetzt 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 in Abbildung 4 dargestellt, enthält die aspnet_Roles Tabelle einen Datensatz für die soeben 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. Fügen Sie dazu der Seite ein GridView-Steuerelement hinzu, und legen Sie dessen ID Eigenschaft auf RoleList. Fügen Sie als Nächstes eine Methode zur CodeBehind-Klasse der Seite hinzu und benennen Sie sie mit DisplayRolesInGrid, indem Sie den folgenden Code verwenden:

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

Die Roles Methode der Klasse GetAllRoles gibt alle Rollen im System als Array von Zeichenfolgen zurück. Dieses Array von Zeichenfolgen wird dann an das GridView angebunden. 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 für nachfolgende Postbacks.

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

Besuchen Sie mit diesem Code die Seite über einen Browser. Wie in Abbildung 5 dargestellt, 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: In der GridView werden die Rollen in einer einzelnen Spalte angezeigt (Zum Anzeigen des Bilds mit voller Größe klicken)

GridView zeigt eine einzelne Spalte mit der Beschriftung Item an, da die Eigenschaft AutoGenerateColumns von GridView standardmäßig auf "True" gesetzt ist, wodurch GridView automatisch für jede Eigenschaft in der DataSource eine Spalte erstellt. Ein Array verfügt über eine einzelne Eigenschaft, die die Elemente im Array darstellt, daher die einzelne Spalte in der GridView.

Beim Anzeigen von Daten mit einer GridView möchte ich meine Spalten explizit definieren, anstatt dass sie implizit von GridView generiert werden. Durch die explizite Definition der Spalten ist es wesentlich einfacher, die Daten zu formatieren, die Spalten neu anzuordnen und andere allgemeine Aufgaben auszuführen. Daher aktualisieren wir das deklarative Markup von GridView so, dass seine Spalten explizit definiert sind.

Legen Sie zunächst die Eigenschaft "GridView AutoGenerateColumns " auf "False" fest. Fügen Sie als Nächstes ein TemplateField zum Raster hinzu, legen Sie dessen HeaderText Eigenschaft auf "Rollen" fest, und konfigurieren Sie die ItemTemplate Eigenschaft so, dass der Inhalt des Arrays angezeigt wird. Fügen Sie dazu ein Label-Webkontrollelement mit dem Namen RoleNameLabel zu ItemTemplate hinzu, und binden Sie dessen Text-Eigenschaft an Container.DataItem.

Diese Eigenschaften und der Inhalt von ItemTemplate können deklarativ oder über das Dialogfeld „Felder“ von GridView und über die Bearbeitungsoberfläche „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 hinzu, und legen Sie dessen HeaderText Eigenschaft auf "Role" fest. Um den ItemTemplateInhalt zu definieren, wählen Sie die Option "Vorlagen bearbeiten" aus dem SmartTag von GridView aus. Ziehen Sie ein Label-Websteuerelement auf das ItemTemplate Steuerelement, legen Sie dessen ID Eigenschaft auf RoleNameLabel fest, und konfigurieren Sie die Datenbindungseinstellungen so, dass die Text Eigenschaft an Container.DataItem gebunden ist.

Unabhängig davon, welche Vorgehensweise Sie verwenden, sollte das resultierende deklarative Markup von GridView ähnlich 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 CreateRoleButton Schaltfläche Click so, dass sie 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, RoleList zeigt GridView die gerade hinzugefügte Rolle für postback an und liefert 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 erfolgen, und die Tabelle wird aktualisiert, um Administratoren sowie die neue Rolle Aufseher einzuschließen.

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. Zulassen, dass Benutzer auch Rollen löschen können. Die Roles.DeleteRole Methode verfügt über zwei Überladungen:

• DeleteRole(roleName) - löscht die Rolle roleName. Eine Ausnahme wird ausgelöst, wenn die Rolle ein oder mehr Mitglieder enthält.
• DeleteRole(roleName, throwOnPopulatedRole) - löscht die Rolle roleName. Wenn throwOnPopulateRole auf true gesetzt ist, wird eine Ausnahme ausgelöst, wenn die Rolle ein oder mehrere Mitglieder enthält. Wenn throwOnPopulateRolefalse ist, wird die Rolle gelöscht, unabhängig davon, ob sie Mitglieder 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, schlägt DeleteRole im Stillen fehl, ohne eine Ausnahme auszulösen.

Erweitern wir das GridView-Element ManageRoles.aspx , um eine Schaltfläche "Löschen" einzuschließen, die beim Klicken auf die ausgewählte Rolle gelöscht wird. Beginnen Sie, indem Sie der GridView eine Schaltfläche "Löschen" hinzufügen, 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" in der spalte ganz links fest, und legen Sie dessen DeleteText Eigenschaft auf "Rolle löschen" fest.

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

Nachdem Sie die Schaltfläche "Löschen" hinzugefügt haben, sollte das deklarative Markup Ihres GridView-Steuerelements 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 den 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 programmgesteuert auf das RoleNameLabel Websteuerelement in der Zeile, auf dessen Schaltfläche "Rolle löschen" geklickt wurde. Anschließend wird die Roles.DeleteRole-Methode aufgerufen, wobei die TextRoleNameLabel-Rolle und false übergeben werden, wodurch die Rolle gelöscht wird, unabhängig davon, ob der Rolle Benutzer zugeordnet sind. Schließlich wird die RoleList GridView 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 bestimmten Benutzerklassen zur Verfügung stehen. Es kann beispielsweise eine Reihe von Webseiten geben, auf die nur Administratoren zugreifen können. Anstatt diese Autorisierungsregeln auf Benutzerbasis zu definieren, ist es häufig sinnvoller, die Regeln basierend auf einer Rolle zu definieren. Das heißt, anstatt den Benutzern Scott und Jisun explizit den Zugriff auf die administrativen Webseiten zu gestatten, besteht eine besser verwendbare Vorgehensweise darin, Mitgliedern der Rolle "Administratoren" den Zugriff auf diese Seiten zu ermöglichen, und dann Scott und Jisun als Benutzer zu kennzeichnen, die zur Rolle "Administratoren" gehören.

Das Rollenframework erleichtert das Erstellen und Verwalten von Rollen. In diesem Lernprogramm haben wir untersucht, wie das Rollenframework konfiguriert wird, um SqlRoleProvider zu verwenden, das eine Microsoft SQL Server-Datenbank als Rollenspeicher nutzt. Außerdem wurde eine Webseite erstellt, die die vorhandenen Rollen im System auflistet und ermöglicht, dass neue Rollen erstellt und vorhandene rollen gelöscht werden können. In nachfolgenden Lernprogrammen erfahren Sie, wie Sie Benutzern Rollen zuweisen und rollenbasierte Autorisierung anwenden.

Glückliche Programmierung!

Weiterführende Lektüre

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

• Untersuchen der Mitgliedschaft, Rollen und Profile 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 Web Technologies zusammen. Scott arbeitet als unabhängiger Berater, Trainer und Schriftsteller. Sein neuestes Buch ist Sams Teach Yourself ASP.NET 2.0 in 24 Stunden. Scott kann unter mitchell@4guysfromrolla.com erreicht werden oder über seinen Blog unter http://ScottOnWriting.NET.

Besonderer Dank an

Diese Lernprogrammreihe wurde von vielen hilfreichen Prüfern überprüft. Leitende Prüfer für dieses Lernprogramm sind Alicja Maziarz, Suchi Banerjee und Teresa Murphy. Möchten Sie meine bevorstehenden MSDN-Artikel überprüfen? Wenn das der Fall ist, schreiben Sie mir eine Nachricht an mitchell@4GuysFromRolla.com