Zuweisen von Rollen an Benutzer (C#)

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

Hinweis

Die Verwendung einer Dropdownliste zum Auflisten der Benutzerkonten ist keine ideale Wahl für Websites, auf denen möglicherweise Hunderte von Benutzerkonten vorhanden sind. Eine Dropdownliste ist so konzipiert, dass ein Benutzer ein Element aus einer relativ kurzen Liste von Optionen auswählen kann. Es wird schnell unhandlich, wenn die Anzahl der Listenelemente zunimmt. Wenn Sie eine Website erstellen, die potenziell über eine große Anzahl von Benutzerkonten verfügt, sollten Sie eine alternative Benutzeroberfläche in Betracht ziehen, z. B. eine auslagerungsfähige GridView-Schnittstelle oder eine filterbare Schnittstelle, die den Besucher auffordert, einen Brief auszuwählen, und dann nur die Benutzer anzeigt, deren Benutzername mit dem ausgewählten Buchstaben beginnt.

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 void BindUsersToUserList() 
{ 
     // Get all of the user accounts 
     MembershipUserCollection users = Membership.GetAllUsers(); 
     UserList.DataSource = users; 
     UserList.DataBind(); 
}
 
private void BindRolesToList() 
{ 
     // Get all of the roles 
     string[] roles = Roles.GetAllRoles(); 
     UsersRoleList.DataSource = roles; 
     UsersRoleList.DataBind(); 
}

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.

Hinweis

Die Membership.GetAllUsers Methode verfügt über zwei Überladungen: eine, die keine Eingabeparameter akzeptiert und alle Benutzer zurückgibt, und eine, die ganzzahlige Werte für den Seitenindex und die Seitengröße akzeptiert und nur die angegebene Teilmenge der Benutzer zurückgibt. Wenn große Mengen von Benutzerkonten in einem auslagerungsfähigen Benutzeroberflächenelement angezeigt werden, kann die zweite Überladung verwendet werden, um die Benutzer effizienter zu durchlaufen, da sie nur die genaue Teilmenge der Benutzerkonten und nicht alle von ihnen zurückgibt.

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 void Page_Load(object sender, EventArgs e) 
{ 
     if (!Page.IsPostBack) 
     { 
          // Bind the users and roles 
          BindUsersToUserList(); 
          BindRolesToList(); 
     } 
}

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 void CheckRolesForSelectedUser() 
{ 
     // Determine what roles the selected user belongs to 
     string selectedUserName = UserList.SelectedValue; 
     string[] selectedUsersRoles = Roles.GetRolesForUser(selectedUserName); 

     // Loop through the Repeater's Items and check or uncheck the checkbox as needed 

     foreach (RepeaterItem ri in UsersRoleList.Items) 
     { 
          // Programmatically reference the CheckBox 
          CheckBox RoleCheckBox = ri.FindControl("RoleCheckBox") as CheckBox; 
          // See if RoleCheckBox.Text is in selectedUsersRoles 
          if (selectedUsersRoles.Contains<string>(RoleCheckBox.Text)) 
               RoleCheckBox.Checked = true; 
          else 
               RoleCheckBox.Checked = false; 
     } 
}

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.

Hinweis

Die selectedUserRoles.Contains<string>(...) Syntax wird nicht kompiliert, wenn Sie ASP.NET Version 2.0 verwenden. Die Contains<string> -Methode ist Teil der LINQ-Bibliothek, die in ASP.NET 3.5 neu ist. Wenn Sie weiterhin ASP.NET Version 2.0 verwenden, verwenden Sie stattdessen die Array.IndexOf<string> -Methode .

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 void Page_Load(object sender, EventArgs e) 
{ 
     if (!Page.IsPostBack) 
     { 

          // Bind the users and roles 
          BindUsersToUserList(); 
          BindRolesToList(); 
          // Check the selected user's roles 
          CheckRolesForSelectedUser(); 
     } 
} 

... 

protected void UserList_SelectedIndexChanged(object sender, EventArgs e) 
{ 
     CheckRolesForSelectedUser(); 
}

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 void RoleCheckBox_CheckChanged(object sender, EventArgs e) 
{ 

}

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 void RoleCheckBox_CheckChanged(object sender, EventArgs e) 
{ 
     // Reference the CheckBox that raised this event 
     CheckBox RoleCheckBox = sender as CheckBox; 

     // Get the currently selected user and role 
     string selectedUserName = UserList.SelectedValue; 

     string roleName = RoleCheckBox.Text; 

     // Determine if we need to add or remove the user from this role 
     if (RoleCheckBox.Checked) 
     { 
          // 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); 

     } 
}

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 der Seite ein weiteres DropDownList-Steuerelement UsersAndRoles.aspx 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 void BindRolesToList() 
{ 
     // Get all of the roles 

     string[] roles = Roles.GetAllRoles(); 
     UsersRoleList.DataSource = roles; 
     UsersRoleList.DataBind(); 

     RoleList.DataSource = roles; 
     RoleList.DataBind(); 
}

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 void DisplayUsersBelongingToRole() 
{ 
     // Get the selected role 
     string selectedRoleName = RoleList.SelectedValue; 

     // Get the list of usernames that belong to the role 
     string[] usersBelongingToRole = Roles.GetUsersInRole(selectedRoleName); 

     // Bind the list of users to the GridView 
     RolesUserList.DataSource = usersBelongingToRole; 
     RolesUserList.DataBind(); 
}

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 void Page_Load(object sender, EventArgs e) 
{ 
     if (!Page.IsPostBack) 
     { 
          // Bind the users and roles 
          BindUsersToUserList(); 
          BindRolesToList(); 

          // Check the selected user's roles 
          CheckRolesForSelectedUser(); 

          // Display those users belonging to the currently selected role 
          DisplayUsersBelongingToRole(); 
     } 
} 

... 

protected void RoleList_SelectedIndexChanged(object sender, EventArgs e) 
{ 
     DisplayUsersBelongingToRole(); 
}

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 void RolesUserList_RowDeleting(object sender, GridViewDeleteEventArgs e) 
{ 
     // Get the selected role 
     string selectedRoleName = RoleList.SelectedValue; 

     // Reference the UserNameLabel 
     Label UserNameLabel = RolesUserList.Rows[e.RowIndex].FindControl("UserNameLabel") as 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); 
}

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.

