Création de comptes d’utilisateurs (C#)

par Scott Mitchell

Notes

Depuis la rédaction de cet article, les fournisseurs d’appartenance ASP.NET ont été remplacés par ASP.NET Identity. Nous vous recommandons vivement de mettre à jour les applications pour utiliser la plateforme d’identité ASP.NET plutôt que les fournisseurs d’appartenances proposés au moment de la rédaction de cet article. ASP.NET Identity présente un certain nombre d’avantages par rapport au système d’appartenance ASP.NET, notamment :

• Meilleures performances
• Extensibilité et testabilité améliorées
• Prise en charge d’OAuth, OpenID Connect et de l’authentification à deux facteurs
• Prise en charge des identités basées sur les revendications
• Meilleure interopérabilité avec ASP.Net Core

Télécharger le code ou télécharger un FICHIER PDF

Dans ce tutoriel, nous allons explorer l’utilisation de l’infrastructure d’appartenance (via SqlMembershipProvider) pour créer des comptes d’utilisateur. Nous allons voir comment créer de nouveaux utilisateurs par programmation et via ASP. Contrôle CreateUserWizard intégré de NET.

Introduction

Dans le didacticiel précédent , nous avons installé le schéma des services d’application dans une base de données, qui a ajouté les tables, les vues et les procédures stockées requises par et SqlMembershipProviderSqlRoleProvider. Cela a créé l’infrastructure dont nous aurons besoin pour le reste des didacticiels de cette série. Dans ce tutoriel, nous allons explorer l’utilisation de l’infrastructure d’appartenance (via le SqlMembershipProvider) pour créer de nouveaux comptes d’utilisateur. Nous allons voir comment créer de nouveaux utilisateurs par programmation et via ASP. Contrôle CreateUserWizard intégré de NET.

En plus d’apprendre à créer des comptes d’utilisateur, nous devons également mettre à jour le site web de démonstration que nous avons créé dans le didacticiel Vue d’ensemble de l’authentification par formulaire, puis amélioré dans le didacticiel Configuration de l’authentification par formulaire et rubriques avancées. Notre application web de démonstration a une page de connexion qui valide les informations d’identification des utilisateurs par rapport aux paires nom d’utilisateur/mot de passe codées en dur. En outre, Global.asax inclut du code qui crée des objets et IIdentity personnalisés IPrincipal pour les utilisateurs authentifiés. Nous allons mettre à jour la page de connexion pour valider les informations d’identification des utilisateurs par rapport à l’infrastructure d’appartenance et supprimer le principal personnalisé et la logique d’identité.

C’est parti !

Liste de vérification de l’authentification et de l’appartenance par formulaire

Avant de commencer à travailler avec le framework d’appartenance, prenons un moment pour passer en revue les étapes importantes que nous avons prises pour atteindre ce point. Lorsque vous utilisez l’infrastructure d’appartenance avec dans SqlMembershipProvider un scénario d’authentification basée sur des formulaires, les étapes suivantes doivent être effectuées avant d’implémenter la fonctionnalité d’appartenance dans votre application web :

1. Activez l’authentification basée sur les formulaires. Comme nous l’avons vu dans Vue d’ensemble de l’authentification par formulaire, l’authentification par formulaire est activée en modifiant Web.config et en définissant l’attribut de l’élément <authentication>mode sur .Forms Une fois l’authentification par formulaire activée, chaque demande entrante est examinée pour obtenir un ticket d’authentification par formulaire, qui, le cas échéant, identifie le demandeur.
2. Ajoutez le schéma des services d’application à la base de données appropriée. Lors de l’utilisation de , SqlMembershipProvider nous devons installer le schéma des services d’application dans une base de données. En règle générale, ce schéma est ajouté à la même base de données qui contient le modèle de données de l’application. Le didacticiel Création du schéma d’appartenance dans SQL Server a examiné l’utilisation de l’outil aspnet_regsql.exe pour ce faire.
3. Personnalisez les paramètres de l’application web pour référencer la base de données à l’étape 2. Le didacticiel Création du schéma d’appartenance dans SQL Server a montré deux façons de configurer l’application web afin que le utilise la base de données sélectionnée à l’étape SqlMembershipProvider 2 : en modifiant le nom de la LocalSqlServer chaîne de connexion ou en ajoutant un nouveau fournisseur inscrit à la liste des fournisseurs d’infrastructure d’appartenance et en personnalisant ce nouveau fournisseur pour utiliser la base de données de l’étape 2.

Lors de la création d’une application web qui utilise l’authentification basée sur les SqlMembershipProvider formulaires et , vous devez effectuer ces trois étapes avant d’utiliser la Membership classe ou les contrôles web de connexion ASP.NET. Étant donné que nous avons déjà effectué ces étapes dans les didacticiels précédents, nous sommes prêts à commencer à utiliser l’infrastructure d’appartenance !

Étape 1 : Ajout de nouvelles pages ASP.NET

Dans ce tutoriel et les trois suivants, nous allons examiner différentes fonctions et fonctionnalités liées à l’appartenance. Nous aurons besoin d’une série de pages ASP.NET pour implémenter les rubriques examinées tout au long de ces tutoriels. Nous allons créer ces pages, puis un fichier (Web.sitemap)de plan de site .

Commencez par créer un dossier dans le projet nommé Membership. Ensuite, ajoutez cinq nouvelles pages ASP.NET au Membership dossier, en liant chaque page à la Site.master page master. Nommez les pages :

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

À ce stade, la Explorateur de solutions de votre projet doit ressembler à la capture d’écran illustrée à la figure 1.

Figure 1 : Cinq nouvelles pages ont été ajoutées au Membership dossier (cliquer pour afficher l’image en taille réelle)

À ce stade, chaque page doit avoir les deux contrôles Content, un pour chacun des ContentPlaceHolders de la page master : MainContent et LoginContent.

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

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

Rappelez-vous que le LoginContent balisage par défaut du ContentPlaceHolder affiche un lien pour se connecter ou se déconnecter du site, selon que l’utilisateur est authentifié ou non. Toutefois, la présence du Content2 contrôle Contenu remplace le balisage par défaut de la page master. Comme nous l’avons vu dans le didacticiel Vue d’ensemble de l’authentification par formulaire, cela est utile dans les pages où nous ne voulons pas afficher les options de connexion dans la colonne de gauche.

Toutefois, pour ces cinq pages, nous voulons afficher le balisage par défaut de la page master pour le LoginContent ContentPlaceHolder. Par conséquent, supprimez le balisage déclaratif pour le Content2 contrôle Content. Après cela, le balisage de chacune des cinq pages ne doit contenir qu’un seul contrôle De contenu.

Étape 2 : Création du plan de site

Tous les sites web, sauf les plus trivials, doivent implémenter une certaine forme d’interface utilisateur de navigation. L’interface utilisateur de navigation peut être une simple liste de liens vers les différentes sections du site. Ces liens peuvent également être organisés dans des menus ou des arborescences. En tant que développeurs de pages, la création de l’interface utilisateur de navigation n’est que la moitié de l’histoire. Nous avons également besoin de moyens pour définir la structure logique du site de manière maintenable et mise à jour. À mesure que de nouvelles pages sont ajoutées ou supprimées, nous voulons pouvoir mettre à jour une seule source ( le plan de site) et que ces modifications soient reflétées dans l’interface utilisateur de navigation du site.

Ces deux tâches , la définition du plan de site et l’implémentation d’une interface utilisateur de navigation basée sur le plan de site, sont faciles à accomplir grâce à l’infrastructure Plan de site et aux contrôles Web de navigation ajoutés dans ASP.NET version 2.0. L’infrastructure Plan de site permet à un développeur de définir un plan de site, puis d’y accéder par le biais d’une API programmatique (laSiteMap classe ). Les contrôles web de navigation intégrés incluent un contrôle Menu, le contrôle TreeView et le contrôle SiteMapPath.

À l’instar des frameworks Membership et Roles, l’infrastructure Site Map est créée sur le modèle du fournisseur. Le travail de la classe de fournisseur Site Map consiste à générer la structure en mémoire utilisée par la SiteMap classe à partir d’un magasin de données persistant, tel qu’un fichier XML ou une table de base de données. Le .NET Framework est fourni avec un fournisseur de plan de site par défaut qui lit les données de plan de site à partir d’un fichier XML (XmlSiteMapProvider), et il s’agit du fournisseur que nous allons utiliser dans ce didacticiel. Pour obtenir d’autres implémentations de fournisseurs de plan de site, reportez-vous à la section Lectures supplémentaires à la fin de ce didacticiel.

Le fournisseur de plan de site par défaut s’attend à ce qu’un fichier XML correctement mis en forme nommé Web.sitemap existe dans le répertoire racine. Étant donné que nous utilisons ce fournisseur par défaut, nous devons ajouter un tel fichier et définir la structure du plan de site dans le format XML approprié. Pour ajouter le fichier, cliquez avec le bouton droit sur le nom du projet dans Explorateur de solutions et choisissez Ajouter un nouvel élément. Dans la boîte de dialogue, choisissez d’ajouter un fichier de type Site Map nommé Web.sitemap.

Figure 2 : Ajouter un fichier nommé Web.sitemap au répertoire racine du projet (cliquer pour afficher l’image en taille réelle)

Le fichier de plan de site XML définit la structure du site web en tant que hiérarchie. Cette relation hiérarchique est modélisée dans le fichier XML via l’ascendance des <siteMapNode> éléments. Le Web.sitemap doit commencer par un <siteMap> nœud parent qui a précisément un <siteMapNode> enfant. Cet élément de niveau <siteMapNode> supérieur représente la racine de la hiérarchie et peut avoir un nombre arbitraire de nœuds descendants. Chaque <siteMapNode> élément doit inclure un title attribut et peut éventuellement inclure url des attributs et description , entre autres ; chaque attribut non vide url doit être unique.

Entrez le code XML suivant dans le Web.sitemap fichier :

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

Le balisage de carte de site ci-dessus définit la hiérarchie illustrée à la figure 3.

Figure 3 : Le plan de site représente une structure de navigation hiérarchique (cliquer pour afficher l’image en taille réelle)

Étape 3 : Mise à jour de la page maître pour inclure une interface utilisateur de navigation

ASP.NET inclut un certain nombre de contrôles Web liés à la navigation pour la conception d’une interface utilisateur. Il s’agit notamment des contrôles Menu, TreeView et SiteMapPath. Les contrôles Menu et TreeView affichent la structure de plan de site dans un menu ou une arborescence, respectivement, tandis que SiteMapPath affiche une barre de navigation qui montre le nœud actuel visité ainsi que ses ancêtres. Les données de plan de site peuvent être liées à d’autres contrôles web de données à l’aide de SiteMapDataSource et sont accessibles par programmation via la SiteMap classe .

Étant donné qu’une discussion approfondie de l’infrastructure de plan de site et des contrôles de navigation dépasse le cadre de cette série de tutoriels, plutôt que de passer du temps à créer notre propre interface utilisateur de navigation, nous allons plutôt emprunter celle utilisée dans ma série de tutoriels Utilisation des données dans ASP.NET 2.0 , qui utilise un contrôle Repeater pour afficher une liste à puces de deux profondeurs de liens de navigation, comme illustré dans la figure 4.

Ajout d’une liste de liens Two-Level dans la colonne de gauche

Pour créer cette interface, ajoutez le balisage déclaratif suivant à la colonne de gauche de la Site.master page master où le texte « TODO: Menu will go here... » réside actuellement.

<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" />

Le balisage ci-dessus lie un contrôle Repeater nommé menu à un SiteMapDataSource, qui retourne la hiérarchie de plan de site définie dans Web.sitemap. Étant donné que la propriété du ShowStartingNode contrôle SiteMapDataSource a la valeur False, elle commence à renvoyer la hiérarchie de la carte de site en commençant par les descendants du nœud « Accueil ». Le répétiteur affiche chacun de ces nœuds (actuellement simplement « Appartenance ») dans un <li> élément. Un autre répétiteur interne affiche ensuite les enfants du nœud actuel dans une liste imbriquée non triée.

La figure 4 montre la sortie rendue du balisage ci-dessus avec la structure de plan de site que nous avons créée à l’étape 2. Le répéteur restitue le balisage de liste non triée de vanille ; les règles de feuille de style en cascade définies dans Styles.css sont responsables de la disposition esthétique. Pour obtenir une description plus détaillée du fonctionnement du balisage ci-dessus, reportez-vous au tutoriel Pages maîtres et navigation de site .

Figure 4 : L’interface utilisateur de navigation est rendue à l’aide de listes imbriquées non triées (cliquez pour afficher l’image en taille réelle)

Ajout d’une navigation de navigation en fil d’ariane

En plus de la liste des liens dans la colonne de gauche, nous allons également faire en sorte que chaque page affiche une barre de navigation. Un fil d’accès est un élément d’interface utilisateur de navigation qui montre rapidement aux utilisateurs leur position actuelle dans la hiérarchie de site. Le contrôle SiteMapPath utilise l’infrastructure Site Map pour déterminer l’emplacement de la page active dans le plan du site, puis affiche un fil d’accès basé sur ces informations.

Plus précisément, ajoutez un <span> élément à l’élément d’en-tête <div> de la page master et définissez l’attribut du class nouvel <span> élément sur « breadcrumb ». (La Styles.css classe contient une règle pour une classe « breadcrumb ». Ensuite, ajoutez un SiteMapPath à ce nouvel <span> élément.

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

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

La figure 5 montre la sortie de SiteMapPath lors de la visite de ~/Membership/CreatingUserAccounts.aspx.

Figure 5 : La barre de navigation affiche la page active et ses ancêtres dans le plan du site (cliquer pour afficher l’image en taille réelle)

Étape 4 : Suppression du principal personnalisé et de la logique d’identité

Les objets d’identité et de principal personnalisés peuvent être associés à l’utilisateur authentifié. Pour ce faire, nous créons un gestionnaire d’événements dans Global.asax pour l’événement de PostAuthenticateRequest l’application FormsAuthenticationModule , qui se déclenche après l’authentification de l’utilisateur. Dans ce gestionnaire d’événements, nous avons remplacé les GenericPrincipal objets et FormsIdentity ajoutés par par les CustomPrincipalFormsAuthenticationModule objets et CustomIdentity que nous avons créés dans ce didacticiel.

Bien que les objets de principal et d’identité personnalisés soient utiles dans certains scénarios, dans la plupart des cas, les GenericPrincipal objets et FormsIdentity sont suffisants. Par conséquent, je pense qu’il serait utile de revenir au comportement par défaut. Apportez cette modification en supprimant ou en commentant le PostAuthenticateRequest gestionnaire d’événements ou en supprimant entièrement le Global.asax fichier.

Étape 5 : Création par programmation d’un nouvel utilisateur

Pour créer un compte d’utilisateur via l’infrastructure d’appartenance, utilisez la méthode de CreateUserla Membership classe . Cette méthode a des paramètres d’entrée pour le nom d’utilisateur, le mot de passe et d’autres champs liés à l’utilisateur. Lors de l’appel, il délègue la création du nouveau compte d’utilisateur au fournisseur d’appartenance configuré, puis retourne un MembershipUser objet représentant le compte d’utilisateur qui vient de se créer.

La CreateUser méthode a quatre surcharges, chacune acceptant un nombre différent de paramètres d’entrée :

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

Ces quatre surcharges diffèrent quant à la quantité d’informations collectées. La première surcharge, par exemple, nécessite uniquement le nom d’utilisateur et le mot de passe pour le nouveau compte d’utilisateur, tandis que la deuxième nécessite également l’adresse e-mail de l’utilisateur.

Ces surcharges existent, car les informations nécessaires à la création d’un compte d’utilisateur dépendent des paramètres de configuration du fournisseur d’appartenance. Dans le tutoriel Création du schéma d’appartenance dans SQL Server nous avons examiné la spécification des paramètres de configuration du fournisseur d’appartenance dans Web.config. Le tableau 2 comprenait une liste complète des paramètres de configuration.

L’un de ces paramètres de configuration du fournisseur d’appartenance qui a un impact sur CreateUser les surcharges qui peuvent être utilisées est le requiresQuestionAndAnswer paramètre . Si requiresQuestionAndAnswer est défini sur true (valeur par défaut), lors de la création d’un compte d’utilisateur, nous devons spécifier une question de sécurité et une réponse. Ces informations sont utilisées ultérieurement si l’utilisateur doit réinitialiser ou modifier son mot de passe. Plus précisément, à ce moment-là, la question de sécurité leur est présentée et ils doivent entrer la réponse correcte pour réinitialiser ou modifier leur mot de passe. Par conséquent, si est requiresQuestionAndAnswer défini sur true , l’appel de l’une des deux CreateUser premières surcharges entraîne une exception, car la question de sécurité et la réponse sont manquantes. Étant donné que notre application est actuellement configurée pour exiger une question de sécurité et une réponse, nous devons utiliser l’une des deux dernières surcharges lors de la création programmatique de l’utilisateur.

Pour illustrer l’utilisation de la CreateUser méthode, nous allons créer une interface utilisateur dans laquelle nous demandons à l’utilisateur son nom, son mot de passe, son e-mail et une réponse à une question de sécurité prédéfinie. Ouvrez la CreatingUserAccounts.aspx page dans le Membership dossier et ajoutez les contrôles Web suivants au contrôle Contenu :

• Zone de texte nommée Username
• TextBox nommé Password, dont TextMode la propriété est définie sur Password
• Zone de texte nommée Email
• Une étiquette nommée SecurityQuestion avec sa Text propriété effacée
• Zone de texte nommée SecurityAnswer
• Un bouton nommé CreateAccountButton dont la propriété Text est définie sur « Créer le compte d’utilisateur »
• Contrôle Label nommé CreateAccountResults avec sa Text propriété effacée

À ce stade, votre écran doit ressembler à la capture d’écran illustrée dans la figure 6.

Figure 6 : Ajouter les différents contrôles web à la CreatingUserAccounts.aspx page (cliquer pour afficher l’image en taille réelle)

Étiquette SecurityQuestion et SecurityAnswer TextBox sont destinés à afficher une question de sécurité prédéfinie et à collecter la réponse de l’utilisateur. Notez que la question de sécurité et la réponse sont stockées sur une base utilisateur par utilisateur, il est donc possible de permettre à chaque utilisateur de définir sa propre question de sécurité. Toutefois, pour cet exemple, j’ai décidé d’utiliser une question de sécurité universelle, à savoir : « Quelle est votre couleur préférée ? »

Pour implémenter cette question de sécurité prédéfinie, ajoutez une constante à la classe code-behind de la page nommée passwordQuestion, en lui attribuant la question de sécurité. Ensuite, dans le Page_Load gestionnaire d’événements, affectez cette constante à la SecurityQuestion propriété de Text Label :

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

Ensuite, créez un gestionnaire d’événements pour l’événement CreateAccountButtonde Click et ajoutez le code suivant :

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;
     }
}

