Zuweisen von Rollen an Benutzer (VB)

von Scott Mitchell

Code herunterladen oder PDF herunterladen

In diesem Tutorial erstellen wir zwei ASP.NET Seiten, um die Verwaltung zu unterstützen, 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 zuzuweisen oder aus einer bestimmten Rolle zu entfernen. Auf der zweiten Seite wird das CreateUserWizard-Steuerelement erweitert, sodass es einen Schritt enthält, um anzugeben, zu welchen Rollen der neu erstellte Benutzer gehört. Dies ist in Szenarien nützlich, in denen ein Administrator in der Lage ist, neue Benutzerkonten zu erstellen.

Einführung

Im vorherigen Tutorial wurden das Rollenframework und der SqlRoleProvideruntersucht. Wir haben gezeigt, 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 einer Rolle zuzuweisen oder daraus zu entfernen. Leider wird ASP.NET nicht mit Websteuerelementen zum Verwalten der Benutzer zu welchen Rollen ausgeliefert. 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 recht 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 zu unterstützen, 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 zuzuweisen oder aus einer bestimmten Rolle zu entfernen. Auf der zweiten Seite wird das CreateUserWizard-Steuerelement erweitert, sodass es einen Schritt enthält, um anzugeben, zu welchen Rollen der neu erstellte Benutzer gehört. Dies ist in Szenarien nützlich, in denen ein Administrator in der Lage ist, neue Benutzerkonten zu erstellen.

Jetzt geht‘s los!

Auflisten, welche Benutzer zu welchen Rollen gehören

Die erste Reihenfolge für dieses Tutorial besteht darin, eine Webseite zu erstellen, über die Benutzer Rollen zugewiesen werden können. Bevor wir uns mit dem Zuweisen von Benutzern zu Rollen befassen, konzentrieren wir uns zunächst darauf, wie wir bestimmen, welche Benutzer zu welchen Rollen gehören. Es gibt zwei Möglichkeiten, diese Informationen anzuzeigen: "nach Rolle" oder "nach Benutzer". Wir könnten dem Besucher erlauben, eine Rolle auszuwählen und ihm 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 ihm dann die Rollen anzuzeigen, die diesem Benutzer zugewiesen sind (die Anzeige "nach Benutzer").

Die Ansicht "nach Rolle" ist nützlich, wenn 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(n) eines bestimmten Benutzers kennen muss. Lassen Sie uns, dass unsere Seite sowohl Schnittstellen "nach Rolle" als auch "nach Benutzer" enthält.

Wir beginnen mit dem Erstellen der Benutzeroberfläche "nach Benutzer". 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 listet die Rollen auf. Wenn Sie einen Benutzer aus der Dropdownliste auswählen, werden die 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 den entsprechenden Rollen hinzuzufügen oder zu entfernen.

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

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

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

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

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

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

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

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

Fügen Sie unterhalb 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 ItemTemplate mit dem folgenden deklarativen Markup:

<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 namens RoleCheckBox. Die CheckBox-Eigenschaft AutoPostBack ist auf True festgelegt, und die Text -Eigenschaft ist an Container.DataItemgebunden. Der Grund für die Datenbindungssyntax liegt einfach Container.DataItem darin, dass das Rollenframework die Liste der Rollennamen als Zeichenfolgenarray zurückgibt, und es ist dieses Zeichenfolgenarray, das wir an den Repeater binden. Eine ausführliche Beschreibung, warum diese Syntax verwendet wird, um den Inhalt eines Arrays anzuzeigen, das an ein Datenwebsteuerelement gebunden ist, liegt außerhalb des Umfangs dieses Tutorials. Weitere Informationen zu diesem Thema finden Sie unter Binden eines skalaren Arrays an ein Datenwebsteuerelement.

An diesem Punkt sollte das deklarative Markup Ihrer Benutzeroberfläche 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 jetzt 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 CodeBehind-Klasse der Seite eine Methode mit dem Namen BindUsersToUserList und eine andere mit dem Namen hinzu BindRolesList, indem Sie den folgenden Code verwenden:

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 Auflistung erstellen, 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 Eigenschaften und DataValueField der UserList DropDownList DataTextField auf "UserName" festgelegt wurden.

Die BindRolesToList -Methode ruft zunächst die -Methode der -KlasseGetAllRoles auf, die ein Zeichenfolgenarray zurückgibt, das die Rollen im System Roles enthält. Dieses Zeichenfolgenarray 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 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. Der Bildschirm sollte ähnlich wie Abbildung 2 aussehen. Alle Benutzerkonten werden in der Dropdownliste aufgefüllt, und 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. Diese Aufgaben werden in den nächsten beiden Abschnitten behandelt.

