Zuweisen von Rollen zu Benutzern (VB)

von Scott Mitchell

Code herunterladen oder PDF herunterladen

In diesem Lernprogramm erstellen wir zwei ASP.NET-Seiten, um zu verwalten, welche Benutzer zu welchen Rollen gehören. Die erste Seite enthält Funktionen, um zu sehen, welche Benutzer zu einer bestimmten Rolle gehören, zu welchen Rollen ein bestimmter Benutzer gehört, und die Möglichkeit, einen bestimmten Benutzer aus einer bestimmten Rolle zuzuweisen oder zu entfernen. Auf der zweiten Seite erweitern wir das CreateUserWizard-Steuerelement so, dass es einen Schritt enthält, um anzugeben, zu welchen Rollen der neu erstellte Benutzer gehört. Dies ist in Szenarien hilfreich, in denen ein Administrator neue Benutzerkonten erstellen kann.

Einführung

Das vorherige Lernprogramm untersuchte das Rollenframework und das SqlRoleProvider; wir haben gesehen, wie sie die Roles Klasse zum Erstellen, Abrufen und Löschen von Rollen verwenden. Zusätzlich zum Erstellen und Löschen von Rollen müssen wir In der Lage sein, Benutzer aus einer Rolle zuzuweisen oder daraus zu entfernen. Leider wird ASP.NET nicht mit Websteuerelementen ausgeliefert, um zu verwalten, welche Benutzer zu welchen Rollen gehören. Stattdessen müssen wir eigene ASP.NET Seiten erstellen, um diese Zuordnungen zu verwalten. Die gute Nachricht ist, dass das Hinzufügen und Entfernen von Benutzern zu Rollen ganz einfach ist. Die Roles Klasse enthält eine Reihe von Methoden zum Hinzufügen eines oder mehrerer Benutzer zu einer oder mehreren Rollen.

In diesem Tutorial erstellen wir zwei ASP.NET-Seiten, um die Verwaltung der Zuordnung von Benutzern zu Rollen zu erleichtern. Die erste Seite enthält Funktionen, um zu sehen, welche Benutzer zu einer bestimmten Rolle gehören, zu welchen Rollen ein bestimmter Benutzer gehört, und die Möglichkeit, einen bestimmten Benutzer aus einer bestimmten Rolle zuzuweisen oder zu entfernen. Auf der zweiten Seite erweitern wir das CreateUserWizard-Steuerelement so, dass es einen Schritt enthält, um anzugeben, zu welchen Rollen der neu erstellte Benutzer gehört. Dies ist in Szenarien hilfreich, in denen ein Administrator neue Benutzerkonten erstellen kann.

Fangen wir an!

Auflisten, welche Benutzer zu welchen Rollen gehören