Le Click gestionnaire d’événements commence par définir une variable nommée createStatus de type MembershipCreateStatus. MembershipCreateStatusest une énumération qui indique le status de l’opérationCreateUser. Par exemple, si le compte d’utilisateur est créé correctement, la instance résultante MembershipCreateStatus sera définie sur la valeur Success; en revanche, si l’opération échoue car il existe déjà un utilisateur avec le même nom d’utilisateur, elle sera définie sur une valeur de DuplicateUserName. Dans la CreateUser surcharge que nous utilisons, nous devons passer un MembershipCreateStatus instance à la méthode en tant que out paramètre. Ce paramètre est défini sur la valeur appropriée dans la CreateUser méthode, et nous pouvons examiner sa valeur après l’appel de la méthode pour déterminer si le compte d’utilisateur a été créé avec succès.

Après avoir appelé CreateUser, une createStatusswitch instruction est utilisée pour générer un message approprié en fonction de la valeur affectée à createStatus. Les figures 7 illustrent la sortie lorsqu’un nouvel utilisateur a été créé avec succès. Les figures 8 et 9 montrent la sortie lorsque le compte d’utilisateur n’est pas créé. Dans la figure 8, le visiteur a entré un mot de passe de cinq lettres, qui ne répond pas aux exigences de force de mot de passe décrites dans les paramètres de configuration du fournisseur d’appartenance. Dans la figure 9, le visiteur tente de créer un compte d’utilisateur avec un nom d’utilisateur existant (celui créé dans la figure 7).