Abbildung 2: Auf der Seite werden die Benutzer und Rollen angezeigt (Klicken Sie hier, um das bild in voller Größe anzuzeigen)

Ü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 Kontrollkästchen von UsersRoleLists aktualisieren, sodass das Kontrollkästchen für eine bestimmte Rolle nur aktiviert wird, wenn der ausgewählte Benutzer zu dieser Rolle gehört. Erstellen Sie hierzu eine Methode namens 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 bestimmt zunächst, wer der ausgewählte Benutzer ist. Anschließend wird die Methode der Roles-Klasse GetRolesForUser(userName) verwendet, um den Rollensatz des angegebenen Benutzers als Zeichenfolgenarray zurückzugeben. Als Nächstes werden die Elemente des Repeaters aufgelistet, und das RoleCheckBox CheckBox-Element jedes Elements wird programmgesteuert referenziert. Das CheckBox-Element wird nur aktiviert, wenn die Rolle, der es entspricht, im selectedUsersRoles Zeichenfolgenarray enthalten ist.

Die CheckRolesForSelectedUser Methode muss in zwei Fällen aufgerufen werden: wenn die Seite zum ersten Mal geladen wird und wenn der ausgewählte Index der 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, Benutzer Rollen zuzuweisen, verfügen keine Benutzer über Rollen. Wir erstellen die Schnittstelle zum Zuweisen von Benutzern zu Rollen in einem Augenblick, sodass Sie entweder mein Wort nehmen können, dass dieser Code funktioniert, und überprüfen, ob er dies später tut, oder Sie können Benutzer manuell zu Rollen hinzufügen, indem Sie Datensätze in die aspnet_UsersInRoles Tabelle einfügen, um diese Funktionalität jetzt zu testen.

Zuweisen und Entfernen von Benutzern aus Rollen

Wenn der Besucher ein CheckBox-Element im UsersRoleList Repeater überprüft oder deaktiviert, müssen wir den ausgewählten Benutzer 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 ist. Kurz gesagt, wir müssen einen Ereignishandler für das CheckBox-Ereignis CheckChanged erstellen. Da sich checkBox in einem Repeater-Steuerelement befindet, müssen wir die Ereignishandlerinstallation manuell hinzufügen. Fügen Sie zunächst den Ereignishandler der CodeBehind-Klasse als Protected Methode hinzu, z. B. so:

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

Wir kehren zurück, um den Code für diesen Ereignishandler zu schreiben. Aber zuerst schließen wir das Ereignis ab, das sanitäre Anlagen behandelt. Fügen Sie aus dem CheckBox-Element innerhalb des ItemTemplateRepeaters hinzu OnCheckedChanged="RoleCheckBox_CheckChanged". Diese Syntax verdrahtet den RoleCheckBox_CheckChanged Ereignishandler mit dem RoleCheckBox-Ereignis.CheckedChanged

<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. Wir müssen zunächst auf das CheckBox-Steuerelement verweisen, das das Ereignis ausgelöst hat, da dieses CheckBox-instance uns mitteilt, welche Rolle über seine Text Eigenschaften und Checked deaktiviert wurde. Mithilfe dieser Informationen zusammen mit dem Benutzernamen des ausgewählten Benutzers fügen wir den Benutzer der Rolle über die -Klasse AddUserToRole oder -Methode hinzu oder RemoveUserFromRoleentfernen sie Roles daraus.

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 zunächst programmgesteuert auf das CheckBox-Element, das das Ereignis ausgelöst hat, das über den sender Eingabeparameter verfügbar ist. Wenn checkBox aktiviert ist, wird der ausgewählte Benutzer der angegebenen Rolle hinzugefügt, andernfalls wird er aus der Rolle entfernt. In beiden Fällen zeigt die ActionStatus Bezeichnung eine Meldung an, in der die gerade ausgeführte Aktion zusammengefasst wird.

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 den Rollen Administratoren und Vorgesetzten hinzu.

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

Wählen Sie als Nächstes Benutzer Bruce aus der Dropdownliste aus. Es gibt ein Postback, und die CheckBoxen des Repeaters werden über CheckRolesForSelectedUseraktualisiert. Da Bruce noch keiner Rolle angehört, sind die beiden Kontrollkästchen deaktiviert. Fügen Sie als Nächstes Bruce der Rolle "Supervisors" hinzu.

Abbildung 4: Bruce wurde der 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 "Supervisors" 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 Benutzeroberfläche "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 von Benutzern an, die dieser Rolle in einer GridView angehören.

