Partager via

Vue d’ensemble des fournisseurs de stockage personnalisés pour ASP.NET Identity

  • Article

par Tom FitzMacken

ASP.NET Identity est un système extensible qui vous permet de créer votre propre fournisseur de stockage et de le connecter à votre application sans re-travailler l’application. Cette rubrique explique comment créer un fournisseur de stockage personnalisé pour ASP.NET Identity. Il couvre les concepts importants pour la création de votre propre fournisseur de stockage, mais il ne s’agit pas d’une procédure pas à pas d’implémentation d’un fournisseur de stockage personnalisé.

Pour obtenir un exemple d’implémentation d’un fournisseur de stockage personnalisé, consultez Implémentation d’un fournisseur de stockage mySQL ASP.NET d’identité personnalisé.

Cette rubrique a été mise à jour pour ASP.NET Identity 2.0.

Versions logicielles utilisées dans le tutoriel

  • Visual Studio 2013 avec Update 2
  • ASP.NET Identity 2

Introduction

Par défaut, le système d’identité ASP.NET stocke les informations utilisateur dans une base de données SQL Server et utilise Entity Framework Code First pour créer la base de données. Pour de nombreuses applications, cette approche fonctionne bien. Toutefois, vous pouvez préférer utiliser un autre type de mécanisme de persistance, tel que Stockage Table Azure, ou vous avez peut-être déjà des tables de base de données avec une structure très différente de l’implémentation par défaut. Dans les deux cas, vous pouvez écrire un fournisseur personnalisé pour votre mécanisme de stockage et le connecter à votre application.

ASP.NET Identity est inclus par défaut dans la plupart des modèles Visual Studio 2013. Vous pouvez obtenir des mises à jour de ASP.NET Identity via le package NuGet EntityFramework d’identité AspNet.

Cette rubrique contient les sections suivantes :

Comprendre l’architecture

ASP.NET Identity se compose de classes appelées gestionnaires et magasins. Les gestionnaires sont des classes de haut niveau qu’un développeur d’applications utilise pour effectuer des opérations, telles que la création d’un utilisateur, dans le système d’identité ASP.NET. Les magasins sont des classes de niveau inférieur qui spécifient la façon dont les entités, telles que les utilisateurs et les rôles, sont conservées. Les magasins sont étroitement associés au mécanisme de persistance, mais les gestionnaires sont dissociés des magasins, ce qui signifie que vous pouvez remplacer le mécanisme de persistance sans perturber l’ensemble de l’application.

Le diagramme suivant montre comment votre application web interagit avec les gestionnaires et les magasins interagissent avec la couche d’accès aux données.

Diagramme montrant comment votre application web interagit avec les gestionnaires

Pour créer un fournisseur de stockage personnalisé pour ASP.NET Identity, vous devez créer la source de données, la couche d’accès aux données et les classes de magasin qui interagissent avec cette couche d’accès aux données. Vous pouvez continuer à utiliser les mêmes API de gestionnaire pour effectuer des opérations de données sur l’utilisateur, mais maintenant ces données sont enregistrées dans un autre système de stockage.

Vous n’avez pas besoin de personnaliser les classes de gestionnaire, car lors de la création d’une nouvelle instance de UserManager ou RoleManager, vous fournissez le type de la classe utilisateur et transmettez une instance de la classe store en tant qu’argument. Cette approche vous permet de brancher vos classes personnalisées dans la structure existante. Vous verrez comment instancier UserManager et RoleManager avec vos classes de magasin personnalisées dans la section Reconfigurer l’application pour utiliser un nouveau fournisseur de stockage.

Comprendre les données stockées

Pour implémenter un fournisseur de stockage personnalisé, vous devez comprendre les types de données utilisés avec ASP.NET Identity et déterminer les fonctionnalités pertinentes pour votre application.

Données Description
Utilisateurs Utilisateurs inscrits de votre site web. Inclut l’ID d’utilisateur et le nom d’utilisateur. Peut inclure un mot de passe haché si les utilisateurs se connectent avec des informations d’identification spécifiques à votre site (plutôt que d’utiliser des informations d’identification provenant d’un site externe comme Facebook) et un tampon de sécurité pour indiquer si quelque chose a changé dans les informations d’identification de l’utilisateur. Peut également inclure l’adresse e-mail, le numéro de téléphone, si l’authentification à deux facteurs est activée, le nombre actuel d’échecs de connexion et si un compte a été verrouillé.
Revendications utilisateur Ensemble d’instructions (ou revendications) relatives à l’utilisateur qui représentent l’identité de l’utilisateur. Peut permettre une plus grande expression de l’identité de l’utilisateur que celle qui peut être obtenue par le biais des rôles.
Connexions utilisateur Informations sur le fournisseur d’authentification externe (comme Facebook) à utiliser lors de la connexion d’un utilisateur.
Rôles Groupes d’autorisation pour votre site. Inclut l’ID de rôle et le nom du rôle (comme « Administration » ou « Employé »).

