Använda cookie autentisering utan ASP.NET Core Identity

2025-09-12

ASP.NET Core Identity är en komplett, komplett autentiseringsprovider för att skapa och underhålla inloggningar. En cookie-baserad autentiseringsprovider utan ASP.NET Core Identity kan dock användas. Mer information finns i Introduktion till Identity på ASP.NET Core.

Visa eller ladda ned exempelkod (hur du laddar ned)

I demonstrationssyfte i exempelappen hårdkodas användarkontot för den hypotetiska användaren Maria Rodriguez i appen. Använd e-postadressenmaria.rodriguez@contoso.com och eventuella lösenord för att logga in användaren. Användaren autentiseras i AuthenticateUser-metoden i Pages/Account/Login.cshtml.cs-filen. I ett verkligt exempel autentiseras användaren mot ett datalager.

Viktigt!

Från och med ASP.NET Core 10 omdirigeras inte längre kända API-slutpunkter till inloggningssidor när autentisering används cookie . I stället returnerar de statuskoder för 401/403. Mer information finns i BETEENDE för API-slutpunktsautentisering i ASP.NET Core.

Lägg till autentisering mellanprogramtjänsterna med metoderna AddAuthentication och AddCookie.
Anropa UseAuthentication och UseAuthorization och ange egenskapen HttpContext.User och kör auktoriseringsmellanprogrammet för begäranden. UseAuthentication och UseAuthorization måste anropas före Map metoder som MapRazorPages och MapDefaultControllerRoute

using Microsoft.AspNetCore.Authentication.Cookies;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

builder.Services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
    .AddCookie();

builder.Services.AddHttpContextAccessor();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

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

app.UseAuthentication();
app.UseAuthorization();

app.MapRazorPages();
app.MapDefaultControllerRoute();

app.Run();

AuthenticationScheme skickas till AddAuthentication och sätter standardautentiseringsschemat för appen. AuthenticationScheme är användbart när det finns flera instanser av cookie autentisering och appen måste auktorisera med ett specifikt schema. När du ställer in AuthenticationScheme till CookieAuthenticationDefaults.AuthenticationScheme ger det värdet "Cookies" för schemat. Valfritt strängvärde kan användas som särskiljer schemat.

Om CookieAuthenticationDefaults.AuthenticationScheme (standardvärde: "Cookies") inte används som schema anger du det schema som används när du konfigurerar autentiseringsprovidern. Annars används standardschemat. Om till exempel "ContosoCookie" används som schema anger du det schema som används när du konfigurerar autentiseringsprovidern.

Egenskapen för autentisering cookieIsEssential är inställd på true som standard. Autentiseringscookies tillåts när en webbplatsbesökare inte har samtyckt till datainsamling. Mer information finns i Stöd för den allmänna dataskyddsförordningen (GDPR) i ASP.NET Core.

Klassen CookieAuthenticationOptions används för att konfigurera alternativen för autentiseringsprovidern.

Konfigurera CookieAuthenticationOptions i AddCookie -metoden:

using Microsoft.AspNetCore.Authentication.Cookies;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

builder.Services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
    .AddCookie(options =>
    {
        options.ExpireTimeSpan = TimeSpan.FromMinutes(20);
        options.SlidingExpiration = true;
        options.AccessDeniedPath = "/Forbidden/";
    });

builder.Services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

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

app.UseAuthentication();
app.UseAuthorization();

app.MapRazorPages();
app.MapDefaultControllerRoute();

app.Run();

PrincipmellanprogrammetCookie (GitHub-källa)UseCookiePolicy möjliggör cookie principfunktioner. Mellanprogram bearbetas i den ordning de läggs till, och Cookie Policy-mellanprogram bör läggas till före cookie autentiseringsmellanprogram.

Använd CookiePolicyOptions som tillhandahålls till Cookie Policy Middleware för att kontrollera globala egenskaper för cookie bearbetning och koppla till cookie bearbetningshanterare när cookies läggs till eller tas bort.

