MVC5 (VS2012) identité CreateIdentityAsync - la valeur ne peut pas être nulle

j'ai eu la même erreur dans le passé mais seulement quand j'ai créé l'utilisateur avec L'outil de Migration Entity Framework. Lors de la création d'un utilisateur et de la signature avec le site web, Je n'avais pas d'erreur.

mon erreur était que je ne fournissais pas un SecurityStamp avec migration.

SecurityStamp = Guid.NewGuid().ToString()

cette propriété ensemble, tout a fonctionné.

j'ai eu un problème similaire. La Solution était de définir la propriété SecurityStamp-de L'entité-utilisateur.

Background: le client veut avoir des comptes Admin-/Superuser-avec des mots de passe dans la base de données et un groupe d'utilisateurs supplémentaires - qui seront en mesure de se connecter sans mot de passe - dans un fichier XML...

donc j'hérite de L'Userstore Entity Framework, j'annule FindByIdAsync et FindByNameAsync, je recherche le fichier XML pour l'utilisateur et je renvoie une nouvelle User-Entity. (si pas de l'utilisateur a été trouvé par l'implémentation par défaut)

j'ai eu la même Exception que Jon en créant une Identitédemande.

après quelques recherches, j'ai découvert que mes nouvelles entités utilisatrices n'avaient pas de SecurityStamp. Et le asp.net UserManager par défaut attend une SecurityStamp et veut la définir comme une revendication dans L'Entitédemande.

après avoir défini une valeur à cette propriété-j'ai utilisé une chaîne qui contient un préfixe et le nom d'utilisateur - tout fonctionne très bien pour je.

j'ai fait la même chose que @user3347549.

il m'a fallu du temps pour comprendre d'où venait l'erreur, bravo à dotPeek pour ça!

j'utilise ma propre implémentation de UserManager et UserStore, parce que je voulais des types de Guid (uniqueidentifier dans MSSQL) comme clés, et non des chaînes (bien qu'ils soient juste des placeholders pour les GUID)

merci à lien et en particulier cette réponse, que j'ai inclus à titre de référence dans le cas le lien disparaît, de HaoK (@Hao Kung ici SO):

vous devriez ensemencer le tampon de sécurité avec quelque chose d'aléatoire, comme un nouveau travail de guid.

j'ai implémenté mon propre ClaimsIdentityFactory (qui ressemble exactement au même de ce que j'ai trouvé dans dotPeek) et j'ai juste modifié une ligne dans la méthode CreateAsync

public class ClaimsIdentityFactory<TUser, TKey> : IClaimsIdentityFactory<TUser, TKey>
    where TUser : class, IUser<TKey>
    where TKey : IEquatable<TKey>
{
    /// <summary>
    /// Claim type used for role claims
    /// </summary>
    public string RoleClaimType { get; set; }

    /// <summary>
    /// Claim type used for the user name
    /// </summary>
    public string UserNameClaimType { get; set; }

    /// <summary>
    /// Claim type used for the user id
    /// </summary>
    public string UserIdClaimType { get; set; }

    /// <summary>
    /// Claim type used for the user security stamp
    /// </summary>
    public string SecurityStampClaimType { get; set; }

    /// <summary>
    /// Constructor
    /// </summary>
    public ClaimsIdentityFactory()
    {
        RoleClaimType = "http://schemas.microsoft.com/ws/2008/06/identity/claims/role";
        UserIdClaimType = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier";
        UserNameClaimType = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name";
        SecurityStampClaimType = "AspNet.Identity.SecurityStamp";
    }

    /// <summary>
    /// Create a ClaimsIdentity from a user
    /// </summary>
    /// <param name="manager">
    /// </param>
    /// <param name="user">
    /// </param>
    /// <param name="authenticationType">
    /// </param>
    /// <returns>
    /// </returns>
    public virtual async Task<ClaimsIdentity> CreateAsync(UserManager<TUser, TKey> manager, TUser user, string authenticationType)
    {
        if (manager == null)
            throw new ArgumentNullException("manager");
        if (user == null)
            throw new ArgumentNullException("user");

        var id = new ClaimsIdentity(authenticationType, UserNameClaimType, RoleClaimType);
        id.AddClaim(new Claim(UserIdClaimType, ConvertIdToString(user.Id), "http://www.w3.org/2001/XMLSchema#string"));
        id.AddClaim(new Claim(UserNameClaimType, user.UserName, "http://www.w3.org/2001/XMLSchema#string"));
        id.AddClaim(new Claim("http://schemas.microsoft.com/accesscontrolservice/2010/07/claims/identityprovider", "ASP.NET Identity", "http://www.w3.org/2001/XMLSchema#string"));
        if (manager.SupportsUserSecurityStamp)
        {
            ClaimsIdentity claimsIdentity1 = id;
            string securityStampClaimType = SecurityStampClaimType;
            ClaimsIdentity claimsIdentity2 = claimsIdentity1;
            string str = await manager.GetSecurityStampAsync(user.Id).ConfigureAwait(false);
            Claim claim = new Claim(securityStampClaimType, str ?? Guid.NewGuid().ToString());
            claimsIdentity2.AddClaim(claim);
        }
        if (manager.SupportsUserRole)
        {
            IList<string> roles = await manager.GetRolesAsync(user.Id).ConfigureAwait(false);
            foreach (string str in roles)
                id.AddClaim(new Claim(RoleClaimType, str, "http://www.w3.org/2001/XMLSchema#string"));
        }
        if (manager.SupportsUserClaim)
            id.AddClaims(await manager.GetClaimsAsync(user.Id).ConfigureAwait(false));
        return id;
    }

    /// <summary>
    /// Convert the key to a string, by default just calls .ToString()
    /// </summary>
    /// <param name="key">
    /// </param>
    /// <returns>
    /// </returns>
    protected virtual string ConvertIdToString(TKey key)
    {
        if ((object)key == null)
            throw new ArgumentNullException("key");
        else
            return key.ToString();
    }
}

