Erstellen und Verwalten von Rollen (VB)

von Scott Mitchell

Hinweis

Seit diesem Artikel wurden die ASP.NET-Mitgliedschaftsanbieter von ASP.NET Identity abgelöst. Es wird dringend empfohlen, Apps so zu aktualisieren, dass sie die ASP.NET Identity-Plattform anstelle der Mitgliedschaftsanbieter verwenden, die zum Zeitpunkt des Schreibens dieses Artikels vorgestellt wurden. ASP.NET Identity bietet eine Reihe von Vorteilen gegenüber dem ASP.NET Mitgliedschaftssystem, darunter:

• Bessere Leistung
• Verbesserte Erweiterbarkeit und Testbarkeit
• Unterstützung für OAuth, OpenID Connect und zweistufige Authentifizierung
• Unterstützung der anspruchsbasierten Identität
• Bessere Interoperabilität mit ASP.Net Core

Code herunterladen oder PDF herunterladen

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

Einführung

Im Tutorial "Benutzerbasierte Autorisierung" haben wir die Verwendung der URL-Autorisierung untersucht, um bestimmte Benutzer auf einer 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 den Seitenzugriff oder die Funktionalität auf Benutzerbasis kann jedoch in Szenarien, in denen viele Benutzerkonten vorhanden sind oder sich die Berechtigungen von Benutzern häufig ändern, zu einem Wartungs alptraum werden. Jedes Mal, wenn ein Benutzer die Autorisierung erhält oder verliert, um eine bestimmte Aufgabe auszuführen, muss der Administrator die entsprechenden URL-Autorisierungsregeln, das deklarative Markup und den 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 Administratorbenutzer reserviert sind. Mit den Techniken, die im Tutorial "Benutzerbasierte Autorisierung" gelernt wurden, 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 wenn ein vorhandener Administrator ihre Administratorrechte widerrufen musste, müssen 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 Verwaltungsaufgaben 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-, deklarativen 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 Benutzer daraus entfernen, die Gruppe von Benutzern bestimmen, die zu einer bestimmten Rolle gehören, und ermitteln, ob ein Benutzer zu einer bestimmten Rolle gehört. Nachdem das Rollenframework konfiguriert wurde, können wir den Zugriff auf Seiten rollenweise ü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. Anschließend 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 aus Rollen entfernen. Im Tutorial " Rollenbasierte Autorisierung" erfahren Sie, wie Sie den Zugriff auf Seiten rollenweise einschränken und die Seitenfunktionalität je nach Rolle anpassen können. Jetzt geht‘s los!

Schritt 1: Hinzufügen neuer ASP.NET Seiten

In diesem tutorial und den beiden nächsten werden wir verschiedene rollenbezogene Funktionen und Funktionen untersuchen. Wir benötigen eine Reihe von ASP.NET Seiten, um die in diesen Tutorials behandelten Themen zu implementieren. Erstellen Sie diese Seiten, und aktualisieren Sie die Websiteübersicht.

Erstellen Sie zunächst einen neuen Ordner im Projekt mit dem Namen Roles. Fügen Sie als Nächstes dem Ordner vier neue ASP.NET Seiten hinzu, wobei Roles 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 dem Screenshot in Abbildung 1 ähneln.

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

Jede Seite sollte zu diesem Zeitpunkt ü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 ASP.NET Seite überschreibt jedoch das Standardmarkup der master Seite. Wie im Tutorial Übersicht über die Formularauthentifizierung beschrieben, ist das Überschreiben des Standardmarkups auf Seiten nützlich, auf denen anmeldebezogene Optionen in der linken Spalte nicht 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 jede der vier Seiten nur ein Content-Steuerelement enthalten.

Abschließend 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 Siteübersicht aktualisiert wurde, besuchen Sie die Website über einen Browser. Wie Abbildung 2 zeigt, enthält die Navigation auf der linken Seite jetzt 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 dem Anbietermodell 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 der Abdeckungen funktionieren das Rollenframework und SqlRoleProvider funktionieren 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 freigegebene Methoden wie CreateRole, DeleteRole, GetAllRoles, AddUserToRole, IsUserInRoleusw. Wenn eine dieser Methoden aufgerufen wird, delegiert die Roles -Klasse den Aufruf an den konfigurierten Anbieter. Die SqlRoleProvider funktioniert 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, Ansichten und gespeicherte Prozeduren verfügt. Diese erforderlichen Datenbankobjekte können mit dem aspnet_regsql.exe Tool hinzugefügt werden. Zu diesem Zeitpunkt verfügen wir bereits über eine Datenbank mit dem schema, das für das SqlRoleProvidererforderlich ist. Zurück im Tutorial Erstellen des Mitgliedschaftsschemas in SQL Server haben wir eine Datenbank mit dem Namen SecurityTutorials.mdf und zum aspnet_regsql.exe Hinzufügen der Anwendungsdienste erstellt, die die für die erforderlichen SqlRoleProviderDatenbankobjekte enthält. Daher müssen wir nur 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 es zu aktivieren, müssen Sie das <roleManager> Attribut des enabled Elements auf true "Gefällt mir" 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 vom AspNetSqlRoleProvider Typ 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 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 aspnet.mdfverweist.