MinimumSameSitePolicy Standardvärdet är SameSiteMode.Lax att tillåta OAuth2-autentisering. För att strikt tillämpa en same-site-princip för SameSiteMode.Strict, anger du MinimumSameSitePolicy. Även om den här inställningen bryter OAuth2 och andra autentiseringsscheman för korsande ursprung höjs säkerhetsnivån för andra typer av appar som inte förlitar sig på bearbetning av cookie begäranden mellan ursprung.

I följande exempel visas hur du konfigurerar cookie autentisering med Cookie principmellanprogram:

var cookiePolicyOptions = new CookiePolicyOptions
{
    MinimumSameSitePolicy = SameSiteMode.Strict,
};

app.UseCookiePolicy(cookiePolicyOptions);

Inställningen Cookie Principmellanprogram för MinimumSameSitePolicy kan påverka inställningen för Cookie.SameSite i CookieAuthenticationOptions inställningar enligt matrisen nedan.

MinimumSameSitePolicy	Cookie. SameSite	Resulterande Cookie. SameSite-inställning
SameSiteMode.None	SameSiteMode.None SameSiteMode.Lax SameSiteMode.Strict	SameSiteMode.None SameSiteMode.Lax SameSiteMode.Strict
SameSiteMode.Lax	SameSiteMode.None SameSiteMode.Lax SameSiteMode.Strict	SameSiteMode.Lax SameSiteMode.Lax SameSiteMode.Strict
SameSiteMode.Strict	SameSiteMode.None SameSiteMode.Lax SameSiteMode.Strict	SameSiteMode.Strict SameSiteMode.Strict SameSiteMode.Strict

För att skapa en cookie som innehåller användarinformation, konstruera en ClaimsPrincipal. Användarinformationen serialiseras och lagras i cookie.

Skapa en ClaimsIdentity med nödvändiga Claims och för att logga in användaren, anropa SignInAsync. Login.cshtml.cs i exempelappen innehåller följande kod:

public async Task<IActionResult> OnPostAsync(string returnUrl = null)
{
    ReturnUrl = returnUrl;

    if (ModelState.IsValid)
    {
        // Use Input.Email and Input.Password to authenticate the user
        // with your custom authentication logic.
        //
        // For demonstration purposes, the sample validates the user
        // on the email address maria.rodriguez@contoso.com with 
        // any password that passes model validation.

        var user = await AuthenticateUser(Input.Email, Input.Password);

        if (user == null)
        {
            ModelState.AddModelError(string.Empty, "Invalid login attempt.");
            return Page();
        }

        var claims = new List<Claim>
        {
            new Claim(ClaimTypes.Name, user.Email),
            new Claim("FullName", user.FullName),
            new Claim(ClaimTypes.Role, "Administrator"),
        };

        var claimsIdentity = new ClaimsIdentity(
            claims, CookieAuthenticationDefaults.AuthenticationScheme);

        var authProperties = new AuthenticationProperties
        {
            //AllowRefresh = <bool>,
            // Refreshing the authentication session should be allowed.

            //ExpiresUtc = DateTimeOffset.UtcNow.AddMinutes(10),
            // The time at which the authentication ticket expires. A 
            // value set here overrides the ExpireTimeSpan option of 
            // CookieAuthenticationOptions set with AddCookie.

            //IsPersistent = true,
            // Whether the authentication session is persisted across 
            // multiple requests. When used with cookies, controls
            // whether the cookie's lifetime is absolute (matching the
            // lifetime of the authentication ticket) or session-based.

            //IssuedUtc = <DateTimeOffset>,
            // The time at which the authentication ticket was issued.

            //RedirectUri = <string>
            // The full path or absolute URI to be used as an http 
            // redirect response value.
        };

        await HttpContext.SignInAsync(
            CookieAuthenticationDefaults.AuthenticationScheme, 
            new ClaimsPrincipal(claimsIdentity), 
            authProperties);

        _logger.LogInformation("User {Email} logged in at {Time}.", 
            user.Email, DateTime.UtcNow);

        return LocalRedirect(Url.GetLocalUrl(returnUrl));
    }

    // Something failed. Redisplay the form.
    return Page();
}