Figure 7 : Création réussie d’un nouveau compte d’utilisateur (cliquer pour afficher l’image en taille réelle)

Figure 8 : Le compte d’utilisateur n’est pas créé, car le mot de passe fourni est trop faible (cliquez pour afficher l’image en taille réelle)

Figure 9 : Le compte d’utilisateur n’est pas créé, car le nom d’utilisateur est déjà en cours d’utilisation (cliquez pour afficher l’image en taille réelle)

Notes

Vous vous demandez peut-être comment déterminer la réussite ou l’échec lors de l’utilisation de l’une des deux CreateUser premières surcharges de méthode, dont aucune n’a un paramètre de type MembershipCreateStatus. Ces deux premières surcharges lèvent une MembershipCreateUserException exception en cas de défaillance, qui inclut une StatusCode propriété de type MembershipCreateStatus.

Après avoir créé quelques comptes d’utilisateur, vérifiez que les comptes ont été créés en listant le contenu des aspnet_Users tables et aspnet_Membership dans la SecurityTutorials.mdf base de données. Comme le montre la figure 10, j’ai ajouté deux utilisateurs via la CreatingUserAccounts.aspx page : Tito et Bruce.

Figure 10 : Il existe deux utilisateurs dans le magasin d’utilisateurs d’appartenance : Tito et Bruce (cliquer pour afficher l’image en taille réelle)

