---
title: "Utöka Context.User.Identity med fler attribut"
type: "forum-thread"
url: "https://www.webforum.nu/amne/dotnet/185466-utöka-context-user-identity-med-fler-attribut"
topic: ".NET"
topic_url: "https://www.webforum.nu/amne/dotnet"
author: "lilja"
published: "2010-12-07T10:19:07.000Z"
updated: "2010-12-15T21:21:14.000Z"
replies: 3
views: 623
page: 1
pages: 1
language: "sv-SE"
site: "webForum — webforum.nu"
rights: "Upphovsrätten till varje inlägg tillhör dess författare."
attribution: "Citera som: webForum, https://www.webforum.nu/amne/dotnet/185466-utöka-context-user-identity-med-fler-attribut"
---

# Utöka Context.User.Identity med fler attribut

## #1 — lilja, 2010-12-07T10:19Z

Jag använder idag FormsAuthentication i en MVC site och skulle vilja utöka användarobjektet på ett bra sätt så att jag kan skicka med inställningar såsom namn, användarbild och liknande. Men hur gör jag det? Jag har läst om att ärva från IPrincipal eller GenericPrincipal men får inte riktigt till det.

Kan det vara så att min CustomPrincipal inte sparas mellan anropen? Jag får följande felmeddelande:
**Unable to cast object of type 'System.Security.Principal.GenericPrincipal' to type 'MVC3Test.Infrastructure.CustomPrincipal'.** 

Jag försöker hämta värdet i min vy (aspx/cshtml sidan)

```
((MVC3Test.Infrastructure.CustomPrincipal)Context.User).Identity.Name
```

I inloggningen gör jag följande när användarens användarnamn och lösenord stämmer.

```
FormsAuthentication.SetAuthCookie(userName, createPersistentCookie);

// Extract the forms authentication cookie
string cookieName = FormsAuthentication.FormsCookieName;
HttpCookie authCookie = HttpContext.Current.Request.Cookies[cookieName];
if (null == authCookie)
{
    // There is no authentication cookie.
    return;
} 
FormsAuthenticationTicket authTicket = null;
try
{
    authTicket = FormsAuthentication.Decrypt(authCookie.Value);
}
catch (Exception ex)
{
    // Log exception details (omitted for simplicity)
    return;
}

// Create a new principal
FormsIdentity id = new FormsIdentity(authTicket);
string[] roles = authTicket.UserData.Split('|');
CustomPrincipal principal = new CustomPrincipal(id, roles);
principal.FirstName = "Sven";

// Attach the new principal object to the current HttpContext object
HttpContext.Current.User = principal;
```

Här försöker jag utöka IPrincipal

```
public class CustomPrincipal : IPrincipal
{
    private IIdentity _identity;
    private string[] _roles;

    public string FirstName { get; set; }

    public CustomPrincipal(IIdentity identity, string[] roles)
    {
        _identity = identity;
        _roles = new string[roles.Length];
        roles.CopyTo(_roles, 0);
        Array.Sort(_roles);
    }

        
    #region IPrincipal Members

    public IIdentity Identity
    {
        get
        {
            return _identity;
        }
    }

    public bool IsInRole(string role)
    {
        return Array.BinarySearch(_roles, role) >= 0 ? true : false;
    }

    #endregion
}
```

Permalänk: https://www.webforum.nu/p/185466

## #2 — onkelborg, 2010-12-07T10:49Z

Det sparas inte mellan anropen, du måste skapa ditt objekt vid varje anrop. Titta på global.asax, det finns en metod där som du kan överlagra, och då där köra din kod.

Permalänk: https://www.webforum.nu/p/2264140

## #3 — doggelito, 2010-12-08T08:06Z

Men är inte det där lite baklängesprogrammering!? :)

Information om en användare bör väl ligga i en ren användarklass.
Sen kan dock klassen fyllas med hjälp av Context.User.Identity om du vill.

```
public class User
{
     public int ID {get; set; }
     public string FirstName {get; set; }
     ...
}
```

```
User currentUser = AccountService.GetUser(Context.User.Identity);
```

Permalänk: https://www.webforum.nu/p/2264197

## #4 — lilja, 2010-12-15T21:21Z

Jag löste det genom att lagra ett JSON objekt i UserData i inloggad användares cookie. Till detta har jag en hjälpklass som serialiserar och desirialiserar den data som finns i UserData.

När jag vill läsa informationen hämtar jag cookien, dekrypterar den och deserialiserar.

Om jag vill ändra informationen hämtar jag cookien, dekrypterar, deserialiserar, skapar en ny ticket och lägger in ny data i UserData samt sparar cookien.

Vid inloggning

```
var userState = new UserState()
{
    Username = "SomeUsername",
    DisplayName = "SomeDisplayName",
    SomeProperty = "some little text"
};
string userData = userState.ToJson();
var authTicket = new FormsAuthenticationTicket(1, user.Username, DateTime.Now, DateTime.Now.AddMinutes(30), false, userData);

string cookieContents = FormsAuthentication.Encrypt(authTicket);
var cookie = new HttpCookie(FormsAuthentication.FormsCookieName, cookieContents)
{
    Expires = authTicket.Expiration,
    Path = FormsAuthentication.FormsCookiePath
};

httpResponse.Cookies.Add(cookie);
```

Läsa

```
HttpCookie authCookie = this.Request.Cookies[FormsAuthentication.FormsCookieName];
if (authCookie != null)
{
    FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);

    var userState = UserState.FromJson(authTicket.UserData);
}
```

Ändra

```
HttpCookie authCookie = this.Request.Cookies[FormsAuthentication.FormsCookieName];
if (authCookie != null)
{
    FormsAuthenticationTicket authTicket = FormsAuthentication.Decrypt(authCookie.Value);
    var userState = UserState.FromJson(authTicket.UserData);
    userState.SomeProperty = "some text";
    string newUserData = userState.ToJson();
    var newTicket = new FormsAuthenticationTicket(
        authTicket.Version,
        authTicket.Name,
        authTicket.IssueDate,
        authTicket.Expiration,
        authTicket.IsPersistent,
        newUserData,
        authTicket.CookiePath);
    authCookie.Value = FormsAuthentication.Encrypt(newTicket);
    this.Response.Cookies.Set(authCookie);
}
```

Hjälpklassen som sparas i UserData

```
public class UserState
{
    public string Username { get; set; }
    public string DisplayName { get; set; }
    public int SomeProperty { get; set; }

    public string ToJson()
    {
        JavaScriptSerializer serializer = new JavaScriptSerializer();
        return serializer.Serialize(this);
    }

    public static UserState FromJson(string text)
    {
        JavaScriptSerializer serializer = new JavaScriptSerializer();
        return serializer.Deserialize<UserState>(text);
    }
}
```

Hojta gärna om jag gör något jag inte borde göra :)

Permalänk: https://www.webforum.nu/p/2264678

---

Tråden på webben: https://www.webforum.nu/amne/dotnet/185466-utöka-context-user-identity-med-fler-attribut