Créer la couche d’accès aux données

Cette rubrique suppose que vous êtes familiarisé avec le mécanisme de persistance que vous allez utiliser et comment créer des entités pour ce mécanisme. Cette rubrique ne fournit pas de détails sur la création des dépôts ou des classes d’accès aux données ; au lieu de cela, il fournit des suggestions sur les décisions de conception que vous devez prendre lorsque vous utilisez ASP.NET Identity.

Vous disposez d’une grande liberté lors de la conception des dépôts pour un fournisseur de magasins personnalisé. Vous devez uniquement créer des référentiels pour les fonctionnalités que vous envisagez d’utiliser dans votre application. Par exemple, si vous n’utilisez pas de rôles dans votre application, vous n’avez pas besoin de créer de stockage pour les rôles ou les rôles d’utilisateur. Votre technologie et votre infrastructure existante peuvent nécessiter une structure très différente de l’implémentation par défaut de ASP.NET Identity. Dans votre couche d’accès aux données, vous fournissez la logique pour travailler avec la structure de vos dépôts.

Pour une implémentation MySQL de référentiels de données pour ASP.NET Identity 2.0, consultez MySQLIdentity.sql.

Dans la couche d’accès aux données, vous fournissez la logique permettant d’enregistrer les données de ASP.NET Identity dans votre source de données. La couche d’accès aux données de votre fournisseur de stockage personnalisé peut inclure les classes suivantes pour stocker des informations sur l’utilisateur et le rôle.

Classe Description Exemple
Context Encapsule les informations pour vous connecter à votre mécanisme de persistance et exécuter des requêtes. Cette classe est centrale pour votre couche d’accès aux données. Les autres classes de données nécessitent une instance de cette classe pour effectuer leurs opérations. Vous allez également initialiser vos classes de magasin avec un instance de cette classe. MySQLDatabase
Stockage utilisateur Stocke et récupère les informations utilisateur (telles que le nom d’utilisateur et le hachage de mot de passe). UserTable (MySQL)
Stockage des rôles Stocke et récupère les informations de rôle (telles que le nom du rôle). RoleTable (MySQL)
Stockage UserClaims Stocke et récupère les informations de revendication utilisateur (telles que le type et la valeur de la revendication). UserClaimsTable (MySQL)
Stockage UserLogins Stocke et récupère les informations de connexion utilisateur (par exemple, un fournisseur d’authentification externe). UserLoginsTable (MySQL)
Stockage UserRole Stocke et récupère les rôles auxquels un utilisateur est affecté. UserRoleTable (MySQL)

Là encore, vous devez uniquement implémenter les classes que vous avez l’intention d’utiliser dans votre application.

Dans les classes d’accès aux données, vous fournissez du code pour effectuer des opérations de données pour votre mécanisme de persistance particulier. Par exemple, dans l’implémentation MySQL, la classe UserTable contient une méthode permettant d’insérer un nouvel enregistrement dans la table de base de données Users. La variable nommée _database est une instance de la classe MySQLDatabase.

public int Insert(TUser user)
{
    string commandText = @"Insert into Users (UserName, Id, PasswordHash, SecurityStamp,Email,EmailConfirmed,PhoneNumber,PhoneNumberConfirmed, AccessFailedCount,LockoutEnabled,LockoutEndDateUtc,TwoFactorEnabled)
        values (@name, @id, @pwdHash, @SecStamp,@email,@emailconfirmed,@phonenumber,@phonenumberconfirmed,@accesscount,@lockoutenabled,@lockoutenddate,@twofactorenabled)";
    Dictionary<string, object> parameters = new Dictionary<string, object>();
    parameters.Add("@name", user.UserName);
    parameters.Add("@id", user.Id);
    parameters.Add("@pwdHash", user.PasswordHash);
    parameters.Add("@SecStamp", user.SecurityStamp);
    parameters.Add("@email", user.Email);
    parameters.Add("@emailconfirmed", user.EmailConfirmed);
    parameters.Add("@phonenumber", user.PhoneNumber);
    parameters.Add("@phonenumberconfirmed", user.PhoneNumberConfirmed);
    parameters.Add("@accesscount", user.AccessFailedCount);
    parameters.Add("@lockoutenabled", user.LockoutEnabled);
    parameters.Add("@lockoutenddate", user.LockoutEndDateUtc);
    parameters.Add("@twofactorenabled", user.TwoFactorEnabled);

    return _database.Execute(commandText, parameters);
}

