Serialisierung des Tokencaches in MSAL.NETToken cache serialization in MSAL.NET

Nachdem ein Token abgerufen wurde, wird es von der Microsoft-Authentifizierungsbibliothek (MSAL) zwischengespeichert.After a token is acquired, it is cached by the Microsoft Authentication Library (MSAL). Der Anwendungscode sollte zunächst versuchen, ein Token aus dem Cache abzurufen, bevor andere Methoden angewendet werden.Application code should try to get a token from the cache before acquiring a token by another method. Dieser Artikel beschreibt die standardmäßige und benutzerdefinierte Serialisierung des Tokencaches in MSAL.NET.This article discusses default and custom serialization of the token cache in MSAL.NET.

Dieser Artikel bezieht sich auf MSAL.NET 3.x.This article is for MSAL.NET 3.x. Wenn Sie sich für MSAL.NET 2.x interessieren, informieren Sie sich unter Serialisierung des Tokencaches in MSAL.NET 2.x.If you're interested in MSAL.NET 2.x, see Token cache serialization in MSAL.NET 2.x.

Standardserialisierung für mobile PlattformenDefault serialization for mobile platforms

In MSAL.NET wird standardmäßig ein InMemory-Tokencache bereitgestellt.In MSAL.NET, an in-memory token cache is provided by default. Die Serialisierung wird standardmäßig für Plattformen bereitgestellt, in denen sicherer Speicher dem Benutzer als Teil der Plattform angeboten wird.Serialization is provided by default for platforms where secure storage is available for a user as part of the platform. Dies trifft auf die Universelle Windows-Plattform (UWP), Xamarin.iOS und Xamarin.Android zu.This is the case for Universal Windows Platform (UWP), Xamarin.iOS, and Xamarin.Android.

Hinweis

Wenn Sie ein Xamarin.Android-Projekt von MSAL.NET 1.x zu MSAL.NET 3.x migrieren, können Sie android:allowBackup="false" Ihrem Projekt hinzufügen. So vermeiden Sie, dass alte zwischengespeicherte Token wiederkehren, wenn die Wiederherstellung des lokalen Speichers in einer Visual Studio-Bereitstellung ausgelöst wird.When you migrate a Xamarin.Android project from MSAL.NET 1.x to MSAL.NET 3.x, you might want to add android:allowBackup="false" to your project to avoid old cached tokens from coming back when Visual Studio deployments trigger a restore of local storage. Weitere Informationen finden Sie in der Beschreibung zu Problem 659.See Issue #659.

Benutzerdefinierte Serialisierung für Windows-Desktopanwendungen und Web-Apps/Web-APIsCustom serialization for Windows desktop apps and web apps/web APIs

Beachten Sie, dass für mobile Plattformen (UWP, Xamarin.iOS und Xamarin.Android) keine benutzerdefinierte Serialisierung verfügbar ist.Remember, custom serialization isn't available on mobile platforms (UWP, Xamarin.iOS, and Xamarin.Android). MSAL implementiert bereits einen sicheren und leistungsfähigen Serialisierungsmechanismus für diese Plattformen.MSAL already defines a secure and performant serialization mechanism for these platforms. .NET Desktop- und .NET Core-Anwendungen verfügen jedoch über unterschiedliche Architekturen, sodass MSAL keinen allgemeingültigen Serialisierungsmechanismus implementieren kann..NET desktop and .NET Core applications, however, have varied architectures and MSAL can't implement a general-purpose serialization mechanism. Token können von Websites beispielsweise bevorzugt in einem Redis-Cache und von Desktopanwendungen bevorzugt in einer verschlüsselten Datei gespeichert werden.For example, web sites may choose to store tokens in a Redis cache, or desktop apps store tokens in an encrypted file. Für die Serialisierung gilt es also keine universelle Lösung.So serialization isn't provided out-of-the-box. Passen Sie die Serialisierung an, um eine einheitliche Nutzung des Tokencaches in .NET Desktop oder .NET Core sicherzustellen.To have a persistent token cache application in .NET desktop or .NET Core, customize the serialization.

