Introduzione all'identità in ASP.NET CoreIntroduction to Identity on ASP.NET Core

Di Rick AndersonBy Rick Anderson

ASP.NET Core Identity è un sistema di appartenenza che aggiunge funzionalità di accesso per le app ASP.NET Core.ASP.NET Core Identity is a membership system that adds login functionality to ASP.NET Core apps. Gli utenti possono creare un account con le informazioni di accesso archiviate nell'identità o è possibile usare un provider di accesso esterno.Users can create an account with the login information stored in Identity or they can use an external login provider. Provider di accesso esterni supportati includono Facebook, Google, Account Microsoft e Twitter.Supported external login providers include Facebook, Google, Microsoft Account, and Twitter.

Identità può essere configurato usando un database di SQL Server per archiviare nomi utente, password e i dati del profilo.Identity can be configured using a SQL Server database to store user names, passwords, and profile data. In alternativa, un altro archivio permanente utilizzabile, ad esempio, archiviazione tabelle di Azure.Alternatively, another persistent store can be used, for example, Azure Table Storage.

Visualizzare o scaricare il codice di esempio (come scaricare)).View or download the sample code (how to download)).

In questo argomento, informazioni su come usare l'identità per registrare, accedere e disconnettersi da un utente.In this topic, you learn how to use Identity to register, log in, and log out a user. Per istruzioni più dettagliate sulla creazione di App che usano l'identità, vedere la sezione passaggi successivi alla fine di questo articolo.For more detailed instructions about creating apps that use Identity, see the Next Steps section at the end of this article.

AddDefaultIdentity e AddIdentityAddDefaultIdentity and AddIdentity

AddDefaultIdentity è stato introdotto in ASP.NET Core 2.1.AddDefaultIdentity was introduced in ASP.NET Core 2.1. La chiamata AddDefaultIdentity è simile alla chiamata seguente:Calling AddDefaultIdentity is similar to calling the following:

Visualizzare AddDefaultIdentity origine per altre informazioni.See AddDefaultIdentity source for more information.

Creare un'app Web con l'autenticazioneCreate a Web app with authentication

Creare un progetto di applicazione Web ASP.NET Core con account utente individuali.Create an ASP.NET Core Web Application project with Individual User Accounts.

  • Selezionare File > Nuovo > Progetto.Select File > New > Project.
  • Selezionare Applicazione Web ASP.NET Core.Select ASP.NET Core Web Application. Denominare il progetto App Web 1 avere lo stesso spazio dei nomi come il download del progetto.Name the project WebApp1 to have the same namespace as the project download. Fare clic su OK.Click OK.
  • Selezionare un ASP.NET Core applicazione Web, quindi selezionare Modifica autenticazione.Select an ASP.NET Core Web Application, then select Change Authentication.
  • Selezionare account utente individuali e fare clic su OK.Select Individual User Accounts and click OK.

Fornisce il progetto generato ASP.NET Core Identity come una libreria di classi Razor.The generated project provides ASP.NET Core Identity as a Razor Class Library. La libreria di classi di identità Razor espone gli endpoint con il Identity area.The Identity Razor Class Library exposes endpoints with the Identity area. Ad esempio:For example:

  • / Identità/Account/Login/Identity/Account/Login
  • / Identità/Account/disconnessione/Identity/Account/Logout
  • / Identità/Account/gestire/Identity/Account/Manage

Applicare le migrazioniApply migrations

Applicare le migrazioni per inizializzare il database.Apply the migrations to initialise the database.

Eseguire il comando seguente in Package Manager Console (console di gestione pacchetti):Run the following command in the Package Manager Console (PMC):

PM> Update-Database

Registrazione di test e account di accessoTest Register and Login

Eseguire l'app e registrare un utente.Run the app and register a user. A seconda delle dimensioni dello schermo, potrebbe essere necessario selezionare il pulsante Attiva/Disattiva navigazione per vedere le registrare e Login collegamenti.Depending on your screen size, you might need to select the navigation toggle button to see the Register and Login links.