Bien que le magasin d’utilisateurs Membership inclut désormais les informations de compte de Bruce et Tito, nous n’avons pas encore implémenté de fonctionnalités qui permettent à Bruce ou Tito de se connecter au site. Actuellement, Login.aspx valide les informations d’identification de l’utilisateur par rapport à un ensemble codé en dur de paires nom d’utilisateur/mot de passe. Il ne valide pas les informations d’identification fournies par rapport à l’infrastructure d’appartenance. Pour l’instant, voir les nouveaux comptes d’utilisateur dans les aspnet_Users tables et aspnet_Membership devra suffire. Dans le tutoriel suivant, Validation des informations d’identification de l’utilisateur sur le magasin d’utilisateurs d’appartenance, nous allons mettre à jour la page de connexion pour valider par rapport au magasin d’appartenances.

Notes

Si vous ne voyez aucun utilisateur dans votre SecurityTutorials.mdf base de données, c’est peut-être parce que votre application web utilise le fournisseur d’appartenance par défaut, AspNetSqlMembershipProvider, qui utilise la ASPNETDB.mdf base de données comme magasin d’utilisateurs. Pour déterminer s’il s’agit du problème, cliquez sur le bouton Actualiser dans le Explorateur de solutions. Si une base de données nommée ASPNETDB.mdf a été ajoutée au App_Data dossier, il s’agit du problème. Revenez à l’étape 4 du didacticiel Création du schéma d’appartenance dans SQL Server pour obtenir des instructions sur la façon de configurer correctement le fournisseur d’appartenance.