Die folgenden Klassen und Schnittstellen sind an der Serialisierung des Tokencaches beteiligt:The following classes and interfaces are used in token cache serialization:

  • ITokenCache definiert Ereignisse zum Abonnieren von Anforderungen zur Tokencacheserialisierung sowie Methoden zum Serialisieren oder Deserialisieren des Caches in verschiedenen Formaten (ADAL v3.0, MSAL 2.x und MSAL 3.x = ADAL v5.0).ITokenCache, which defines events to subscribe to token cache serialization requests as well as methods to serialize or de-serialize the cache at various formats (ADAL v3.0, MSAL 2.x, and MSAL 3.x = ADAL v5.0).

  • TokenCacheCallback ist ein an die Ereignisse übergebener Rückruf, damit Sie die Serialisierung verarbeiten können.TokenCacheCallback is a callback passed to the events so that you can handle the serialization. Sie werden mit Argumenten vom Typ TokenCacheNotificationArgs aufgerufen.They'll be called with arguments of type TokenCacheNotificationArgs.

  • TokenCacheNotificationArgs stellt nur den ClientId der Anwendung und einen Verweis auf den Benutzer bereit, für den das Token verfügbar ist.TokenCacheNotificationArgs only provides the ClientId of the application and a reference to the user for which the token is available.

    Klassendiagramm

Wichtig

MSAL.NET erstellt automatisch Tokencaches und stellt den IToken-Cache für Sie bereit, wenn Sie die UserTokenCache-Methode und die AppTokenCache-Eigenschaften einer Anwendung aufrufen.MSAL.NET creates token caches for you and provides you with the IToken cache when you call an application's UserTokenCache and AppTokenCache properties. Sie müssen die Schnittstelle nicht selbst implementieren.You are not supposed to implement the interface yourself. Beim Implementieren einer benutzerdefinierten Serialisierung des Tokencaches müssen Sie folgende Aufgaben ausführen:Your responsibility, when you implement a custom token cache serialization, is to:

  • Sie müssen auf BeforeAccess- und AfterAccess-„Ereignisse“ (oder deren asynchrone Varianten) reagieren.React to BeforeAccess and AfterAccess "events" (or their Async flavors). Der BeforeAccess-Delegat ist für die Deserialisierung des Caches zuständig, während der AfterAccess-Delegat den Cache serialisiert.The BeforeAccess delegate is responsible to deserialize the cache, whereas the AfterAccess one is responsible for serializing the cache.
  • Einige dieser Ereignisse speichern oder laden Blobs, die über das Ereignisargument an den gewünschten Speicher übergeben werden.Part of these events store or load blobs, which are passed through the event argument to whatever storage you want.

Die Strategien variieren, je nachdem, ob Sie eine Tokencacheserialisierung für eine öffentliche Clientanwendung (Desktop) oder eine vertrauliche Clientanwendung (Web-App/Web-API, Daemon-App) schreiben.The strategies are different depending on if you're writing a token cache serialization for a public client application (desktop), or a confidential client application) (web app / web API, daemon app).

Tokencache für einen öffentlichen ClientToken cache for a public client

Seit MSAL.NET v2.x haben Sie mehrere Optionen, um den Tokencache eines öffentlichen Clients zu serialisieren.Since MSAL.NET v2.x you have several options for serializing the token cache of a public client. Sie können den Cache nur für das MSAL.NET-Format serialisieren (das einheitliche Cacheformat wird von MSAL und Plattformen unterstützt).You can serialize the cache only to the MSAL.NET format (the unified format cache is common across MSAL and the platforms). Auch die ältere, in ADAL V3 gebräuchliche Serialisierung des Tokencaches wird unterstützt.You can also support the legacy token cache serialization of ADAL V3.

Im folgenden Beispiel wird u. a. erläutert, wie die Serialisierung des Tokencaches angepasst werden kann, damit der SSO-Zustand von ADAL.NET 3.x, ADAL.NET 5.x und MSAL.NET gemeinsam verwendet werden kann: active-directory-dotnet-v1-to-v2Customizing the token cache serialization to share the single sign-on state between ADAL.NET 3.x, ADAL.NET 5.x, and MSAL.NET is explained in part of the following sample: active-directory-dotnet-v1-to-v2.

Hinweis