Visualizzare il database di identitàView the Identity database

  • Dal View dal menu Esplora oggetti di SQL Server (SSOX).From the View menu, select SQL Server Object Explorer (SSOX).
  • Passare a (localdb) MSSQLLocalDB (Server SQL 13).Navigate to (localdb)MSSQLLocalDB(SQL Server 13). Fare clic su dbo. AspNetUsers > consente di visualizzare dati:Right-click on dbo.AspNetUsers > View Data:

Menu di scelta rapida nella tabella AspNetUsers in Esplora oggetti di SQL Server

Configurare i servizi di identitàConfigure Identity services

Aggiunta di servizi ConfigureServices.Services are added in ConfigureServices. Il modello tipico consiste nel chiamare tutti i metodi Add{Service} e quindi chiamare tutti i metodi services.Configure{Service}.The typical pattern is to call all the Add{Service} methods, and then call all the services.Configure{Service} methods.

public void ConfigureServices(IServiceCollection services)
{
    services.Configure<CookiePolicyOptions>(options =>
    {
        options.CheckConsentNeeded = context => true;
        options.MinimumSameSitePolicy = SameSiteMode.None;
    });

    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(
            Configuration.GetConnectionString("DefaultConnection")));
    services.AddDefaultIdentity<IdentityUser>()
        .AddDefaultUI(UIFramework.Bootstrap4)
        .AddEntityFrameworkStores<ApplicationDbContext>();

    services.Configure<IdentityOptions>(options =>
    {
        // Password settings.
        options.Password.RequireDigit = true;
        options.Password.RequireLowercase = true;
        options.Password.RequireNonAlphanumeric = true;
        options.Password.RequireUppercase = true;
        options.Password.RequiredLength = 6;
        options.Password.RequiredUniqueChars = 1;

        // Lockout settings.
        options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5);
        options.Lockout.MaxFailedAccessAttempts = 5;
        options.Lockout.AllowedForNewUsers = true;

        // User settings.
        options.User.AllowedUserNameCharacters =
        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@+";
        options.User.RequireUniqueEmail = false;
    });

    services.ConfigureApplicationCookie(options =>
    {
        // Cookie settings
        options.Cookie.HttpOnly = true;
        options.ExpireTimeSpan = TimeSpan.FromMinutes(5);

        options.LoginPath = "/Identity/Account/Login";
        options.AccessDeniedPath = "/Identity/Account/AccessDenied";
        options.SlidingExpiration = true;
    });

    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}

Il codice precedente configura l'identità con valori predefiniti dell'opzione.The preceding code configures Identity with default option values. Servizi sono resi disponibili per l'app tramite il inserimento delle dipendenze.Services are made available to the app through dependency injection.