Hinweis

Die Schaltfläche "Entfernen" erfordert keine Bestätigung durch den Benutzer, bevor der Benutzer aus der Rolle entfernt wird. Ich lade Sie ein, eine gewisse Benutzerbestätigung hinzuzufügen. Eine der einfachsten Möglichkeiten zum Bestätigen einer Aktion ist ein clientseitiges Bestätigungsdialogfeld. Weitere Informationen zu diesem Verfahren finden Sie unter Hinzufügen Client-Side Bestätigung beim Löschen.

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 das AddUserToRoleButton , und fügen Sie den folgenden Code hinzu:

protected void AddUserToRoleButton_Click(object sender, EventArgs e) 
{ 
     // Get the selected role and username 

     string selectedRoleName = RoleList.SelectedValue; 
     string userNameToAddToRole = UserNameToAddToRole.Text; 

     // Make sure that a value was entered 
     if (userNameToAddToRole.Trim().Length == 0) 
     { 
          ActionStatus.Text = "You must enter a username in the textbox."; 
          return; 
     } 

     // Make sure that the user exists in the system 
     MembershipUser userInfo = Membership.GetUser(userNameToAddToRole); 
     if (userInfo == null) 
     { 
          ActionStatus.Text = string.Format("The user {0} does not exist in the system.", userNameToAddToRole); 

          return; 
     } 

     // Make sure that the user doesn't already belong to this role 
     if (Roles.IsUserInRole(userNameToAddToRole, selectedRoleName)) 
     { 
          ActionStatus.Text = string.Format("User {0} already is a member of role {1}.", userNameToAddToRole, selectedRoleName); 
          return; 
     } 

     // If we reach here, we need to add the user to the role 
     Roles.AddUserToRole(userNameToAddToRole, 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); }

Der Großteil des Codes im Click Ereignishandler führt verschiedene Überprüfungen durch. Dadurch wird sichergestellt, dass der Besucher einen Benutzernamen im UserNameToAddToRole Textfeld 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 eine entsprechende Meldung in ActionStatus angezeigt, und der Ereignishandler wird beendet. Wenn alle Überprüfungen erfolgreich sind, wird der Benutzer der Rolle über die Roles.AddUserToRole -Methode hinzugefügt. Anschließend wird die TextBox-Eigenschaft Text gelöscht, die 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.

Hinweis