Das Tokencacheformat für die MSAL.NET 1.1.4-Vorschau wird in MSAL 2.x nicht mehr unterstützt.The MSAL.NET 1.1.4-preview token cache format is no longer supported in MSAL 2.x. Wenn Sie über Anwendungen verfügen, die MSAL.NET 1.x nutzen, müssen sich Ihre Benutzer erneut anmelden.If you have applications leveraging MSAL.NET 1.x, your users will have to re-sign-in. Dafür wird jedoch die Migration von ADAL 4.x (und 3.x) unterstützt.Alternately, the migration from ADAL 4.x (and 3.x) is supported.

Einfache Serialisierung des Tokencaches (nur MSAL)Simple token cache serialization (MSAL only)

Das folgende Beispiel zeigt eine einfache Implementierung der benutzerdefinierten Serialisierung eines Tokencaches für Desktopanwendungen.Below is an example of a naive implementation of custom serialization of a token cache for desktop applications. Hier entspricht der Benutzertokencache einer Datei im selben Ordner wie die Anwendung.Here, the user token cache is a file in the same folder as the application.

Nach dem Erstellen der Anwendung aktivieren Sie die Serialisierung durch einen Aufruf der TokenCacheHelper.EnableSerialization()-Methode, wobei der UserTokenCache der Anwendung übergeben wird.After you build the application, you enable the serialization by calling the TokenCacheHelper.EnableSerialization() method and passing the application UserTokenCache.

app = PublicClientApplicationBuilder.Create(ClientId)
    .Build();
TokenCacheHelper.EnableSerialization(app.UserTokenCache);

Die TokenCacheHelper-Hilfsklasse ist wie folgt definiert:The TokenCacheHelper helper class is defined as:

static class TokenCacheHelper
 {
  public static void EnableSerialization(ITokenCache tokenCache)
  {
   tokenCache.SetBeforeAccess(BeforeAccessNotification);
   tokenCache.SetAfterAccess(AfterAccessNotification);
  }

  /// <summary>
  /// Path to the token cache. Note that this could be something different for instance for MSIX applications:
  /// private static readonly string CacheFilePath =
  /// $"{Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData)}\{AppName}\msalcache.bin";
  /// </summary>
  public static readonly string CacheFilePath = System.Reflection.Assembly.GetExecutingAssembly().Location + ".msalcache.bin3";

  private static readonly object FileLock = new object();


  private static void BeforeAccessNotification(TokenCacheNotificationArgs args)
  {
   lock (FileLock)
   {
    args.TokenCache.DeserializeMsalV3(File.Exists(CacheFilePath)
            ? ProtectedData.Unprotect(File.ReadAllBytes(CacheFilePath),
                                      null,
                                      DataProtectionScope.CurrentUser)
            : null);
   }
  }

  private static void AfterAccessNotification(TokenCacheNotificationArgs args)
  {
   // if the access operation resulted in a cache update
   if (args.HasStateChanged)
   {
    lock (FileLock)
    {
     // reflect changesgs in the persistent store
     File.WriteAllBytes(CacheFilePath,
                         ProtectedData.Protect(args.TokenCache.SerializeMsalV3(),
                                                 null,
                                                 DataProtectionScope.CurrentUser)
                         );
    }
   }
  }
 }

Ein dateibasiertes Serialisierungsmodul für einen Tokencache in Produktionsqualität, das für öffentliche Clientanwendungen (Desktopanwendungen unter Windows, Mac und Linux) verwendet wird, ist in der Open-Source-Bibliothek Microsoft.Identity.Client.Extensions.Msal verfügbar.A product quality token cache file based serializer for public client applications (for desktop applications running on Windows, Mac and Linux) is available from the Microsoft.Identity.Client.Extensions.Msal open-source library. Sie können das Modul aus dem folgenden NuGet-Paket in Ihre Anwendungen einbeziehen: Microsoft.Identity.Client.Extensions.Msal.You can include it in your applications from the following NuGet package: Microsoft.Identity.Client.Extensions.Msal.

Duale Serialisierung des Tokencaches (einheitlicher MSAL-Cache und ADAL v3)Dual token cache serialization (MSAL unified cache and ADAL v3)

Um die Serialisierung des Tokencaches sowohl mit dem einheitlichen Cacheformat (üblich in ADAL.NET 4.x und MSAL.NET 2.x) als auch mit anderen MSALs (derselben oder einer früheren Generation auf derselben Plattform) zu implementieren, können Sie den folgenden Code nutzen:If you want to implement token cache serialization both with the unified cache format (common to ADAL.NET 4.x, MSAL.NET 2.x, and other MSALs of the same generation or older, on the same platform), take a look at the following code:

string appLocation = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location;
string cacheFolder = Path.GetFullPath(appLocation) + @"..\..\..\..");
string adalV3cacheFileName = Path.Combine(cacheFolder, "cacheAdalV3.bin");
string unifiedCacheFileName = Path.Combine(cacheFolder, "unifiedCache.bin");

IPublicClientApplication app;
app = PublicClientApplicationBuilder.Create(clientId)
                                    .Build();
FilesBasedTokenCacheHelper.EnableSerialization(app.UserTokenCache,
                                               unifiedCacheFileName,
                                               adalV3cacheFileName);

Hierbei ist die Hilfsklasse wie folgt definiert:This time the helper class as defined as:

using System;
using System.IO;
using System.Security.Cryptography;
using Microsoft.Identity.Client;

namespace CommonCacheMsalV3
{
 /// <summary>
 /// Simple persistent cache implementation of the dual cache serialization (ADAL V3 legacy
 /// and unified cache format) for a desktop applications (from MSAL 2.x)
 /// </summary>
 static class FilesBasedTokenCacheHelper
 {
  /// <summary>
  /// Enables the serialization of the token cache
  /// </summary>
  /// <param name="adalV3CacheFileName">File name where the cache is serialized with the
  /// ADAL V3 token cache format. Can
  /// be <c>null</c> if you don't want to implement the legacy ADAL V3 token cache
  /// serialization in your MSAL 2.x+ application</param>
  /// <param name="unifiedCacheFileName">File name where the cache is serialized
  /// with the Unified cache format, common to
  /// ADAL V4 and MSAL V2 and above, and also across ADAL/MSAL on the same platform.
  ///  Should not be <c>null</c></param>
  /// <returns></returns>
  public static void EnableSerialization(ITokenCache tokenCache, string unifiedCacheFileName, string adalV3CacheFileName)
  {
   UnifiedCacheFileName = unifiedCacheFileName;
   AdalV3CacheFileName = adalV3CacheFileName;

   tokenCache.SetBeforeAccess(BeforeAccessNotification);
   tokenCache.SetAfterAccess(AfterAccessNotification);
  }

  /// <summary>
  /// File path where the token cache is serialized with the unified cache format
  /// (ADAL.NET V4, MSAL.NET V3)
  /// </summary>
  public static string UnifiedCacheFileName { get; private set; }

  /// <summary>
  /// File path where the token cache is serialized with the legacy ADAL V3 format
  /// </summary>
  public static string AdalV3CacheFileName { get; private set; }

  private static readonly object FileLock = new object();

  public static void BeforeAccessNotification(TokenCacheNotificationArgs args)
  {
   lock (FileLock)
   {
    args.TokenCache.DeserializeAdalV3(ReadFromFileIfExists(AdalV3CacheFileName));
    try
    {
     args.TokenCache.DeserializeMsalV3(ReadFromFileIfExists(UnifiedCacheFileName));
    }
    catch(Exception ex)
    {
     // Compatibility with the MSAL v2 cache if you used one
     args.TokenCache.DeserializeMsalV2(ReadFromFileIfExists(UnifiedCacheFileName));
    }
   }
  }

  public static void AfterAccessNotification(TokenCacheNotificationArgs args)
  {
   // if the access operation resulted in a cache update
   if (args.HasStateChanged)
   {
    lock (FileLock)
    {
     WriteToFileIfNotNull(UnifiedCacheFileName, args.TokenCache.SerializeMsalV3());
     if (!string.IsNullOrWhiteSpace(AdalV3CacheFileName))
     {
      WriteToFileIfNotNull(AdalV3CacheFileName, args.TokenCache.SerializeAdalV3());
     }
    }
   }
  }

  /// <summary>
  /// Read the content of a file if it exists
  /// </summary>
  /// <param name="path">File path</param>
  /// <returns>Content of the file (in bytes)</returns>
  private static byte[] ReadFromFileIfExists(string path)
  {
   byte[] protectedBytes = (!string.IsNullOrEmpty(path) && File.Exists(path))
       ? File.ReadAllBytes(path) : null;
   byte[] unprotectedBytes = encrypt ?
       ((protectedBytes != null) ? ProtectedData.Unprotect(protectedBytes, null, DataProtectionScope.CurrentUser) : null)
       : protectedBytes;
   return unprotectedBytes;
  }