Après avoir créé vos classes d’accès aux données, vous devez créer des classes de magasin qui appellent les méthodes spécifiques dans la couche d’accès aux données.

Personnaliser la classe utilisateur

Lorsque vous implémentez votre propre fournisseur de stockage, vous devez créer une classe utilisateur équivalente à la classe IdentityUser dans l’espace de noms Microsoft.ASP.NET.Identity.EntityFramework :

Le diagramme suivant montre la classe IdentityUser que vous devez créer et l’interface à implémenter dans cette classe.

Image de la classe Identity User

L’interface IUser<TKey> définit les propriétés que le UserManager tente d’appeler lors de l’exécution des opérations demandées. L’interface contient deux propriétés : Id et UserName. L’interface TKey> IUser< vous permet de spécifier le type de clé pour l’utilisateur via le paramètre TKey générique. Le type de la propriété Id correspond à la valeur du paramètre TKey.

L’infrastructure Identity fournit également l’interface IUser (sans le paramètre générique) lorsque vous souhaitez utiliser une valeur de chaîne pour la clé.

La classe IdentityUser implémente IUser et contient des propriétés ou constructeurs supplémentaires pour les utilisateurs de votre site web. L’exemple suivant montre une classe IdentityUser qui utilise un entier pour la clé. Le champ Id est défini sur int pour correspondre à la valeur du paramètre générique.

public class IdentityUser : IUser<int>
{
    public IdentityUser() { ... }
    public IdentityUser(string userName) { ... }
    public int Id { get; set; }
    public string UserName { get; set; }
    // can also define optional properties such as:
    //    PasswordHash
    //    SecurityStamp
    //    Claims
    //    Logins
    //    Roles
}

Pour une implémentation complète, consultez IdentityUser (MySQL).

Personnaliser le magasin d’utilisateurs

Vous créez également une classe UserStore qui fournit les méthodes pour toutes les opérations de données sur l’utilisateur. Cette classe est équivalente à la classe UserStore<TUser> dans l’espace de noms Microsoft.ASP.NET.Identity.EntityFramework . Dans votre classe UserStore, vous implémentez l’IUserStore<TUser, TKey> et l’une des interfaces facultatives. Vous sélectionnez les interfaces facultatives à implémenter en fonction des fonctionnalités que vous souhaitez fournir dans votre application.

L’image suivante montre la classe UserStore que vous devez créer et les interfaces appropriées.

Image de la classe User Store

Le modèle de projet par défaut dans Visual Studio contient du code qui suppose que de nombreuses interfaces facultatives ont été implémentées dans le magasin d’utilisateurs. Si vous utilisez le modèle par défaut avec un magasin d’utilisateurs personnalisé, vous devez soit implémenter des interfaces facultatives dans votre magasin d’utilisateurs, soit modifier le code du modèle pour ne plus appeler des méthodes dans les interfaces que vous n’avez pas implémentées.

L’exemple suivant montre une classe de magasin d’utilisateurs simple. Le paramètre générique TUser prend le type de votre classe d’utilisateur qui est généralement la classe IdentityUser que vous avez définie. Le paramètre générique TKey prend le type de votre clé utilisateur.

public class UserStore : IUserStore<IdentityUser, int>
{
    public UserStore() { ... }
    public UserStore(ExampleStorage database) { ... }
    public Task CreateAsync(IdentityUser user) { ... }
    public Task DeleteAsync(IdentityUser user) { ... }
    public Task<IdentityUser> FindByIdAsync(int userId) { ... }
    public Task<IdentityUser> FindByNameAsync(string userName) { ... }
    public Task UpdateAsync(IdentityUser user) { ... }
    public void Dispose() { ... }
}

Dans cet exemple, le constructeur qui prend un paramètre nommé database de type ExampleDatabase n’est qu’une illustration de la façon de passer votre classe d’accès aux données. Par exemple, dans l’implémentation MySQL, ce constructeur prend un paramètre de type MySQLDatabase.

