Comment devrais-je accéder à mon ApplicationUser propriétés à partir de l'intérieur de mon MVC 6 Vues?

Je pense que vous devriez utiliser des Allégations de la propriété de l'Utilisateur à cet effet. Je l'ai trouvé bon post à ce sujet: http://benfoster.io/blog/customising-claims-transformation-in-aspnet-core-identity

De l'utilisateur de la classe

public class ApplicationUser : IdentityUser
{
    public string MyProperty { get; set; }
}

Mettons MyProperty dans les Revendications de l'Utilisateur Authentifié. Pour cela, nous impérieuses UserClaimsPrincipalFactory

public class MyUserClaimsPrincipalFactory : UserClaimsPrincipalFactory<ApplicationUser, IdentityRole>
{
    public MyUserClaimsPrincipalFactory (
        UserManager<ApplicationUser> userManager,
        RoleManager<IdentityRole> roleManager,
        IOptions<IdentityOptions> optionsAccessor) : base(userManager, roleManager, optionsAccessor)
    {
    }

    public async override Task<ClaimsPrincipal> CreateAsync(ApplicationUser user)
    {
        var principal = await base.CreateAsync(user);

        //Putting our Property to Claims
        //I'm using ClaimType.Email, but you may use any other or your own
        ((ClaimsIdentity)principal.Identity).AddClaims(new[] {
        new Claim(ClaimTypes.Email, user.MyProperty)
    });

        return principal;
    }
}

De l'enregistrement de notre UserClaimsPrincipalFactory en Démarrage.cs

public void ConfigureServices(IServiceCollection services)
{
    //...
    services.AddScoped<IUserClaimsPrincipalFactory<ApplicationUser>, MyUserClaimsPrincipalFactory>();
    //...
}

Maintenant, nous pouvons accéder à notre propery comme ce

User.Claims.FirstOrDefault(v => v.Type == ClaimTypes.Email).Value;

Nous pouvons créer une extension

namespace MyProject.MyExtensions
{
    public static class MyUserPrincipalExtension
    {
        public static string MyProperty(this ClaimsPrincipal user)
        {
            if (user.Identity.IsAuthenticated)
            {
                return user.Claims.FirstOrDefault(v => v.Type == ClaimTypes.Email).Value;
            }

            return "";
        }
    }
}