  /// <summary>
  /// Writes a blob of bytes to a file. If the blob is <c>null</c>, deletes the file
  /// </summary>
  /// <param name="path">path to the file to write</param>
  /// <param name="blob">Blob of bytes to write</param>
  private static void WriteToFileIfNotNull(string path, byte[] blob)
  {
   if (blob != null)
   {
    byte[] protectedBytes = encrypt
      ? ProtectedData.Protect(blob, null, DataProtectionScope.CurrentUser)
      : blob;
    File.WriteAllBytes(path, protectedBytes);
   }
   else
   {
    File.Delete(path);
   }
  }

  // Change if you want to test with an un-encrypted blob (this is a json format)
  private static bool encrypt = true;
 }
}

Tokencache für eine Web-App (vertrauliche Clientanwendung)Token cache for a web app (confidential client application)

In Web-Apps oder Web-APIs kann der Cache die Sitzung, einen Redis-Cache oder eine Datenbank nutzen.In web apps or web APIs, the cache could leverage the session, a Redis cache, or a database. In Web-Apps oder Web-APIs sollten Sie jeweils einen Tokencache pro Konto bereithalten.You should keep one token cache per account in web apps or web APIs.

Bei Web-Apps sollte der Tokencache durch die Konto-ID mit einem Schlüssel versehen werden.For web apps, the token cache should be keyed by the account ID.

Bei Web-APIs sollte das Konto durch den Hash des Tokens, das zum Aufrufen der API verwendet wird, mit einem Schlüssel versehen werden.For web APIs, the account should be keyed by the hash of the token used to call the API.

MSAL.NET bietet eine benutzerdefinierte Tokencache-Serialisierung in .NET Framework- und .NET Core-Plattformen.MSAL.NET provides custom token cache serialization in .NET Framework and .NET Core subplatforms. Ereignisse werden beim Zugriff auf den Cache ausgelöst; Apps können auswählen, ob der Cache serialisiert oder deserialisiert werden soll.Events are fired when the cache is accessed, apps can choose whether to serialize or deserialize the cache. In vertraulichen Clientanwendungen, die Benutzer behandeln (Web-Apps, die Benutzer anmelden und Web-APIs aufrufen, und Web-APIs, die nachgeschaltete Web-APIs aufrufen), können viele Benutzer vorhanden sein. Die Benutzer werden dann parallel verarbeitet.On confidential client applications that handle users (web apps that sign in users and call web APIs, and web APIs calling downstream web APIs), there can be many users and the users are processed in parallel. Aus Sicherheits- und Leistungsgründen wird empfohlen, jeweils einen Cache pro Benutzer zu serialisieren.For security and performance reasons, our recommendation is to serialize one cache per user. Serialisierungsereignisse berechnen anhand der Identität des verarbeiteten Benutzers einen Cacheschlüssel und serialisieren/deserialisieren einen Tokencache für diesen Benutzer.Serialization events compute a cache key based on the identity of the processed user and serialize/deserialize a token cache for that user.

Die Bibliothek Microsoft.Identity.Web stellt das NuGet-Paket Microsoft.Identity.Web in der Vorschau bereit, das die Tokencacheserialisierung enthält:The Microsoft.Identity.Web library provides a preview NuGet package Microsoft.Identity.Web containing token cache serialization:

ErweiterungsmethodeExtension Method Subnamespace „Microsoft.Identity.Web“Microsoft.Identity.Web sub namespace BESCHREIBUNGDescription
AddInMemoryTokenCaches TokenCacheProviders.InMemory InMemory-Tokencacheserialisierung.In memory token cache serialization. Diese Implementierung eignet sich hervorragend für Beispiele.This implementation is great in samples. Sie eignet sich auch für Produktionsanwendungen, falls es Ihnen nichts ausmacht, wenn der Tokencache beim Neustart der Web-App verloren geht.It's also good in production applications provided you don't mind if the token cache is lost when the web app is restarted. AddInMemoryTokenCaches verwendet einen optionalen Parameter vom Typ MsalMemoryTokenCacheOptions, mit dem Sie die Zeitspanne angeben können, nach der der Cacheeintrag abläuft, sofern er nicht verwendet wird.AddInMemoryTokenCaches takes an optional parameter of type MsalMemoryTokenCacheOptions that enables you to specify the duration after which the cache entry will expire unless it's used.
AddSessionTokenCaches TokenCacheProviders.Session Der Tokencache ist an die Benutzersitzung gebunden.The token cache is bound to the user session. Diese Option ist nicht ideal, wenn das ID-Token viele Ansprüche enthält, da das Cookie zu groß wird.This option isn't ideal if the ID token contains many claims as the cookie would become too large.
AddDistributedTokenCaches TokenCacheProviders.Distributed Der Tokencache ist ein Adapter für die ASP.NET Core-Implementierung IDistributedCache. Daher stehen ein verteilter Speichercache, ein Redis-Cache, ein verteilter NCache oder ein SQL Server-Cache zur Auswahl.The token cache is an adapter against the ASP.NET Core IDistributedCache implementation, therefore enabling you to choose between a distributed memory cache, a Redis cache, a distributed NCache, or a SQL Server cache. Einzelheiten zu den IDistributedCache-Implementierungen finden Sie unter https://docs.microsoft.com/aspnet/core/performance/caching/distributed#distributed-memory-cache.For details about the IDistributedCache implementations, see https://docs.microsoft.com/aspnet/core/performance/caching/distributed#distributed-memory-cache.

Im Folgenden finden Sie ein Beispiel für die Verwendung des In-Memory-Caches in der ConfigureServices-Methode der Startup-Klasse in einer ASP.NET Core-Anwendung:Here's an example of using the in-memory cache in the ConfigureServices method of the Startup class in an ASP.NET Core application:

// or use a distributed Token Cache by adding
    services.AddSignIn(Configuration);
    services.AddWebAppCallsProtectedWebApi(Configuration, new string[] { scopesToRequest })
            .AddInMemoryTokenCaches();

Beispiele für mögliche verteilte Caches:Examples of possible distributed caches:

// or use a distributed Token Cache by adding
    services.AddSignIn(Configuration);
    services.AddWebAppCallsProtectedWebApi(Configuration, new string[] { scopesToRequest })
            .AddDistributedTokenCaches();

// and then choose your implementation

// For instance the distributed in memory cache (not cleared when you stop the app)
services.AddDistributedMemoryCache()

// Or a Redis cache
services.AddStackExchangeRedisCache(options =>
{
 options.Configuration = "localhost";
 options.InstanceName = "SampleInstance";
});

// Or even a SQL Server token cache
services.AddDistributedSqlServerCache(options =>
{
 options.ConnectionString = _config["DistCache_ConnectionString"];
 options.SchemaName = "dbo";
 options.TableName = "TestCache";
});

Die Nutzung wird im Tutorial zum Erstellen einer Web-App mit ASP.NET Core in der Phase 2-2 Tokencache dargestellt.Their usage is featured in the ASP.NET Core web app tutorial in the phase 2-2 Token Cache.

Nächste SchritteNext steps

Die folgenden Beispiele veranschaulichen die Serialisierung des Tokencaches.The following samples illustrate token cache serialization.

BeispielSample PlattformPlatform BESCHREIBUNGDescription
active-directory-dotnet-desktop-msgraph-v2active-directory-dotnet-desktop-msgraph-v2 Desktop (WPF)Desktop (WPF) Windows Desktop .NET (WPF)-Anwendung, die die Microsoft Graph-API aufruftWindows Desktop .NET (WPF) application calling the Microsoft Graph API. Das Diagramm zeigt eine Topologie mit dem Fluss der WPF-Desktop-App „TodoListClient“ durch interaktives Abrufen eines Tokens zu Azure AD und Microsoft Graph.
active-directory-dotnet-v1-to-v2active-directory-dotnet-v1-to-v2 Desktop (Konsole)Desktop (Console) Eine Reihe von Visual Studio-Lösungen, welche die Migration von Azure AD v1.0-Anwendungen (mit ADAL.NET) zu Microsoft Identity Platform-Anwendungen (mit MSAL.NET) veranschaulichen.Set of Visual Studio solutions illustrating the migration of Azure AD v1.0 applications (using ADAL.NET) to Microsoft identity platform applications (using MSAL.NET). Spezielle Informationen finden Sie unter Tokencache-Migration.In particular, see Token Cache Migration