5

我使用 VS2013 ASP.NET SPA 模板作为我的 Web 应用程序的起点，该应用程序使用新的 ASP.NET 身份框架。这是来自模板：

public partial class Startup
 {
     static Startup()
     {
     UserManagerFactory = () => new UserManager<IdentityUser>(new UserStore<IdentityUser>());
....
}

因此，由于没有 DbContext 被传递到上面的 UserStore 构造函数中，这向我表明正在创建一个新的 DbContext。由于我还想利用数据上下文（用于请求期间的其他数据操作），所以我稍微更改了模板代码：

public partial class Startup
 {
public static DerivedDbContext=null;

    static Startup()
    {
   context = new DerivedDbContext();
           UserManagerFactory = () => new UserManager<IdentityUser>(new UserStore<IdentityUser>(context));
...
}

现在，我可以通过访问从我的任何控制器中使用相同的 DbContext：

Startup.context

但是，当多个请求同时进入时，我遇到了麻烦，因为不相关的操作发生在同一个 DbContext 中。从这里，有人向我指出，我不应该为应用程序的整个生命周期实例化单个 DbContext，而应该只为特定请求的生命周期实例化，所以我将实例化移动到控制器的构造函数，但是现在，我在控制器中有自己的 DbContext，而 UserManager 仍然有自己的（并且在 Startup 类中创建）。

为什么模板为所有用户（在 Startup 类中）实例化一次 UserManager？是否值得担心，通过在控制器构造函数中创建我自己的 DbContext，有两个 DbContext（我在控制器的构造函数中创建的一个，另一个在 UserManager 中，在 Startup 类中创建）同时运行？在所有请求之间共享一个 UserManager 是否可以接受，但在所有请求之间共享一个 DbContext 通常是不可接受的？

使用两个不同的上下文似乎很愚蠢，我注意到我有时会得到一个不同步的数据视图。我想了解是否有其他人在使用此模板时遇到此问题。

**编辑：我知道像 nInject 这样的 IOC 框架可能有助于在这种情况下管理对象生命周期，但我想首先了解如何在没有此类框架帮助的情况下完成此任务。

谢谢...-本

4

1 回答 1

3

所以模式应该是每个请求一个 UserManager 和一个 DbContext。在 2.0-alpha1 版本中，我们试图通过添加一些新的身份中间件来简化这件事，这些中间件可以处理这两个问题：

我们正在开发一个更新的示例包来演示这些，但与此同时

您可以将以下 IdentityModels.cs/Startup.Auth.cs 添加到新包中：

public class ApplicationUser : IdentityUser
{
    public async Task<ClaimsIdentity> GenerateUserIdentityAsync(UserManager<ApplicationUser> manager)
    {
        // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
        var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);
        // Add custom user claims here
        return userIdentity;
    }
}

public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
{
    public ApplicationDbContext()
        : base("DefaultConnection")
    {
    }

    public static ApplicationDbContext Create() {
        return new ApplicationDbContext();
    }
}

public class ApplicationUserManager : UserManager<ApplicationUser> {
    // Configure the application user manager
    public ApplicationUserManager(IUserStore<ApplicationUser> store) : base(store) {
    }

    public static ApplicationUserManager Create(IdentityFactoryOptions<ApplicationUserManager> options) {
        var manager = new ApplicationUserManager(new UserStore<ApplicationUser>(options.Context.GetDbContext()));
        //var manager = new ApplicationUserManager(new AzureStore<ApplicationUser>());
        manager.UserValidator = new UserValidator<ApplicationUser>(manager) {
            AllowOnlyAlphanumericUserNames = false,
            RequireUniqueEmail = true
        };
        manager.PasswordValidator = new MinimumLengthValidator(6);
        var dataProtectionProvider = options.DataProtectionProvider;
        if (dataProtectionProvider != null) {
            manager.PasswordResetTokens = new DataProtectorTokenProvider(dataProtectionProvider.Create("PasswordReset"));
            manager.UserConfirmationTokens = new DataProtectorTokenProvider(dataProtectionProvider.Create("ConfirmUser"));
        }
        return manager;
    }
}

public static class OwinExtensions {
    public static IAppBuilder UseDbContextFactory(this IAppBuilder app, Func<DbContext> createCallback) {
        if (app == null) {
            throw new ArgumentNullException("app");
        }
        if (createCallback == null) {
            throw new ArgumentNullException("createCallback");
        }

        app.Use(typeof(IdentityFactoryMiddleware<DbContext, IdentityFactoryOptions<DbContext>>), 
            new IdentityFactoryOptions<DbContext>() { 
                Provider = new IdentityFactoryProvider<DbContext>() {
                    OnCreate = (options) => createCallback()
                }
            });
        return app;
    }

    public static DbContext GetDbContext(this IOwinContext context) {
        if (context == null) {
            throw new ArgumentNullException("context");
        }
        return context.Get<DbContext>();
    }
}

以下内容进入 Startup.Auth.cs：

    public void ConfigureAuth(IAppBuilder app) {
        // Configure the db context and user manager to use per request
        app.UseDbContextFactory(ApplicationDbContext.Create);
        app.UseUserManagerFactory(new IdentityFactoryOptions<ApplicationUserManager>() {
            DataProtectionProvider = app.GetDataProtectionProvider(),
            Provider = new IdentityFactoryProvider<ApplicationUserManager>() {
                OnCreate = ApplicationUserManager.Create
            }
        });

        // Enable the application to use a cookie to store information for the signed in user
        // and to use a cookie to temporarily store information about a user logging in with a third party login provider
        // Configure the sign in cookie
        app.UseCookieAuthentication(new CookieAuthenticationOptions {
            AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
            LoginPath = new PathString("/Account/Login"),
            Provider = new CookieAuthenticationProvider {
                OnValidateIdentity = SecurityStampValidator.OnValidateIdentity<ApplicationUserManager, ApplicationUser>(
                    validateInterval: TimeSpan.FromSeconds(5),
                    regenerateIdentity: (manager, user) => user.GenerateUserIdentityAsync(manager))
            }
        });
        app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);
于 2013-12-27T01:02:21.673 回答