La ligne I a été modifié à partir de

Claim claim = new Claim(securityStampClaimType, str);

Claim claim = new Claim(securityStampClaimType, str ?? Guid.NewGuid().ToString());

je n'ai pas encore de comprendre ce que cela signifie, mais au moins cela fonctionne pour le moment et je peux continuer à tester mon application. Je suppose que cette erreur apparaît parce que je n'ai pas entièrement implémenté une partie de la pile D'identité. Pour utiliser cette nouvelle usine, tapez simplement ceci dans le UserManager constructeur:

ClaimsIdentityFactory = new ClaimsIdentityFactory<TUser, Guid>();

par défaut UserManager tentera d'obtenir les revendications et ajouter/supprimer des revendications même si vous n'avez pas mis en œuvre. Si vous n'avez pas besoin de réclamations, la solution que j'ai trouvé est de mettre en œuvre votre propre UserManager ou implémenter des méthodes "ne rien faire" dans votre UserStore.

public Task AddClaimAsync(TUser user, Claim claim)
{
    return Task.FromResult<int>(0);
}

public Task<IList<Claim>> GetClaimsAsync(TUser user)
{
    return Task.FromResult<IList<Claim>>(new List<Claim>());
}

public Task RemoveClaimAsync(TUser user, Claim claim)
{
    return Task.FromResult<int>(0);
}

J'ai dû implémenter ClaimsIdentityFactory et mettre en place le UserManager.ClaimsIdentityFactory propriété, c.-à-d. Dans la classe AccountController.

Dans mon cas, c'était quelque chose de totalement différent. C'était une question D'ordre de code de démarrage D'Owin

mon code buggy:

public void ConfigureAuth(IAppBuilder app)
{

   //...

   app.CreatePerOwinContext(ApplicationDbContext.Create);
   app.CreatePerOwinContext<AppUserManager>(AppUserManager.Create);
   app.CreatePerOwinContext<AppSignInManager>(AppSignInManager.Create);
   app.CreatePerOwinContext<AppRoleManager>(AppRoleManager.Create);

   //...

}

Il s'avère, AppSignInManager essayait d'init AppUserManager toujours null parce qu'il n'a pas encore été ajouté à Owin.

en les échangeant simplement ensemble, tout a fonctionné comme un charme

public void ConfigureAuth(IAppBuilder app)
{

   //...

   app.CreatePerOwinContext(ApplicationDbContext.Create);
   app.CreatePerOwinContext<AppSignInManager>(AppSignInManager.Create);
   app.CreatePerOwinContext<AppUserManager>(AppUserManager.Create);
   app.CreatePerOwinContext<AppRoleManager>(AppRoleManager.Create);

   //...

}