Dans la plupart des scénarios de création de compte d’utilisateur, le visiteur se voit présenter une interface permettant d’entrer son nom d’utilisateur, son mot de passe, son e-mail et d’autres informations essentielles, à laquelle un nouveau compte est créé. Dans cette étape, nous avons examiné la création manuelle d’une telle interface, puis nous avons vu comment utiliser la Membership.CreateUser méthode pour ajouter par programmation le nouveau compte d’utilisateur en fonction des entrées de l’utilisateur. Toutefois, notre code vient de créer le nouveau compte d’utilisateur. Il n’a effectué aucune action de suivi, comme la connexion de l’utilisateur au site sous le compte d’utilisateur qui vient de créer, ou l’envoi d’un e-mail de confirmation à l’utilisateur. Ces étapes supplémentaires nécessitent du code supplémentaire dans le gestionnaire d’événements de Click Button.

ASP.NET est fourni avec le contrôle CreateUserWizard, qui est conçu pour gérer le processus de création de compte d’utilisateur, du rendu d’une interface utilisateur pour la création de nouveaux comptes d’utilisateur à la création du compte dans l’infrastructure d’appartenance et à l’exécution de tâches post-création de compte, telles que l’envoi d’un e-mail de confirmation et la journalisation de l’utilisateur qui vient de créer dans le site. L’utilisation du contrôle CreateUserWizard consiste à faire glisser le contrôle CreateUserWizard de la boîte à outils vers une page, puis à définir quelques propriétés. Dans la plupart des cas, vous n’avez pas besoin d’écrire une seule ligne de code. Nous allons explorer ce contrôle astcieux en détail à l’étape 6.

Si de nouveaux comptes d’utilisateur sont créés uniquement via une page web Créer un compte classique, il est peu probable que vous ayez besoin d’écrire du code qui utilise la CreateUser méthode, car le contrôle CreateUserWizard répondra probablement à vos besoins. Toutefois, la méthode est pratique dans les CreateUser scénarios où vous avez besoin d’une expérience utilisateur créer un compte hautement personnalisée ou lorsque vous devez créer par programmation de nouveaux comptes d’utilisateur via une autre interface. Par exemple, vous pouvez avoir une page qui permet à un utilisateur de charger un fichier XML contenant des informations utilisateur à partir d’une autre application. La page peut analyser le contenu du fichier XML chargé et créer un compte pour chaque utilisateur représenté dans le xml en appelant la CreateUser méthode .

Étape 6 : Création d’un utilisateur avec le contrôle CreateUserWizard

ASP.NET est fourni avec un certain nombre de contrôles Web de connexion. Ces contrôles facilitent de nombreux scénarios courants liés au compte d’utilisateur et à la connexion. Le contrôle CreateUserWizard est un contrôle de ce type conçu pour présenter une interface utilisateur permettant d’ajouter un nouveau compte d’utilisateur à l’infrastructure d’appartenance.

Comme la plupart des autres contrôles Web liés à la connexion, createUserWizard peut être utilisé sans écrire une seule ligne de code. Il fournit intuitivement une interface utilisateur basée sur les paramètres de configuration du fournisseur d’appartenance et appelle en interne la méthode de CreateUser la Membership classe après que l’utilisateur a entré les informations nécessaires et a cliqué sur le bouton « Créer un utilisateur ». Le contrôle CreateUserWizard est extrêmement personnalisable. Il existe une multitude d’événements qui se déclenchent au cours des différentes étapes du processus de création de compte. Nous pouvons créer des gestionnaires d’événements, si nécessaire, pour injecter une logique personnalisée dans le flux de travail de création de compte. En outre, l’apparence de CreateUserWizard est très flexible. Plusieurs propriétés définissent l’apparence de l’interface par défaut ; Si nécessaire, le contrôle peut être converti en modèle ou des « étapes » supplémentaires d’inscription utilisateur peuvent être ajoutées.

Commençons par jeter un coup d’œil à l’utilisation de l’interface et du comportement par défaut du contrôle CreateUserWizard. Nous allons ensuite découvrir comment personnaliser l’apparence via les propriétés et les événements du contrôle.

Examen de l’interface et du comportement par défaut de CreateUserWizard

Revenez à la CreatingUserAccounts.aspx page dans le Membership dossier, basculez vers le mode Création ou Fractionnement, puis ajoutez un contrôle CreateUserWizard en haut de la page. Le contrôle CreateUserWizard est classé sous la section Contrôles de connexion de la boîte à outils. Après avoir ajouté le contrôle, définissez sa ID propriété sur RegisterUser. Comme le montre la capture d’écran de la figure 11, CreateUserWizard affiche une interface avec des zones de texte pour le nom d’utilisateur, le mot de passe, l’adresse e-mail et la question et la réponse de sécurité du nouvel utilisateur.

Figure 11 : Le contrôle CreateUserWizard restitue une interface utilisateur de création générique (cliquez pour afficher l’image en taille réelle)

Prenons un moment pour comparer l’interface utilisateur par défaut générée par le contrôle CreateUserWizard avec l’interface que nous avons créée à l’étape 5. Pour commencer, le contrôle CreateUserWizard permet au visiteur de spécifier à la fois la question de sécurité et la réponse, alors que notre interface créée manuellement utilisait une question de sécurité prédéfinie. L’interface du contrôle CreateUserWizard inclut également des contrôles de validation, alors que nous n’avions pas encore implémenté la validation sur les champs de formulaire de notre interface. Et l’interface de contrôle CreateUserWizard inclut une zone de texte « Confirmer le mot de passe » (ainsi qu’un CompareValidator pour garantir que le texte entré dans les zones de texte « Mot de passe » et « Comparer le mot de passe » est égal).