Om du vill se kodkommentar översatta till andra språk än engelska kan du meddela oss i det här GitHub-diskussionsproblemet.

SignInAsync skapar en krypterad cookie och lägger till den i det aktuella svaret. Om AuthenticationScheme inte anges används standardschemat.

RedirectUri används endast på några specifika sökvägar som standard, till exempel inloggningssökvägen och utloggningssökvägarna. Mer information finns i CookieAuthenticationHandler-källan.

ASP.NET Cores dataskyddssystem används för kryptering. För en app som finns på flera datorer, belastningsutjämning mellan appar eller användning av en webbgrupp konfigurerar du dataskydd för att använda samma nyckelring och appidentifierare.

Logga ut

Om du vill logga ut den aktuella användaren och ta bort deras cookieanropar du SignOutAsync:

public async Task OnGetAsync(string returnUrl = null)
{
    if (!string.IsNullOrEmpty(ErrorMessage))
    {
        ModelState.AddModelError(string.Empty, ErrorMessage);
    }

    // Clear the existing external cookie
    await HttpContext.SignOutAsync(
        CookieAuthenticationDefaults.AuthenticationScheme);

    ReturnUrl = returnUrl;
}

När webbläsaren stängs tas sessionsbaserade cookies bort automatiskt (icke-beständiga cookies), men inga cookies rensas när en enskild flik stängs. Servern meddelas inte om flik- eller webbläsarstängningshändelser.

Reagera på backend-ändringar

När en cookie har skapats är cookie den enda identitetskällan. Om ett användarkonto är inaktiverat i serverdelssystem:

Appens cookie autentiseringssystem fortsätter att bearbeta begäranden baserat på autentiseringen cookie.
Användaren är fortfarande inloggad i appen så länge autentiseringen cookie är giltig.

Händelsen ValidatePrincipal kan användas för att avlyssna och åsidosätta verifieringen av cookie-identiteten. Om du verifierar cookie varje begäran minskar risken för att återkallade användare får åtkomst till appen.

En metod för cookie validering baseras på att hålla reda på när användardatabasen ändras. Om databasen inte har ändrats sedan cookie utfärdades till användaren behöver du inte autentisera om användaren om deras cookie fortfarande är giltigt. I exempelappen implementeras databasen i IUserRepository och lagrar ett LastChanged värde. När en användare uppdateras i databasen LastChanged anges värdet till den aktuella tiden.

För att ogiltigförklara en cookie när databasen ändras baserat på LastChanged värdet skapar cookie du med ett LastChanged anspråk som innehåller det aktuella LastChanged värdet från databasen:

var claims = new List<Claim>
{
    new Claim(ClaimTypes.Name, user.Email),
    new Claim("LastChanged", {Database Value})
};

var claimsIdentity = new ClaimsIdentity(
    claims,
    CookieAuthenticationDefaults.AuthenticationScheme);

await HttpContext.SignInAsync(
    CookieAuthenticationDefaults.AuthenticationScheme, 
    new ClaimsPrincipal(claimsIdentity));

Om du vill implementera en åsidosättning för ValidatePrincipal händelsen skriver du en metod med följande signatur i en klass som härleds från CookieAuthenticationEvents:

ValidatePrincipal(CookieValidatePrincipalContext)

Följande är ett exempel på implementering av CookieAuthenticationEvents:

using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authentication.Cookies;

public class CustomCookieAuthenticationEvents : CookieAuthenticationEvents
{
    private readonly IUserRepository _userRepository;

    public CustomCookieAuthenticationEvents(IUserRepository userRepository)
    {
        _userRepository = userRepository;
    }

    public override async Task ValidatePrincipal(CookieValidatePrincipalContext context)
    {
        var userPrincipal = context.Principal;

        // Look for the LastChanged claim.
        var lastChanged = (from c in userPrincipal.Claims
                           where c.Type == "LastChanged"
                           select c.Value).FirstOrDefault();

        if (string.IsNullOrEmpty(lastChanged) ||
            !_userRepository.ValidateLastChanged(lastChanged))
        {
            context.RejectPrincipal();

            await context.HttpContext.SignOutAsync(
                CookieAuthenticationDefaults.AuthenticationScheme);
        }
    }
}