Wenn wir also einfach das Rollenframework aktivieren, ohne anbieterinformationen in der Datei unserer Anwendung Web.config anzugeben, 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 zwei Arten durchgeführt werden:

• Geben Sie einen Wert für dieLocalSqlServerVerbindungszeichenfolgenname inWeb.config. Durch Überschreiben des Werts des LocalSqlServer Verbindungszeichenfolgennamens in Web.configkönnen wir den standardmäßig registrierten Rollenanbieter (AspNetSqlRoleProvider) verwenden und sicherstellen, dass er ordnungsgemäß mit der SecurityTutorials.mdf Datenbank funktioniert. Weitere Informationen zu diesem Verfahren 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 ...

 &nbsp &nbsp<roleManager enabled="true" defaultProvider="SecurityTutorialsSqlRoleProvider">
 &nbsp &nbsp &nbsp<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 SecurityTutorialsSqlRoleProviderEinstellung "s" auf SecurityTutorialsfestgelegt. Dies applicationName ist die gleiche applicationName Einstellung, die vom Mitgliedschaftsanbieter (SecurityTutorialsSqlMembershipProvider) verwendet wird. Das Element für SqlRoleProvider den <add> enthält möglicherweise auch ein commandTimeout Attribut, um die Dauer des Datenbanktimeouts in Sekunden anzugeben. Der Standardwert ist 30.

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

Hinweis

Das obige Konfigurationsmarkup veranschaulicht die Verwendung der <roleManager> Attribute und defaultProvider des enabled Elements. Es gibt eine Reihe weiterer Attribute, die beeinflussen, wie das Rollenframework Rolleninformationen auf Benutzerbasis zuordnet. Diese Einstellungen werden im Tutorial zur rollenbasierten Autorisierung untersucht.

Schritt 3: Untersuchen der Rollen-API

Die Funktionalität des Rollenframeworks wird über die -Klasse verfügbar gemacht, die Rolesdreizehn freigegebene 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 dem System hinzugefügt oder daraus 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 Sie Benutzer rollen zuordnen. Die Roles Methoden , AddUserToRoles, AddUsersToRoleund AddUsersToRoles der Klasse AddUserToRolefügen mindestens einen Benutzer zu einer oder mehreren Rollen hinzu. Um Benutzer aus Rollen zu entfernen, verwenden Sie die RemoveUserFromRoleMethoden , RemoveUserFromRoles, RemoveUsersFromRoleoder RemoveUsersFromRoles .

Im Tutorial zur rollenbasierten Autorisierung werden Möglichkeiten zum programmgesteuerten Ein- oder Ausblenden von Funktionen anhand der Rolle des aktuell angemeldeten Benutzers untersucht. Um dies zu erreichen, können wir die Methoden , GetRolesForUser, GetUsersInRoleoder IsUserInRole der Role-Klasse FindUsersInRoleverwenden.

Hinweis

Beachten Sie, dass die -Klasse den Aufruf an den konfigurierten Anbieter delegiert, Roles wenn eine dieser Methoden aufgerufen wird. In unserem Fall bedeutet dies, dass der Aufruf an gesendet SqlRoleProviderwird. Führt SqlRoleProvider dann den entsprechenden Datenbankvorgang basierend auf der aufgerufenen Methode aus. Der Code Roles.CreateRole("Administrators") führt beispielsweise dazu, dass die SqlRoleProvideraspnet_Roles_CreateRole gespeicherte Prozedur ausgeführt wird, die einen neuen Datensatz in die Tabelle mit dem aspnet_Roles Namen Administratoren einfügt.

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

Schritt 4: Erstellen neuer Rollen

Rollen bieten eine Möglichkeit, Benutzer willkürlich zu gruppieren, und am häufigsten wird diese Gruppierung verwendet, um Autorisierungsregeln bequemer anzuwenden. Um Rollen jedoch als Autorisierungsmechanismus verwenden zu können, müssen wir zunächst 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.

Hinweis