Vengono abilitate le identità chiamando UseAuthentication.Identity is enabled by calling UseAuthentication. UseAuthentication aggiunge l'autenticazione middleware alla pipeline delle richieste.UseAuthentication adds authentication middleware to the request pipeline.

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
        app.UseDatabaseErrorPage();
    }
    else
    {
        app.UseExceptionHandler("/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseCookiePolicy();

    app.UseAuthentication();

    app.UseMvc();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

    services.AddIdentity<ApplicationUser, IdentityRole>()
        .AddEntityFrameworkStores<ApplicationDbContext>()
        .AddDefaultTokenProviders();

    services.Configure<IdentityOptions>(options =>
    {
        // Password settings
        options.Password.RequireDigit = true;
        options.Password.RequiredLength = 8;
        options.Password.RequireNonAlphanumeric = false;
        options.Password.RequireUppercase = true;
        options.Password.RequireLowercase = false;
        options.Password.RequiredUniqueChars = 6;

        // Lockout settings
        options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(30);
        options.Lockout.MaxFailedAccessAttempts = 10;
        options.Lockout.AllowedForNewUsers = true;

        // User settings
        options.User.RequireUniqueEmail = true;
    });

    services.ConfigureApplicationCookie(options =>
    {
        // Cookie settings
        options.Cookie.HttpOnly = true;
        options.ExpireTimeSpan = TimeSpan.FromMinutes(30);
        // If the LoginPath isn't set, ASP.NET Core defaults 
        // the path to /Account/Login.
        options.LoginPath = "/Account/Login";
        // If the AccessDeniedPath isn't set, ASP.NET Core defaults 
        // the path to /Account/AccessDenied.
        options.AccessDeniedPath = "/Account/AccessDenied";
        options.SlidingExpiration = true;
    });

    // Add application services.
    services.AddTransient<IEmailSender, EmailSender>();

    services.AddMvc();
}

Servizi sono resi disponibili per l'applicazione attraverso inserimento delle dipendenze.Services are made available to the application through dependency injection.

Identità è abilitata per l'applicazione chiamando UseAuthentication nel metodoConfigure.Identity is enabled for the application by calling UseAuthentication in the Configure method. UseAuthentication aggiunge l'autenticazione middleware alla pipeline delle richieste.UseAuthentication adds authentication middleware to the request pipeline.

// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
        app.UseBrowserLink();
        app.UseDatabaseErrorPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
    }

    app.UseStaticFiles();

    app.UseAuthentication();

    app.UseMvc(routes =>
    {
        routes.MapRoute(
            name: "default",
            template: "{controller=Home}/{action=Index}/{id?}");
    });
}
public void ConfigureServices(IServiceCollection services)
{
    // Add framework services.
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

    services.AddIdentity<ApplicationUser, IdentityRole>()
        .AddEntityFrameworkStores<ApplicationDbContext>()
        .AddDefaultTokenProviders();

    services.AddMvc();

    // Configure Identity
    services.Configure<IdentityOptions>(options =>
    {
        // Password settings
        options.Password.RequireDigit = true;
        options.Password.RequiredLength = 8;
        options.Password.RequireNonAlphanumeric = false;
        options.Password.RequireUppercase = true;
        options.Password.RequireLowercase = false;

        // Lockout settings
        options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(30);
        options.Lockout.MaxFailedAccessAttempts = 10;

        // Cookie settings
        options.Cookies.ApplicationCookie.ExpireTimeSpan = TimeSpan.FromDays(150);
        options.Cookies.ApplicationCookie.LoginPath = "/Account/Login";

        // User settings
        options.User.RequireUniqueEmail = true;
    });

    // Add application services.
    services.AddTransient<IEmailSender, AuthMessageSender>();
    services.AddTransient<ISmsSender, AuthMessageSender>();
}

Questi servizi sono resi disponibili per l'applicazione attraverso inserimento delle dipendenze.These services are made available to the application through dependency injection.

Identità è abilitata per l'applicazione chiamando UseIdentity nel metodoConfigure.Identity is enabled for the application by calling UseIdentity in the Configure method. UseIdentity Aggiunge l'autenticazione basata su cookie middleware alla pipeline delle richieste.UseIdentity adds cookie-based authentication middleware to the request pipeline.

public void Configure(IApplicationBuilder app,
    IHostingEnvironment env, 
    ILoggerFactory loggerFactory)
{
    loggerFactory.AddConsole(Configuration.GetSection("Logging"));
    loggerFactory.AddDebug();

    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
        app.UseDatabaseErrorPage();
        app.UseBrowserLink();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
    }

    app.UseStaticFiles();

    app.UseIdentity();

    // Add external authentication middleware below. To configure them please see https://go.microsoft.com/fwlink/?LinkID=532715

    app.UseMvc(routes =>
    {
        routes.MapRoute(
            name: "default",
            template: "{controller=Home}/{action=Index}/{id?}");
    });
}

Per altre informazioni, vedere la classe IdentityOptions e avvio dell'applicazione.For more information, see the IdentityOptions Class and Application Startup.

Eseguire lo scaffolding di registrazione, l'account di accesso e disconnessioneScaffold Register, Login, and LogOut

Seguire le lo scaffolding di identità in un progetto Razor con autorizzazione istruzioni per generare il codice riportato in questa sezione.Follow the Scaffold identity into a Razor project with authorization instructions to generate the code shown in this section.

Aggiungere i file di registrazione, l'account di accesso e disconnessione.Add the Register, Login, and LogOut files.

Esaminare RegisterExamine Register