Registrera händelseinstansen under cookie tjänstregistreringen. Tillhandahåll en avgränsad tjänstregistrering för din CustomCookieAuthenticationEvents klass:

using Microsoft.AspNetCore.Authentication.Cookies;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddControllersWithViews();

builder.Services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
    .AddCookie(options =>
    {
        options.EventsType = typeof(CustomCookieAuthenticationEvents);
    });

builder.Services.AddScoped<CustomCookieAuthenticationEvents>();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

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

app.UseAuthentication();
app.UseAuthorization();

app.MapRazorPages();
app.MapDefaultControllerRoute();

app.Run();

Överväg en situation där användarens namn uppdateras – ett beslut som inte påverkar säkerheten på något sätt. Om du vill uppdatera användarens huvudidentitet utan att förstöra den, anropar du context.ReplacePrincipal och ställer in egenskapen context.ShouldRenew till true.

Warning

Den metod som beskrivs här utlöses för varje begäran. Validering av autentiseringscookies för alla användare på varje begäran kan resultera i en stor prestandaavgift för appen.

Beständiga cookies

Du kanske vill att cookie ska vara kvar mellan webbläsarsessioner. Den här beständigheten bör endast aktiveras med uttryckligt användarmedgivande med kryssrutan "Kom ihåg mig" vid inloggning eller en liknande mekanism.

Följande kodfragment skapar en identitet och motsvarande cookie som överlever när webbläsaren stängs. Tidigare konfigurerade inställningar för glidande förfallodatum respekteras. Om den cookie upphör att gälla medan webbläsaren är stängd, rensas cookie när webbläsaren startas om.

Ange IsPersistent till true i AuthenticationProperties:

// using Microsoft.AspNetCore.Authentication;

await HttpContext.SignInAsync(
    CookieAuthenticationDefaults.AuthenticationScheme,
    new ClaimsPrincipal(claimsIdentity),
    new AuthenticationProperties
    {
        IsPersistent = true
    });

En absolut förfallotid kan anges med ExpiresUtc. För att skapa en beständig cookie måste också IsPersistent anges. Annars skapas den cookie med en sessionsbaserad livslängd och kan upphöra att gälla antingen före eller efter den autentiseringsbiljett som den innehåller. När ExpiresUtc har angetts åsidosätter det värdet på inställningen ExpireTimeSpan i CookieAuthenticationOptions, om den är angiven.

Följande kodfragment skapar en identitet och en motsvarande komponent cookie som varar i 20 minuter. Detta ignorerar alla glidande förfalloinställningar som tidigare konfigurerats.

// using Microsoft.AspNetCore.Authentication;

await HttpContext.SignInAsync(
    CookieAuthenticationDefaults.AuthenticationScheme,
    new ClaimsPrincipal(claimsIdentity),
    new AuthenticationProperties
    {
        IsPersistent = true,
        ExpiresUtc = DateTime.UtcNow.AddMinutes(20)
    });

Visa eller ladda ned exempelkod (hur du laddar ned)

Configuration

I Startup.ConfigureServices-metoden skapar du autentiseringstjänster för mellanprogram med AddAuthentication och AddCookie metoderna:

services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
    .AddCookie();

AuthenticationScheme skickas till AddAuthentication och sätter standardautentiseringsschemat för appen. AuthenticationScheme är användbart när det finns flera instanser av cookie autentisering och du vill auktorisera med ett specifikt schema. AuthenticationScheme att ange CookieAuthenticationDefaults.AuthenticationScheme ger värdet "Cookies" för schemat. Du kan ange valfritt strängvärde som skiljer schemat åt.

Appens autentiseringsschema skiljer sig från appens autentiseringsschema cookie . När ett cookie autentiseringsschema inte har angetts för AddCookieanvänder CookieAuthenticationDefaults.AuthenticationScheme det ("Cookies").

Anropa Startup.Configure och UseAuthentication i UseAuthorization för att ange HttpContext.User-egenskapen och köra Authorization Middleware för begäranden. Anropa UseAuthentication-metoden och UseAuthorization-metoden innan du anropar UseEndpoints:

Klassen CookieAuthenticationOptions används för att konfigurera alternativen för autentiseringsprovidern.

Ange CookieAuthenticationOptions i tjänstkonfigurationen för autentisering i Startup.ConfigureServices -metoden:

services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
    .AddCookie(options =>
    {
        ...
    });

Cookie Principmellanprogram aktiverar cookie principfunktioner. Att lägga till mellanprogrammet i appbearbetningspipelinen är orderkänsligt– det påverkar endast underordnade komponenter som registrerats i pipelinen och Cookie Principmellanprogram bör läggas till innan cookie mellanprogram för autentisering.

I följande exempel visas hur du konfigurerar cookie autentisering med Cookie principmellanprogram:

var cookiePolicyOptions = new CookiePolicyOptions
{
    MinimumSameSitePolicy = SameSiteMode.Strict,
};

app.UseCookiePolicy(cookiePolicyOptions);

Inställningen Cookie Principmellanprogram för MinimumSameSitePolicy kan påverka inställningen för Cookie.SameSite i CookieAuthenticationOptions inställningar enligt matrisen nedan.

MinimumSameSitePolicy	Cookie. SameSite	Resulterande Cookie. SameSite-inställning
SameSiteMode.None	SameSiteMode.None SameSiteMode.Lax SameSiteMode.Strict	SameSiteMode.None SameSiteMode.Lax SameSiteMode.Strict
SameSiteMode.Lax	SameSiteMode.None SameSiteMode.Lax SameSiteMode.Strict	SameSiteMode.Lax SameSiteMode.Lax SameSiteMode.Strict
SameSiteMode.Strict	SameSiteMode.None SameSiteMode.Lax SameSiteMode.Strict	SameSiteMode.Strict SameSiteMode.Strict SameSiteMode.Strict

För att skapa en cookie som innehåller användarinformation, konstruera en ClaimsPrincipal. Användarinformationen serialiseras och lagras i cookie.

Skapa en ClaimsIdentity med nödvändiga Claims och kalla SignInAsync för att logga in användaren.

var claims = new List<Claim>
{
    new Claim(ClaimTypes.Name, user.Email),
    new Claim("FullName", user.FullName),
    new Claim(ClaimTypes.Role, "Administrator"),
};

var claimsIdentity = new ClaimsIdentity(
    claims, CookieAuthenticationDefaults.AuthenticationScheme);

var authProperties = new AuthenticationProperties
{
    //AllowRefresh = <bool>,
    // Refreshing the authentication session should be allowed.

    //ExpiresUtc = DateTimeOffset.UtcNow.AddMinutes(10),
    // The time at which the authentication ticket expires. A 
    // value set here overrides the ExpireTimeSpan option of 
    // CookieAuthenticationOptions set with AddCookie.

    //IsPersistent = true,
    // Whether the authentication session is persisted across 
    // multiple requests. When used with cookies, controls
    // whether the cookie's lifetime is absolute (matching the
    // lifetime of the authentication ticket) or session-based.

    //IssuedUtc = <DateTimeOffset>,
    // The time at which the authentication ticket was issued.

    //RedirectUri = <string>
    // The full path or absolute URI to be used as an http 
    // redirect response value.
};

await HttpContext.SignInAsync(
    CookieAuthenticationDefaults.AuthenticationScheme, 
    new ClaimsPrincipal(claimsIdentity), 
    authProperties);

Om du vill se kodkommentar översatta till andra språk än engelska kan du meddela oss i det här GitHub-diskussionsproblemet.

SignInAsync skapar en krypterad cookie och lägger till den i det aktuella svaret. Om AuthenticationScheme inte anges används standardschemat.

RedirectUri används endast på några specifika sökvägar som standard, till exempel inloggningssökvägen och utloggningssökvägarna. Mer information finns i CookieAuthenticationHandler-källan.

Logga ut

Om du vill logga ut den aktuella användaren och ta bort deras cookieanropar du SignOutAsync:

await HttpContext.SignOutAsync(
    CookieAuthenticationDefaults.AuthenticationScheme);