Der erste Schritt in diesem Tutorial besteht darin, eine Webseite zu erstellen, über die Benutzern Rollen zugewiesen werden können. Bevor wir uns mit der Zuweisung von Benutzern zu Rollen befassen, konzentrieren wir uns zunächst darauf, zu bestimmen, welche Benutzer zu welchen Rollen gehören. Es gibt zwei Möglichkeiten, diese Informationen anzuzeigen: "nach Rolle" oder "nach Benutzer". Wir könnten es dem Besucher ermöglichen, eine Rolle auszuwählen und dann alle Benutzer anzuzeigen, die zur Rolle gehören (die Anzeige "nach Rolle" oder wir könnten den Besucher auffordern, einen Benutzer auszuwählen und dann die Rollen anzuzeigen, die diesem Benutzer zugewiesen sind (die Anzeige "nach Benutzer").

Die Ansicht "nach Rolle" ist in Situationen nützlich, in denen der Besucher die Gruppe von Benutzern kennen möchte, die zu einer bestimmten Rolle gehören; Die Ansicht "nach Benutzer" ist ideal, wenn der Besucher die Rolle eines bestimmten Benutzers kennen muss. Lassen Sie unsere Seite sowohl "nach Rolle" als auch "nach Benutzer" Schnittstellen beinhalten.

Wir beginnen mit der Erstellung der benutzerspezifischen Oberfläche. Diese Schnittstelle besteht aus einer Dropdownliste und einer Liste von Kontrollkästchen. Die Dropdownliste wird mit der Gruppe der Benutzer im System aufgefüllt; die Kontrollkästchen auflisten die Rollen. Wenn Sie einen Benutzer aus der Dropdownliste auswählen, werden diese Rollen überprüft, zu denen der Benutzer gehört. Die Person, die die Seite besucht, kann dann die Kontrollkästchen aktivieren oder deaktivieren, um den ausgewählten Benutzer aus den entsprechenden Rollen hinzuzufügen oder zu entfernen.

Schritt 1: Erstellen der Benutzeroberfläche "Nach Benutzer"

Öffnen Sie die Seite UsersAndRoles.aspx. Fügen Sie oben auf der Seite ein Bezeichnungswebsteuerelement mit dem Namen ActionStatus hinzu, und löschen Sie dessen Text Eigenschaft. Wir verwenden dieses Label, um Feedback zu den ausgeführten Aktionen zu geben, und zeigen Meldungen wie "Benutzer Tito wurde zur Rolle 'Administratoren' hinzugefügt" oder "Benutzer Jisun wurde aus der Rolle 'Supervisors' entfernt" an. Um diese Nachrichten hervorzuheben, setzen Sie die CssClass-Eigenschaft des Labels auf "Wichtig".

<p align="center"> 
     <asp:Label ID="ActionStatus" runat="server" CssClass="Important"> </asp:Label> 
</p>

Fügen Sie als Nächstes die folgende CSS-Klassendefinition zum Styles.css Stylesheet hinzu:

.Important 
{ 
     font-size: large; 
     color: Red; 
}

Diese CSS-Definition weist den Browser an, die Beschriftung mit einer großen roten Schriftart anzuzeigen. Abbildung 1 zeigt diesen Effekt durch den Visual Studio Designer.

Abbildung 1: Die Eigenschaft " CssClass Label" führt zu einer großen, roten Schriftart (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Fügen Sie als Nächstes der Seite eine DropDownList hinzu, legen Sie deren ID-Eigenschaft auf UserList fest, und legen Sie deren AutoPostBack-Eigenschaft auf "True" fest. Wir verwenden diese DropDownList, um alle Benutzer im System auflisten. Diese DropDownList wird an eine Auflistung von MembershipUser-Objekten gebunden. Da die DropDownList die UserName-Eigenschaft des MembershipUser-Objekts anzeigen soll (und als Wert der Listenelemente verwendet werden soll), legen Sie die Eigenschaften DataTextField und DataValueField der DropDownList auf "UserName" fest.

Fügen Sie unter der DropDownList einen Repeater mit dem Namen hinzu UsersRoleList. Dieser Repeater listet alle Rollen im System als Reihe von Kontrollkästchen auf. Definieren Sie den Repeater mithilfe des folgenden deklarativen Markups ItemTemplate:

<asp:Repeater ID="UsersRoleList" runat="server"> 
     <ItemTemplate> 
          <asp:CheckBox runat="server" ID="RoleCheckBox" AutoPostBack="true" 
               Text='<%# Container.DataItem %>' /> 
          <br /> 
     </ItemTemplate> 
</asp:Repeater>

Das ItemTemplate Markup enthält ein einzelnes CheckBox-Websteuerelement mit dem Namen RoleCheckBox. Die Eigenschaft der CheckBox AutoPostBack ist auf Wahr festgelegt, und die Eigenschaft Text ist an Container.DataItem gebunden. Der Grund, warum die Datenbindungssyntax einfach Container.DataItem ist, liegt darin, dass das Rollenframework die Liste der Rollennamen als Zeichenfolgenarray zurückgibt. Es ist dieses Zeichenfolgenarray, das an den Repeater gebunden wird. Eine gründliche Beschreibung, warum diese Syntax verwendet wird, um den Inhalt eines Arrays anzuzeigen, das an ein Datenwebsteuerelement gebunden ist, liegt außerhalb des Umfangs dieses Lernprogramms. Weitere Informationen zu diesem Thema finden Sie unter Binden eines skalaren Arrays an ein Datenwebsteuerelement.

An diesem Punkt im Prozess sollte das deklarative Markup Ihrer Benutzeroberfläche ähnlich wie folgt aussehen:

<h3>Manage Roles By User</h3> 
<p> 
     <b>Select a User:</b> 
     <asp:DropDownList ID="UserList" runat="server" AutoPostBack="True" 
          DataTextField="UserName" DataValueField="UserName"> 
     </asp:DropDownList> 
</p> 
<p> 
     <asp:Repeater ID="UsersRoleList" runat="server"> 
          <ItemTemplate> 
               <asp:CheckBox runat="server" ID="RoleCheckBox" AutoPostBack="true" 
                    Text='<%# Container.DataItem %>' /> 
               <br /> 
          </ItemTemplate> 
     </asp:Repeater> 
</p>

Wir sind nun bereit, den Code zu schreiben, um den Satz von Benutzerkonten an die DropDownList und den Satz von Rollen an den Repeater zu binden. Fügen Sie in der Code-Behind-Klasse der Seite mit dem folgenden Code eine Methode mit dem Namen BindUsersToUserList und eine andere Methode mit dem Namen BindRolesList hinzu.

Private Sub BindUsersToUserList() 
     ' Get all of the user accounts 
     Dim users As MembershipUserCollection = Membership.GetAllUsers() 
     UserList.DataSource = users 
     UserList.DataBind() 
End Sub 
 
Private Sub BindRolesToList() 
     ' Get all of the roles 
     Dim roleNames() As String = Roles.GetAllRoles() 
     UsersRoleList.DataSource = roleNames 
     UsersRoleList.DataBind() 
End Sub

Die BindUsersToUserList Methode ruft alle Benutzerkonten im System über die Membership.GetAllUsers Methode ab. Dadurch wird ein MembershipUserCollection Objekt zurückgegeben, bei dem es sich um eine Auflistung von MembershipUser Instanzen handelt. Diese Auflistung wird dann an die UserList DropDownList gebunden. Die MembershipUser Instanzen, die die Sammlung maken, enthalten eine Vielzahl von Eigenschaften, wie UserName, , Email, CreationDateund IsOnline. Um die DropDownList anzuweisen, den Wert der UserName Eigenschaft anzuzeigen, stellen Sie sicher, dass die DataTextField und DataValueField Eigenschaften der UserList DropDownList auf "UserName" festgelegt wurden.

Die BindRolesToList Methode ruft zunächst die Methode der Roles Klasse GetAllRolesauf, die ein Zeichenfolgenarray zurückgibt, das die Rollen im System enthält. Dieses String-Array wird dann an den Repeater gebunden.

Schließlich müssen wir diese beiden Methoden aufrufen, wenn die Seite zum ersten Mal geladen wird. Fügen Sie dem Page_Load Ereignishandler den folgenden Code hinzu:

Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load 
     If Not Page.IsPostBack Then 
          ' Bind the users and roles 
          BindUsersToUserList() 
          BindRolesToList() 
     End If 
End Sub

Nehmen Sie sich mit diesem Code einen Moment Zeit, um die Seite über einen Browser zu besuchen; Ihr Bildschirm sollte ähnlich aussehen wie in Abbildung 2. Alle Benutzerkonten werden in der Dropdownliste aufgefüllt, darunter wird jede Rolle als Kontrollkästchen angezeigt. Da wir die AutoPostBack Eigenschaften von DropDownList und CheckBoxes auf "True" festlegen, führt das Ändern des ausgewählten Benutzers oder das Überprüfen oder Deaktivieren einer Rolle zu einem Postback. Es wird jedoch keine Aktion ausgeführt, da wir noch Code schreiben müssen, um diese Aktionen zu behandeln. Wir werden diese Aufgaben in den nächsten beiden Abschnitten angehen.

Abbildung 2: Auf der Seite werden die Benutzer und Rollen angezeigt (Zum Anzeigen des Bilds mit voller Größe klicken)

Überprüfen der Rollen, zu der der ausgewählte Benutzer gehört

Wenn die Seite zum ersten Mal geladen wird oder wenn der Besucher einen neuen Benutzer aus der Dropdownliste auswählt, müssen wir die UsersRoleListKontrollkästchen aktualisieren, damit ein bestimmtes Rollenkontrollkästchen nur aktiviert wird, wenn der ausgewählte Benutzer zu dieser Rolle gehört. Erstellen Sie dazu eine Methode CheckRolesForSelectedUser mit dem folgenden Code:

Private Sub CheckRolesForSelectedUser() 
     ' Determine what roles the selected user belongs to 
     Dim selectedUserName As String = UserList.SelectedValue 
     Dim selectedUsersRoles() As String = Roles.GetRolesForUser(selectedUserName) 
 
     ' Loop through the Repeater's Items and check or uncheck the checkbox as needed 
     For Each ri As RepeaterItem In UsersRoleList.Items 
          ' Programmatically reference the CheckBox 
          Dim RoleCheckBox As CheckBox = CType(ri.FindControl("RoleCheckBox"), CheckBox) 
          ' See if RoleCheckBox.Text is in selectedUsersRoles 
          If Linq.Enumerable.Contains(Of String)(selectedUsersRoles, RoleCheckBox.Text) Then 
               RoleCheckBox.Checked = True 
          Else 
               RoleCheckBox.Checked = False 
          End If 
     Next 
End Sub

Der obige Code beginnt mit der Bestimmung, wer der ausgewählte Benutzer ist. Anschließend wird die Methode der Rollenklasse GetRolesForUser(userName) verwendet, um den Satz der Rollen des angegebenen Benutzers als Zeichenfolgenarray zurückzugeben. Als Nächstes werden die Elemente des Repeaters aufgezählt, und auf das CheckBox-Element RoleCheckBox jedes Elements wird programmgesteuert verwiesen. Die CheckBox ist nur markiert, wenn die Rolle, der sie zugeordnet ist, im selectedUsersRoles Zeichenfolgen-Array enthalten ist.

Die CheckRolesForSelectedUser Methode muss in zwei Fällen aufgerufen werden: wenn die Seite zum ersten Mal geladen wird und wann immer der ausgewählte Index von UserList DropDownList geändert wird. Rufen Sie daher diese Methode aus dem Page_Load Ereignishandler auf (nach den Aufrufen von BindUsersToUserList und BindRolesToList). Erstellen Sie außerdem einen Ereignishandler für das DropDownList-Ereignis SelectedIndexChanged , und rufen Sie diese Methode von dort aus auf.

Protected Sub Page_Load(ByVal sender As Object,ByVal e As System.EventArgs) Handles Me.Load 
     If Not Page.IsPostBack Then 
          ' Bind the users and roles 
          BindUsersToUserList() 
          BindRolesToList() 
          ' Check the selected user's roles 
          CheckRolesForSelectedUser() 
     End If 
End Sub 
 
... 
 
Protected Sub UserList_SelectedIndexChanged(ByVal sender As Object,ByVal e As System.EventArgs) Handles UserList.SelectedIndexChanged 
     CheckRolesForSelectedUser() 
End Sub

Mit diesem Code können Sie die Seite über den Browser testen. Da die UsersAndRoles.aspx Seite derzeit jedoch nicht in der Lage ist, Benutzern Rollen zuzuweisen, verfügen keine Benutzer über Rollen. Wir werden gleich die Benutzeroberfläche zum Zuweisen von Benutzern zu Rollen erstellen, sodass Sie entweder mir glauben können, dass dieser Code funktioniert, und dies später überprüfen, oder Sie können Benutzer manuell zu Rollen hinzufügen, indem Sie Datensätze in die Tabelle aspnet_UsersInRoles einfügen, um diese Funktionalität jetzt zu testen.

Zuweisen und Entfernen von Benutzern aus Rollen

Wenn der Besucher ein CheckBox-Steuerelement im UsersRoleList Repeater aktiviert oder deaktiviert, müssen wir den ausgewählten Benutzer aus der entsprechenden Rolle hinzufügen oder entfernen. Die CheckBox-Eigenschaft AutoPostBack ist derzeit auf "True" festgelegt, was zu einem Postback führt, wenn ein CheckBox-Element im Repeater aktiviert oder deaktiviert wird. Kurz gesagt, wir müssen einen Ereignishandler für das CheckBox-Ereignis CheckChanged erstellen. Da sich das CheckBox-Steuerelement in einem Repeater-Steuerelement befindet, müssen wir die Ereignishandler-Sanitärinstallation manuell hinzufügen. Beginnen Sie mit dem Hinzufügen des Ereignishandlers zur CodeBehind-Klasse als Protected Methode, z. B.:

Protected Sub RoleCheckBox_CheckChanged(ByVal sender As Object, ByVal e As EventArgs) 
 
End Sub

Wir kehren in einem Moment zum Schreiben des Codes für diesen Ereignishandler zurück. Lassen Sie uns aber zuerst die Ereignisbehandlung für die Sanitärinstallation abschließen. Fügen Sie aus dem CheckBox-Steuerelement innerhalb des Repeaters ItemTemplatehinzu OnCheckedChanged="RoleCheckBox_CheckChanged". Diese Syntax verbindet den RoleCheckBox_CheckChanged-Ereignishandler mit dem RoleCheckBox-CheckedChanged-Ereignis.

<asp:CheckBox runat="server" ID="RoleCheckBox" 
     AutoPostBack="true" 
     Text='<%# Container.DataItem %>' 
     OnCheckedChanged="RoleCheckBox_CheckChanged" />

Unsere letzte Aufgabe besteht darin, den RoleCheckBox_CheckChanged Ereignishandler abzuschließen. Zunächst müssen wir auf das CheckBox-Steuerelement verweisen, das das Ereignis ausgelöst hat, da diese CheckBox-Instanz uns angibt, welche Rolle über die zugehörigen Text Eigenschaften Checked überprüft oder deaktiviert wurde. Unter Verwendung dieser Informationen, zusammen mit dem Benutzernamen des ausgewählten Benutzers, fügen wir den Benutzer über die Roles-Klasse mit der AddUserToRole-Methode zur Rolle hinzu oder entfernen ihn daraus mittels der RemoveUserFromRole-Methode.

Protected Sub RoleCheckBox_CheckChanged(ByVal sender As Object, ByVal e As EventArgs) 
     'Reference the CheckBox that raised this event 
     Dim RoleCheckBox As CheckBox = CType(sender, CheckBox) 
 
     ' Get the currently selected user and role 
     Dim selectedUserName As String = UserList.SelectedValue 
     Dim roleName As String = RoleCheckBox.Text 
 
     ' Determine if we need to add or remove the user from this role 
     If RoleCheckBox.Checked Then 
          ' Add the user to the role 
          Roles.AddUserToRole(selectedUserName, roleName) 
          ' Display a status message 
          ActionStatus.Text = String.Format("User {0} was added to role {1}.", selectedUserName,roleName) 
     Else 
          ' Remove the user from the role 
          Roles.RemoveUserFromRole(selectedUserName, roleName) 
          ' Display a status message 
          ActionStatus.Text = String.Format("User {0} was removed from role {1}.", selectedUserName,roleName) 
     End If 
End Sub

Der obige Code verweist programmgesteuert auf das CheckBox-Element, das das Ereignis ausgelöst hat, das über den sender Eingabeparameter verfügbar ist. Wenn das CheckBox-Steuerelement aktiviert ist, wird der ausgewählte Benutzer der angegebenen Rolle hinzugefügt, andernfalls werden sie aus der Rolle entfernt. In beiden Fällen zeigt die ActionStatus Bezeichnung eine Meldung an, die die soeben ausgeführte Aktion zusammenfasst.

Nehmen Sie sich einen Moment Zeit, um diese Seite über einen Browser zu testen. Wählen Sie benutzer Tito aus, und fügen Sie Tito sowohl den Rollen "Administratoren" als auch "Supervisors" hinzu.

Abbildung 3: Tito wurde den Rollen "Administratoren" und "Vorgesetzten" hinzugefügt (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Wählen Sie als Nächstes den Benutzer Bruce aus der Dropdownliste aus. Es gibt einen Postback, und die Kontrollkästchen des Repeaters werden über das CheckRolesForSelectedUser aktualisiert. Da Bruce noch keiner Rolle angehört, sind die beiden Kontrollkästchen deaktiviert. Als Nächstes fügen Sie Bruce zur Rolle "Supervisors" hinzu.

Abbildung 4: Bruce wurde zur Rolle "Supervisors" hinzugefügt (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Um die Funktionalität der CheckRolesForSelectedUser Methode weiter zu überprüfen, wählen Sie einen anderen Benutzer als Tito oder Bruce aus. Beachten Sie, dass die Kontrollkästchen automatisch deaktiviert werden und angeben, dass sie keiner Rolle angehören. Kehren Sie nach Tito zurück. Sowohl die Kontrollkästchen "Administratoren" als auch "Supervisor" sollten aktiviert werden.

Schritt 2: Erstellen der Benutzeroberfläche „Nach Rollen“

An diesem Punkt haben wir die Benutzeroberfläche "nach Benutzern" abgeschlossen und sind bereit, mit der Bewältigung der Schnittstelle "nach Rollen" zu beginnen. Die Benutzeroberfläche "nach Rollen" fordert den Benutzer auf, eine Rolle aus einer Dropdownliste auszuwählen, und zeigt dann die Gruppe der Benutzer an, die zu dieser Rolle in einer GridView gehören.

Fügen Sie ein weiteres DropDownList-Steuerelement zu dem Steuerelement UsersAndRoles.aspx page hinzu. Platzieren Sie dieses Steuerelement unter dem Repeater-Steuerelement, nennen Sie es RoleList, und legen Sie dessen AutoPostBack Eigenschaft auf "True" fest. Fügen Sie darunter eine GridView hinzu, und nennen Sie sie RolesUserList. Diese GridView listet die Benutzer auf, die zur ausgewählten Rolle gehören. Legen Sie die Eigenschaft des GridView-AutoGenerateColumns auf "False" fest, fügen Sie der Columns-Sammlung des Grids ein TemplateField hinzu und legen Sie dessen HeaderText-Eigenschaft auf "Users" fest. Definieren Sie das TemplateField so, dass es den Wert des Datenbindungsausdrucks ItemTemplateContainer.DataItem in der Eigenschaft Text eines Labels mit dem Namen UserNameLabel anzeigt.

Nach dem Hinzufügen und Konfigurieren der GridView sollte das deklarative Markup Ihrer "nach Rolle"-Schnittstelle wie folgt aussehen:

<h3>Manage Users By Role</h3> 
<p> 
     <b>Select a Role:</b> 
     <asp:DropDownList ID="RoleList" runat="server" AutoPostBack="true"></asp:DropDownList> 
</p> 
<p> 
     <asp:GridView ID="RolesUserList" runat="server" AutoGenerateColumns="false" 
          EmptyDataText="No users belong to this role."> 
          <Columns> 
               <asp:TemplateField HeaderText="Users"> 
                    <ItemTemplate> 
                         <asp:Label runat="server" id="UserNameLabel" 
                              Text='<%# Container.DataItem %>'></asp:Label> 
                    </ItemTemplate> 
               </asp:TemplateField> 
          </Columns> 
     </asp:GridView> 
</p>

Wir müssen die RoleList DropDownList mit den Rollen im System auffüllen. Aktualisieren Sie dazu die BindRolesToList Methode so, dass das von der Roles.GetAllRoles Methode zurückgegebene Zeichenfolgenarray an die RolesList DropDownList (sowie den UsersRoleList Repeater) gebunden wird.

Private Sub BindRolesToList() 
     ' Get all of the roles 
     Dim roleNames() As String = Roles.GetAllRoles() 
     UsersRoleList.DataSource = roleNames 
     UsersRoleList.DataBind() 
 
     RoleList.DataSource = roleNames 
     RoleList.DataBind() 
End Sub

Die letzten beiden Zeilen in der BindRolesToList Methode wurden hinzugefügt, um den Satz von Rollen an das RoleList DropDownList-Steuerelement zu binden. Abbildung 5 zeigt das Endergebnis, wenn sie in einem Browser angezeigt wird – eine Dropdownliste, die mit den Rollen des Systems gefüllt ist.

Abbildung 5: Die Rollen werden in der RoleList DropDownList angezeigt (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Anzeigen der Benutzer, die zur ausgewählten Rolle gehören

Wenn die Seite zum ersten Mal geladen wird oder wenn eine neue Rolle aus der RoleList DropDownList ausgewählt wird, müssen wir die Liste der Benutzer anzeigen, die zu dieser Rolle in gridView gehören. Erstellen Sie mithilfe des folgenden Codes eine Methode mit dem Namen DisplayUsersBelongingToRole :

Private Sub DisplayUsersBelongingToRole() 
     ' Get the selected role 
     Dim selectedRoleName As String = RoleList.SelectedValue 
 
     ' Get the list of usernames that belong to the role 
     Dim usersBelongingToRole() As String = Roles.GetUsersInRole(selectedRoleName) 
 
     ' Bind the list of users to the GridView 
     RolesUserList.DataSource = usersBelongingToRole 
     RolesUserList.DataBind() 
End Sub

Diese Methode beginnt mit dem Abrufen der ausgewählten Rolle aus der RoleList DropDownList. Anschließend wird die Roles.GetUsersInRole(roleName) Methode verwendet, um ein Zeichenfolgenarray der Benutzernamen der Benutzer abzurufen, die dieser Rolle angehören. Dieses Array wird dann an die RolesUserList GridView gebunden.

Diese Methode muss unter zwei Umständen aufgerufen werden: wenn die Seite anfangs geladen wird und die ausgewählte Rolle in der RoleList DropDownList geändert wird. Aktualisieren Sie daher den Page_Load Ereignishandler so, dass diese Methode nach dem Aufruf von CheckRolesForSelectedUser aufgerufen wird. Erstellen Sie als Nächstes einen Ereignishandler für das RoleListEreignis SelectedIndexChanged , und rufen Sie diese Methode auch von dort auf.

Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load 
     If Not Page.IsPostBack Then 
          ' Bind the users and roles 
          BindUsersToUserList() 
          BindRolesToList() 
 
          ' Check the selected user's roles 
          CheckRolesForSelectedUser() 
 
          'Display those users belonging to the currently selected role 
          DisplayUsersBelongingToRole() 
     End If 
End Sub 
 
... 
 
Protected Sub RoleList_SelectedIndexChanged(ByVal sender As Object, ByVal e As System.EventArgs) Handles RoleList.SelectedIndexChanged 
     DisplayUsersBelongingToRole() 
End Sub

Mit diesem Code sollte die GridView RolesUserList die Benutzer anzeigen, die zur ausgewählten Rolle gehören. Wie in Abbildung 6 dargestellt, besteht die Rolle "Supervisors" aus zwei Mitgliedern: Bruce und Tito.

Abbildung 6: Die GridView listet die Benutzer auf, die zur ausgewählten Rolle gehören (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Entfernen von Benutzern aus der ausgewählten Rolle

Erweitern wir die RolesUserList GridView so, dass sie eine Spalte mit "Entfernen"-Schaltflächen enthält. Wenn Sie auf die Schaltfläche "Entfernen" für einen bestimmten Benutzer klicken, werden sie aus dieser Rolle entfernt.

Fügen Sie zunächst ein Schaltflächenfeld "Löschen" zur GridView hinzu. Legen Sie fest, dass dieses Feld am weitesten links abgelegt wird, und ändern Sie dessen DeleteText Eigenschaft von "Delete" (Standard) in "Entfernen".

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

Wenn auf die Schaltfläche "Entfernen" geklickt wird, wird ein Postback ausgelöst, und das GridView-Ereignis RowDeleting wird ausgelöst. Wir müssen einen Ereignishandler für dieses Ereignis erstellen und Code schreiben, der den Benutzer aus der ausgewählten Rolle entfernt. Erstellen Sie den Ereignishandler, und fügen Sie dann den folgenden Code hinzu:

Protected Sub RolesUserList_RowDeleting(ByVal sender As Object, ByVal e As System.Web.UI.WebControls.GridViewDeleteEventArgs) Handles RolesUserList.RowDeleting 
     ' Get the selected role 
     Dim selectedRoleName As String = RoleList.SelectedValue 
 
     ' Reference the UserNameLabel 
     Dim UserNameLabel As Label = CType(RolesUserList.Rows(e.RowIndex).FindControl("UserNameLabel"),Label) 
 
     ' Remove the user from the role 
     Roles.RemoveUserFromRole(UserNameLabel.Text, selectedRoleName) 
 
     ' Refresh the GridView 
     DisplayUsersBelongingToRole() 
 
     ' Display a status message 
     ActionStatus.Text = String.Format("User {0} was removed from role {1}.", UserNameLabel.Text,selectedRoleName) 
End Sub

Der Code beginnt mit der Ermittlung des ausgewählten Rollennamens. Anschließend wird programmgesteuert auf das UserNameLabel Steuerelement aus der Zeile verwiesen, auf dessen Schaltfläche "Entfernen" geklickt wurde, um den Benutzernamen des zu entfernenden Benutzers zu ermitteln. Der Benutzer wird dann über einen Aufruf der Methode aus der Roles.RemoveUserFromRole Rolle entfernt. Die RolesUserList GridView wird dann aktualisiert, und eine Meldung wird über das ActionStatus Bezeichnungssteuerelement angezeigt.

Abbildung 8 zeigt die Seite, nachdem der Benutzer Tito aus der Gruppe "Supervisors" entfernt wurde.

Abbildung 8: Alas, Tito ist kein Supervisor mehr (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Hinzufügen neuer Benutzer zur ausgewählten Rolle

Neben dem Entfernen von Benutzern aus der ausgewählten Rolle sollte der Besucher dieser Seite auch in der Lage sein, der ausgewählten Rolle einen Benutzer hinzuzufügen. Die beste Benutzeroberfläche zum Hinzufügen eines Benutzers zur ausgewählten Rolle hängt von der Anzahl der Benutzerkonten ab, die Sie erwarten. Wenn Ihre Website nur ein paar Dutzend Benutzerkonten oder weniger enthält, könnten Sie hier eine DropDownList verwenden. Wenn Tausende von Benutzerkonten vorhanden sein könnten, sollten Sie eine Benutzeroberfläche einschließen, die es dem Besucher ermöglicht, die Konten durch die Konten zu blättern, nach einem bestimmten Konto zu suchen oder die Benutzerkonten auf andere Weise zu filtern.

Für diese Seite verwenden wir eine sehr einfache Schnittstelle, die unabhängig von der Anzahl der Benutzerkonten im System funktioniert. Wir verwenden ein TextBox-Element, das den Besucher auffordert, den Benutzernamen des Benutzers einzugeben, den er der ausgewählten Rolle hinzufügen möchte. Wenn kein Benutzer mit diesem Namen vorhanden ist oder der Benutzer bereits Mitglied der Rolle ist, wird eine Meldung in ActionStatus Label angezeigt. Wenn der Benutzer vorhanden ist und kein Mitglied der Rolle ist, fügen wir sie der Rolle hinzu und aktualisieren das Raster.

Fügen Sie unter der GridView ein Textfeld und eine Schaltfläche hinzu. Legen Sie das TextBox-Element ID auf UserNameToAddToRole fest und legen Sie die Eigenschaften ID und Text der Schaltfläche auf AddUserToRoleButton bzw. "Benutzer zur Rolle hinzufügen" fest.

<p> 
     <b>UserName:</b> 
     <asp:TextBox ID="UserNameToAddToRole" runat="server"></asp:TextBox> 
     <br /> 
     <asp:Button ID="AddUserToRoleButton" runat="server" Text="Add User to Role" /> 
</p>

Erstellen Sie als Nächstes einen Click Ereignishandler für AddUserToRoleButton und fügen Sie den folgenden Code hinzu:

Protected Sub AddUserToRoleButton_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles AddUserToRoleButton.Click 
     ' Get the selected role and username 
     Dim selectedRoleName As String = RoleList.SelectedValue 
     Dim userToAddToRole As String = UserNameToAddToRole.Text 
 
     ' Make sure that a value was entered 
     If userToAddToRole.Trim().Length = 0 Then 
          ActionStatus.Text = "You must enter a username in the textbox." 
          Exit Sub 
     End If 
 
     ' Make sure that the user exists in the system 
     Dim userInfo As MembershipUser = Membership.GetUser(userToAddToRole) 
     If userInfo Is Nothing Then 
          ActionStatus.Text = String.Format("The user {0} does not exist in the system.",userNameToAddToRole) 
          Exit Sub 
     End If 
 
     ' Make sure that the user doesn't already belong to this role 
     If Roles.IsUserInRole(userToAddToRole, selectedRoleName) Then 
          ActionStatus.Text = String.Format("User {0} already is a member of role {1}.", UserNameToAddToRole,selectedRoleName) 
          Exit Sub 
     End If 
 
     ' If we reach here, we need to add the user to the role 
     Roles.AddUserToRole(userToAddToRole, selectedRoleName) 
 
     ' Clear out the TextBox 
     userNameToAddToRole.Text = String.Empty 
 
     ' Refresh the GridView 
     DisplayUsersBelongingToRole() 
 
     ' Display a status message 
     ActionStatus.Text = String.Format("User {0} was added to role {1}.", UserNameToAddToRole,selectedRoleName) 
End Sub

Der Großteil des Codes im Click Ereignishandler führt verschiedene Überprüfungen durch. Es stellt sicher, dass der Besucher einen Benutzernamen im UserNameToAddToRole TextBox-Objekt angegeben hat, dass der Benutzer im System vorhanden ist und dass er nicht bereits zur ausgewählten Rolle gehört. Wenn eine dieser Prüfungen fehlschlägt, wird eine entsprechende Meldung in ActionStatus angezeigt, und der Ereignishandler wird beendet. Wenn alle Prüfungen bestehen, wird der Benutzer über die Roles.AddUserToRole Methode der Rolle hinzugefügt. Anschließend wird die Eigenschaft des TextBox-Steuerelements Text gelöscht, der GridView wird aktualisiert, und das ActionStatus Label zeigt eine Meldung an, dass der angegebene Benutzer der ausgewählten Rolle erfolgreich hinzugefügt wurde.

Besuchen Sie die Seite über einen Browser, und wählen Sie die Rolle "Supervisors" aus der RoleList DropDownList aus. Versuchen Sie, einen ungültigen Benutzernamen einzugeben. Es sollte eine Meldung angezeigt werden, in der erläutert wird, dass der Benutzer nicht im System vorhanden ist.

Abbildung 9: Sie können einer Rolle keinen nicht vorhandenen Benutzer hinzufügen (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Versuchen Sie nun, einen gültigen Benutzer hinzuzufügen. Fahren Sie fort, und fügen Sie Tito der Rolle "Supervisors" erneut hinzu.

Abbildung 10: Tito ist wieder ein Vorgesetzter! (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Schritt 3: Queraktualisierung der Schnittstellen "Nach Benutzer" und "Nach Rolle"

Die UsersAndRoles.aspx Seite bietet zwei unterschiedliche Schnittstellen zum Verwalten von Benutzern und Rollen. Derzeit agieren diese beiden Schnittstellen unabhängig voneinander, sodass es möglich ist, dass eine in einer Schnittstelle vorgenommene Änderung nicht sofort in der anderen widerzuspiegeln ist. Stellen Sie sich beispielsweise vor, dass der Besucher auf der Seite die Rolle "Supervisors" aus der RoleList DropDownList auswählt, die Bruce und Tito als Mitglieder auflistet. Als Nächstes wählt der Besucher Tito aus der UserList DropDownList aus, wodurch die Kontrollkästchen "Administratoren" und "Supervisors" im UsersRoleList Repeater überprüft werden. Wenn der Besucher dann die Rolle "Supervisor" aus dem Repeater abwählt, wird Tito aus der Rolle "Supervisor" entfernt, aber diese Änderung wird in der Schnittstelle "nach Rolle" nicht widergespiegelt. Das GridView zeigt Tito weiterhin als Mitglied der Rolle "Vorgesetzte" an.

Um dies zu beheben, müssen wir die GridView aktualisieren, wenn eine Rolle vom UsersRoleList Repeater aktiviert oder deaktiviert wird. Ebenso müssen wir den Repeater aktualisieren, wenn ein Benutzer aus der Benutzeroberfläche "nach Rolle" entfernt oder zu einer Rolle hinzugefügt wird.

Der Repeater in der Benutzeroberfläche "nach Benutzer" wird aktualisiert, indem die CheckRolesForSelectedUser Methode aufgerufen wird. Die Schnittstelle "nach Rolle" kann im RolesUserList Ereignishandler von RowDeleting GridView und im Ereignishandler der AddUserToRoleButtonClick Schaltfläche geändert werden. Daher müssen wir die CheckRolesForSelectedUser Methode aus jeder dieser Methoden aufrufen.

Protected Sub RolesUserList_RowDeleting(ByVal sender As Object, ByVal e As System.Web.UI.WebControls.GridViewDeleteEventArgs) Handles RolesUserList.RowDeleting 
     ... Code removed for brevity ... 
 
     ' Refresh the "by user" interface 
     CheckRolesForSelectedUser() 
End Sub 
 
Protected Sub AddUserToRoleButton_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles AddUserToRoleButton.Click 
     ... Code removed for brevity ... 
 
     ' Refresh the "by user" interface 
     CheckRolesForSelectedUser() 
End Sub

Ebenso wird die GridView in der Benutzeroberfläche "nach Rolle" durch Aufrufen der DisplayUsersBelongingToRole Methode aktualisiert, und die Benutzeroberfläche "nach Benutzer" wird über den RoleCheckBox_CheckChanged Ereignishandler geändert. Daher müssen wir die DisplayUsersBelongingToRole Methode aus diesem Ereignishandler aufrufen.

Protected Sub RoleCheckBox_CheckChanged(ByVal sender As Object, ByVal e As EventArgs) 
     ... Code removed for brevity ... 
 
     ' Refresh the "by role" interface 
     DisplayUsersBelongingToRole() 
End Sub

Mit diesen geringfügigen Codeänderungen werden die Schnittstellen "nach Benutzer" und "nach Rolle" jetzt übergreifend ordnungsgemäß aktualisiert. Um dies zu überprüfen, besuchen Sie die Seite über einen Browser, und wählen Sie Tito und Supervisors aus den UserList jeweiligen RoleList DropDownLists aus. Beachten Sie, dass Tito, wenn Sie die Rolle "Supervisors" für ihn im Repeater in der Benutzeroberfläche "nach Benutzer" abwählen, automatisch aus der GridView in der Benutzeroberfläche "nach Rolle" entfernt wird. Das Wiedereinfügen von Tito in die Rolle "Supervisors" über die Schnittstelle „nach Rolle“ aktiviert automatisch erneut das Kontrollkästchen "Supervisors" in der Oberfläche „nach Benutzer“.

Schritt 4: Anpassen des CreateUserWizard zum Einschließen eines Schritts "Rollen angeben"

Im Lernprogramm zum Erstellen von Benutzerkonten haben wir erfahren, wie Sie das CreateUserWizard-Websteuerelement verwenden, um eine Benutzeroberfläche zum Erstellen eines neuen Benutzerkontos bereitzustellen. Das CreateUserWizard-Steuerelement kann auf zwei Arten verwendet werden:

• Als Mittel für Besucher, ihr eigenes Benutzerkonto auf der Website zu erstellen, und
• Als Mittel für Administratoren zum Erstellen neuer Konten

Im ersten Anwendungsfall kommt ein Besucher zur Website und füllt die CreateUserWizard aus, indem er seine Informationen eingibt, um sich auf der Website zu registrieren. Im zweiten Fall erstellt ein Administrator ein neues Konto für eine andere Person.

Wenn ein Konto von einem Administrator für eine andere Person erstellt wird, kann es hilfreich sein, dem Administrator anzugeben, zu welchen Rollen das neue Benutzerkonto gehört. Im Lernprogramm zum Speichernzusätzlicher Benutzerinformationen haben wir erfahren, wie Sie die CreateUserWizard anpassen, indem Sie weitere hinzufügenWizardSteps. Sehen wir uns an, wie Sie dem CreateUserWizard einen zusätzlichen Schritt hinzufügen, um die Rollen des neuen Benutzers anzugeben.

Öffnen Sie die CreateUserWizardWithRoles.aspx Seite, und fügen Sie ein CreateUserWizard-Steuerelement namens hinzu RegisterUserWithRoles. Legen Sie die Eigenschaft des Steuerelements ContinueDestinationPageUrl auf "~/Default.aspx" fest. Da hier ein Administrator dieses CreateUserWizard-Steuerelement zum Erstellen neuer Benutzerkonten verwendet, legen Sie die Eigenschaft des Steuerelements LoginCreatedUser auf "False" fest. Diese LoginCreatedUser Eigenschaft gibt an, ob der Besucher automatisch als der gerade erstellte Benutzer angemeldet ist und standardmäßig auf "True" festgelegt ist. Wir setzen es auf "False", weil wir wollen, dass ein Administrator, wenn er ein neues Konto erstellt, weiterhin in seinem eigenen Konto angemeldet bleibt.

Wählen Sie als Nächstes die Option "Hinzufügen/Entfernen WizardSteps..." aus dem Smart Tag des CreateUserWizard aus und fügen Sie ein neues WizardStep hinzu, indem Sie dessen ID auf SpecifyRolesStep setzen. Verschieben Sie dies SpecifyRolesStep WizardStep so, dass es nach dem Schritt "Registrieren für Ihr neues Konto" kommt, aber vor dem Schritt "Abschließen". Legen Sie die Eigenschaft Title von WizardStep auf "Rollen angeben" fest, dessen Eigenschaft StepType auf Step und dessen Eigenschaft AllowReturn auf "False".

Abbildung 11: Hinzufügen der Option "Rollen angeben" WizardStep zum CreateUserWizard (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Nach dieser Änderung sollte das deklarative Markup ihres CreateUserWizard wie folgt aussehen:

<asp:CreateUserWizard ID="RegisterUserWithRoles" runat="server" 
     ContinueDestinationPageUrl="~/Default.aspx" LoginCreatedUser="False"> 
     <WizardSteps> 
          <asp:CreateUserWizardStep ID="CreateUserWizardStep1" runat="server"> 
          </asp:CreateUserWizardStep> 
          <asp:WizardStep ID="SpecifyRolesStep" runat="server" StepType="Step" 
               Title="Specify Roles" AllowReturn="False"> 
          </asp:WizardStep> 
          <asp:CompleteWizardStep ID="CompleteWizardStep1" runat="server"> 
          </asp:CompleteWizardStep> 
     </WizardSteps> 
</asp:CreateUserWizard>

Fügen Sie im Abschnitt "Rollen angeben" eine CheckBoxList mit dem Namen RoleList. hinzu. Diese CheckBoxList listet die verfügbaren Rollen auf, sodass die Person, die die Seite besucht, überprüfen kann, zu welchen Rollen der neu erstellte Benutzer gehört.

Wir bleiben bei zwei Codierungsaufgaben: Zuerst müssen wir die RoleList CheckBoxList mit den Rollen im System auffüllen. Zweitens müssen wir den erstellten Benutzer zu den ausgewählten Rollen hinzufügen, wenn der Benutzer vom Schritt "Rollen angeben" zum Schritt "Abgeschlossen" wechselt. Wir können die erste Aufgabe im Page_Load Ereignishandler ausführen. Der folgende Code verweist programmgesteuert auf das RoleList CheckBox-Objekt auf dem ersten Besuch auf der Seite und bindet die Rollen im System an das System.

Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load 
     If Not Page.IsPostBack Then 
          ' Reference the SpecifyRolesStep WizardStep 
          Dim SpecifyRolesStep As WizardStep = CType(RegisterUserWithRoles.FindControl("SpecifyRolesStep"),WizardStep) 
 
          ' Reference the RoleList CheckBoxList 
          Dim RoleList As CheckBoxList = CType(SpecifyRolesStep.FindControl("RoleList"), CheckBoxList) 
 
          ' Bind the set of roles to RoleList 
          RoleList.DataSource = Roles.GetAllRoles() 
          RoleList.DataBind() 
     End If 
End Sub

Der obige Code sollte Ihnen vertraut vorkommen. Im Lernprogramm zum Speichernzusätzlicher Benutzerinformationen haben wir zwei Anweisungen FindControl verwendet, um auf ein Websteuerelement von einer benutzerdefinierten WizardStep zu verweisen. Und der Code, der die Rollen an die CheckBoxList bindet, wurde zuvor in diesem Tutorial übernommen.

Um die zweite Programmieraufgabe auszuführen, müssen wir wissen, wann der Schritt "Rollen angeben" abgeschlossen wurde. Erinnern Sie sich daran, dass createUserWizard über ein ActiveStepChanged Ereignis verfügt, das jedes Mal ausgelöst wird, wenn der Besucher von einem Schritt zu einem anderen navigiert. Hier können wir ermitteln, ob der Benutzer den Schritt "Abgeschlossen" erreicht hat; wenn ja, müssen wir den Benutzer zu den ausgewählten Rollen hinzufügen.

Erstellen Sie einen Ereignishandler für das ActiveStepChanged Ereignis, und fügen Sie den folgenden Code hinzu:

Protected Sub RegisterUserWithRoles_ActiveStepChanged(ByVal sender As Object, ByVal e As System.EventArgs) Handles RegisterUserWithRoles.ActiveStepChanged 
     'Have we JUST reached the Complete step? 
     If RegisterUserWithRoles.ActiveStep.Title = "Complete" Then 
          ' Reference the SpecifyRolesStep WizardStep 
          Dim SpecifyRolesStep As WizardStep = CType(RegisterUserWithRoles.FindControl("SpecifyRolesStep"),WizardStep) 
 
          ' Reference the RoleList CheckBoxList 
          Dim RoleList As CheckBoxList = CType(SpecifyRolesStep.FindControl("RoleList"), CheckBoxList) 
 
          ' Add the checked roles to the just-added user 
          For Each li As ListItem In RoleList.Items 
               If li.Selected Then 
                    Roles.AddUserToRole(RegisterUserWithRoles.UserName, li.Text) 
               End If 
          Next 
     End If 
End Sub

Wenn der Benutzer gerade den Schritt "Abgeschlossen" erreicht hat, listet der Ereignishandler die Elemente der RoleList CheckBoxList auf, und der gerade erstellte Benutzer wird den ausgewählten Rollen zugewiesen.

Besuchen Sie diese Seite über einen Browser. Der erste Schritt im CreateUserWizard ist der Standardschritt "Registrieren für Ihr neues Konto", der zur Eingabe des Benutzernamens, kennworts, der E-Mail und anderer Schlüsselinformationen des neuen Benutzers auffordert. Geben Sie die Informationen ein, um einen neuen Benutzer namens Wanda zu erstellen.

Abbildung 12: Erstellen eines neuen Benutzers namens Wanda (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Klicken Sie auf die Schaltfläche "Benutzer erstellen". Die CreateUserWizard ruft die Membership.CreateUser Methode intern auf, erstellt das neue Benutzerkonto und wird dann mit dem nächsten Schritt "Rollen angeben" fortgefahren. Hier werden die Systemrollen aufgelistet. Markieren Sie das Kontrollfeld "Supervisors" und klicken Sie auf "Weiter".

Abbildung 13: Machen Sie Wanda zu einem Mitglied der Rolle "Supervisors" (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Durch Klicken auf "Weiter" wird ein Postback verursacht und ActiveStep wird auf den Schritt "Abgeschlossen" gesetzt. ActiveStepChanged Im Ereignishandler wird das zuletzt erstellte Benutzerkonto der Rolle "Supervisors" zugewiesen. Um dies zu überprüfen, kehren Sie zur UsersAndRoles.aspx Seite zurück, und wählen Sie "Supervisors" aus der RoleList DropDownList aus. Wie in Abbildung 14 dargestellt, bestehen die Supervisoren nun aus drei Benutzern: Bruce, Tito und Wanda.

Abbildung 14: Bruce, Tito und Wanda sind alle Supervisoren (Zum Anzeigen des Bilds mit voller Größe klicken)

Zusammenfassung

Das Rollenframework bietet Methoden zum Abrufen von Informationen zu den Rollen und Methoden eines bestimmten Benutzers, um zu bestimmen, welche Benutzer zu einer bestimmten Rolle gehören. Darüber hinaus gibt es eine Reihe von Methoden zum Hinzufügen und Entfernen eines oder mehrerer Benutzer zu einer oder mehreren Rollen. In diesem Lernprogramm haben wir uns auf nur zwei dieser Methoden konzentriert: AddUserToRole und RemoveUserFromRole. Es gibt zusätzliche Varianten, mit denen sie einer einzelnen Rolle mehrere Benutzer hinzufügen und einem einzelnen Benutzer mehrere Rollen zuweisen können.

Dieses Lernprogramm enthält auch eine Betrachtung der Erweiterung des CreateUserWizard-Steuerelements, um die Rollen des neu erstellten Benutzers mithilfe eines WizardStep anzugeben. Ein solcher Schritt könnte einem Administrator helfen, den Prozess der Erstellung von Benutzerkonten für neue Benutzer zu optimieren.

An diesem Punkt haben wir gesehen, wie Sie Rollen erstellen und löschen und wie Sie Benutzer aus Rollen hinzufügen und entfernen. Aber wir müssen uns noch die Anwendung der rollenbasierten Autorisierung ansehen. Im befassen wir uns mit der Definition von URL-Autorisierungsregeln auf Rollenbasis sowie mit dem Einschränken der Funktionalität auf Seitenebene basierend auf den rollenbasierten Rollen des aktuell angemeldeten Benutzers.

Glückliche Programmierung!

Weiterführende Lektüre

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

• Übersicht über ASP.NET Websiteverwaltungstool
• Untersuchung von ASP.NET-Mitgliedschaft, -Rollen und -Profil

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. Leitender Prüfer für dieses Lernprogramm war 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