Um sicherzustellen, dass der angegebene Benutzer nicht bereits zur ausgewählten Rolle gehört, verwenden wir die Roles.IsUserInRole(userName, roleName) -Methode, die einen booleschen Wert zurückgibt, der angibt, ob userName ein Mitglied von roleName ist. Diese Methode wird im nächsten Tutorial erneut verwendet, wenn wir uns mit der rollenbasierten Autorisierung befassen.

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, die erklärt, dass der Benutzer nicht im System vorhanden ist.

Abbildung 9: Hinzufügen eines nicht vorhandenen Benutzers zu einer Rolle nicht möglich (Klicken Sie hier, um das 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 Vorgesetzter! (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 es möglich ist, dass eine In einer Schnittstelle vorgenommene Änderung nicht sofort in der anderen widerspiegelt wird. Stellen Sie sich beispielsweise vor, dass der Besucher der Seite die Rolle Supervisors aus der DropDownList auswählt, in der RoleList Bruce und Tito als Mitglieder aufgeführt werden. Als Nächstes wählt der Besucher Tito aus der UserList DropDownList aus, wodurch die Kontrollkästchen Administratoren und Vorgesetzte 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 nicht in der Schnittstelle "nach Rolle" widerspiegelt. In der GridView wird Tito weiterhin als Mitglied der Rolle "Supervisors" angezeigt.

Um dies zu beheben, müssen wir gridView aktualisieren, wenn eine Rolle im UsersRoleList Repeater aktiviert oder deaktiviert wird. Ebenso müssen wir den Repeater aktualisieren, wenn ein Benutzer aus der "by role"-Schnittstelle entfernt oder einer Rolle hinzugefügt wird.

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

protected void RolesUserList_RowDeleting(object sender, GridViewDeleteEventArgs e) 
{ 
     ... Code removed for brevity ... 

     // Refresh the "by user" interface 
     CheckRolesForSelectedUser(); 
} 

protected void AddUserToRoleButton_Click(object sender, EventArgs e) 
{ 
     ... Code removed for brevity ... 


     // Refresh the "by user" interface 
     CheckRolesForSelectedUser(); 
}

Auf ähnliche Weise wird die GridView in der "nach Rolle"-Schnittstelle aktualisiert, indem die DisplayUsersBelongingToRole -Methode aufgerufen wird, und die "nach Benutzer"-Schnittstelle wird durch den RoleCheckBox_CheckChanged Ereignishandler geändert. Daher müssen wir die DisplayUsersBelongingToRole -Methode aus diesem Ereignishandler aufrufen.

protected void RoleCheckBox_CheckChanged(object sender, EventArgs e) 
{ 
     ... Code removed for brevity... 

     // Refresh the "by role" interface 
     DisplayUsersBelongingToRole(); 
}

Mit diesen geringfügigen Codeänderungen werden die Schnittstellen "nach Benutzer" und "nach Rolle" jetzt ordnungsgemäß übergreifend 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 . DropDownLists aus. Beachten Sie, dass Tito automatisch aus der GridView-Schnittstelle entfernt wird, wenn Sie die Rolle "Supervisors" für Tito über den Repeater in der Benutzeroberfläche "nach Rolle" deaktivieren. Das Hinzufügen von Tito zurück zur Rolle "Supervisors" über die Benutzeroberfläche "nach Rolle" überprüft das Kontrollkästchen Supervisors in der Benutzeroberfläche "nach Benutzer" automatisch erneut.

Schritt 4: Anpassen des CreateUserWizard-Werts für den Schritt "Rollen angeben"

Im Tutorial Erstellen von Benutzerkonten haben wir erfahren, wie Sie das Websteuerelement CreateUserWizard verwenden, um eine Schnittstelle 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 zur Website und füllt den 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 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 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 mit dem Namen hinzu RegisterUserWithRoles. Legen Sie die -Eigenschaft des Steuerelements ContinueDestinationPageUrl auf "~/Default.aspx" fest. Da hier die Idee besteht, dass 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 soeben erstellter Benutzer angemeldet wird, und standardmäßig auf True festgelegt ist. Wir haben es auf False festgelegt, denn wenn ein Administrator ein neues Konto erstellt, soll er als er selbst angemeldet bleiben.

Wählen Sie als Nächstes die Option "Hinzufügen/Entfernen WizardSteps..." aus. aus dem Smarttag von CreateUserWizard, und fügen Sie einen neuen WizardStephinzu, und legen Sie auf ID fest SpecifyRolesStep. Verschieben Sie die SpecifyRolesStep WizardStep so, dass es nach dem Schritt "Registrieren für Ihr neues Konto", aber vor dem Schritt "Abschließen" erfolgt. Legen Sie die WizardStepEigenschaft von 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 RoleListhinzu. 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 Codierungsaufgaben: 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 "Abgeschlossen" wechselt. Wir können die erste Aufgabe im Page_Load Ereignishandler ausführen. Der folgende Code verweist programmgesteuert auf die RoleList CheckBox beim ersten Besuch der Seite und bindet die Rollen im System an diese.

protected void Page_Load(object sender, EventArgs e) 
{ 
     if (!Page.IsPostBack) 
     { 
          // Reference the SpecifyRolesStep WizardStep 
          WizardStep SpecifyRolesStep = RegisterUserWithRoles.FindControl("SpecifyRolesStep") as WizardStep; 

          // Reference the RoleList CheckBoxList 
          CheckBoxList RoleList = SpecifyRolesStep.FindControl("RoleList") as CheckBoxList; 

          // Bind the set of roles to RoleList 
          RoleList.DataSource = Roles.GetAllRoles(); 
          RoleList.DataBind(); 
     } 
}

Der obige Code sollte vertraut aussehen. Im Tutorial Speichernzusätzlicher Benutzerinformationen haben wir zwei FindControl Anweisungen verwendet, um auf ein Websteuerelement in einem benutzerdefinierten WizardStepzu verweisen. Und der Code, der die Rollen an die CheckBoxList bindet, wurde zuvor 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 "Abgeschlossen" 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 void RegisterUserWithRoles_ActiveStepChanged(object sender, EventArgs e) 
{ 
     // Have we JUST reached the Complete step? 
     if (RegisterUserWithRoles.ActiveStep.Title == "Complete") 
     { 
          // Reference the SpecifyRolesStep WizardStep 
          WizardStep SpecifyRolesStep = RegisterUserWithRoles.FindControl("SpecifyRolesStep") as WizardStep; 

          // Reference the RoleList CheckBoxList 
          CheckBoxList RoleList = SpecifyRolesStep.FindControl("RoleList") as CheckBoxList; 

          // Add the checked roles to the just-added user 
          foreach (ListItem li in RoleList.Items) 

          { 
               if (li.Selected) 
                    Roles.AddUserToRole(RegisterUserWithRoles.UserName, li.Text); 
          } 
     } 
}

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", in dem der Benutzername, das Kennwort, die E-Mail-Adresse und andere wichtige Informationen des neuen Benutzers einfordert. 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 die Membership.CreateUser -Methode intern auf, erstellt das neue Benutzerkonto und geht dann mit dem nächsten Schritt "Rollen angeben" fort. Hier sind die Systemrollen aufgeführt. Aktivieren Sie das Kontrollkästchen Supervisors, und klicken Sie auf Weiter.

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

Das Klicken auf Weiter bewirkt ein Postback und aktualisiert den ActiveStep Schritt "Abgeschlossen". 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 Vorgesetzten (Klicken, um das Bild in voller Größe anzuzeigen)

Zusammenfassung

Das Rollenframework bietet Methoden zum Abrufen von Informationen zu den Rollen eines bestimmten Benutzers und 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 der folgenden Methoden konzentriert: AddUserToRole und RemoveUserFromRole. Es gibt zusätzliche Varianten zum Hinzufügen mehrerer Benutzer zu einer einzelnen Rolle und zum Zuweisen mehrerer Rollen zu einem einzelnen Benutzer.

Dieses Tutorial beinhaltete auch einen Blick darauf, das CreateUserWizard-Steuerelement um ein WizardStep zu erweitern, 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 Rollen erstellt und gelöscht werden und wie Benutzer aus Rollen hinzugefügt und daraus entfernt werden. Wir müssen uns jedoch noch mit der Anwendung der rollenbasierten Autorisierung befassen. Im folgenden Tutorial untersuchen wir das Definieren von URL-Autorisierungsregeln auf Rollenbasis sowie das Einschränken der Funktionalität auf Seitenebene basierend auf den aktuell angemeldeten Benutzerrollen.

Viel Spaß beim Programmieren!

Weitere Informationen

Weitere Informationen zu den in diesem Tutorial erläuterten 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 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. Leitende Prüferin für dieses Tutorial war 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