Quando un utente sceglie il registrare collegamento, il RegisterModel.OnPostAsync azione viene richiamata.When a user clicks the Register link, the RegisterModel.OnPostAsync action is invoked. L'utente viene creato mediante CreateAsync nel _userManager oggetto.The user is created by CreateAsync on the _userManager object. _userManager viene fornito dall'inserimento delle dipendenze):_userManager is provided by dependency injection):

public async Task<IActionResult> OnPostAsync(string returnUrl = null)
{
    returnUrl = returnUrl ?? Url.Content("~/");
    if (ModelState.IsValid)
    {
        var user = new IdentityUser { UserName = Input.Email, Email = Input.Email };
        var result = await _userManager.CreateAsync(user, Input.Password);
        if (result.Succeeded)
        {
            _logger.LogInformation("User created a new account with password.");

            var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
            var callbackUrl = Url.Page(
                "/Account/ConfirmEmail",
                pageHandler: null,
                values: new { userId = user.Id, code = code },
                protocol: Request.Scheme);

            await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
                $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");

            await _signInManager.SignInAsync(user, isPersistent: false);
            return LocalRedirect(returnUrl);
        }
        foreach (var error in result.Errors)
        {
            ModelState.AddModelError(string.Empty, error.Description);
        }
    }

    // If we got this far, something failed, redisplay form
    return Page();
}

Quando un utente sceglie il registrare collegamento, il Register azione viene richiamata in AccountController.When a user clicks the Register link, the Register action is invoked on AccountController. L'azioneRegister crea l'utente chiamandoconsente all'utente chiamando CreateAsync sull'oggetto _userManager(fornito all AccountController tramite dependency injection):The Register action creates the user by calling CreateAsync on the _userManager object (provided to AccountController by dependency injection):