Dans votre classe UserStore, vous utilisez les classes d’accès aux données que vous avez créées pour effectuer des opérations. Par exemple, dans l’implémentation MySQL, la classe UserStore a la méthode CreateAsync qui utilise une instance de UserTable pour insérer un nouvel enregistrement. La méthode Insert sur l’objet userTable est la même méthode que celle présentée dans la section précédente.

public Task CreateAsync(IdentityUser user)
{
    if (user == null) {
        throw new ArgumentNullException("user");
    }

    userTable.Insert(user);

    return Task.FromResult<object>(null);
}

Interfaces à implémenter lors de la personnalisation du magasin d’utilisateurs

L’image suivante montre plus de détails sur les fonctionnalités définies dans chaque interface. Toutes les interfaces facultatives héritent d’IUserStore.

Illustration montrant plus de détails sur les fonctionnalités définies dans chaque interface

  • IUserStore
    L’interface TUserStore<TUser, TKey> est la seule interface que vous devez implémenter dans votre magasin d’utilisateurs. Il définit des méthodes pour créer, mettre à jour, supprimer et récupérer des utilisateurs.

  • IUserClaimStore
    L’interface TUserClaimStore<TUser, TKey> définit les méthodes que vous devez implémenter dans votre magasin d’utilisateurs pour activer les revendications utilisateur. Il contient des méthodes ou l’ajout, la suppression et la récupération de revendications utilisateur.

  • IUserLoginStore
    Le TUserLoginStore<TUser, TKey> définit les méthodes que vous devez implémenter dans votre magasin d’utilisateurs pour activer les fournisseurs d’authentification externes. Il contient des méthodes permettant d’ajouter, de supprimer et de récupérer des connexions utilisateur, ainsi qu’une méthode pour récupérer un utilisateur en fonction des informations de connexion.

  • IUserRoleStore
    L’interface TUserRoleStore<TKey, TUser> définit les méthodes que vous devez implémenter dans votre magasin d’utilisateurs pour mapper un utilisateur à un rôle. Il contient des méthodes pour ajouter, supprimer et récupérer les rôles d’un utilisateur, ainsi qu’une méthode à case activée si un utilisateur est affecté à un rôle.

  • IUserPasswordStore
    L’interface TUserPasswordStore<TUser, TKey> définit les méthodes que vous devez implémenter dans votre magasin d’utilisateurs pour conserver les mots de passe hachés. Il contient des méthodes pour obtenir et définir le mot de passe haché, ainsi qu’une méthode qui indique si l’utilisateur a défini un mot de passe.

  • IUserSecurityStampStore
    L’interface TUserSecurityStampStore<TUser, TKey> définit les méthodes que vous devez implémenter dans votre magasin d’utilisateurs pour utiliser un tampon de sécurité pour indiquer si les informations de compte de l’utilisateur ont changé. Ce tampon est mis à jour lorsqu’un utilisateur modifie le mot de passe ou ajoute ou supprime des connexions. Il contient des méthodes permettant d’obtenir et de définir l’empreinte de sécurité.

  • IUserTwoFactorStore
    L’interface TUserTwoFactorStore<TUser, TKey> définit les méthodes que vous devez implémenter pour implémenter l’authentification à deux facteurs. Il contient des méthodes permettant d’obtenir et de définir si l’authentification à deux facteurs est activée pour un utilisateur.

  • IUserPhoneNumberStore
    L’interface TUserPhoneNumberStore<TUser, TKey> définit les méthodes que vous devez implémenter pour stocker les numéros de téléphone des utilisateurs. Il contient des méthodes permettant d’obtenir et de définir le numéro de téléphone et si le numéro de téléphone est confirmé.

  • IUserEmailStore
    L’interface TUserEmailStore<TUser, TKey> définit les méthodes que vous devez implémenter pour stocker les adresses e-mail des utilisateurs. Il contient des méthodes permettant d’obtenir et de définir l’adresse e-mail et indique si l’e-mail est confirmé.

  • IUserLockoutStore
    L’interface TUserLockoutStore<TUser, TKey> définit les méthodes que vous devez implémenter pour stocker des informations sur le verrouillage d’un compte. Il contient des méthodes permettant d’obtenir le nombre actuel de tentatives d’accès ayant échoué, d’obtenir et de définir si le compte peut être verrouillé, d’obtenir et de définir la date de fin du verrouillage, d’incrémenter le nombre de tentatives ayant échoué et de réinitialiser le nombre de tentatives ayant échoué.

  • IQueryableUserStore
    L’interface TUser, TKey> IQueryableUserStore< définit les membres que vous devez implémenter pour fournir un magasin d’utilisateurs interrogeable. Il contient une propriété qui contient les utilisateurs interrogeables.

    Vous implémentez les interfaces nécessaires dans votre application ; par exemple, les interfaces IUserClaimStore, IUserLoginStore, IUserRoleStore, IUserPasswordStore et IUserSecurityStampStore, comme indiqué ci-dessous.

