Hinzufügen von Benutzerkonten (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 Platform anstelle der Mitgliedschaftsanbieter verwenden, die zum Zeitpunkt der Veröffentlichung dieses Artikels vorgestellt wurden. ASP.NET Identity hat 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 für anspruchsbasierte Identitäten
• Bessere Interoperabilität mit ASP.Net Core

Code herunterladen oder PDF herunterladen

In diesem Tutorial erfahren Sie, wie Sie mithilfe des Mitgliedschaftsframeworks (über sqlMembershipProvider) neue Benutzerkonten erstellen. Wir erfahren, wie sie neue Benutzer programmgesteuert und über ASP erstellen. Das integrierte CreateUserWizard-Steuerelement von NET.

Einführung

Im vorherigen Tutorial haben wir das Anwendungsdienstschema in einer Datenbank installiert, in der die von und benötigten Tabellen, Sichten und gespeicherten Prozeduren hinzugefügt wurden SqlMembershipProviderSqlRoleProvider. Dadurch wurde die Infrastruktur erstellt, die wir für die restlichen Tutorials in dieser Reihe benötigen. In diesem Tutorial erfahren Sie, wie Sie das Mitgliedschaftsframework (über ) SqlMembershipProviderverwenden, um neue Benutzerkonten zu erstellen. Wir erfahren, wie sie neue Benutzer programmgesteuert und über ASP erstellen. Das integrierte CreateUserWizard-Steuerelement von NET.

Zusätzlich zum Erstellen neuer Benutzerkonten müssen wir auch die Demowebsite aktualisieren, die wir zuerst im Tutorial Eine Übersicht über die Formularauthentifizierung erstellt und dann im Tutorial Konfiguration und Erweiterte Themen zur Formularauthentifizierung erweitert haben. Unsere Demo-Webanwendung verfügt über eine Anmeldeseite, auf der die Anmeldeinformationen der Benutzer anhand hartcodierter Benutzernamen-Kennwort-Paare überprüft werden. Darüber hinaus enthält Code, Global.asax der benutzerdefinierte IPrincipal Objekte und IIdentity Objekte für authentifizierte Benutzer erstellt. Wir aktualisieren die Anmeldeseite, um die Anmeldeinformationen der Benutzer anhand des Mitgliedschaftsframeworks zu überprüfen und den benutzerdefinierten Prinzipal und die Identitätslogik zu entfernen.

Jetzt geht‘s los!

Checkliste zur Formularauthentifizierung und -mitgliedschaft

Bevor wir mit der Arbeit mit dem Mitgliedschaftsframework beginnen, nehmen wir uns einen Moment Zeit, um die wichtigen Schritte zu überprüfen, die wir unternommen haben, um diesen Punkt zu erreichen. Wenn Sie das Mitgliedschaftsframework mit in SqlMembershipProvider einem formularbasierten Authentifizierungsszenario verwenden, müssen die folgenden Schritte ausgeführt werden, bevor Sie die Mitgliedschaftsfunktionalität in Ihrer Webanwendung implementieren:

1. Aktivieren sie die formularbasierte Authentifizierung. Wie unter Übersicht über die Formularauthentifizierung beschrieben, wird die Formularauthentifizierung durch Bearbeiten Web.config und Festlegen des <authentication> -Attributs des mode Elements auf Formsaktiviert. Wenn die Formularauthentifizierung aktiviert ist, wird jede eingehende Anforderung auf ein Formularauthentifizierungsticket untersucht, das den Anforderer identifiziert, sofern vorhanden.
2. Fügen Sie das Anwendungsdienstschema der entsprechenden Datenbank hinzu. Bei Verwendung von SqlMembershipProvider müssen wir das Anwendungsdienstschema in einer Datenbank installieren. Normalerweise wird dieses Schema derselben Datenbank hinzugefügt, die das Datenmodell der Anwendung enthält. Das Tutorial Erstellen des Mitgliedschaftsschemas in SQL Server Lernprogramm zur Verwendung des aspnet_regsql.exe Tools, um dies zu erreichen.
3. Passen Sie die Einstellungen der Webanwendung an, um auf die Datenbank aus Schritt 2 zu verweisen. Im Tutorial Erstellen des Mitgliedschaftsschemas in SQL Server wurden zwei Möglichkeiten zum Konfigurieren der Webanwendung gezeigt, sodass die SqlMembershipProvider in Schritt 2 ausgewählte Datenbank verwendet wird: durch Ändern des Namens der LocalSqlServer Verbindungszeichenfolge oder durch Hinzufügen eines neuen registrierten Anbieters zur Liste der Mitgliedschaftsframeworkanbieter und Anpassen des neuen Anbieters für die Verwendung der Datenbank aus Schritt 2.

Beim Erstellen einer Webanwendung, die die SqlMembershipProvider formularbasierte Authentifizierung und verwendet, müssen Sie diese drei Schritte ausführen, bevor Sie die -Klasse oder die Membership ASP.NET-Websteuerelemente verwenden. Da wir diese Schritte bereits in den vorherigen Tutorials ausgeführt haben, können wir mit der Verwendung des Mitgliedschaftsframeworks beginnen!

Schritt 1: Hinzufügen neuer ASP.NET Pages

In diesem tutorial und den nächsten drei werden wir verschiedene mitgliedschaftsbezogene Funktionen und Funktionen untersuchen. Wir benötigen eine Reihe von ASP.NET Seiten, um die in diesen Tutorials behandelten Themen zu implementieren. Lassen Sie uns diese Seiten und dann eine Siteübersichtsdatei (Web.sitemap)erstellen.

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

• CreatingUserAccounts.aspx
• UserBasedAuthorization.aspx
• EnhancedCreateUserWizard.aspx
• AdditionalUserInfo.aspx
• Guestbook.aspx

An diesem Punkt sollte die Projektmappen-Explorer Ihres Projekts ähnlich dem Screenshot in Abbildung 1 aussehen.

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

Jede Seite sollte an diesem Punkt über die beiden Content-Steuerelemente verfügen, eines für jedes der ContentPlaceHolders der master Seite: MainContent und LoginContent.

<asp:Content ID="Content1" ContentPlaceHolderID="MainContent"

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

Denken Sie daran, dass das LoginContent Standardmarkup von ContentPlaceHolder einen Link zum Anmelden oder Abmelden der Website anzeigt, je nachdem, ob der Benutzer authentifiziert ist. Das Vorhandensein des Content2 Inhaltssteuerelements überschreibt jedoch das Standardmarkup der master Seite. Wie im Tutorial Eine Übersicht über die Formularauthentifizierung beschrieben, ist dies auf Seiten nützlich, auf denen in der linken Spalte keine Anmeldeoptionen angezeigt werden sollen.

Für diese fünf Seiten möchten wir jedoch das Standardmarkup der master Seite für den LoginContent ContentPlaceHolder anzeigen. Entfernen Sie daher das deklarative Markup für das Content2 Content-Steuerelement. Danach sollte jedes der fünf Seiten-Markups nur ein Content-Steuerelement enthalten.

Schritt 2: Erstellen der Site Map

Alle außer den trivialsten Websites müssen eine Form einer Navigations-Benutzeroberfläche implementieren. Die Navigations-Benutzeroberfläche kann eine einfache Liste von Links zu den verschiedenen Abschnitten der Website sein. Alternativ können diese Links in Menüs oder Strukturansichten angeordnet werden. Als Seitenentwickler ist das Erstellen der Navigations-Benutzeroberfläche nur die Hälfte der Geschichte. Wir benötigen auch einige Mittel, um die logische Struktur der Website auf verwaltbare und aktualisierbare Weise zu definieren. Wenn neue Seiten hinzugefügt oder vorhandene Seiten entfernt werden, möchten wir in der Lage sein, eine einzelne Quelle – die Websiteübersicht – zu aktualisieren und diese Änderungen auf der Navigations-Benutzeroberfläche der Website widerzuspiegeln.

Diese beiden Aufgaben – Definieren der Websitekarte und Implementieren einer navigationsbasierten Benutzeroberfläche basierend auf der Websiteübersicht – sind dank des Site Map-Frameworks und der Navigationswebsteuerelemente, die in ASP.NET Version 2.0 hinzugefügt wurden, einfach zu erledigen. Das Site Map-Framework ermöglicht es einem Entwickler, eine Siteübersicht zu definieren und dann über eine programmgesteuerte API (die SiteMap -Klasse) darauf zuzugreifen. Die integrierten Navigationswebsteuerelemente umfassen ein Menu-Steuerelement, das TreeView-Steuerelement und das SiteMapPath-Steuerelement.

Wie die Frameworks "Mitgliedschaft" und "Rollen" wird auch das Websitezuordnungsframework auf dem Anbietermodell erstellt. Die Aufgabe der Site Map-Anbieterklasse besteht darin, die von der SiteMap -Klasse verwendete In-Memory-Struktur aus einem persistenten Datenspeicher zu generieren, z. B. aus einer XML-Datei oder einer Datenbanktabelle. Die .NET Framework wird mit einem Standardmäßiganbieter für die Standortzuordnung bereitgestellt, der die Siteübersichtsdaten aus einer XML-Datei (XmlSiteMapProvider) liest. Dies ist der Anbieter, den wir in diesem Tutorial verwenden werden. Informationen zu einigen alternativen Implementierungen des Site Map-Anbieters finden Sie im Abschnitt Weitere Lesungen am Ende dieses Tutorials.

Der Standardmäßige Site Map-Anbieter erwartet, dass im Stammverzeichnis eine ordnungsgemäß formatierte XML-Datei mit dem Namen Web.sitemap vorhanden ist. Da wir diesen Standardanbieter verwenden, müssen wir eine solche Datei hinzufügen und die Struktur der Sitemap im entsprechenden XML-Format definieren. Klicken Sie zum Hinzufügen der Datei mit der rechten Maustaste auf den Projektnamen in Projektmappen-Explorer, und wählen Sie Neues Element hinzufügen aus. Wählen Sie im Dialogfeld aus, um eine Datei vom Typ Site Map mit dem Namen Web.sitemaphinzuzufügen.

Abbildung 2: Hinzufügen einer Datei namens Web.sitemap zum Stammverzeichnis des Projekts (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Die XML-Websitezuordnungsdatei definiert die Struktur der Website als Hierarchie. Diese hierarchische Beziehung wird in der XML-Datei über die Herkunft der <siteMapNode> Elemente modelliert. Die Web.sitemap muss mit einem <siteMap> übergeordneten Knoten beginnen, der genau über ein untergeordnetes <siteMapNode> Element verfügt. Dieses Element der obersten Ebene <siteMapNode> stellt den Stamm der Hierarchie dar und kann eine beliebige Anzahl absteigender Knoten aufweisen. Jedes <siteMapNode> Element muss ein title -Attribut enthalten und kann unter anderem Attribute und description enthaltenurl. Jedes nicht leere url Attribut muss eindeutig sein.

Geben Sie den folgenden XML-Code in die Web.sitemap Datei ein:

<?xml version="1.0" encoding="utf-8" ?>

<siteMap xmlns="http://schemas.microsoft.com/AspNet/SiteMap-File-1.0" >
     <siteMapNode url="~/Default.aspx" title="Home">
          <siteMapNode title="Membership">
               <siteMapNode url="~/Membership/CreatingUserAccounts.aspx" title="Creating User Accounts" />

               <siteMapNode url="~/Membership/UserBasedAuthorization.aspx" title="User-Based Authorization" />
               <siteMapNode url="~/Membership/Guestbook.aspx" title="Storing Additional User Information" />
          </siteMapNode>

     </siteMapNode>
</siteMap>

Das obige Site map-Markup definiert die hierarchie, die in Abbildung 3 dargestellt ist.

Abbildung 3: Die Websiteübersicht stellt eine hierarchische Navigationsstruktur dar (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Schritt 3: Aktualisieren der Gestaltungsvorlage, um eine Navigations-Benutzeroberfläche einzuschließen

ASP.NET enthält eine Reihe navigationsbezogener Websteuerelemente zum Entwerfen einer Benutzeroberfläche. Dazu gehören die Steuerelemente Menu, TreeView und SiteMapPath. Die Steuerelemente Menu und TreeView rendern die Struktur der Websiteübersicht in einem Menü bzw. in einer Struktur, während siteMapPath ein Breadcrumb anzeigt, der den aktuell besuchten Knoten sowie seine Vorgänger anzeigt. Die Siteübersichtsdaten können mithilfe der SiteMapDataSource an andere Datenwebsteuerelemente gebunden werden und über die -Klasse programmgesteuert auf sie SiteMap zugegriffen werden.

Da eine gründliche Erläuterung des Websiteübersichtsframeworks und der Navigationssteuerelemente über den Rahmen dieser Tutorialreihe hinausgeht, anstatt Zeit mit dem Erstellen einer eigenen Navigationsbenutzeroberfläche zu verbringen, sollten Wir uns stattdessen die in meiner Tutorialreihe Arbeiten mit Daten in ASP.NET 2.0 verwenden, die ein Repeater-Steuerelement verwendet, um eine zweistufige Liste von Navigationslinks anzuzeigen. wie in Abbildung 4 dargestellt.

Hinzufügen einer Two-Level Liste von Links in der linken Spalte

Um diese Schnittstelle zu erstellen, fügen Sie das folgende deklarative Markup der linken Spalte der Site.master master Seite hinzu, in der der Text "TODO: Menu will go here..." befindet sich derzeit.

<ul>
     <li>

          <asp:HyperLink runat="server" ID="lnkHome" NavigateUrl="~/Default.aspx">Home</asp:HyperLink>
     </li>
     <asp:Repeater runat="server" ID="menu" DataSourceID="SiteMapDataSource1">

          <ItemTemplate>
               <li>
                    <asp:HyperLink ID="lnkMenuItem" runat="server" 
                         NavigateUrl='<%# Eval("Url") %>'><%# Eval("Title") %></asp:HyperLink>

                    <asp:Repeater ID="submenu" runat="server" DataSource="<%#
                         ((SiteMapNode) Container.DataItem).ChildNodes %>">
                         <HeaderTemplate>
                              <ul>
                         </HeaderTemplate>
                         <ItemTemplate>

                              <li>
                                   <asp:HyperLink ID="lnkMenuItem" runat="server" NavigateUrl='<%#
                                        Eval("Url") %>'><%# Eval("Title") %></asp:HyperLink>

                              </li>
                         </ItemTemplate>
                         <FooterTemplate>
                              </ul>
                         </FooterTemplate>
                    </asp:Repeater>
               </li>
          </ItemTemplate>
     </asp:Repeater>

</ul>
    
<asp:SiteMapDataSource ID="SiteMapDataSource1" runat="server" ShowStartingNode="false" />

Das obige Markup bindet ein Repeater-Steuerelement namens menu an eine SiteMapDataSource, die die in Web.sitemapdefinierte Hierarchie der Siteübersicht zurückgibt. Da die Eigenschaft des ShowStartingNode SiteMapDataSource-Steuerelements auf False festgelegt ist, beginnt die Rückgabe der Hierarchie der Websitezuordnung beginnend mit den Nachfolgern des Knotens "Home". Der Repeater zeigt jeden dieser Knoten (derzeit nur "Mitgliedschaft") in einem <li> -Element an. Ein weiterer, innerer Repeater zeigt dann die untergeordneten Elemente des aktuellen Knotens in einer geschachtelten ungeordneten Liste an.

Abbildung 4 zeigt die gerenderte Ausgabe des obigen Markups mit der Siteübersichtsstruktur, die wir in Schritt 2 erstellt haben. Der Repeater rendert Vanilla ungeordnetes Listenmarkup; die in Styles.css definierten Cascading Stylesheet-Regeln sind für das ästhetisch ansprechende Layout verantwortlich. Eine ausführlichere Beschreibung der Funktionsweise des obigen Markups finden Sie im Tutorial gestaltungsvorlagen und Websitenavigation .

Abbildung 4: Die Navigationsbenutzeroberfläche wird mithilfe geschachtelter, nicht sortierter Listen gerendert (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Hinzufügen der Breadcrumb-Navigation

Zusätzlich zur Liste der Links in der linken Spalte wird für jede Seite ein Breadcrumb angezeigt. Ein Breadcrumb ist ein Navigationselement der Benutzeroberfläche, das Benutzern schnell ihre aktuelle Position in der Websitehierarchie anzeigt. Das SiteMapPath-Steuerelement verwendet das Site Map-Framework, um den Standort der aktuellen Seite in der Siteübersicht zu bestimmen und zeigt dann basierend auf diesen Informationen ein Breadcrumb an.

Fügen Sie insbesondere dem Headerelement <div> der master Seite ein <span> Element hinzu, und legen Sie das Attribut des class neuen <span> Elements auf "breadcrumb" fest. (Die Styles.css -Klasse enthält eine Regel für eine Breadcrumb-Klasse.) Fügen Sie als Nächstes diesem neuen <span> Element einen SiteMapPath hinzu.

<div id="header">
     <span class="title">User Account Tutorials</span><br />
     <span class="breadcrumb">
          <asp:SiteMapPath ID="SiteMapPath1" runat="server">

          </asp:SiteMapPath>
     </span>
</div>

Abbildung 5 zeigt die Ausgabe von SiteMapPath beim Besuch ~/Membership/CreatingUserAccounts.aspx.

Abbildung 5: Die Breadcrumb zeigt die aktuelle Seite und die zugehörigen Vorgänger in der Websiteübersicht an (Klicken, um das bild in voller Größe anzuzeigen)

Schritt 4: Entfernen des benutzerdefinierten Prinzipals und der Identitätslogik

Benutzerdefinierte Prinzipal- und Identitätsobjekte können dem authentifizierten Benutzer zugeordnet werden. Dies wurde erreicht, indem wir einen Ereignishandler Global.asax für das Ereignis der Anwendung PostAuthenticateRequest erstellt haben, das ausgelöst wird, nachdem der FormsAuthenticationModule den Benutzer authentifiziert hat. In diesem Ereignishandler haben wir die GenericPrincipal von hinzugefügten Objekte und FormsIdentity durch die FormsAuthenticationModule objekte und CustomIdentity ersetzt, die CustomPrincipal wir in diesem Tutorial erstellt haben.

Während benutzerdefinierte Prinzipal- und Identitätsobjekte in bestimmten Szenarien nützlich sind, sind in den meisten Fällen die GenericPrincipal Objekte und FormsIdentity ausreichend. Daher denke ich, dass es sich lohnen würde, zum Standardverhalten zurückzukehren. Nehmen Sie diese Änderung vor, indem Sie entweder den PostAuthenticateRequest Ereignishandler entfernen oder auskommentieren oder die Global.asax Datei vollständig löschen.

Schritt 5: Programmgesteuertes Erstellen eines neuen Benutzers

Verwenden Sie die Methode der KlasseCreateUser, um ein neues Benutzerkonto über das Membership Membership-Framework zu erstellen. Diese Methode verfügt über Eingabeparameter für den Benutzernamen, das Kennwort und andere benutzerbezogene Felder. Beim Aufruf delegiert er die Erstellung des neuen Benutzerkontos an den konfigurierten Mitgliedschaftsanbieter und gibt dann ein MembershipUser Objekt zurück, das das gerade erstellte Benutzerkonto darstellt.

Die CreateUser Methode verfügt über vier Überladungen, von denen jede eine unterschiedliche Anzahl von Eingabeparametern akzeptiert:

• CreateUser(username, password)
• CreateUser(username, password, email)
• CreateUser(username, password, email, passwordQuestion, passwordAnswer, isApproved, MembershipCreateStatus)
• CreateUser(username, password, email, passwordQuestion, passwordAnswer, isApproved, providerUserKey, MembershipCreateStatus)

Diese vier Überladungen unterscheiden sich hinsichtlich der Menge der gesammelten Informationen. Die erste Überladung erfordert beispielsweise nur den Benutzernamen und das Kennwort für das neue Benutzerkonto, während die zweite auch die E-Mail-Adresse des Benutzers erfordert.

Diese Überladungen sind vorhanden, da die zum Erstellen eines neuen Benutzerkontos benötigten Informationen von den Konfigurationseinstellungen des Mitgliedschaftsanbieters abhängen. Im Tutorial Erstellen des Mitgliedschaftsschemas in SQL Server wurde die Angabe der Konfigurationseinstellungen des Mitgliedschaftsanbieters in untersucht.Web.config Tabelle 2 enthält eine vollständige Liste der Konfigurationseinstellungen.

Eine solche Konfigurationseinstellung des Mitgliedschaftsanbieters, die sich darauf auswirkt, welche CreateUser Überladungen verwendet werden können, ist die requiresQuestionAndAnswer Einstellung. Wenn requiresQuestionAndAnswer auf true (Standard) festgelegt ist, müssen wir beim Erstellen eines neuen Benutzerkontos eine Sicherheitsfrage und -antwort angeben. Diese Informationen werden später verwendet, wenn der Benutzer sein Kennwort zurücksetzen oder ändern muss. Insbesondere wird ihnen zu diesem Zeitpunkt die Sicherheitsfrage angezeigt, und sie müssen die richtige Antwort eingeben, um ihr Kennwort zurückzusetzen oder zu ändern. Wenn also auf festgelegt requiresQuestionAndAnswer ist, führt das Aufrufen einer der ersten beiden CreateUser Überladungen zu true einer Ausnahme, da die Sicherheitsfrage und -antwort fehlen. Da unsere Anwendung derzeit so konfiguriert ist, dass eine Sicherheitsfrage und -antwort erforderlich ist, müssen wir beim programmgesteuerten Erstellen eines Benutzers eine der beiden letzten Überladungen verwenden.

Um die Verwendung der CreateUser Methode zu veranschaulichen, erstellen wir eine Benutzeroberfläche, in der wir den Benutzer zur Eingabe seines Namens, Kennworts, seiner E-Mail-Adresse und einer Antwort auf eine vordefinierte Sicherheitsfrage auffordern. Öffnen Sie die CreatingUserAccounts.aspx Seite im Membership Ordner, und fügen Sie dem Content-Steuerelement die folgenden Websteuerelemente hinzu:

• Ein Textfeld mit dem Namen Username
• Ein TextBox-Element mit dem Namen Password, dessen TextMode Eigenschaft auf festgelegt ist Password
• Ein Textfeld mit dem Namen Email
• Eine Bezeichnung namens SecurityQuestion mit deaktivierter Text Eigenschaft
• Ein Textfeld mit dem Namen SecurityAnswer
• Eine Schaltfläche namens CreateAccountButton , deren Text-Eigenschaft auf "Benutzerkonto erstellen" festgelegt ist
• Ein Label-Steuerelement namens CreateAccountResults mit deaktivierter Text Eigenschaft

An diesem Punkt sollte Ihr Bildschirm dem Screenshot in Abbildung 6 ähneln.

Abbildung 6: Hinzufügen der verschiedenen Websteuerelemente zur Seite (Klicken Sie hier, um dasCreatingUserAccounts.aspx bild in voller Größe anzuzeigen)

Label SecurityQuestion und SecurityAnswer TextBox sollen eine vordefinierte Sicherheitsfrage anzeigen und die Antwort des Benutzers sammeln. Beachten Sie, dass sowohl die Sicherheitsfrage als auch die Antwort auf Benutzerbasis gespeichert werden, sodass es möglich ist, jedem Benutzer zu ermöglichen, seine eigene Sicherheitsfrage zu definieren. Für dieses Beispiel habe ich jedoch entschieden, eine universelle Sicherheitsfrage zu verwenden, nämlich: "Was ist Ihre Lieblingsfarbe?"

Um diese vordefinierte Sicherheitsfrage zu implementieren, fügen Sie der CodeBehind-Klasse der Seite eine Konstante mit dem Namen passwordQuestionhinzu, und weisen Sie ihr die Sicherheitsfrage zu. Weisen Sie dann im Page_Load Ereignishandler diese Konstante der SecurityQuestion Label-Eigenschaft Text zu:

const string passwordQuestion = "What is your favorite color";
    
protected void Page_Load(object sender, EventArgs e)
{
     if (!Page.IsPostBack)
          SecurityQuestion.Text = passwordQuestion;
}

Erstellen Sie als Nächstes einen Ereignishandler für das CreateAccountButtonEreignis des -Ereignisses, Click und fügen Sie den folgenden Code hinzu:

protected void CreateAccountButton_Click(object sender, EventArgs e)
{
     MembershipCreateStatus createStatus;
     MembershipUser newUser = Membership.CreateUser(Username.Text, Password.Text, Email.Text, passwordQuestion, SecurityAnswer.Text, true, out createStatus);
     switch (createStatus)
     {
          case MembershipCreateStatus.Success:
               CreateAccountResults.Text = "The user account was successfully created!";
               break;
          case MembershipCreateStatus.DuplicateUserName:
               CreateAccountResults.Text = "There already exists a user with this username.";
               break;

          case MembershipCreateStatus.DuplicateEmail:
               CreateAccountResults.Text = "There already exists a user with this email address.";
               break;
          case MembershipCreateStatus.InvalidEmail:
               CreateAccountResults.Text = "There email address you provided in invalid.";
               break;
          case MembershipCreateStatus.InvalidAnswer:
               CreateAccountResults.Text = "There security answer was invalid.";
               break;
          case MembershipCreateStatus.InvalidPassword:
               CreateAccountResults.Text = "The password you provided is invalid. It must be seven characters long and have at least one non-alphanumeric character.";

               break;
          default:
               CreateAccountResults.Text = "There was an unknown error; the user account was NOT created.";
               break;
     }
}

Der Click Ereignishandler definiert zunächst eine Variable mit dem Namen createStatus vom Typ MembershipCreateStatus. MembershipCreateStatusist eine Enumeration, die die status des CreateUser Vorgangs angibt. Wenn das Benutzerkonto beispielsweise erfolgreich erstellt wurde, wird der resultierende MembershipCreateStatus instance auf den Wert von Successfestgelegt. Wenn der Vorgang hingegen fehlschlägt, da bereits ein Benutzer mit demselben Benutzernamen vorhanden ist, wird er auf den Wert DuplicateUserNamefestgelegt. In der CreateUser von uns verwendeten Überladung müssen wir eine MembershipCreateStatus instance als out Parameter an die -Methode übergeben. Dieser Parameter ist auf den entsprechenden Wert innerhalb der CreateUser -Methode festgelegt, und wir können seinen Wert nach dem Methodenaufruf untersuchen, um festzustellen, ob das Benutzerkonto erfolgreich erstellt wurde.

Nach dem Aufrufen CreateUservon wird createStatuseine switch -Anweisung verwendet, um eine entsprechende Nachricht abhängig vom zugewiesenen Wert auszugeben createStatus. Abbildung 7 zeigt die Ausgabe, wenn ein neuer Benutzer erfolgreich erstellt wurde. Abbildungen 8 und 9 zeigen die Ausgabe, wenn das Benutzerkonto nicht erstellt wird. In Abbildung 8 hat der Besucher ein Kennwort mit fünf Buchstaben eingegeben, das nicht den Anforderungen an die Kennwortstärke entspricht, die in den Konfigurationseinstellungen des Mitgliedschaftsanbieters beschrieben sind. In Abbildung 9 versucht der Besucher, ein Benutzerkonto mit einem vorhandenen Benutzernamen (dem in Abbildung 7 erstellten) zu erstellen.

Abbildung 7: Ein neues Benutzerkonto wurde erfolgreich erstellt (Klicken Sie hier, um das bild in voller Größe anzuzeigen)

Abbildung 8: Das Benutzerkonto wird nicht erstellt, da das angegebene Kennwort zu schwach ist (Klicken Sie hier, um das vollständige Bild anzuzeigen)

Abbildung 9: Das Benutzerkonto wird nicht erstellt, da der Benutzername bereits verwendet wird (Klicken Sie hier, um das bild in voller Größe anzuzeigen)

Hinweis

Möglicherweise fragen Sie sich, wie Sie Erfolg oder Fehler feststellen können, wenn Sie eine der ersten beiden CreateUser Methodenüberladungen verwenden, von denen keine über einen Parameter vom Typ verfügt MembershipCreateStatus. Diese ersten beiden Überladungen lösen eine MembershipCreateUserException Ausnahme aufgrund eines Fehlers aus, der eine StatusCode -Eigenschaft vom Typ MembershipCreateStatusenthält.

Überprüfen Sie nach dem Erstellen einiger Benutzerkonten, ob die Konten erstellt wurden, indem Sie den Inhalt der aspnet_Users Tabellen und aspnet_Membership in der SecurityTutorials.mdf Datenbank auflisten. Wie Abbildung 10 zeigt, habe ich zwei Benutzer über die CreatingUserAccounts.aspx Seite hinzugefügt: Tito und Bruce.

Abbildung 10: Es gibt zwei Benutzer im Mitgliedschaftsbenutzerspeicher: Tito und Bruce (Klicken Sie, um das bild in voller Größe anzuzeigen)

Während der Mitgliedschaftsbenutzerspeicher jetzt Die Kontoinformationen von Bruce und Tito enthält, haben wir noch keine Funktionalität implementiert, die es Bruce oder Tito ermöglicht, sich bei der Website anzumelden. Login.aspx Derzeit werden die Anmeldeinformationen des Benutzers anhand eines hartcodierten Satz von Benutzernamen-Kennwort-Paaren überprüft. Die angegebenen Anmeldeinformationen werden nicht mit dem Mitgliedschaftsframework überprüft. Zur Zeit müssen die neuen Benutzerkonten in den aspnet_Users Tabellen und aspnet_Membership angezeigt werden. Im nächsten Tutorial, Überprüfen von Benutzeranmeldeinformationen für den Mitgliedschaftsbenutzerspeicher, aktualisieren wir die Anmeldeseite, um sie mit dem Mitgliedschaftsspeicher zu überprüfen.

Hinweis

Wenn keine Benutzer in Ihrer SecurityTutorials.mdf Datenbank angezeigt werden, kann dies darauf zurückzuführen sein, dass Ihre Webanwendung den Standardmitgliedschaftsanbieter verwendet, AspNetSqlMembershipProviderder die ASPNETDB.mdf Datenbank als Benutzerspeicher verwendet. Um festzustellen, ob dies das Problem ist, klicken Sie auf die Schaltfläche Aktualisieren im Projektmappen-Explorer. Wenn dem App_Data Ordner eine Datenbank mit dem Namen ASPNETDB.mdf hinzugefügt wurde, ist dies das Problem. Kehren Sie zu Schritt 4 des Tutorials Erstellen des Mitgliedschaftsschemas in SQL Server Anleitungen zum ordnungsgemäßen Konfigurieren des Mitgliedschaftsanbieters zurück.

In den meisten Szenarien zum Erstellen eines Benutzerkontos wird dem Besucher eine Benutzeroberfläche angezeigt, um seinen Benutzernamen, sein Kennwort, seine E-Mail-Adresse und andere wichtige Informationen einzugeben, an dem ein neues Konto erstellt wird. In diesem Schritt haben wir uns mit dem manuellen Erstellen einer solchen Schnittstelle befasst und dann erfahren, wie sie mithilfe der Membership.CreateUser -Methode das neue Benutzerkonto programmgesteuert auf Grundlage der Eingaben des Benutzers hinzufügen können. Unser Code hat jedoch gerade das neue Benutzerkonto erstellt. Es wurden keine Folgeaktionen ausgeführt, z. B. die Anmeldung des Benutzers bei der Website unter dem gerade erstellten Benutzerkonto oder das Senden einer Bestätigungs-E-Mail an den Benutzer. Diese zusätzlichen Schritte erfordern zusätzlichen Code im Ereignishandler der Click Schaltfläche.

ASP.NET wird mit dem CreateUserWizard-Steuerelement ausgeliefert, das für den Erstellungsprozess des Benutzerkontos konzipiert ist, vom Rendern einer Benutzeroberfläche zum Erstellen neuer Benutzerkonten über das Erstellen des Kontos im Mitgliedschaftsframework bis hin zum Ausführen von Aufgaben nach der Kontoerstellung, z. B. das Senden einer Bestätigungs-E-Mail und das Protokollieren des gerade erstellten Benutzers auf der Website. Die Verwendung des CreateUserWizard-Steuerelements ist so einfach, wie das CreateUserWizard-Steuerelement aus der Toolbox auf eine Seite zu ziehen und dann einige Eigenschaften festzulegen. In den meisten Fällen müssen Sie keine einzige Codezeile schreiben. Wir werden diese raffinierte Steuerung in Schritt 6 ausführlich untersuchen.

Wenn neue Benutzerkonten nur über eine typische Webseite zum Erstellen eines Kontos erstellt werden, ist es unwahrscheinlich, dass Sie jemals Code schreiben müssen, der die CreateUser -Methode verwendet, da das CreateUserWizard-Steuerelement wahrscheinlich Ihre Anforderungen erfüllt. Die Methode ist jedoch praktisch in Szenarien, CreateUser in denen Sie eine stark angepasste Benutzeroberfläche zum Erstellen eines Kontos benötigen oder wenn Sie programmgesteuert neue Benutzerkonten über eine alternative Schnittstelle erstellen müssen. Beispielsweise verfügen Sie über eine Seite, die es einem Benutzer ermöglicht, eine XML-Datei hochzuladen, die Benutzerinformationen aus einer anderen Anwendung enthält. Die Seite analysiert möglicherweise den Inhalt der hochgeladenen XML-Datei und erstellt ein neues Konto für jeden im XML dargestellten Benutzer, indem die CreateUser -Methode aufgerufen wird.

Schritt 6: Erstellen eines neuen Benutzers mit dem CreateUserWizard-Steuerelement

ASP.NET wird mit einer Reihe von Anmeldewebsteuerelementen ausgeliefert. Diese Steuerelemente helfen in vielen gängigen Szenarien im Zusammenhang mit Benutzerkonten und Anmeldungen. Das CreateUserWizard-Steuerelement ist ein solches Steuerelement, das eine Benutzeroberfläche zum Hinzufügen eines neuen Benutzerkontos zum Mitgliedschaftsframework darstellt.

Wie viele der anderen Login-bezogenen Websteuerelemente kann auch der CreateUserWizard verwendet werden, ohne eine einzige Codezeile zu schreiben. Es stellt intuitiv eine Benutzeroberfläche bereit, die auf den Konfigurationseinstellungen des Mitgliedschaftsanbieters basiert, und ruft intern die Methode der Membership Klasse CreateUser auf, nachdem der Benutzer die erforderlichen Informationen eingegeben und auf die Schaltfläche "Benutzer erstellen" klickt. Das CreateUserWizard-Steuerelement ist extrem anpassbar. Es gibt eine Vielzahl von Ereignissen, die während verschiedener Phasen des Kontoerstellungsprozesses ausgelöst werden. Wir können bei Bedarf Ereignishandler erstellen, um benutzerdefinierte Logik in den Workflow zur Kontoerstellung einzufügen. Darüber hinaus ist die Darstellung des CreateUserWizard sehr flexibel. Es gibt eine Reihe von Eigenschaften, die die Darstellung der Standardschnittstelle definieren. bei Bedarf kann das Steuerelement in eine Vorlage konvertiert werden, oder es können zusätzliche "Schritte" für die Benutzerregistrierung hinzugefügt werden.

Beginnen wir mit einem Blick auf die Verwendung der Standardschnittstelle und des Standardverhaltens des CreateUserWizard-Steuerelements. Anschließend erfahren Sie, wie Sie die Darstellung über die Eigenschaften und Ereignisse des Steuerelements anpassen können.

Untersuchen der Standardschnittstelle und des Standardverhaltens von CreateUserWizard

Kehren Sie zur CreatingUserAccounts.aspx Seite im Membership Ordner zurück, wechseln Sie zum Entwurfs- oder Split-Modus, und fügen Sie dann oben auf der Seite ein CreateUserWizard-Steuerelement hinzu. Das CreateUserWizard-Steuerelement wird im Abschnitt Anmeldesteuerelemente der Toolbox abgelegt. Legen Sie nach dem Hinzufügen des Steuerelements seine ID -Eigenschaft auf fest RegisterUser. Wie der Screenshot in Abbildung 11 zeigt, rendert createUserWizard eine Schnittstelle mit Textfeldern für den Benutzernamen, das Kennwort, die E-Mail-Adresse sowie die Sicherheitsfrage und -antwort des neuen Benutzers.

Abbildung 11: Das CreateUserWizard-Steuerelement rendert eine generische Benutzeroberfläche zum Erstellen (klicken, um das bild in voller Größe anzuzeigen)

Nehmen wir uns einen Moment Zeit, um die vom CreateUserWizard-Steuerelement generierte Standardbenutzeroberfläche mit der in Schritt 5 erstellten Schnittstelle zu vergleichen. Für den Anfang ermöglicht das CreateUserWizard-Steuerelement dem Besucher, sowohl die Sicherheitsfrage als auch die Antwort anzugeben, während unsere manuell erstellte Schnittstelle eine vordefinierte Sicherheitsfrage verwendet. Die Schnittstelle des CreateUserWizard-Steuerelements enthält auch Validierungssteuerelemente, während wir die Überprüfung für die Formularfelder unserer Schnittstelle noch nicht implementiert hatten. Und die CreateUserWizard-Steuerelementschnittstelle enthält ein Textfeld "Kennwort bestätigen" (zusammen mit einem CompareValidator, um sicherzustellen, dass der eingegebene Text in die Textfelder "Kennwort" und "Kennwort vergleichen" gleich sind).

Interessant ist, dass das CreateUserWizard-Steuerelement beim Rendern der Benutzeroberfläche die Konfigurationseinstellungen des Mitgliedschaftsanbieters abhört. Beispielsweise werden die Textfelder für Sicherheitsfragen und -antworten nur angezeigt, wenn requiresQuestionAndAnswer auf True festgelegt ist. Ebenso fügt CreateUserWizard automatisch ein RegularExpressionValidator-Steuerelement hinzu, um sicherzustellen, dass die Anforderungen an die Kennwortstärke erfüllt werden, und legt dessen ErrorMessage Eigenschaften und ValidationExpression basierend auf den minRequiredPasswordLengthKonfigurationseinstellungen , minRequiredNonalphanumericCharactersund passwordStrengthRegularExpression fest.

Das CreateUserWizard-Steuerelement wird, wie der Name schon sagt, vom Assistenten-Steuerelement abgeleitet. Assistentensteuerelemente sind so konzipiert, dass sie eine Schnittstelle zum Ausführen von Aufgaben mit mehreren Schritten bereitstellen. Ein Wizard-Steuerelement kann eine beliebige Anzahl von WizardStepsaufweisen, von denen jedes eine Vorlage ist, die die HTML- und Websteuerelemente für diesen Schritt definiert. Das Assistent-Steuerelement zeigt zunächst den ersten WizardStepan, zusammen mit Navigationssteuerelementen, die es dem Benutzer ermöglichen, von einem Schritt zum nächsten fortzufahren oder zu den vorherigen Schritten zurückzukehren.

Wie das deklarative Markup in Abbildung 11 zeigt, umfasst die Standardschnittstelle des CreateUserWizard-Steuerelements zwei WizardSteps:

• CreateUserWizardStep – rendert die Schnittstelle, um Informationen zum Erstellen des neuen Benutzerkontos zu sammeln. Dies ist der Schritt in Abbildung 11.
• CompleteWizardStep – rendert eine Meldung, die angibt, dass das Konto erfolgreich erstellt wurde.

Die Darstellung und das Verhalten des CreateUserWizard können geändert werden, indem Sie einen dieser Schritte in Vorlagen konvertieren oder Ihre eigene WizardStepshinzufügen. Im Tutorial Zum Speichern zusätzlicher Benutzerinformationen wird das Hinzufügen einer WizardStep zur Registrierungsschnittstelle erläutert.

Sehen Wir uns das CreateUserWizard-Steuerelement in Aktion an. Besuchen Sie die CreatingUserAccounts.aspx Seite über einen Browser. Geben Sie zunächst einige ungültige Werte in die CreateUserWizard-Schnittstelle ein. Versuchen Sie, ein Kennwort einzugeben, das nicht den Anforderungen an die Kennwortstärke entspricht, oder lassen Sie das Textfeld "Benutzername" leer. CreateUserWizard zeigt eine entsprechende Fehlermeldung an. Abbildung 12 zeigt die Ausgabe beim Versuch, einen Benutzer mit einem unzureichend sicheren Kennwort zu erstellen.

Abbildung 12: Die CreateUserWizard-Überprüfungssteuerelemente werden automatisch eingefügt (klicken, um das vollständige Bild anzuzeigen)

Geben Sie als Nächstes die entsprechenden Werte in createUserWizard ein, und klicken Sie auf die Schaltfläche "Benutzer erstellen". Wenn die erforderlichen Felder eingegeben wurden und die Kennwortstärke ausreichend ist, erstellt createUserWizard über das Mitgliedschaftsframework ein neues Benutzerkonto und zeigt dann die Benutzeroberfläche des CompleteWizardStepBenutzers an (siehe Abbildung 13). Im Hintergrund ruft createUserWizard die Membership.CreateUser -Methode auf, genau wie in Schritt 5.

Abbildung 13: Ein neues Benutzerkonto wurde erfolgreich erstellt (Klicken Sie hier, um das bild in voller Größe anzuzeigen)

Hinweis

Wie Abbildung 13 zeigt, enthält die CompleteWizardStepSchnittstelle der Schnittstelle eine Schaltfläche Weiter. Wenn Sie an diesem Punkt darauf klicken, wird jedoch nur ein Postback ausgeführt, sodass der Besucher auf derselben Seite bleibt. Im Abschnitt "Anpassen der Darstellung und des Verhaltens des CreateUserWizard über seine Eigenschaften" wird erläutert, wie Diese Schaltfläche den Besucher Default.aspx (oder eine andere Seite) senden kann.

Kehren Sie nach dem Erstellen eines neuen Benutzerkontos zu Visual Studio zurück, und überprüfen Sie die aspnet_Users Tabellen und aspnet_Membership wie in Abbildung 10, um zu überprüfen, ob das Konto erfolgreich erstellt wurde.

Anpassen des Verhaltens und der Darstellung des CreateUserWizard über seine Eigenschaften

CreateUserWizard kann auf verschiedene Arten angepasst werden, über Eigenschaften, WizardSteps, und Ereignishandler. In diesem Abschnitt erfahren Sie, wie Sie das Erscheinungsbild des Steuerelements über seine Eigenschaften anpassen. Im nächsten Abschnitt wird das Verhalten des Steuerelements durch Ereignishandler erweitert.

Praktisch der gesamte Text, der in der Standardbenutzeroberfläche des CreateUserWizard-Steuerelements angezeigt wird, kann über die Vielzahl von Eigenschaften angepasst werden. Die Bezeichnungen "Benutzername", "Kennwort", "Kennwort bestätigen", "E-Mail", "Sicherheitsfrage" und "Sicherheitsantwort", die links neben den Textfelds angezeigt werden, können beispielsweise durch die UserNameLabelTextEigenschaften , , PasswordLabelText, ConfirmPasswordLabelText, EmailLabelTextQuestionLabelTextund AnswerLabelText angepasst werden. Ebenso gibt es Eigenschaften zum Angeben des Texts für die Schaltflächen "Benutzer erstellen" und "Weiter" in und CreateUserWizardStepCompleteWizardStepsowie zum Angeben, ob diese Schaltflächen als Schaltflächen, LinkButtons oder ImageButtons gerendert werden.

Die Farben, Rahmen, Schriftarten und andere visuelle Elemente können über eine Vielzahl von Stileigenschaften konfiguriert werden. Das CreateUserWizard-Steuerelement selbst verfügt über die allgemeinen Websteuerelementstileigenschaften – BackColor, BorderStyle, CssClass, Fontusw. – und es gibt eine Reihe von Formateigenschaften zum Definieren der Darstellung für bestimmte Abschnitte der CreateUserWizard-Schnittstelle. Die TextBoxStyle -Eigenschaft für instance definiert die Formatvorlagen für die Textfelder im CreateUserWizardStep, während die TitleTextStyle -Eigenschaft die Formatvorlage für den Titel ("Registrieren für Ihr neues Konto") definiert.

Zusätzlich zu den darstellungsbezogenen Eigenschaften gibt es eine Reihe von Eigenschaften, die das Verhalten des CreateUserWizard-Steuerelements beeinflussen. Wenn DisplayCancelButton die Eigenschaft auf True festgelegt ist, wird die Schaltfläche Abbrechen neben der Schaltfläche "Benutzer erstellen" angezeigt (der Standardwert ist False). Wenn Sie die Schaltfläche Abbrechen anzeigen, stellen Sie sicher, dass Sie auch die CancelDestinationPageUrl Eigenschaft festlegen, die die Seite angibt, an die der Benutzer gesendet wird, nachdem er auf Abbrechen geklickt hat. Wie im vorherigen Abschnitt erwähnt, bewirkt die Schaltfläche Weiter in der CompleteWizardStepBenutzeroberfläche ein Postback, lässt den Besucher jedoch auf derselben Seite zurück. Um den Besucher nach dem Klicken auf die Schaltfläche Weiter auf eine andere Seite zu senden, geben Sie einfach die URL in der ContinueDestinationPageUrl Eigenschaft an.

Aktualisieren Wir das RegisterUser CreateUserWizard-Steuerelement, um eine Schaltfläche Abbrechen anzuzeigen und den Besucher zu senden, Default.aspx wenn auf die Schaltfläche Abbrechen oder Fortfahren geklickt wird. Um dies zu erreichen, legen Sie die DisplayCancelButton Eigenschaft auf True und die CancelDestinationPageUrl Eigenschaften und ContinueDestinationPageUrl auf "~/Default.aspx" fest. Abbildung 14 zeigt den aktualisierten CreateUserWizard, wenn er über einen Browser angezeigt wird.

Abbildung 14: Schaltfläche CreateUserWizardStep "Abbrechen" enthält (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Wenn ein Besucher einen Benutzernamen, ein Kennwort, eine E-Mail-Adresse und eine Sicherheitsfrage eingibt und auf "Benutzer erstellen" klickt, wird ein neues Benutzerkonto erstellt, und der Besucher wird als dieser neu erstellte Benutzer angemeldet. Unter der Annahme, dass die Person, die die Seite besucht, ein neues Konto für sich selbst erstellt, ist dies wahrscheinlich das gewünschte Verhalten. Möglicherweise möchten Sie administratoren jedoch erlauben, neue Benutzerkonten hinzuzufügen. Dabei würde das Benutzerkonto erstellt, aber der Administrator bliebe als Administrator (und nicht als neu erstelltes Konto) angemeldet. Dieses Verhalten kann durch die boolesche LoginCreatedUser Eigenschaft geändert werden.

Benutzerkonten im Mitgliedschaftsframework enthalten ein genehmigtes Flag. Benutzer, die nicht genehmigt wurden, können sich nicht bei der Website anmelden. Standardmäßig wird ein neu erstelltes Konto als genehmigt markiert, sodass sich der Benutzer sofort bei der Website anmelden kann. Es ist jedoch möglich, dass neue Benutzerkonten als nicht genehmigt gekennzeichnet werden. Vielleicht möchten Sie, dass ein Administrator neue Benutzer manuell genehmigt, bevor sie sich anmelden können. Oder sie möchten überprüfen, ob die bei der Registrierung eingegebene E-Mail-Adresse gültig ist, bevor Sie einem Benutzer die Anmeldung erlauben. In jedem Fall können Sie das neu erstellte Benutzerkonto als nicht genehmigt markieren lassen, indem Sie die Eigenschaft des DisableCreatedUser CreateUserWizard-Steuerelements auf True festlegen (der Standardwert ist False).

Weitere verhaltensbezogene Eigenschaften von Beachten sind und AutoGeneratePasswordMailDefinition. Wenn die AutoGeneratePassword -Eigenschaft auf True festgelegt ist, CreateUserWizardStep werden die Textfelder "Kennwort" und "Kennwort bestätigen" nicht angezeigt. Stattdessen wird das Kennwort des neu erstellten Benutzers automatisch mithilfe der -Methode der KlasseGeneratePassword generiert.Membership Die GeneratePassword Methode erstellt ein Kennwort mit einer angegebenen Länge und einer ausreichenden Anzahl nicht alphanumerischer Zeichen, um die konfigurierten Anforderungen an die Kennwortstärke zu erfüllen.

Die MailDefinition Eigenschaft ist nützlich, wenn Sie eine E-Mail an die E-Mail-Adresse senden möchten, die während des Kontoerstellungsprozesses angegeben wurde. Die MailDefinition -Eigenschaft enthält eine Reihe von Untereigenschaften zum Definieren von Informationen über die erstellte E-Mail-Nachricht. Diese Untereigenschaften umfassen Optionen wie Subject, , Priority, IsBodyHtmlFrom, CCund BodyFileName. Die BodyFileName -Eigenschaft verweist auf eine Text- oder HTML-Datei, die den Text für die E-Mail-Nachricht enthält. Der Text unterstützt zwei vordefinierte Platzhalter: <%UserName%> und <%Password%>. Wenn diese Platzhalter in der BodyFileName Datei vorhanden sind, werden sie durch den Namen und das Kennwort des gerade erstellten Benutzers ersetzt.

Hinweis

Die CreateUserWizard -Eigenschaft des Steuerelements MailDefinition gibt nur Details zur E-Mail-Nachricht an, die beim Erstellen eines neuen Kontos gesendet wird. Es enthält keine Details dazu, wie die E-Mail-Nachricht tatsächlich gesendet wird (d. a. ob ein SMTP-Server oder ein E-Mail-Ablageverzeichnis verwendet wird, irgendwelche Authentifizierungsinformationen usw.). Diese Details auf niedriger Ebene müssen im <system.net> Abschnitt in Web.configdefiniert werden. Weitere Informationen zu diesen Konfigurationseinstellungen und zum Senden von E-Mails aus ASP.NET 2.0 im Allgemeinen finden Sie in den häufig gestellten Fragen unter SystemNetMail.com und in meinem Artikel Senden von Email in ASP.NET 2.0.

Erweitern des CreateUserWizard-Verhaltens mithilfe von Ereignishandlern

Das CreateUserWizard-Steuerelement löst während des Workflows eine Reihe von Ereignissen aus. Wenn ein Besucher beispielsweise seinen Benutzernamen, sein Kennwort und andere relevante Informationen eingibt und auf die Schaltfläche "Benutzer erstellen" klickt, löst das CreateUserWizard-Steuerelement sein Ereignis ausCreatingUser. Wenn während des Erstellungsprozesses ein Problem auftritt, wird das CreateUserError Ereignis ausgelöst. Wenn der Benutzer jedoch erfolgreich erstellt wurde, wird das CreatedUser Ereignis ausgelöst. Es gibt zusätzliche CreateUserWizard-Steuerelementereignisse, die ausgelöst werden, aber dies sind die drei am häufigsten deutschen.

In bestimmten Szenarien möchten wir möglicherweise auf den CreateUserWizard-Workflow tippen, was wir tun können, indem wir einen Ereignishandler für das entsprechende Ereignis erstellen. Um dies zu veranschaulichen, erweitern wir das RegisterUser CreateUserWizard-Steuerelement, um eine benutzerdefinierte Überprüfung für Den Benutzernamen und das Kennwort einzuschließen. Verbessern wir insbesondere unseren CreateUserWizard, sodass Benutzernamen keine führenden oder nachfolgenden Leerzeichen enthalten können und der Benutzername an keinem beliebigen Ort im Kennwort angezeigt werden kann. Kurz gesagt, wir möchten verhindern, dass jemand einen Benutzernamen wie "Scott" oder eine Kombination aus Benutzername und Kennwort wie "Scott" und "Scott.1234" erstellt.

Um dies zu erreichen, erstellen wir einen Ereignishandler für das CreatingUser Ereignis, um unsere zusätzlichen Überprüfungen durchzuführen. Wenn die angegebenen Daten ungültig sind, müssen wir den Erstellungsprozess abbrechen. Außerdem müssen wir der Seite ein Label Web-Steuerelement hinzufügen, um eine Meldung anzuzeigen, in der erklärt wird, dass der Benutzername oder das Kennwort ungültig ist. Fügen Sie zunächst ein Label-Steuerelement unter dem CreateUserWizard-Steuerelement hinzu, und legen Sie dessen ID -Eigenschaft auf InvalidUserNameOrPasswordMessage und seine ForeColor -Eigenschaft auf fest Red. Löschen Sie die - Text Eigenschaft, und legen Sie die EnableViewState Eigenschaften und Visible auf False fest.

<asp:Label runat="server" id="InvalidUserNameOrPasswordMessage"
     Visible="false" ForeColor="Red" EnableViewState="false">

</asp:Label>

Erstellen Sie als Nächstes einen Ereignishandler für das Ereignis des CreatingUser CreateUserWizard-Steuerelements. Um einen Ereignishandler zu erstellen, wählen Sie das Steuerelement im Designer aus, und wechseln Sie dann zum Eigenschaftenfenster. Klicken Sie dort auf das Blitzsymbol, und doppelklicken Sie dann auf das entsprechende Ereignis, um den Ereignishandler zu erstellen.

Fügen Sie dem CreatingUser -Ereignishandler folgenden Code hinzu:

protected void RegisterUser_CreatingUser(object sender, LoginCancelEventArgs e)
{
     string trimmedUserName = RegisterUser.UserName.Trim();
     if (RegisterUser.UserName.Length != trimmedUserName.Length)
     {
          // Show the error message
          InvalidUserNameOrPasswordMessage.Text = "The username cannot contain leading or trailing spaces.";
          InvalidUserNameOrPasswordMessage.Visible = true;

          // Cancel the create user workflow
          e.Cancel = true;
     }
     else
     {
          // Username is valid, make sure that the password does not contain the username

          if (RegisterUser.Password.IndexOf(RegisterUser.UserName, StringComparison.OrdinalIgnoreCase) >= 0)
          {
               // Show the error message
               InvalidUserNameOrPasswordMessage.Text = "The username may not appear anywhere in the password.";
               InvalidUserNameOrPasswordMessage.Visible = true;
               // Cancel the create user workflow
               e.Cancel = true;
          }
     }
}

Beachten Sie, dass der Benutzername und das Kennwort, die in das CreateUserWizard-Steuerelement eingegeben wurden, über die UserName Eigenschaften und Passwordverfügbar sind. Wir verwenden diese Eigenschaften im obigen Ereignishandler, um zu bestimmen, ob der angegebene Benutzername führende oder nachfolgende Leerzeichen enthält und ob der Benutzername innerhalb des Kennworts gefunden wird. Wenn eine dieser Bedingungen erfüllt ist, wird eine Fehlermeldung in der InvalidUserNameOrPasswordMessage Bezeichnung angezeigt, und die -Eigenschaft des Ereignishandlers e.Cancel ist auf truefestgelegt. Wenn e.Cancel auf truefestgelegt ist, wird der Workflow von CreateUserWizard kurzgeschlossen und der Erstellungsprozess des Benutzerkontos abgebrochen.

Abbildung 15 zeigt einen Screenshot, der zeigt CreatingUserAccounts.aspx , wann der Benutzer einen Benutzernamen mit führenden Leerzeichen eingibt.

Abbildung 15: Benutzernamen mit führenden oder nachgestellten Leerzeichen sind nicht zulässig (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Hinweis

Ein Beispiel für die Verwendung des Ereignisses CreatedUser des CreateUserWizard-Steuerelements finden Sie im Tutorial Zum Speichern zusätzlicher Benutzerinformationen.

Zusammenfassung

Die Membership -Methode der CreateUser -Klasse erstellt ein neues Benutzerkonto im Membership-Framework. Dazu delegiert er den Aufruf an den konfigurierten Mitgliedschaftsanbieter. Im Fall von SqlMembershipProviderfügt die -Methode den CreateUseraspnet_Users Datenbanktabellen und aspnet_Membership einen Datensatz hinzu.

Während neue Benutzerkonten programmgesteuert erstellt werden können (wie in Schritt 5 dargestellt), ist die Verwendung des CreateUserWizard-Steuerelements ein schnellerer und einfacherer Ansatz. Dieses Steuerelement rendert eine mehrstufige Benutzeroberfläche zum Sammeln von Benutzerinformationen und Erstellen eines neuen Benutzers im Mitgliedschaftsframework. Hinter den Hüllen verwendet dieses Steuerelement die gleiche Membership.CreateUser Methode wie in Schritt 5 untersucht, aber das Steuerelement erstellt die Benutzeroberfläche und Validierungssteuerelemente und reagiert auf Fehler beim Erstellen von Benutzerkonten, ohne einen Lick von Code schreiben zu müssen.

An diesem Punkt verfügen wir über die Funktionalität, um neue Benutzerkonten zu erstellen. Die Anmeldeseite wird jedoch weiterhin anhand der hartcodierten Anmeldeinformationen überprüft, die wir im zweiten Tutorial angegeben haben. Im nächsten Tutorial wird aktualisiertLogin.aspx, um die vom Benutzer angegebenen Anmeldeinformationen anhand des Mitgliedschaftsframeworks zu überprüfen.

Viel Spaß beim Programmieren!

Weitere Informationen

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

• CreateUser Technische Dokumentation
• Übersicht über das CreateUserWizard-Steuerelement
• Erstellen eines Datei-System-Based-Siteübersichtsanbieters
• Erstellen einer schrittweisen Benutzeroberfläche mit dem ASP.NET 2.0-Assistentensteuerelement
• Untersuchen der Websitenavigation von ASP.NET 2.0
• Gestaltungsvorlagen und Websitenavigation
• Der SQL-Site map-Anbieter, auf den Sie gewartet haben

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 ab mitchell@4GuysFromRolla.com.

ZurückWeiter