//
// POST: /Account/Register
[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Register(RegisterViewModel model)
{
    if (ModelState.IsValid)
    {
        var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
        var result = await _userManager.CreateAsync(user, model.Password);
        if (result.Succeeded)
        {
            // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
            // Send an email with this link
            //var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
            //var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
            //await _emailSender.SendEmailAsync(model.Email, "Confirm your account",
            //    "Please confirm your account by clicking this link: <a href=\"" + callbackUrl + "\">link</a>");
            await _signInManager.SignInAsync(user, isPersistent: false);
            _logger.LogInformation(3, "User created a new account with password.");
            return RedirectToAction(nameof(HomeController.Index), "Home");
        }
        AddErrors(result);
    }

    // If we got this far, something failed, redisplay form
    return View(model);
}

Se l'utente è stato creato correttamente, l'utente è connesso tramite la chiamata al metodo _signInManager.SignInAsync.If the user was created successfully, the user is logged in by the call to _signInManager.SignInAsync.

Nota: Visualizzare conferma dell'account per i passaggi per impedire l'accesso immediato al momento della registrazione.Note: See account confirmation for steps to prevent immediate login at registration.

AccediLog in

Il modulo di accesso viene visualizzato quando:The Login form is displayed when:

  • Il Accedi Seleziona collegamento.The Log in link is selected.
  • Un utente prova ad accedere a una pagina con restrizioni che non sono autorizzati ad accedere o quando non sono stati autenticati dal sistema.A user attempts to access a restricted page that they aren't authorized to access or when they haven't been authenticated by the system.

Quando viene inviato il modulo nella pagina di accesso, il OnPostAsync viene chiamata azione.When the form on the Login page is submitted, the OnPostAsync action is called. PasswordSignInAsync viene chiamato sul _signInManager oggetto (fornito dall'inserimento di dipendenze).PasswordSignInAsync is called on the _signInManager object (provided by dependency injection).

public async Task<IActionResult> OnPostAsync(string returnUrl = null)
{
    returnUrl = returnUrl ?? Url.Content("~/");

    if (ModelState.IsValid)
    {
        // This doesn't count login failures towards account lockout
        // To enable password failures to trigger account lockout, 
        // set lockoutOnFailure: true
        var result = await _signInManager.PasswordSignInAsync(Input.Email, 
            Input.Password, Input.RememberMe, lockoutOnFailure: true);
        if (result.Succeeded)
        {
            _logger.LogInformation("User logged in.");
            return LocalRedirect(returnUrl);
        }
        if (result.RequiresTwoFactor)
        {
            return RedirectToPage("./LoginWith2fa", new { ReturnUrl = returnUrl, RememberMe = Input.RememberMe });
        }
        if (result.IsLockedOut)
        {
            _logger.LogWarning("User account locked out.");
            return RedirectToPage("./Lockout");
        }
        else
        {
            ModelState.AddModelError(string.Empty, "Invalid login attempt.");
            return Page();
        }
    }

    // If we got this far, something failed, redisplay form
    return Page();
}

La classe base Controller espone una proprietà User a cui è possibile accedere dai metodi del controller.The base Controller class exposes a User property that you can access from controller methods. Ad esempio, è possibile enumerare User.Claims e prendere decisioni di autorizzazione.For instance, you can enumerate User.Claims and make authorization decisions. Per altre informazioni, vedere Introduzione alle autorizzazioni in ASP.NET Core.For more information, see Introduzione alle autorizzazioni in ASP.NET Core.

Il modulo di accesso viene visualizzato quando gli utenti selezionano il Accedi collegare o vengono reindirizzati quando si accede a una pagina che richiede l'autenticazione.The Login form is displayed when users select the Log in link or are redirected when accessing a page that requires authentication. Quando l'utente invia il form nella pagina di accesso, il metodo di azioneAccountControllernell Loginviene invocato.When the user submits the form on the Login page, the AccountController Login action is called.

L'azione Login chiama PasswordSignInAsync sul _signInManager oggetto (fornito all AccountController tramite dependency injection).The Login action calls PasswordSignInAsync on the _signInManager object (provided to AccountController by dependency injection).

//
// POST: /Account/Login
[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
{
    ViewData["ReturnUrl"] = returnUrl;
    if (ModelState.IsValid)
    {
        // This doesn't count login failures towards account lockout
        // To enable password failures to trigger account lockout, set lockoutOnFailure: true
        var result = await _signInManager.PasswordSignInAsync(model.Email, 
            model.Password, model.RememberMe, lockoutOnFailure: false);
        if (result.Succeeded)
        {
            _logger.LogInformation(1, "User logged in.");
            return RedirectToLocal(returnUrl);
        }
        if (result.RequiresTwoFactor)
        {
            return RedirectToAction(nameof(SendCode), new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
        }
        if (result.IsLockedOut)
        {
            _logger.LogWarning(2, "User account locked out.");
            return View("Lockout");
        }
        else
        {
            ModelState.AddModelError(string.Empty, "Invalid login attempt.");
            return View(model);
        }
    }

    // If we got this far, something failed, redisplay form
    return View(model);
}

La base (Controller oppure PageModel) classe espone un User proprietà.The base (Controller or PageModel) class exposes a User property. Ad esempio, User.Claims può essere enumerata per prendere decisioni di autorizzazione.For example, User.Claims can be enumerated to make authorization decisions.

Effettuare la disconnessioneLog out

Il disconnettersi collegamento richiama il LogoutModel.OnPost azione.The Log out link invokes the LogoutModel.OnPost action.

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.Extensions.Logging;
using System.Threading.Tasks;

namespace WebApp1.Areas.Identity.Pages.Account
{
    [AllowAnonymous]
    public class LogoutModel : PageModel
    {
        private readonly SignInManager<IdentityUser> _signInManager;
        private readonly ILogger<LogoutModel> _logger;

        public LogoutModel(SignInManager<IdentityUser> signInManager, ILogger<LogoutModel> logger)
        {
            _signInManager = signInManager;
            _logger = logger;
        }

        public void OnGet()
        {
        }

        public async Task<IActionResult> OnPost(string returnUrl = null)
        {
            await _signInManager.SignOutAsync();
            _logger.LogInformation("User logged out.");
            if (returnUrl != null)
            {
                return LocalRedirect(returnUrl);
            }
            else
            {
                return Page();
            }
        }
    }
}

SignOutAsync Cancella le attestazioni dell'utente archiviate in un cookie.SignOutAsync clears the user's claims stored in a cookie. Dopo la chiamata non di reindirizzamento SignOutAsync o l'utente verrà non disconnessione.Don't redirect after calling SignOutAsync or the user will not be signed out.

Post viene specificato nella Pages/Shared/_LoginPartial.cshtml:Post is specified in the Pages/Shared/_LoginPartial.cshtml:

@using Microsoft.AspNetCore.Identity
@inject SignInManager<IdentityUser> SignInManager
@inject UserManager<IdentityUser> UserManager

<ul class="navbar-nav">
    @if (SignInManager.IsSignedIn(User))
    {
        <li class="nav-item">
            <a class="nav-link text-dark" asp-area="Identity"
               asp-page="/Account/Manage/Index"
               title="Manage">Hello@User.Identity.Name!</a>
        </li>
        <li class="nav-item">
            <form class="form-inline" asp-area="Identity" asp-page="/Account/Logout" 
                   asp-route-returnUrl="@Url.Page("/", new { area = "" })" 
                   method="post">
                <button type="submit" class="nav-link btn btn-link text-dark">Logout</button>
            </form>
        </li>
    }
    else
    {
        <li class="nav-item">
            <a class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Register">Register</a>
        </li>
        <li class="nav-item">
            <a class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Login">Login</a>
        </li>
    }
</ul>


Fare clic sul collegamento disconnettersi per chiamare l'azione LogOut.Clicking the Log out link calls the LogOut action.

//
// POST: /Account/LogOut
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> LogOut()
{
    await _signInManager.SignOutAsync();
    _logger.LogInformation(4, "User logged out.");
    return RedirectToAction(nameof(HomeController.Index), "Home");
}

Il codice precedente chiama il _signInManager.SignOutAsync (metodo).The preceding code calls the _signInManager.SignOutAsync method. Il metodo SignOutAsync cancella attestazioni dell'utente archiviate in un cookie.The SignOutAsync method clears the user's claims stored in a cookie.

Verificare l'identitàTest Identity

I modelli di progetto web predefinita è consentire l'accesso anonimo alle pagine home.The default web project templates allow anonymous access to the home pages. Per verificare l'identità, aggiungere [Authorize] alla pagina di Privacy.To test Identity, add [Authorize] to the Privacy page.

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc.RazorPages;

namespace WebApp1.Pages
{
    [Authorize]
    public class PrivacyModel : PageModel
    {
        public void OnGet()
        {
        }
    }
}

Se si è connessi, disconnettersi. Eseguire l'app e selezionare il Privacy collegamento.If you are signed in, sign out. Run the app and select the Privacy link. Si verrà reindirizzati alla pagina di accesso.You are redirected to the login page.

Esplorare identitàExplore Identity

Per ulteriori dettagli sulle identità:To explore Identity in more detail:

Componenti delle identitàIdentity Components

Tutte le identità NuGet pacchetti dipendenti sono inclusi nel metapacchetto Microsoft.AspNetCore.App.All the Identity dependent NuGet packages are included in the Microsoft.AspNetCore.App metapackage.

Il pacchetto per l'identità primario viene Microsoft.AspNetCore.Identity.The primary package for Identity is Microsoft.AspNetCore.Identity. Questo pacchetto contiene il set principale di interfacce per ASP.NET Core Identity e viene incluso per Microsoft.AspNetCore.Identity.EntityFrameworkCore.This package contains the core set of interfaces for ASP.NET Core Identity, and is included by Microsoft.AspNetCore.Identity.EntityFrameworkCore.

Migrazione ad ASP.NET Core IdentityMigrating to ASP.NET Core Identity

Per altre informazioni e istruzioni sulla migrazione archivio di identità esistente, vedere eseguire la migrazione di autenticazione e identità.For more information and guidance on migrating your existing Identity store, see Migrate Authentication and Identity.

Impostare la complessità della passwordSetting password strength

Visualizzare configurazione per un esempio che imposta i requisiti di lunghezza minima della password.See Configuration for a sample that sets the minimum password requirements.

Passaggi successiviNext Steps