Il convient d'ajouter @à l'Aide de la Vue (je l'ajouter à la global _ViewImport.cshtml)

@using MyProject.MyExtensions

Et, enfin, nous pouvons utiliser cette propriété dans n'importe quelle Vue que l'appel de méthode

@User.MyProperty()

---

Dans ce cas, vous n'avez pas les requêtes supplémentaires à la base de données pour obtenir des informations de l'utilisateur.

OriginalL'auteur Alfer

OK, voici comment j'ai finalement fait. J'ai utilisé une nouvelle fonctionnalité dans MVC6 appelé de voir les Composants. Ils fonctionnent un peu comme des vues partielles, mais ils ont un "mini contrôleur". La Vue est un Composant léger contrôleur de ne pas participer à la liaison de modèle, mais il peut avoir quelque chose de passé en paramètres du constructeur, éventuellement à l'aide de l'injection de dépendance et puis il est possible de construire un Modèle de Vue et passer à une vue partielle. Ainsi, par exemple, vous pouvez injecter une UserManager exemple dans la Vue Component, l'utiliser pour récupérer le ApplicationUser objet pour l'utilisateur actuel et passer à la vue partielle.

Voici à quoi il ressemble dans le code. Tout d'abord, le point de Vue de la Composante, qui vit dans /ViewComponents répertoire:

public class UserProfileViewComponent : ViewComponent
    {
    readonly UserManager<ApplicationUser> userManager;

    public UserProfileViewComponent(UserManager<ApplicationUser> userManager)
        {
        Contract.Requires(userManager != null);
        this.userManager = userManager;
        }

    public IViewComponentResult Invoke([CanBeNull] ClaimsPrincipal user)
        {
        return InvokeAsync(user).WaitForResult();
        }

    public async Task<IViewComponentResult> InvokeAsync([CanBeNull] ClaimsPrincipal user)
        {
        if (user == null || !user.IsSignedIn())
            return View(anonymousUser);
        var userId = user.GetUserId();
        if (string.IsNullOrWhiteSpace(userId))
            return View(anonymousUser);
        try
            {
            var appUser = await userManager.FindByIdAsync(userId);
            return View(appUser ?? anonymousUser);
            }
        catch (Exception) {
        return View(anonymousUser);
        }
        }

    static readonly ApplicationUser anonymousUser = new ApplicationUser
        {
        Email = string.Empty,
        Id = "anonymous",
        PhoneNumber = "n/a"
        };
    }

Noter que le userManager paramètre du constructeur est injecté par le framework MVC; il est configuré par défaut dans Startup.cs dans un nouveau projet, donc il n'y a aucune configuration à faire.

La vue de composant est appelé, sans surprise, par l'appel de la Invoke méthode ou la version asynchrone. La méthode récupère un ApplicationUser si possible, sinon, il utilise un utilisateur anonyme avec une certaine sécurité defaultspreconfigured. Il utilise à cet utilisateur de son partiel vue s le modèle de vue. Le point de vue des vies dans /Views/Shared/Components/UserProfile/Default.cshtml et commence comme ceci:

@model ApplicationUser

<div class="dropdown profile-element">
    <span>
        @Html.GravatarImage(Model.Email, size:80)
    </span>
    <a data-toggle="dropdown" class="dropdown-toggle" href="#">
        <span class="clear">
            <span class="block m-t-xs">
                <strong class="font-bold">@Model.UserName</strong>
            </span> <span class="text-muted text-xs block">@Model.PhoneNumber <b class="caret"></b></span>
        </span>
    </a>

</div>

Et enfin, j'appelle cela de l'intérieur de mon _Navigation.cshtml vue partielle de la sorte:

@await Component.InvokeAsync("UserProfile", User)

Celle-ci répond à toutes mes exigences, parce que:

1. Je suis d'effectuer la recherche de base de données dans un contrôleur (une Vue de Composant est un type de contrôleur) et non pas en Vue. De plus, les données peuvent très bien être déjà en mémoire que le cadre aura déjà authentifié la demande. Je n'ai pas regardé si une autre base de données aller-retour qui se passe réellement, et je n'aurai probablement pas la peine, mais si quelqu'un sait, s'il vous plaît carillon!
2. La logique est dans un lieu bien défini; la SEC principe est respecté.
3. Je n'ai pas à modifier n'importe quel autre Modèle de Vue.

La suite!!! J'espère que quelqu'un va trouver cela utile...

OriginalL'auteur Tim Long

Comme je l'ai été interrogé à ce sujet, je poste ma solution éventuelle, quoique dans un autre (MVC5/EF6).

Tout d'abord, j'ai défini une interface:

public interface ICurrentUser
    {
    ///<summary>
    ///    Gets the display name of the user.
    ///</summary>
    ///<value>The display name.</value>
    string DisplayName { get; }

    ///<summary>
    ///    Gets the login name of the user. This is typically what the user would enter in the login screen, but may be
    ///    something different.
    ///</summary>
    ///<value>The name of the login.</value>
    string LoginName { get; }

    ///<summary>
    ///    Gets the unique identifier of the user. Typically this is used as the Row ID in whatever store is used to persist
    ///    the user's details.
    ///</summary>
    ///<value>The unique identifier.</value>
    string UniqueId { get; }

    ///<summary>
    ///    Gets a value indicating whether the user has been authenticated.
    ///</summary>
    ///<value><c>true</c> if this instance is authenticated; otherwise, <c>false</c>.</value>
    bool IsAuthenticated { get; }

Puis, j'en œuvre que dans une classe de béton:

///<summary>
///    Encapsulates the concept of a 'current user' based on ASP.Net Identity.
///</summary>
///<seealso cref="MS.Gamification.DataAccess.ICurrentUser" />
public class AspNetIdentityCurrentUser : ICurrentUser
    {
    private readonly IIdentity identity;
    private readonly UserManager<ApplicationUser, string> manager;
    private ApplicationUser user;

    ///<summary>
    ///    Initializes a new instance of the <see cref="AspNetIdentityCurrentUser" /> class.
    ///</summary>
    ///<param name="manager">The ASP.Net Identity User Manager.</param>
    ///<param name="identity">The identity as reported by the HTTP Context.</param>
    public AspNetIdentityCurrentUser(ApplicationUserManager manager, IIdentity identity)
        {
        this.manager = manager;
        this.identity = identity;
        }

    ///<summary>
    ///    Gets the display name of the user. This implementation returns the login name.
    ///</summary>
    ///<value>The display name.</value>
    public string DisplayName => identity.Name;

    ///<summary>
    ///    Gets the login name of the user.
    ///    something different.
    ///</summary>
    ///<value>The name of the login.</value>
    public string LoginName => identity.Name;

    ///<summary>
    ///    Gets the unique identifier of the user, which can be used to look the user up in a database.
    ///    the user's details.
    ///</summary>
    ///<value>The unique identifier.</value>
    public string UniqueId
        {
        get
            {
            if (user == null)
                user = GetApplicationUser();
            return user.Id;
            }
        }

    ///<summary>
    ///    Gets a value indicating whether the user has been authenticated.
    ///</summary>
    ///<value><c>true</c> if the user is authenticated; otherwise, <c>false</c>.</value>
    public bool IsAuthenticated => identity.IsAuthenticated;

    private ApplicationUser GetApplicationUser()
        {
        return manager.FindByName(LoginName);
        }
    }

Enfin, je fais la configuration suivante dans mon DI noyau (je suis en utilisant Ninject):

        kernel.Bind<ApplicationUserManager>().ToSelf()
            .InRequestScope();
        kernel.Bind<ApplicationSignInManager>().ToSelf().InRequestScope();
        kernel.Bind<IAuthenticationManager>()
            .ToMethod(m => HttpContext.Current.GetOwinContext().Authentication)
            .InRequestScope();
        kernel.Bind<IIdentity>().ToMethod(p => HttpContext.Current.User.Identity).InRequestScope();
        kernel.Bind<ICurrentUser>().To<AspNetIdentityCurrentUser>();

Alors à chaque fois que je veux accéder à l'utilisateur actuel, il me suffit de l'injecter dans mon contrôleur par l'ajout d'un paramètre dans le constructeur de type ICurrentUser.

J'aime bien cette solution, comme l'a joliment encapsule la préoccupation et évite mon contrôleurs ayant une dépendance directe sur EF.

OriginalL'auteur Tim Long