public class UserStore : IUserStore<IdentityUser, int>,
                         IUserClaimStore<IdentityUser, int>,
                         IUserLoginStore<IdentityUser, int>,
                         IUserRoleStore<IdentityUser, int>,
                         IUserPasswordStore<IdentityUser, int>,
                         IUserSecurityStampStore<IdentityUser, int>
{
    // interface implementations not shown
}

Pour une implémentation complète (y compris toutes les interfaces), consultez UserStore (MySQL).

IdentityUserClaim, IdentityUserLogin et IdentityUserRole

L’espace de noms Microsoft.AspNet.Identity.EntityFramework contient des implémentations des classes IdentityUserClaim, IdentityUserLogin et IdentityUserRole . Si vous utilisez ces fonctionnalités, vous pouvez créer vos propres versions de ces classes et définir les propriétés de votre application. Toutefois, il est parfois plus efficace de ne pas charger ces entités en mémoire lors de l’exécution d’opérations de base (telles que l’ajout ou la suppression d’une revendication d’un utilisateur). Au lieu de cela, les classes de magasin principal peuvent exécuter ces opérations directement sur la source de données. Par exemple, la méthode UserStore.GetClaimsAsync() peut appeler userClaimTable.FindByUserId(user). Id) pour exécuter une requête directement sur cette table et retourner une liste de revendications.

public Task<IList<Claim>> GetClaimsAsync(IdentityUser user)
{
    ClaimsIdentity identity = userClaimsTable.FindByUserId(user.Id);
    return Task.FromResult<IList<Claim>>(identity.Claims.ToList());
}

Personnaliser la classe de rôle

Lorsque vous implémentez votre propre fournisseur de stockage, vous devez créer une classe de rôle équivalente à la classe IdentityRole dans l’espace de noms Microsoft.ASP.NET.Identity.EntityFramework :

Le diagramme suivant montre la classe IdentityRole que vous devez créer et l’interface à implémenter dans cette classe.

Image de la classe Identity Role

L’interface IRole<TKey> définit les propriétés que le RoleManager tente d’appeler lors de l’exécution des opérations demandées. L’interface contient deux propriétés : ID et Nom. L’interface TKey> IRole< vous permet de spécifier le type de clé pour le rôle via le paramètre TKey générique. Le type de la propriété Id correspond à la valeur du paramètre TKey.

L’infrastructure Identity fournit également l’interface IRole (sans le paramètre générique) lorsque vous souhaitez utiliser une valeur de chaîne pour la clé.

L’exemple suivant montre une classe IdentityRole qui utilise un entier pour la clé. Le champ Id est défini sur int pour correspondre à la valeur du paramètre générique.

public class IdentityRole : IRole<int>
{
    public IdentityRole() { ... }
    public IdentityRole(string roleName) { ... }
    public int Id { get; set; }
    public string Name { get; set; }
}

Pour une implémentation complète, consultez IdentityRole (MySQL).

Personnaliser le magasin de rôles

Vous créez également une classe RoleStore qui fournit les méthodes pour toutes les opérations de données sur les rôles. Cette classe est équivalente à la classe RoleStore<TRole> dans l’espace de noms Microsoft.ASP.NET.Identity.EntityFramework. Dans votre classe RoleStore, vous implémentez l’interface IRoleStore<TRole, TKey> et éventuellement L’interface IQueryableRoleStore<TRole, TKey> .

Image montrant une classe de magasin de rôles

L’exemple suivant montre une classe de magasin de rôles. Le paramètre générique TRole prend le type de votre classe de rôle qui est généralement la classe IdentityRole que vous avez définie. Le paramètre générique TKey prend le type de votre clé de rôle.