Ce qui est intéressant, c’est que le contrôle CreateUserWizard consulte les paramètres de configuration du fournisseur d’appartenances lors du rendu de son interface utilisateur. Par exemple, les zones de texte question et réponse de sécurité s’affichent uniquement si requiresQuestionAndAnswer a la valeur True. De même, CreateUserWizard ajoute automatiquement un contrôle RegularExpressionValidator pour s’assurer que les exigences de force de mot de passe sont remplies, et définit ses ErrorMessage propriétés et ValidationExpression en fonction des minRequiredPasswordLengthparamètres de configuration , minRequiredNonalphanumericCharacterset passwordStrengthRegularExpression .

Le contrôle CreateUserWizard, comme son nom l’indique, est dérivé du contrôle Assistant. Les contrôles de l’Assistant sont conçus pour fournir une interface permettant d’effectuer des tâches en plusieurs étapes. Un contrôle Assistant peut avoir un nombre arbitraire de WizardSteps, chacun d’eux étant un modèle qui définit les contrôles HTML et Web pour cette étape. Le contrôle Assistant affiche initialement le premier WizardStep, ainsi que les contrôles de navigation qui permettent à l’utilisateur de passer d’une étape à la suivante, ou de revenir aux étapes précédentes.

Comme le montre le balisage déclaratif de la figure 11, l’interface par défaut du contrôle CreateUserWizard comprend deux WizardSteps:

• CreateUserWizardStep : restitue l’interface pour collecter des informations pour la création du compte d’utilisateur. Il s’agit de l’étape indiquée dans la figure 11.
• CompleteWizardStep : affiche un message indiquant que le compte a été créé avec succès.

L’apparence et le comportement de CreateUserWizard peuvent être modifiés en convertissant l’une de ces étapes en modèles ou en ajoutant votre propre WizardSteps. Nous allons examiner l’ajout d’un WizardStep à l’interface d’inscription dans le didacticiel Stockage d’informations utilisateur supplémentaires .

Voyons le contrôle CreateUserWizard en action. Visitez la CreatingUserAccounts.aspx page via un navigateur. Commencez par entrer des valeurs non valides dans l’interface de CreateUserWizard. Essayez d’entrer un mot de passe qui n’est pas conforme aux exigences de force du mot de passe ou de laisser la zone de texte « Nom d’utilisateur » vide. CreateUserWizard affiche un message d’erreur approprié. La figure 12 montre la sortie lors de la tentative de création d’un utilisateur avec un mot de passe insuffisamment fort.

Figure 12 : CreateUserWizard injecte automatiquement des contrôles de validation (cliquez pour afficher l’image en taille réelle)

Ensuite, entrez les valeurs appropriées dans CreateUserWizard, puis cliquez sur le bouton « Créer un utilisateur ». En supposant que les champs requis ont été entrés et que la force du mot de passe est suffisante, CreateUserWizard crée un compte d’utilisateur via l’infrastructure d’appartenance, puis affiche l’interface CompleteWizardStepde (voir la figure 13). En arrière-plan, createUserWizard appelle la Membership.CreateUser méthode, comme nous l’avons fait à l’étape 5.

Figure 13 : Un nouveau compte d’utilisateur a été créé avec succès (cliquez pour afficher l’image en taille réelle)

Notes

Comme le montre la figure 13, l’interface CompleteWizardStepde inclut un bouton Continuer. Toutefois, à ce stade, le fait de cliquer dessus effectue simplement une publication, laissant le visiteur sur la même page. Dans la section « Personnalisation de l’apparence et du comportement de CreateUserWizard par le biais de ses propriétés », nous allons voir comment ce bouton peut envoyer le visiteur à (ou à Default.aspx une autre page).

Après avoir créé un compte d’utilisateur, revenez à Visual Studio et examinez les tables et aspnet_Membership comme nous l’avons aspnet_Users fait dans la figure 10 pour vérifier que le compte a été correctement créé.

Personnalisation du comportement et de l’apparence de CreateUserWizard via ses propriétés

CreateUserWizard peut être personnalisé de différentes façons, par le biais de propriétés, WizardStepsde et de gestionnaires d’événements. Dans cette section, nous allons voir comment personnaliser l’apparence du contrôle par le biais de ses propriétés ; La section suivante examine l’extension du comportement du contrôle via des gestionnaires d’événements.

Pratiquement tout le texte affiché dans l’interface utilisateur par défaut du contrôle CreateUserWizard peut être personnalisé par le biais de sa pléthore de propriétés. Par exemple, les étiquettes « Nom d’utilisateur », « Mot de passe », « Confirmer le mot de passe », « E-mail », « Question de sécurité » et « Réponse de sécurité » affichées à gauche des zones de texte peuvent être personnalisées par les UserNameLabelTextpropriétés , PasswordLabelText, ConfirmPasswordLabelTextEmailLabelText, QuestionLabelText, et AnswerLabelText , respectivement. De même, il existe des propriétés permettant de spécifier le texte des boutons « Créer un utilisateur » et « Continuer » dans et CreateUserWizardStepCompleteWizardStep, ainsi que si ces boutons sont affichés sous la forme Buttons, LinkButtons ou ImageButtons.

Les couleurs, bordures, polices et autres éléments visuels sont configurables via une multitude de propriétés de style. Le contrôle CreateUserWizard lui-même a les propriétés de style de contrôle Web courantes ( BackColor, BorderStyle, CssClassFont, et ainsi de suite) et il existe un certain nombre de propriétés de style permettant de définir l’apparence de sections particulières de l’interface de CreateUserWizard. La TextBoxStyle propriété, pour instance, définit les styles des zones de texte dans , CreateUserWizardSteptandis que la TitleTextStyle propriété définit le style du titre (« Inscrivez-vous à votre nouveau compte »).