Reagera på backend-ändringar

När en cookie har skapats är cookie den enda identitetskällan. Om ett användarkonto är inaktiverat i serverdelssystem:

Appens cookie autentiseringssystem fortsätter att bearbeta begäranden baserat på autentiseringen cookie.
Användaren är fortfarande inloggad i appen så länge autentiseringen cookie är giltig.

var claims = new List<Claim>
{
    new Claim(ClaimTypes.Name, user.Email),
    new Claim("LastChanged", {Database Value})
};

var claimsIdentity = new ClaimsIdentity(
    claims, 
    CookieAuthenticationDefaults.AuthenticationScheme);

await HttpContext.SignInAsync(
    CookieAuthenticationDefaults.AuthenticationScheme, 
    new ClaimsPrincipal(claimsIdentity));

Om du vill implementera en åsidosättning för ValidatePrincipal händelsen skriver du en metod med följande signatur i en klass som härleds från CookieAuthenticationEvents:

ValidatePrincipal(CookieValidatePrincipalContext)

Följande är ett exempel på implementering av CookieAuthenticationEvents:

using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authentication.Cookies;

public class CustomCookieAuthenticationEvents : CookieAuthenticationEvents
{
    private readonly IUserRepository _userRepository;

    public CustomCookieAuthenticationEvents(IUserRepository userRepository)
    {
        // Get the database from registered DI services.
        _userRepository = userRepository;
    }

    public override async Task ValidatePrincipal(CookieValidatePrincipalContext context)
    {
        var userPrincipal = context.Principal;

        // Look for the LastChanged claim.
        var lastChanged = (from c in userPrincipal.Claims
                           where c.Type == "LastChanged"
                           select c.Value).FirstOrDefault();

        if (string.IsNullOrEmpty(lastChanged) ||
            !_userRepository.ValidateLastChanged(lastChanged))
        {
            context.RejectPrincipal();

            await context.HttpContext.SignOutAsync(
                CookieAuthenticationDefaults.AuthenticationScheme);
        }
    }
}

Registrera händelseinstansen under tjänstregistreringen i cookie-metoden Startup.ConfigureServices. Tillhandahåll en avgränsad tjänstregistrering för din CustomCookieAuthenticationEvents klass:

services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
    .AddCookie(options =>
    {
        options.EventsType = typeof(CustomCookieAuthenticationEvents);
    });

services.AddScoped<CustomCookieAuthenticationEvents>();

Warning

Den metod som beskrivs här utlöses för varje begäran. Validering av autentiseringscookies för alla användare på varje begäran kan resultera i en stor prestandaavgift för appen.

Beständiga cookies

Ange IsPersistent till true i AuthenticationProperties:

// using Microsoft.AspNetCore.Authentication;

await HttpContext.SignInAsync(
    CookieAuthenticationDefaults.AuthenticationScheme,
    new ClaimsPrincipal(claimsIdentity),
    new AuthenticationProperties
    {
        IsPersistent = true
    });

Följande kodfragment skapar en identitet och en motsvarande komponent cookie som varar i 20 minuter. Detta ignorerar alla glidande förfalloinställningar som tidigare konfigurerats.

// using Microsoft.AspNetCore.Authentication;

await HttpContext.SignInAsync(
    CookieAuthenticationDefaults.AuthenticationScheme,
    new ClaimsPrincipal(claimsIdentity),
    new AuthenticationProperties
    {
        IsPersistent = true,
        ExpiresUtc = DateTime.UtcNow.AddMinutes(20)
    });

Feedback

Var den här sidan till hjälp?

Dela via

Använda cookie autentisering utan ASP.NET Core Identity

Lägga till cookie autentisering

Cookie Principmellanprogram

Skapa en autentisering cookie

Logga ut

Reagera på backend-ändringar

Beständiga cookies

Absolut cookie förfallodatum

Configuration

Cookie Principmellanprogram

Skapa en autentisering cookie

Logga ut

Reagera på backend-ändringar

Beständiga cookies

Absolut cookie förfallodatum

Feedback

Ytterligare resurser