Fügen Sie dem UsersAndRoles.aspx pageein weiteres DropDownList-Steuerelement hinzu. Platzieren Sie diese unter dem Repeater-Steuerelement, nennen Sie es RoleList, und legen Sie seine AutoPostBack Eigenschaft auf True fest. Fügen Sie darunter eine GridView hinzu, und nennen Sie sie RolesUserList. Diese GridView listet die Benutzer auf, die der ausgewählten Rolle angehören. Legen Sie die GridView-Eigenschaft AutoGenerateColumns auf False fest, fügen Sie der Auflistung des Rasters Columns ein TemplateField hinzu, und legen Sie die HeaderText Eigenschaft auf "Users" fest. Definieren Sie die TemplateField-Eigenschaft ItemTemplate so, dass der Wert des Datenbindungsausdrucks Container.DataItem in der Text Eigenschaft eines Label mit dem Namen UserNameLabelangezeigt wird.

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 dem Satz von Rollen im System auffüllen. Aktualisieren Sie dazu die BindRolesToList -Methode so, dass das von der -Methode zurückgegebene Zeichenfolgenarray an die RolesListRoles.GetAllRoles 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 Rollensatz an das RoleList DropDownList-Steuerelement zu binden. Abbildung 5 zeigt das Endergebnis, wenn es über einen Browser angezeigt wird – eine Dropdownliste mit den Systemrollen.

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 eine neue Rolle aus der RoleList DropDownList ausgewählt wird, muss die Liste der Benutzer, die zu dieser Rolle gehören, in GridView angezeigt werden. Erstellen Sie eine Methode namens mit DisplayUsersBelongingToRole dem folgenden Code:

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 UserNames der Benutzer abzurufen, die zu dieser Rolle gehören. Dieses Array wird dann an die RolesUserList GridView gebunden.

Diese Methode muss unter zwei Umständen aufgerufen werden: wenn die Seite zuerst geladen wird und wenn sich die ausgewählte Rolle in der RoleList DropDownList ändert. Aktualisieren Sie daher den Page_Load Ereignishandler so, dass diese Methode nach dem Aufruf CheckRolesForSelectedUservon aufgerufen wird. Erstellen Sie als Nächstes einen Ereignishandler für das RoleList-Ereignis des -Ereignisses SelectedIndexChanged , und rufen Sie diese Methode auch 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() 
 
          '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

Wenn dieser Code vorhanden ist, sollte die RolesUserList GridView die Benutzer anzeigen, die der ausgewählten Rolle angehören. Wie Abbildung 6 zeigt, besteht die Rolle "Supervisors" aus zwei Mitgliedern: Bruce und Tito.

Abbildung 6: Die GridView listet die Benutzer auf, die der ausgewählten Rolle angehö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 Schaltflächen "Entfernen" 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. Lassen Sie dieses Feld als das am häufigsten gespeicherte Feld links angezeigt werden, und ändern Sie seine DeleteText Eigenschaft von "Delete" (Standardeinstellung) in "Remove".

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, folgt ein Postback, 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 Bestimmung des ausgewählten Rollennamens. Anschließend wird programmgesteuert auf das UserNameLabel Steuerelement aus der Zeile verwiesen, auf deren Schaltfläche "Entfernen" geklickt wurde, um den Benutzernamen des zu entfernenden Benutzers zu bestimmen. Der Benutzer wird dann über einen Aufruf der -Methode aus der Roles.RemoveUserFromRole Rolle entfernt. Anschließend RolesUserList wird die GridView aktualisiert, und eine Meldung wird über das ActionStatus Label-Steuerelement angezeigt.

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

Abbildung 8: Leider ist Tito kein Vorgesetzter 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 Schnittstelle 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önnen Sie hier eine DropDownList verwenden. Wenn es Tausende von Benutzerkonten gibt, sollten Sie eine Benutzeroberfläche einschließen, die es dem Besucher ermöglicht, die Konten zu durchsuchen, 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 nämlich ein Textfeld, 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 Bezeichnung angezeigt. Wenn der Benutzer jedoch vorhanden ist und kein Mitglied der Rolle ist, fügen wir sie der Rolle hinzu und aktualisieren das Raster.