Outre les propriétés liées à l’apparence, il existe un certain nombre de propriétés qui affectent le comportement du contrôle CreateUserWizard. La DisplayCancelButton propriété, si elle est définie sur True, affiche un bouton Annuler en regard du bouton « Créer un utilisateur » (la valeur par défaut est False). Si vous affichez le bouton Annuler, veillez à définir également la CancelDestinationPageUrl propriété , qui spécifie la page vers laquelle l’utilisateur est envoyé après avoir cliqué sur Annuler. Comme indiqué dans la section précédente, le bouton Continuer dans l’interface CompleteWizardStepde provoque une publication, mais laisse le visiteur sur la même page. Pour envoyer le visiteur à une autre page après avoir cliqué sur le bouton Continuer, spécifiez simplement l’URL dans la ContinueDestinationPageUrl propriété .

Nous allons mettre à jour le RegisterUser contrôle CreateUserWizard pour afficher un bouton Annuler et pour envoyer le visiteur lorsque Default.aspx vous cliquez sur les boutons Annuler ou Continuer. Pour ce faire, définissez la propriété sur DisplayCancelButton True et les CancelDestinationPageUrl propriétés et ContinueDestinationPageUrl sur « ~/Default.aspx ». La figure 14 montre la mise à jour de CreateUserWizard lorsqu’elle est consultée via un navigateur.

Figure 14 : CreateUserWizardStep Bouton Inclut un bouton Annuler (cliquer pour afficher l’image en taille réelle)

Lorsqu’un visiteur entre un nom d’utilisateur, un mot de passe, une adresse e-mail et une question de sécurité et une réponse, puis clique sur « Créer un utilisateur », un compte d’utilisateur est créé et le visiteur est connecté en tant qu’utilisateur nouvellement créé. En supposant que la personne qui visite la page crée un compte pour elle-même, il s’agit probablement du comportement souhaité. Toutefois, vous pouvez autoriser les administrateurs à ajouter de nouveaux comptes d’utilisateur. Ce faisant, le compte d’utilisateur est créé, mais l’administrateur reste connecté en tant qu’administrateur (et non en tant que compte nouvellement créé). Ce comportement peut être modifié via la propriété booléenneLoginCreatedUser.

Les comptes d’utilisateur dans l’infrastructure d’appartenance contiennent un indicateur approuvé ; les utilisateurs qui ne sont pas approuvés ne peuvent pas se connecter au site. Par défaut, un compte nouvellement créé est marqué comme approuvé, ce qui permet à l’utilisateur de se connecter immédiatement au site. Toutefois, il est possible d’avoir de nouveaux comptes d’utilisateur marqués comme non approuvés. Peut-être souhaitez-vous qu’un administrateur approuve manuellement les nouveaux utilisateurs avant qu’ils puissent se connecter ; ou peut-être souhaitez-vous vérifier que l’adresse e-mail entrée lors de l’inscription est valide avant d’autoriser un utilisateur à se connecter. Quoi qu’il en soit, vous pouvez marquer le compte d’utilisateur nouvellement créé comme non approuvé en définissant la propriété du DisableCreatedUser contrôle CreateUserWizard sur True (la valeur par défaut est False).

D’autres propriétés liées au comportement notées incluent AutoGeneratePassword et MailDefinition. Si la propriété a la AutoGeneratePassword valeur True, le CreateUserWizardStep n’affiche pas les zones de texte « Mot de passe » et « Confirmer le mot de passe ». Au lieu de cela, le mot de passe de l’utilisateur nouvellement créé est généré automatiquement à l’aide de la méthode de GeneratePasswordla Membership classe . La GeneratePassword méthode construit un mot de passe d’une longueur spécifiée et avec un nombre suffisant de caractères non alphanumériques pour répondre aux exigences de force de mot de passe configurées.

La MailDefinition propriété est utile si vous souhaitez envoyer un e-mail à l’adresse e-mail spécifiée lors du processus de création de compte. La MailDefinition propriété inclut une série de sous-propriétés permettant de définir des informations sur le message électronique construit. Ces sous-propriétés incluent des options telles que Subject, Priority, IsBodyHtml, From, CCet BodyFileName. La BodyFileName propriété pointe vers un fichier texte ou HTML qui contient le corps du message électronique. Le corps prend en charge deux espaces réservés prédéfinis : <%UserName%> et <%Password%>. Ces espaces réservés, s’ils sont présents dans le BodyFileName fichier, seront remplacés par le nom et le mot de passe de l’utilisateur créés.

Notes

La CreateUserWizard propriété du MailDefinition contrôle spécifie simplement des détails sur l’e-mail envoyé lors de la création d’un compte. Il n’inclut pas de détails sur la façon dont le message électronique est réellement envoyé (c’est-à-dire si un serveur SMTP ou un répertoire de dépôt de messages est utilisé, des informations d’authentification, etc.). Ces détails de bas niveau doivent être définis dans la section de <system.net>Web.config. Pour plus d’informations sur ces paramètres de configuration et sur l’envoi d’e-mails à partir de ASP.NET 2.0 en général, reportez-vous aux QUESTIONS sur SystemNetMail.com et à mon article Envoi de Email dans ASP.NET 2.0.

Extension du comportement de CreateUserWizard à l’aide de gestionnaires d’événements

Le contrôle CreateUserWizard déclenche un certain nombre d’événements pendant son workflow. Par exemple, lorsqu’un visiteur entre son nom d’utilisateur, son mot de passe et d’autres informations pertinentes et clique sur le bouton « Créer un utilisateur », le contrôle CreateUserWizard déclenche son CreatingUser événement. En cas de problème pendant le processus de création, l’événementCreateUserError est déclenché. Toutefois, si l’utilisateur est correctement créé, l’événementCreatedUser est déclenché. D’autres événements de contrôle CreateUserWizard sont déclenchés, mais il s’agit des trois événements les plus germaniques.