public class RoleStore : IRoleStore<IdentityRole, int>
{
    public RoleStore() { ... }
    public RoleStore(ExampleStorage database) { ... }
    public Task CreateAsync(IdentityRole role) { ... }
    public Task DeleteAsync(IdentityRole role) { ... }
    public Task<IdentityRole> FindByIdAsync(int roleId) { ... }
    public Task<IdentityRole> FindByNameAsync(string roleName) { ... }
    public Task UpdateAsync(IdentityRole role) { ... }
    public void Dispose() { ... }
}

  • IRoleStore<TRole>
    L’interface IRoleStore définit les méthodes à implémenter dans votre classe de magasin de rôles. Il contient des méthodes pour créer, mettre à jour, supprimer et récupérer des rôles.

  • RoleStore<TRole>
    Pour personnaliser RoleStore, créez une classe qui implémente l’interface IRoleStore. Vous devez uniquement implémenter cette classe si vous souhaitez utiliser des rôles sur votre système. Le constructeur qui accepte un paramètre nommé base de données de type ExampleDatabase n’est qu’une illustration de la façon de passer votre classe d’accès aux données. Par exemple, dans l’implémentation MySQL, ce constructeur prend un paramètre de type MySQLDatabase.

    Pour une implémentation complète, consultez RoleStore (MySQL).

Reconfigurer l’application pour utiliser un nouveau fournisseur de stockage

Vous avez implémenté votre nouveau fournisseur de stockage. À présent, vous devez configurer votre application pour utiliser ce fournisseur de stockage. Si le fournisseur de stockage par défaut a été inclus dans votre projet, vous devez supprimer le fournisseur par défaut et le remplacer par votre fournisseur.

Remplacer le fournisseur de stockage par défaut dans le projet MVC

  1. Dans la fenêtre Gérer les packages NuGet , désinstallez le package EntityFramework Microsoft ASP.NET Identity . Vous pouvez trouver ce package en recherchant Identity.EntityFramework dans Packages installés.
    Image de la fenêtre Nu Get packages Il vous sera demandé si vous souhaitez également désinstaller Entity Framework. Si vous n’en avez pas besoin dans d’autres parties de votre application, vous pouvez la désinstaller.

  2. Dans le fichier IdentityModels.cs du dossier Models, supprimez ou commentez les classes ApplicationUser et ApplicationDbContext . Dans une application MVC, vous pouvez supprimer l’intégralité du fichier IdentityModels.cs. Dans une application Web Forms, supprimez les deux classes, mais veillez à conserver la classe d’assistance qui se trouve également dans le fichier IdentityModels.cs.

  3. Si votre fournisseur de stockage réside dans un projet distinct, ajoutez-lui une référence dans votre application web.

  4. Remplacez toutes les références à using Microsoft.AspNet.Identity.EntityFramework; par une instruction using pour l’espace de noms de votre fournisseur de stockage.

  5. Dans la classe Startup.Auth.cs, modifiez la méthode ConfigureAuth pour utiliser une seule instance du contexte approprié.

    public void ConfigureAuth(IAppBuilder app)
{
    app.CreatePerOwinContext(ExampleStorageContext.Create);
    app.CreatePerOwinContext(ApplicationUserManager.Create);
    ...

  6. Dans le dossier App_Start, ouvrez IdentityConfig.cs. Dans la classe ApplicationUserManager, modifiez la méthode Create pour retourner un gestionnaire d’utilisateurs qui utilise votre magasin d’utilisateurs personnalisé.

    public static ApplicationUserManager Create(IdentityFactoryOptions<ApplicationUserManager> options, IOwinContext context) 
{
    var manager = new ApplicationUserManager(new UserStore(context.Get<ExampleStorageContext>()));
    ...
}

  7. Remplacez toutes les références à ApplicationUser par IdentityUser.

  8. Le projet par défaut inclut certains membres de la classe user qui ne sont pas définis dans l’interface IUser ; par exemple Email, PasswordHash et GenerateUserIdentityAsync. Si votre classe utilisateur n’a pas ces membres, vous devez les implémenter ou modifier le code qui utilise ces membres.

  9. Si vous avez créé des instances de RoleManager, modifiez ce code pour utiliser votre nouvelle classe RoleStore.

    var roleManager = new RoleManager<IdentityRole>(new RoleStore(context.Get<ExampleStorageContext>()));

  10. Le projet par défaut est conçu pour une classe utilisateur qui a une valeur de chaîne pour la clé. Si votre classe utilisateur a un type différent pour la clé (par exemple, un entier), vous devez modifier le projet pour qu’il fonctionne avec votre type. Consultez Modifier la clé primaire pour les utilisateurs dans ASP.NET Identity.

  11. Si nécessaire, ajoutez la chaîne de connexion au fichier Web.config.

Autres ressources