Fügen Sie unter GridView ein Textfeld und eine Schaltfläche hinzu. Legen Sie die Textfeld's ID auf UserNameToAddToRole fest, und legen Sie die Eigenschaften der Schaltfläche ID und Text 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 die 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. Dadurch wird sichergestellt, dass der Besucher einen Benutzernamen in TextBox UserNameToAddToRole angegeben hat, dass der Benutzer im System vorhanden ist und nicht bereits zur ausgewählten Rolle gehört. Wenn eine dieser Überprüfungen fehlschlägt, wird in ActionStatus eine entsprechende Meldung angezeigt, und der Ereignishandler wird beendet. Wenn alle Überprüfungen erfolgreich sind, wird der Benutzer der Rolle über die Roles.AddUserToRole -Methode hinzugefügt. Danach wird die TextBox-Eigenschaft Text gelöscht, gridView wird aktualisiert, und die ActionStatus Bezeichnung zeigt eine Meldung an, die angibt, dass der angegebene Benutzer erfolgreich der ausgewählten Rolle 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 erklärt 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 ein Bild in voller Größe anzuzeigen)

Versuchen Sie nun, einen gültigen Benutzer hinzuzufügen. Fügen Sie Tito der Rolle "Supervisors" erneut hinzu.

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

Schritt 3: Kreuzaktualisierung 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 eine In einer Schnittstelle vorgenommene Änderung möglicherweise nicht sofort in der anderen widerzuspiegeln ist. Angenommen, der Besucher der Seite wählt die Rolle Supervisors aus der RoleList DropDownList aus, 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 deaktiviert, wird Tito aus der Rolle "Supervisors" entfernt, aber diese Änderung wird in der Benutzeroberfläche "nach Rolle" nicht widerspiegelt. Die GridView zeigt weiterhin Tito als Mitglied der Rolle "Supervisors" an.

Um dies zu beheben, müssen wir 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 einer Rolle hinzugefügt wird.

Der Repeater in der Benutzeroberfläche "nach Benutzer" wird durch Aufrufen der CheckRolesForSelectedUser -Methode aktualisiert. Die Schnittstelle "by role" kann im RolesUserList GridView-Ereignishandler RowDeleting 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 "by role"-Schnittstelle aktualisiert, indem die DisplayUsersBelongingToRole -Methode aufgerufen wird, 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 ordnungsgemäß übereinander aktualisiert. Um dies zu überprüfen, besuchen Sie die Seite über einen Browser, und wählen Sie Tito und Supervisors aus den UserList DropDownLists bzw RoleList . aus. Wenn Sie die Rolle "Supervisors" für Tito aus dem Repeater in der Benutzeroberfläche "nach Benutzer" deaktivieren, wird Tito in der Benutzeroberfläche "nach Rolle" automatisch aus gridView entfernt. Wenn Sie Tito über die Benutzeroberfläche "nach Rolle" wieder zur Rolle "Supervisors" hinzufügen, wird das Kontrollkästchen Supervisors in der Benutzeroberfläche "nach Benutzer" automatisch erneut überprüft.

Schritt 4: Anpassen des CreateUserWizard, um einen Schritt "Rollen angeben" einzuschließen

Im Tutorial 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, neue Konten zu erstellen

Im ersten Anwendungsfall kommt ein Besucher auf die Website und füllt createUserWizard aus und gibt seine Informationen ein, 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 zu erlauben, anzugeben, zu welchen Rollen das neue Benutzerkonto gehört. Im Tutorial Zum Speichernzusätzlicher Benutzerinformationen haben wir erfahren, wie Sie createUserWizard anpassen, indem Sie zusätzliche WizardStepshinzufügen. Sehen wir uns an, wie Sie 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 die Idee hier ist, dass ein Administrator dieses CreateUserWizard-Steuerelement verwendet, um neue Benutzerkonten zu erstellen, legen Sie die -Eigenschaft des Steuerelements LoginCreatedUser auf False fest. Diese LoginCreatedUser Eigenschaft gibt an, ob der Besucher automatisch als soeben erstellter Benutzer angemeldet wird, und standardmäßig true. Wir legen es auf False fest, da ein Administrator, wenn er ein neues Konto erstellt, als er selbst angemeldet bleiben soll.

Wählen Sie als Nächstes die Option "Hinzufügen/Entfernen WizardSteps..." aus. aus dem Smarttag von CreateUserWizard, und fügen Sie ein neues WizardStephinzu, und legen Sie auf ID fest SpecifyRolesStep. Verschieben Sie die SpecifyRolesStep WizardStep , sodass sie nach dem Schritt "Registrieren für Ihr neues Konto", aber vor dem Schritt "Abschließen" erfolgt. Legen Sie die -Eigenschaft des WizardStep-Objekts Title auf "Rollen angeben" fest, die - StepType Eigenschaft auf Stepund die - AllowReturn Eigenschaft auf False.