Dans certains scénarios, nous pouvons utiliser le workflow CreateUserWizard, ce que nous pouvons faire en créant un gestionnaire d’événements pour l’événement approprié. Pour illustrer cela, nous allons améliorer le RegisterUser contrôle CreateUserWizard pour inclure une validation personnalisée sur le nom d’utilisateur et le mot de passe. En particulier, nous allons améliorer notre CreateUserWizard afin que les noms d’utilisateur ne puissent pas contenir d’espaces de début ou de fin et que le nom d’utilisateur ne puisse apparaître n’importe où dans le mot de passe. En bref, nous voulons empêcher quelqu’un de créer un nom d’utilisateur comme « Scott », ou d’avoir une combinaison nom d’utilisateur/mot de passe comme « Scott » et « Scott.1234 ».

Pour ce faire, nous allons créer un gestionnaire d’événements pour l’événement CreatingUser afin d’effectuer nos vérifications de validation supplémentaires. Si les données fournies ne sont pas valides, nous devons annuler le processus de création. Nous devons également ajouter un contrôle Label Web à la page pour afficher un message expliquant que le nom d’utilisateur ou le mot de passe n’est pas valide. Commencez par ajouter un contrôle Label sous le contrôle CreateUserWizard, en définissant sa ID propriété sur InvalidUserNameOrPasswordMessage et sa ForeColor propriété sur Red. Effacez sa Text propriété et définissez ses EnableViewState propriétés et Visible sur False.

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

</asp:Label>

Ensuite, créez un gestionnaire d’événements pour l’événement du CreatingUser contrôle CreateUserWizard. Pour créer un gestionnaire d’événements, sélectionnez le contrôle dans le Designer, puis accédez au Fenêtre Propriétés. À partir de là, cliquez sur l’icône éclair, puis double-cliquez sur l’événement approprié pour créer le gestionnaire d’événements.

Ajoutez le code suivant au gestionnaire d'événements CreatingUser :

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;
          }
     }
}

Notez que le nom d’utilisateur et le mot de passe entrés dans le contrôle CreateUserWizard sont disponibles via ses UserName propriétés etPassword, respectivement. Nous utilisons ces propriétés dans le gestionnaire d’événements ci-dessus pour déterminer si le nom d’utilisateur fourni contient des espaces de début ou de fin et si le nom d’utilisateur se trouve dans le mot de passe. Si l’une de ces conditions est remplie, un message d’erreur s’affiche dans l’étiquette InvalidUserNameOrPasswordMessage et la propriété du e.Cancel gestionnaire d’événements est définie sur true. Si e.Cancel a la valeur true, CreateUserWizard court-circuite son workflow, annulant ainsi le processus de création du compte d’utilisateur.

La figure 15 montre une capture d’écran du CreatingUserAccounts.aspx moment où l’utilisateur entre un nom d’utilisateur avec des espaces de début.

Figure 15 : Les noms d’utilisateur avec des espaces de début ou de fin ne sont pas autorisés (cliquer pour afficher l’image en taille réelle)

Notes

Nous verrons un exemple d’utilisation de l’événement du CreatedUser contrôle CreateUserWizard dans le didacticiel Stockage d’informations utilisateur supplémentaires.

Résumé

La Membership méthode de la CreateUser classe crée un compte d’utilisateur dans l’infrastructure Membership. Il le fait en déléguant l’appel au fournisseur d’appartenance configuré. Dans le cas de , SqlMembershipProviderla CreateUser méthode ajoute un enregistrement aux aspnet_Users tables de base de données et .aspnet_Membership

Bien que de nouveaux comptes d’utilisateur puissent être créés par programmation (comme nous l’avons vu à l’étape 5), une approche plus rapide et plus facile consiste à utiliser le contrôle CreateUserWizard. Ce contrôle affiche une interface utilisateur à plusieurs étapes pour collecter des informations utilisateur et créer un utilisateur dans l’infrastructure d’appartenance. Sous les couvertures, ce contrôle utilise la même Membership.CreateUser méthode que celle examinée à l’étape 5, mais le contrôle crée l’interface utilisateur, les contrôles de validation et répond aux erreurs de création de compte d’utilisateur sans avoir à écrire de code.

À ce stade, nous avons la fonctionnalité en place pour créer des comptes d’utilisateur. Toutefois, la page de connexion est toujours en cours de validation par rapport aux informations d’identification codées en dur que nous avons spécifiées dans le deuxième tutoriel. Dans le tutoriel suivant , nous allons mettre à jour Login.aspx pour valider les informations d’identification fournies par l’utilisateur par rapport à l’infrastructure d’appartenance.

Bonne programmation!

En savoir plus

Pour plus d’informations sur les sujets abordés dans ce didacticiel, consultez les ressources suivantes :

• CreateUser Documentation technique
• Vue d’ensemble du contrôle CreateUserWizard
• Création d’un fournisseur de plan de site System-Based fichier
• Création d’une interface utilisateur pas à pas avec le contrôle Assistant ASP.NET 2.0
• Examen de la navigation de site de ASP.NET 2.0
• Pages maîtres et navigation de site
• Le fournisseur de carte de site SQL que vous attendiez

À propos de l’auteur

Scott Mitchell, auteur de plusieurs livres ASP/ASP.NET et fondateur de 4GuysFromRolla.com, travaille avec les technologies Web Microsoft depuis 1998. Scott travaille comme consultant indépendant, formateur et écrivain. Son dernier livre est Sams Teach Yourself ASP.NET 2.0 in 24 Hours. Scott peut être joint à l’adresse mitchell@4guysfromrolla.com ou via son blog à l’adresse http://ScottOnWriting.NET.

Un merci spécial à...

Cette série de tutoriels a été examinée par de nombreux réviseurs utiles. La réviseure principale de ce tutoriel était Teresa Murphy. Vous souhaitez consulter mes prochains articles MSDN ? Si c’est le cas, déposez-moi une ligne à mitchell@4GuysFromRolla.com.

PrécédentSuivant