Hämta en token från tokencachen med hjälp av MSAL.NET

När du hämtar en åtkomsttoken med hjälp av Microsofts autentiseringsbibliotek för .NET (MSAL.NET) cachelagras token. När programmet behöver en token bör det först försöka hämta den från cacheminnet.

Du kan övervaka tokenens källa genom att granska egenskapen AuthenticationResult.AuthenticationResultMetadata.TokenSource.

Webbplatser och webb-API:er

ASP.NET Core och ASP.NET klassiska webbplatser bör integreras med Microsoft. Identity.Web, en omslutning för MSAL.NET. Tokencachelagring i minnet eller distribuerad tokencachelagring kan konfigureras enligt beskrivningen i serialisering av tokencache.

Webb-API:er på ASP.NET Core bör använda Microsoft. Identity.Web. Webb-API:er i klassisk ASP.NET använder MSAL direkt genom att anropa AcquireTokenOnBehalfOf och bör konfigurera minnes- eller distribuerad cachelagring. För mer information, se Token cache-serialisering i MSAL.NET. Det finns ingen anledning att anropa API:et AcquireTokenSilent eftersom det inte finns något API för att rensa cacheminnet. Cachestorlek kan hanteras genom att ange borttagningsprinciper i det underliggande cachelagret, till exempel MemoryCache, Redis osv.

Webbtjänst/Daemon-appar

Applikationer som begär token för en appidentitet, utan att någon användare är inblandad, genom att anropa AcquireTokenForClient kan antingen förlita sig på MSAL:s interna cachelagring eller definiera egen minnesbaserad tokencache eller distribuerad tokencache. Instruktioner och mer information finns i Token cache serialisering i MSAL.NET.

Eftersom ingen användare är inblandad finns det ingen anledning att anropa AcquireTokenSilent. AcquireTokenForClient kommer att titta i cachen på egen hand eftersom det inte finns något API för att rensa cacheminnet. Cachestorleken är proportionell med antalet klienter och resurser som du behöver token för. Cachestorlek kan hanteras genom att ange borttagningsprinciper i det underliggande cachelagret, till exempel MemoryCache, Redis osv.

Skrivbordsprogram, kommandoradsprogram och mobila program

Skrivbords-, kommandorads- och mobilprogram bör först anropa AcquireTokenSilent metoden för att kontrollera om en acceptabel token finns i cacheminnet. I många fall är det möjligt att hämta en annan token med fler behörigheter baserat på en token i cachen. Det går också att uppdatera en token när den närmar sig förfallodatum (eftersom tokencacheminnet också innehåller en uppdateringstoken).

För autentiseringsflöden som kräver en användarinteraktion cachelagrar MSAL åtkomst-, uppdaterings- och ID-token och IAccount objektet, som representerar information om ett enda konto. Läs mer om IAccount. För programflöden, till exempel klientautentiseringsuppgifter, cachelagras endast åtkomsttoken, eftersom IAccount objektet och ID-token kräver en användare och uppdateringstoken inte är tillämpligt.

Det rekommenderade mönstret är att anropa AcquireTokenSilent metoden först. Om AcquireTokenSilent misslyckas hämtar du en token med andra metoder.

I följande exempel försöker programmet först hämta en token från tokencachen. Om ett MsalUiRequiredException undantag utlöses hämtar programmet en token interaktivt.

var accounts = await app.GetAccountsAsync();

AuthenticationResult result = null;
try
{
     result = await app.AcquireTokenSilent(scopes, accounts.FirstOrDefault())
                       .ExecuteAsync();
}
catch (MsalUiRequiredException ex)
{
    // A MsalUiRequiredException happened on AcquireTokenSilent.
    // This indicates you need to call AcquireTokenInteractive to acquire a token
    Debug.WriteLine($"MsalUiRequiredException: {ex.Message}");

    try
    {
        result = await app.AcquireTokenInteractive(scopes)
                          .ExecuteAsync();
    }
    catch (MsalException msalex)
    {
        ResultText.Text = $"Error Acquiring Token:{System.Environment.NewLine}{msalex}";
    }
}
catch (Exception ex)
{
    ResultText.Text = $"Error Acquiring Token Silently:{System.Environment.NewLine}{ex}";
    return;
}

if (result != null)
{
    string accessToken = result.AccessToken;
    // Use the token
}

Rensning av cacheminnet

Om du tar bort konton från cacheminnet i offentliga klientprogram rensas det. Detta tar dock inte bort sessionscookien, som finns i webbläsaren.

var accounts = (await app.GetAccountsAsync()).ToList();

// clear the cache
while (accounts.Any())
{
   await app.RemoveAsync(accounts.First());
   accounts = (await app.GetAccountsAsync()).ToList();
}