Où stocker les informations utilisateur ASP.NET MVC utilisant L'authentification Forms?

j'utilise cette solution:

ASP.NET 2.0 authentification des formulaires-le conserver personnalisé et simple

pour résumer: j'ai créé ma propre implémentation principale. Il est stocké dans HttpContext.Actuel.Cache. S'il est perdu, j'ai le nom d'utilisateur du cookie d'autorisation côté client et je peux le reconstruire. Cette solution ne repose pas sur la Session, qui peut être facilement perdue.

EDIT

si vous voulez utiliser votre principal dans votre controller et le rendre testable, vous pouvez le faire:

    private MyPrincipal _myPrincipal;
    MyPrincipal MyPrincipal
    {
        get
        {
            if (_myPrincipal == null)
                return (MyPrincipal)User;
            return _myPrincipal;
        }
        set
        {
            _myPrincipal = value;
        }
    }

dans votre test, vous définirez l'objet préparé pour le test. Sinon, il sera repris de HttpContext. Et maintenant je me suis dit, Pourquoi J'utilise Ninject pour le faire?

j'aime en fait utiliser un principe personnalisé et identité personnalisée que j'ai mis dans la méthode d'action de connexion comme

        if (!String.IsNullOrEmpty(username) && !String.IsNullOrEmpty(password) && _authService.IsValidLogin(username, password))
        {
            User objUser = _userService.GetUserByName(username);
            if (objUser != null)
            {
                //** Construct the userdata string
                string userData = objUser.RoleName + "|" + objUser.DistrictID + "|" + objUser.DistrictName + "|" + objUser.ID + "|" + objUser.DisplayName;
                HttpCookie authCookie = FormsAuthentication.GetAuthCookie(username, rememberMe.GetValueOrDefault());
                FormsAuthenticationTicket ticket = FormsAuthentication.Decrypt(authCookie.Value);
                FormsAuthenticationTicket newTicket = new FormsAuthenticationTicket(ticket.Version, ticket.Name, ticket.IssueDate, ticket.Expiration, ticket.IsPersistent, userData);
                authCookie.Value = FormsAuthentication.Encrypt(newTicket);
                Response.Cookies.Add(authCookie);
                return RedirectToAction("Index", "Absence");
            }
            else
            {
                return RedirectToAction("LogOn", "Account");
            }
        }
        else
        {
            return RedirectToAction("LogOn", "Account");
        }

alors dans le principal personnalisé vous pouvez avoir des méthodes qui accèdent à des informations spécifiques que vous avez transmises au constructeur comme

((CustomIdentity)((CustomPrincipal)HttpContext.Current.User).Identity).DisplayName;

où la propriété DisplayName est déclarée dans la classe CustomIdentity.

stocker le côté serveur it dans la session.

par exemple.

// Make this as light as possible and store only what you need
public class UserCedentials
{
    public string Username { get; set; }
    public string SomeOtherInfo { get; set; }
    // etc...
}

puis quand ils s'inscrivent juste faire ce qui suit pour sauver les informations des utilisateurs:

// Should make typesafe accessors for your session objects but you will
// get the point from this example
Session["UserCredentials"] = new UserCredentials()
    { Username = "SomeUserName", SomeOtherInfo = "SomeMoreData" };

ensuite, quand vous en avez besoin, allez le chercher:

UserCredentials user = (UserCredentials)(Session["UserCredentials"]);

j'ai écrit quelques questions / réponses concernant l'autorisation personnalisée dans MVC: comment mettre en œuvre les contrôles d'autorisation dans ASP.NET MVC basé sur les données de la Session?

Comment fonctionne L'étiquette D'autorisation? - Asp.net Mvc

eh Bien, vous aurez à stocker ces quelque part. Deux endroits principaux possibles cependant:

le serveur

vous pouvez soit les mettre en Session. Je vous suggère de créer une classe séparée qui ne contiendra que les données dont vous avez réellement besoin pour éviter de gaspiller trop de mémoire. Ou vous pouvez également stocker dans le Cache qui peut finir par avoir de nombreux appels DB quand il ya d'énormes quantités d'utilisateurs concurrents.

le client

dans ce cas si vous pouvez limiter la quantité de données avec une classe séparée, à cela et utiliser n'importe quel moyen pour sérialiser et envoyer au client. Soit dans un cookie ou dans un URI (si la longueur le permet et les cookies sont désactivés)...

résultat de ces pensées:

la chose principale serait de créer une catégorie distincte si vous gagnez beaucoup de ressources en mémoire de cette façon. Donc, c'est la première chose que vous devriez faire.