Es gibt zwar kein CreateRoleWizard-Websteuerelement, aber es gibt das ASP.NET-Websiteverwaltungstool, bei dem es sich um eine lokale ASP.NET-Anwendung handelt, die beim Anzeigen und Verwalten der Konfiguration Ihrer Webanwendung unterstützt wird. Allerdings bin ich aus zwei Gründen kein großer Fan des ASP.NET Web Site Administration Tools. Erstens ist es ein bisschen fehlerhaft und die Benutzererfahrung lässt viel zu wünschen übrig. Zweitens ist das ASP.NET Web Site Administration Tool so konzipiert, dass es nur lokal funktioniert, was bedeutet, dass Sie Ihre eigenen Rollenverwaltungswebseiten erstellen müssen, wenn Sie Rollen auf einer Livewebsite remote verwalten müssen. Aus diesen beiden Gründen konzentrieren sich dieses und das nächste Tutorial darauf, die erforderlichen Rollenverwaltungstools auf einer Webseite zu erstellen, anstatt sich auf das ASP.NET Websiteverwaltungstool zu verlassen.

Ö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 button ID und Text auf CreateRoleButton bzw. Rolle erstellen fest. An diesem Punkt sollte das deklarative Markup Ihrer Seite in etwa 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 Button-Steuerelement, um einen Click Ereignishandler zu erstellen, und fügen Sie dann den folgenden Code hinzu:

Protected Sub CreateRoleButton_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles CreateRoleButton.Click
 Dim newRoleName As String = RoleName.Text.Trim()

 If Not Roles.RoleExists(newRoleName) Then
 ' Create the role
 Roles.CreateRole(newRoleName)
 End If

 RoleName.Text= String.Empty 
End Sub

Der obige Code beginnt mit dem Zuweisen des gekürzten Rollennamens, der in textBox RoleName eingegeben wurde, der newRoleName Variablen. Als Nächstes wird die -Methode der RolesRoleExists -Klasse aufgerufen, um zu bestimmen, 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 aufgerufen CreateRolewird. Der Click Ereignishandler schließt ab, indem die TextBox-Eigenschaft RoleNameText entfernt wird.

Hinweis

Möglicherweise fragen Sie sich, was passiert, wenn der Benutzer keinen Wert in das RoleName Textfeld eingibt. Wenn der an die CreateRole -Methode übergebene Wert oder eine leere Zeichenfolge ist Nothing , wird eine Ausnahme ausgelöst. Ebenso wird, wenn der Rollenname ein Komma enthält, eine Ausnahme ausgelöst. Folglich sollte die Seite Validierungssteuerelemente enthalten, um sicherzustellen, dass der Benutzer eine Rolle eingibt und keine Kommas enthält. Ich verlasse als Übung für den Leser.

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 ein Bild in voller Größe anzuzeigen)

Was passiert? Es erfolgt ein Postback, aber es gibt keinen visuellen Hinweis, dass die Rolle tatsächlich zum System hinzugefügt wurde. Wir aktualisieren diese Seite in Schritt 5, um visuelles Feedback einzuschließen. Vorerst 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 die ID -Eigenschaft auf fest RoleList. Fügen Sie als Nächstes der CodeBehind-Klasse der Seite eine -Methode mit dem Namen DisplayRolesInGrid hinzu, indem Sie den folgenden Code verwenden:

Private Sub DisplayRolesInGrid()
 RoleList.DataSource = Roles.GetAllRoles()
 RoleList.DataBind()
End Sub

Die Roles -Methode der GetAllRoles -Klasse gibt alle Rollen im System als Array von Zeichenfolgen zurück. Dieses Zeichenfolgenarray wird dann an 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 Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
 If Not Page.IsPostBack Then
 DisplayRolesInGrid()
 End If 
End Sub

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 Item 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 hier, um ein Bild in voller Größe anzuzeigen)

GridView zeigt eine einzelne Spalte mit der Bezeichnung Item an, da die GridView-Eigenschaft AutoGenerateColumns auf True (Standardeinstellung) festgelegt ist, wodurch GridView automatisch eine Spalte für jede Eigenschaft in ihrer 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 einem GridView ziehe ich es vor, meine Spalten explizit zu definieren, anstatt sie implizit von GridView generieren zu lassen. Durch die explizite Definition 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 werden.

Legen Sie zunächst die Eigenschaft von AutoGenerateColumns GridView 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 Web-Steuerelement mit dem Namen hinzu RoleNameLabel , und binden Sie seine ItemTemplateText -Eigenschaft an. Container.DataItem.

Diese Eigenschaften und die ItemTemplateInhalte von können deklarativ oder über das Dialogfeld Felder von GridView und die Benutzeroberflä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. Wählen Sie zum Definieren des ItemTemplateInhalts des Smarttags von GridView die Option Vorlagen bearbeiten aus. Ziehen Sie ein Label Web-Steuerelement auf , ItemTemplatelegen Sie seine ID -Eigenschaft auf RoleNameLabelfest, und konfigurieren Sie die Datenbindungseinstellungen, sodass die Text -Eigenschaft an Container.DataItemgebunden ist.