Abbildung 11: Hinzufügen von "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 unter "Rollen angeben" WizardStepeine CheckBoxList mit dem Namen RoleList. 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 haben zwei Programmieraufgaben: Erstens müssen wir die RoleList CheckBoxList mit den Rollen im System auffüllen. Zweitens müssen wir den erstellten Benutzer den ausgewählten Rollen hinzufügen, wenn der Benutzer vom Schritt "Rollen angeben" zum Schritt "Abschließen" wechselt. Wir können die erste Aufgabe im Page_Load Ereignishandler ausführen. Der folgende Code verweist programmgesteuert auf das RoleList CheckBox-Element beim ersten Besuch der Seite und bindet die Rollen im System daran.

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 vertraut aussehen. Im Tutorial Zum Speichernzusätzlicher Benutzerinformationen haben wir zwei FindControl Anweisungen verwendet, um aus einem benutzerdefinierten WizardStepauf ein Websteuerelement zu verweisen. Und der Code, der die Rollen an die CheckBoxList bindet, wurde weiter oben in diesem Tutorial übernommen.

Um die zweite Programmieraufgabe ausführen zu können, müssen wir wissen, wann der Schritt "Rollen angeben" abgeschlossen wurde. Denken Sie daran, dass createUserWizard über ein ActiveStepChanged Ereignis verfügt, das jedes Mal ausgelöst wird, wenn der Besucher von einem Schritt zum anderen navigiert. Hier können wir feststellen, ob der Benutzer den Schritt "Abschließen" erreicht hat; Wenn ja, müssen wir den Benutzer 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 "Completed" 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", bei dem der Benutzername, das Kennwort, die E-Mail-Adresse und andere wichtige Informationen des neuen Benutzers eingibt. 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". CreateUserWizard ruft intern die Membership.CreateUser -Methode auf, erstellt das neue Benutzerkonto und geht dann mit dem nächsten Schritt fort, "Rollen angeben". Hier sind die Systemrollen aufgeführt. Aktivieren Sie das Kontrollkästchen Supervisors, und klicken Sie auf Weiter.

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

Wenn Sie auf Weiter klicken, wird ein Postback verursacht und auf ActiveStep den Schritt "Abschließen" aktualisiert. ActiveStepChanged Im Ereignishandler wird das kürzlich erstellte Benutzerkonto der Rolle "Supervisors" zugewiesen. Um dies UsersAndRoles.aspx zu überprüfen, kehren Sie zur Seite zurück, und wählen Sie in der DropDownList die RoleList Option Supervisors aus. Wie Abbildung 14 zeigt, bestehen die Supervisors nun aus drei Benutzern: Bruce, Tito und Wanda.

Abbildung 14: Bruce, Tito und Wanda sind alle Supervisors (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Zusammenfassung

Das Rollenframework bietet Methoden zum Abrufen von Informationen zu den Rollen eines bestimmten Benutzers sowie Methoden zum Bestimmen, welche Benutzer zu einer angegebenen 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 Tutorial haben wir uns nur auf zwei dieser Methoden konzentriert: AddUserToRole und RemoveUserFromRole. Es gibt zusätzliche Varianten, die entwickelt wurden, um einer einzelnen Rolle mehrere Benutzer hinzuzufügen und einem einzelnen Benutzer mehrere Rollen zuzuweisen.

Dieses Tutorial enthält auch einen Blick auf die Erweiterung des CreateUserWizard-Steuerelements auf ein WizardStep , um die Rollen des neu erstellten Benutzers anzugeben. Ein solcher Schritt könnte einem Administrator helfen, den Prozess zum Erstellen von Benutzerkonten für neue Benutzer zu optimieren.

An diesem Punkt haben wir erfahren, wie Sie Rollen erstellen und löschen und wie Sie Benutzer zu Rollen hinzufügen und daraus entfernen. Wir müssen uns jedoch noch mit der Anwendung der rollenbasierten Autorisierung befassen. Im folgenden Tutorial wird das Definieren von URL-Autorisierungsregeln auf Rollenbasis sowie das Einschränken der Funktionalität auf Seitenebene anhand der aktuell angemeldeten Benutzerrollen erläutert.

Viel Spaß beim Programmieren!

Weitere Informationen

Weitere Informationen zu den in diesem Tutorial behandelten Themen finden Sie in den folgenden Ressourcen:

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

Zum Autor

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

Besonderen Dank an...

Diese Tutorialreihe wurde von vielen hilfreichen Prüfern überprüft. Leitende Prüferin für dieses Tutorial war Teresa Murphy. Möchten Sie meine anstehenden MSDN-Artikel lesen? Wenn dies der Fall ist, legen Sie mir eine Zeile unter mitchell@4GuysFromRolla.com