Unabhängig davon, welchen Ansatz Sie verwenden, sollte das resultierende deklarative Markup von GridView in etwa 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>

Hinweis

Der Inhalt des Arrays wird mithilfe der Datenbindungssyntax <%# Container.DataItem %>angezeigt. Eine ausführliche Beschreibung der Gründe, warum diese Syntax verwendet wird, wenn der Inhalt eines Arrays angezeigt wird, das an gridView gebunden ist, liegt außerhalb des Rahmens dieses Tutorials. Weitere Informationen zu diesem Thema finden Sie unter Binden eines Skalararrays an ein Datenwebsteuerelement.

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, sodass er die DisplayRolesInGrid -Methode aufruft, wenn eine neue Rolle erstellt wird.

Protected Sub CreateRoleButton_Click(ByVal sender As Object,ByVal e As System.EventArgs) Handles CreateRoleButton.Click
 Dim newRoleName As String = RoleName.Text.Trim()

 If Not Roles.RoleExists(newRoleName) Then
 ' Create the role
 Roles.CreateRole(newRoleName)

 ' Refresh the RoleList Grid
 DisplayRolesInGrid()
 End If

 RoleName.Text = String.Empty 
End Sub

Wenn der Benutzer nun eine neue Rolle hinzufügt, zeigt GridView RoleList die gerade hinzugefügte Rolle im 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 angezeigt, und das Raster wird aktualisiert, um Administratoren sowie die neue Rolle "Supervisors" 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. Lassen Sie es Benutzern ermöglichen, auch Rollen zu löschen. Die Roles.DeleteRole -Methode verfügt über zwei Überladungen:

• DeleteRole(roleName) – löscht den Rollennamen. Eine Ausnahme wird ausgelöst, wenn die Rolle ein oder mehrere Member enthält.
• DeleteRole(roleName, throwOnPopulatedRole) – löscht den Rollennamen. Wenn throwOnPopulateRole ist True, wird eine Ausnahme ausgelöst, wenn die Rolle ein oder mehrere Member enthält. Wenn throwOnPopulateRole ist False, wird die Rolle gelöscht, unabhängig davon, ob sie Member 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 Nothing oder wenn roleName ein Komma enthält. Wenn roleName im System nicht vorhanden ist, DeleteRole schlägt automatisch fehl, ohne dass eine Ausnahme ausgelöst wird.

Erweitern wir gridView ManageRoles.aspx in, um eine Schaltfläche Löschen einzuschließen, die die ausgewählte Rolle löscht, wenn sie darauf geklickt wird. Fügen Sie zunächst der GridView-Ansicht eine Schaltfläche Löschen hinzu, 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 "Löschen" zu 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 in etwa 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 Sub RoleList_RowDeleting(ByVal sender As Object,ByVal e As System.Web.UI.WebControls.GridViewDeleteEventArgs) Handles RoleList.RowDeleting
 ' Get the RoleNameLabel
 Dim RoleNameLabel As Label = CType(RoleList.Rows(e.RowIndex).FindControl("RoleNameLabel"),Label)

 ' Delete the role
 Roles.DeleteRole(RoleNameLabel.Text,False)

 ' Rebind the data to the RoleList grid
 DisplayRolesInGrid()
End Sub

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, wobei der Text von RoleNameLabel und Falseübergeben wird, wodurch 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.

Hinweis

Die Schaltfläche Rolle löschen erfordert keine Bestätigung durch den Benutzer, bevor die Rolle gelöscht wird. Eine der einfachsten Möglichkeiten, eine Aktion zu bestätigen, ist ein clientseitiges Bestätigungsdialogfeld. Weitere Informationen zu diesem Verfahren finden Sie unter Hinzufügen Client-Side Bestätigung beim Löschen.

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 oft sinnvoller, die Regeln basierend auf einer Rolle zu definieren. Das heißt, anstatt Benutzern Scott und Jisun explizit den Zugriff auf die administrativen Webseiten zu erlauben, besteht ein besser verwaltbarer Ansatz darin, Mitgliedern der Rolle "Administratoren" den Zugriff auf diese Seiten zu ermöglichen und scott und Jisun dann 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 ermöglicht, dass neue Rollen erstellt und vorhandene gelöscht werden können. 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 behandelten Themen finden Sie in den folgenden Ressourcen:

• Untersuchen der Mitgliedschaft, der Rollen und des Profils 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 Hours. Scott kann unter mitchell@4guysfromrolla.com oder über seinen Blog unter http://ScottOnWriting.NETerreicht werden.

Besonderer 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 bevorstehenden MSDN-Artikel lesen? Wenn dies der Fall ist, legen Sie eine Zeile unter mitchell@4GuysFromRolla.com

ZurückWeiter