Freigeben über

Tutorial: Anmelden von Benutzern bei der .NET MAUI-Shell-App mithilfe eines externen Mandanten

Gilt für:Weißer Kreis mit grauem X-Symbol. Mitarbeitermieter Grüner Kreis mit weißem Häkchen-Symbol. Externe Mieter (weitere Informationen)

Dieses Lernprogramm ist der letzte Teil einer Reihe, in der das Erstellen eines Anmelde- und Abmeldecodes in der .NET Multi-Platform App UI (.NET MAUI)-Shell veranschaulicht und die App auf der Windows-Plattform ausgeführt wird. In Teil 1 dieser Reihe haben Sie eine .NET MAUI-Shell-App erstellt, msAL SDK-Unterstützung über MSAL-Hilfsklassen hinzugefügt, erforderliche Bibliotheken installiert und eine Bildressource enthalten. In diesem letzten Schritt wird veranschaulicht, wie Sie Anmelde- und Abmeldecode in der .NET MAUI-Shell hinzufügen und die App auf der Windows-Plattform ausführen.

In diesem Tutorial führen Sie Folgendes durch:

  • Fügen Sie Anmelde- und Abmeldecode hinzu.
  • Ändern Sie die App-Shell.
  • Fügen Sie plattformspezifischen Code hinzu.
  • Fügen Sie App-Einstellungen hinzu.
  • Führen Sie die .NET MAUI-Shell-App aus, und testen Sie sie.

Voraussetzungen

Hinzufügen von Anmelde- und Abmeldecode

Die Benutzeroberfläche einer .NET MAUI-App wird aus Objekten erstellt, die den systemeigenen Steuerelementen jeder Zielplattform zugeordnet sind. Die Hauptsteuerelementgruppen zum Erstellen der Benutzeroberfläche einer .NET MAUI-App sind Seiten, Layouts und Ansichten.

Hauptansichtsseite hinzufügen

Die nächsten Schritte organisieren unseren Code so, dass der main view Code definiert ist.

  1. Löschen Sie MainPage.xaml und MainPage.xaml.cs aus Ihrem Projekt, sie werden nicht mehr benötigt. Suchen Sie im Bereich Projektmappen-Explorer den Eintrag für MainPage.xaml, klicken Sie mit der rechten Maustaste darauf, und wählen Sie Löschen aus.

  2. Klicken Sie mit der rechten Maustaste auf das SignInMaui-Projekt, und wählen Sie "> hinzufügen" aus. Benennen Sie den Ordner "Ansichten".

  3. Klicken Sie mit der rechten Maustaste auf die Ansichten.

  4. Wählen Sie "Neues Element>" aus.

  5. Wählen Sie in der Vorlagenliste .NET MAUI aus.

  6. Wählen Sie die .NET MAUI ContentPage (XAML)- Vorlage aus. Nennen Sie die Datei "MainView.xaml".

  7. Wählen Sie Hinzufügen aus.

  8. Die Datei MainView.xaml wird in einem neuen Dokumenten-Tab geöffnet und zeigt das gesamte XAML-Markup an, das die Benutzeroberfläche der Seite repräsentiert. Ersetzen des XAML-Markups durch folgendes Markup:

    <?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="SignInMaui.Views.MainView"
             Title="Microsoft Entra External ID"
             >
    <Shell.BackButtonBehavior>
        <BackButtonBehavior IsVisible="False" IsEnabled="False" />
    </Shell.BackButtonBehavior>

    <ScrollView>
        <VerticalStackLayout 
            Spacing="25" 
            Padding="30,0" 
            VerticalOptions="Center">

            <Image
                Source="external_id.png"
                SemanticProperties.Description="External ID"
                HeightRequest="200"
                HorizontalOptions="Center" />

            <Label 
                Text="CIAM"
                SemanticProperties.HeadingLevel="Level1"
                FontSize="26"
                HorizontalOptions="Center" />

            <Label 
                Text="MAUI sample"
                SemanticProperties.HeadingLevel="Level1"
                FontSize="26"
                HorizontalOptions="Center" />

            <Button 
                x:Name="SignInButton"
                Text="Sign In"
                SemanticProperties.Hint="Sign In"
                Clicked="OnSignInClicked"
                HorizontalOptions="Center"
                IsEnabled="False"/>

        </VerticalStackLayout>
    </ScrollView>
 
</ContentPage>

  9. Speichern Sie die Datei.

    Lassen Sie uns die wichtigsten Teile der XAML-Steuerelemente auf der Seite aufgliedern:

    • <ContentPage> ist das Stammobjekt für die MainView-Klasse.
    • <VerticalStackLayout> ist das untergeordnete Objekt der ContentPage. Dieses Layoutsteuerelement ordnet seine untergeordneten Elemente vertikal nacheinander an.
    • <Image> zeigt ein Bild an, in diesem Fall wird das azureactive_directory.png_ verwendet, das Sie zuvor heruntergeladen haben.
    • <Label>-Steuerelemente zeigen Text an.
    • <Button> kann vom Benutzer gedrückt werden, wodurch das Clicked Ereignis ausgelöst wird. Sie können Code als Reaktion auf das Clicked-Ereignis ausführen.
    • Clicked="OnSignInClicked" das Clicked Ereignis der Schaltfläche wird dem OnSignInClicked Ereignishandler zugewiesen, der in der CodeBehind-Datei definiert wird. Sie erstellen diesen Code im nächsten Schritt.

Behandeln des OnSignInClicked-Ereignisses

Der nächste Schritt besteht darin, den Code für das Clicked-Ereignis der Schaltfläche hinzuzufügen.

  1. Erweitern Sie im Bereich Projektmappen-Explorer von Visual Studio die Datei MainView.xaml, um die CodeBehind-Datei MainView.xaml.cs anzuzeigen. Öffnen Sie die MainView.xaml.cs , und ersetzen Sie den Inhalt der Datei durch folgenden Code:

    // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

using SignInMaui.MSALClient;
using Microsoft.Identity.Client;

namespace SignInMaui.Views
{
    public partial class MainView : ContentPage
    {
        public MainView()
        {
            InitializeComponent();

            IAccount cachedUserAccount = PublicClientSingleton.Instance.MSALClientHelper.FetchSignedInUserFromCache().Result;

            _ = Dispatcher.DispatchAsync(async () =>
            {
                if (cachedUserAccount == null)
                {
                    SignInButton.IsEnabled = true;
                }
                else
                {
                    await Shell.Current.GoToAsync("claimsview");
                }
            });
        }

        private async void OnSignInClicked(object sender, EventArgs e)
        {
            await PublicClientSingleton.Instance.AcquireTokenSilentAsync();
            await Shell.Current.GoToAsync("claimsview");
        }
        protected override bool OnBackButtonPressed() { return true; }

    }
}

Die MainView Klasse ist eine Inhaltsseite, die für die Anzeige der Hauptansicht der App verantwortlich ist. Im Konstruktor ruft es das zwischengespeicherte Benutzerkonto mithilfe der MSALClientHelperPublicClientSingleton Instanz ab und aktiviert die Anmeldeschaltfläche, wenn kein zwischengespeichertes Benutzerkonto gefunden wird.

Wenn auf die Anmeldeschaltfläche geklickt wird, ruft sie die AcquireTokenSilentAsync Methode auf, um ein Token still abzurufen, und navigiert dann mithilfe der claimsview Methode zur Seite Shell.Current.GoToAsync. Darüber hinaus wird die OnBackButtonPressed Methode außer Kraft gesetzt, um true zurückzugeben, was angibt, dass die Zurück-Schaltfläche für diese Ansicht deaktiviert ist.

Ansichtsseite für Ansprüche hinzufügen

Die nächsten Schritte organisieren den Code so, dass die ClaimsView Seite definiert ist. Auf der Seite werden die Ansprüche der Benutzenden angezeigt, die im ID-Token gefunden wurden.

  1. Klicken Sie im Projektmappen-Explorer von Visual Studio mit der rechten Maustaste auf Ansichten.

  2. Wählen Sie "Neues Element>" aus.

  3. Wählen Sie in der Vorlagenliste .NET MAUI aus.

  4. Wählen Sie die .NET MAUI ContentPage (XAML)- Vorlage aus. Nennen Sie die Datei ClaimsView.xaml.

  5. Wählen Sie Hinzufügen aus.

  6. Die Datei ClaimsView.xaml wird auf einer neuen Dokumentregisterkarte geöffnet, auf der das gesamte XAML-Markup angezeigt wird, das die Benutzeroberfläche der Seite darstellt. Ersetzen des XAML-Markups durch folgendes Markup:

    <?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="SignInMaui.Views.ClaimsView"
             Title="ID Token View">
    <Shell.BackButtonBehavior>
        <BackButtonBehavior IsVisible="False" IsEnabled="False" />
    </Shell.BackButtonBehavior>
    <VerticalStackLayout>
        <Label 
            Text="CIAM"
            FontSize="26"
            HorizontalOptions="Center" />
        <Label 
            Text="MAUI sample"
            FontSize="26"
            Padding="0,0,0,20"
            HorizontalOptions="Center" />

        <Label 
            Padding="0,20,0,0"
            VerticalOptions="Center" 
            HorizontalOptions="Center"
            FontSize="18"
            Text="Claims found in ID token"
            />
        <ListView ItemsSource="{Binding IdTokenClaims}"
                  x:Name="Claims">
            <ListView.ItemTemplate>
                <DataTemplate>
                    <ViewCell>
                        <Grid Padding="0, 0, 0, 0">
                            <Label Grid.Column="1" 
                                   Text="{Binding}" 
                                   HorizontalOptions="Center" />
                        </Grid>
                    </ViewCell>
                </DataTemplate>
            </ListView.ItemTemplate>
        </ListView>
        <Button
            x:Name="SignOutButton"
            Text="Sign Out"
            HorizontalOptions="Center"
            Clicked="SignOutButton_Clicked" />
    </VerticalStackLayout>
</ContentPage>

    Dieser XAML-Markupcode stellt das UI-Layout für eine Anspruchsansicht in einer .NET MAUI-App dar. Zunächst wird ContentPage mit einem Titel definiert und das Verhalten der Zurück-Schaltfläche deaktiviert.

    Innerhalb eines VerticalStackLayout gibt es mehrere Label-Elemente, die statischen Text anzeigen, gefolgt von einem ListView namens Claims, der an eine Auflistung gebunden wird, die IdTokenClaims genannt wird, um die im ID-Token gefundenen Claims anzuzeigen. Jeder Anspruch wird in einer ViewCell mit einer DataTemplate gerendert und als zentriertes Label innerhalb eines Rasters angezeigt.

    Schließlich befindet sich unten im Layout eine Sign Out Schaltfläche, die den SignOutButton_Clicked Ereignishandler auslöst, wenn darauf geklickt wird.

Behandeln der ClaimsView-Daten

Der nächste Schritt besteht darin, den Code zum Behandeln ClaimsView von Daten hinzuzufügen.

  1. Erweitern Sie im Bereich Projektmappen-Explorer von Visual Studio die Datei ClaimsView.xaml, um die CodeBehind-Datei ClaimsView.xaml.cs anzuzeigen. Öffnen Sie die ClaimsView.xaml.cs , und ersetzen Sie den Inhalt der Datei durch folgenden Code:

    using SignInMaui.MSALClient;
using Microsoft.Identity.Client;

namespace SignInMaui.Views;

public partial class ClaimsView : ContentPage
{
    public IEnumerable<string> IdTokenClaims { get; set; } = new string[] {"No claims found in ID token"};
    public ClaimsView()
    {
        BindingContext = this;
        InitializeComponent();

        _ = SetViewDataAsync();
    }

    private async Task SetViewDataAsync()
    {
        try
        {
            _ = await PublicClientSingleton.Instance.AcquireTokenSilentAsync();

            IdTokenClaims = PublicClientSingleton.Instance.MSALClientHelper.AuthResult.ClaimsPrincipal.Claims.Select(c => c.Value);

            Claims.ItemsSource = IdTokenClaims;
        }

        catch (MsalUiRequiredException)
        {
            await Shell.Current.GoToAsync("claimsview");
        }
    }

    protected override bool OnBackButtonPressed() { return true; }

    private async void SignOutButton_Clicked(object sender, EventArgs e)
    {
        await PublicClientSingleton.Instance.SignOutAsync().ContinueWith((t) =>
        {
            return Task.CompletedTask;
        });

        await Shell.Current.GoToAsync("mainview");
    }
}

    Der Code in ClaimsView.xaml.cs stellt den CodeBehind für eine Anspruchsansicht in einer .NET MAUI-App dar. Er importiert zuerst die erforderlichen Namespaces und definiert die ClaimsView-Klasse, die ContentPage erweitert. Die IdTokenClaims Eigenschaft ist eine Aufzählung von Zeichenfolgen, die zunächst auf eine einzelne Zeichenfolge festgelegt ist, die angibt, dass keine Ansprüche gefunden wurden.

    Der ClaimsView Konstruktor legt den Bindungskontext auf die aktuelle Instanz fest, initialisiert die Ansichtskomponenten und ruft die SetViewDataAsync Methode asynchron auf. Die SetViewDataAsync-Methode versucht, im Hintergrund ein Token abzurufen, ruft die Ansprüche aus dem Authentifizierungsergebnis ab und legt die IdTokenClaims-Eigenschaft fest, um sie in der ListView mit dem Namen Claims anzuzeigen. Wenn ein MsalUiRequiredException Ereignis auftritt, das angibt, dass die Benutzerinteraktion für die Authentifizierung erforderlich ist, navigiert die App zur Anspruchsansicht.

    Die OnBackButtonPressed-Methode setzt das Verhalten der Zurück-Schaltfläche außer Kraft, sodass immer true zurückgegeben wird und der Benutzer nicht aus dieser Ansicht zurückkehren kann. Der SignOutButton_Clicked-Ereignishandler meldet Benutzer*innen mithilfe der PublicClientSingleton-Instanz ab und navigiert anschließend zur main view.

Ändern der App-Shell

Die AppShell Klasse definiert die visuelle Hierarchie einer App, das XAML-Markup, das beim Erstellen der Benutzeroberfläche der App verwendet wird. Aktualisieren Sie die AppShell, um sie über die Views zu informieren.

  1. Doppelklicken Sie im AppShell.xaml auf die Datei, um den XAML-Editor zu öffnen. Ersetzen Sie das XAML-Markup durch den folgenden Code:

    <?xml version="1.0" encoding="UTF-8" ?>
<Shell
    x:Class="SignInMaui.AppShell"
    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    xmlns:local="clr-namespace:SignInMaui.Views"
    Shell.FlyoutBehavior="Disabled">

    <ShellContent
        Title="Home"
        ContentTemplate="{DataTemplate local:MainView}"
        Route="MainPage" />
</Shell>

    Der XAML-Code definiert eine AppShell Klasse, die das Flyoutverhalten deaktiviert und den Hauptinhalt auf ein ShellContent Element mit einem Titel Home und einer Inhaltsvorlage festlegt, die auf die MainView Klasse verweist.

  2. Erweitern Sie im Projektmappen-Explorer von Visual Studio die Datei AppShell.xaml, um die Code-Behind-Datei AppShell.xaml.cs anzuzeigen. Öffnen Sie die AppShell.xaml.cs , und ersetzen Sie den Inhalt der Datei durch folgenden Code:

    // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
using SignInMaui.Views;

namespace SignInMaui;

public partial class AppShell : Shell
{
    public AppShell()
    {
        InitializeComponent();
        Routing.RegisterRoute("mainview", typeof(MainView));
        Routing.RegisterRoute("claimsview", typeof(ClaimsView));
    }
}

    Sie aktualisieren die AppShell.xaml.cs-Datei, um die erforderlichen Routenregistrierungen für die MainView und ClaimsView einzufügen. Durch Aufrufen der InitializeComponent() Methode stellen Sie sicher, dass die Initialisierung der AppShell Klasse erfolgt. Die RegisterRoute()-Methode ordnet die mainview- und claimsview-Routen ihren jeweiligen Ansichtstypen, MainView und ClaimsView, zu.

Plattformspezifischen Code hinzufügen

Ein .NET MAUI-App-Projekt enthält einen Ordner "Platforms ", wobei jeder untergeordnete Ordner eine Plattform darstellt, auf die .NET MAUI abzielen kann. Um anwendungsspezifisches Verhalten bereitzustellen, das die Standardanwendungsklasse ergänzt, ändern Sie Platforms/Windows/App.xaml.cs.

Ersetzen Sie den Inhalt der Datei durch folgenden Code:

using SignInMaui.MSALClient;
using Microsoft.Identity.Client;
using Microsoft.UI.Xaml;

// To learn more about WinUI, the WinUI project structure,
// and more about our project templates, see: http://aka.ms/winui-project-info.

namespace SignInMaui.WinUI;

/// <summary>
/// Provides application-specific behavior to supplement the default Application class.
/// </summary>
public partial class App : MauiWinUIApplication
{
    /// <summary>
    /// Initializes the singleton application object.  This is the first line of authored code
    /// executed, and as such is the logical equivalent of main() or WinMain().
    /// </summary>
    public App()
    {
        this.InitializeComponent();

        // configure redirect URI for your application
        PlatformConfig.Instance.RedirectUri = $"msal{PublicClientSingleton.Instance.MSALClientHelper.AzureAdConfig.ClientId}://auth";

        // Initialize MSAL
        IAccount existinguser = Task.Run(async () => await PublicClientSingleton.Instance.MSALClientHelper.InitializePublicClientAppAsync()).Result;

    }

    protected override MauiApp CreateMauiApp() => MauiProgram.CreateMauiApp();

    protected override void OnLaunched(LaunchActivatedEventArgs args)
    {
        base.OnLaunched(args);

        var app = SignInMaui.App.Current;
        PlatformConfig.Instance.ParentWindow = ((MauiWinUIWindow)app.Windows[0].Handler.PlatformView).WindowHandle;
    }
}

Im Code konfigurieren Sie den Umleitungs-URI für die Anwendung, initialisieren die MSAL und legen dann das übergeordnete Fenster für die Anwendung fest. Darüber hinaus überschreiben Sie die OnLaunched-Methode, um das Startereignis zu behandeln und das Handle für das übergeordnete Fenster abzurufen.

Hinzufügen von App-Einstellungen

Einstellungen ermöglichen die Trennung von Daten, die das Verhalten einer App aus dem Code konfigurieren, sodass das Verhalten geändert werden kann, ohne die App neu zu erstellen. MauiAppBuilder bietet ConfigurationManager, um Einstellungen in unserer .NET MAUI-App zu konfigurieren. Fügen wir die appsettings.json Datei als EmbeddedResource hinzu.

Führen Sie zum Erstellen von appsettings.json die folgenden Schritte aus:

  1. Klicken Sie im Projektmappen-Explorer von Visual Studio mit der rechten Maustaste auf das SignInMaui-Projekt und wählen Sie >>.

  2. Wählen Sie web>JavaScript JSON-Konfigurationsdatei aus. Nennen Sie die Datei appsettings.json.

  3. Wählen Sie Hinzufügen aus.

  4. appsettings.jsonauswählen

  5. Legen Sie im Bereich Eigenschaften die Option Buildaktion auf Eingebettete Ressource fest.

  6. Legen Sie im EigenschaftenbereichIn Ausgabeverzeichnis kopieren auf Immer kopieren fest.

  7. Ersetzen Sie den Inhalt der appsettings.json Datei durch den folgenden Code:

    {
  "AzureAd": {
    "Authority": "https://Enter_the_Tenant_Subdomain_Here.ciamlogin.com/",
    "ClientId": "Enter_the_Application_Id_Here",
    "CacheFileName": "msal_cache.txt",
    "CacheDir": "C:/temp"
  },
  "DownstreamApi": {
    "Scopes": "openid offline_access"
  }
}

  8. Finden Sie im appsettings.json den Platzhalter:

    1. Enter_the_Tenant_Subdomain_Here und ersetzen Sie es durch die Verzeichnis-(Mandanten-)Unterdomäne. Wenn Ihre primäre Mandantendomäne z. B. contoso.onmicrosoft.comist, verwenden Sie contoso. Wenn Sie Ihren Mandantennamen nicht kennen, lesen Sie die Informationen unter Abrufen der Details des Mandanten.
    2. Enter_the_Application_Id_Here, und ersetzen Sie ihn mit der Anwendungs-ID (Client-ID) der zuvor von Ihnen registrierten Anwendung.

Verwenden einer benutzerdefinierten URL-Domäne (optional)

Verwenden Sie eine benutzerdefinierte Domäne, um die Authentifizierungs-URL vollständig zu kennzeichnen. Aus Benutzerperspektive verbleiben Benutzer während des Authentifizierungsprozesses in Ihrer Domäne, anstatt zu ciamlogin.com Domänennamen umgeleitet zu werden.

Führen Sie die folgenden Schritte aus, um eine benutzerdefinierte Domäne zu verwenden:

  1. Führen Sie die Schritte unter Aktivieren benutzerdefinierter URL-Domänen für Apps in externen Mandanten aus, um eine benutzerdefinierte URL-Domäne für Ihren externen Mandanten zu aktivieren.

  2. Öffnen sie appsettings.json Datei:

    1. Aktualisieren Sie den Wert der Authority Eigenschaft auf https://Enter_the_Custom_Domain_Here/Enter_the_Tenant_ID_Here. Ersetzen Sie sie Enter_the_Custom_Domain_Here durch Ihre benutzerdefinierte URL-Domäne und Enter_the_Tenant_ID_Here durch Ihre Mandanten-ID. Wenn Sie Ihre Mandanten-ID nicht kennen, finden Sie weitere Informationen unter Auslesen der Details Ihres Mandanten.
    2. Hinzufügen einer knownAuthorities Eigenschaft mit einem Wert [Enter_the_Custom_Domain_Here].

Nachdem Sie die Änderungen an Ihrer appsettings.json Datei vorgenommen haben, wenn Ihre benutzerdefinierte URL-Domäne login.contoso.com ist und Ihre Mandanten-ID aaaabbbb-0000-cccc-1111-ddddd222eeeee ist, sollte die Datei ähnlich wie der folgende Codeausschnitt aussehen:

{
  "AzureAd": {
    "Authority": "https://login.contoso.com/aaaabbbb-0000-cccc-1111-dddd2222eeee",
    "ClientId": "Enter_the_Application_Id_Here",
    "CacheFileName": "msal_cache.txt",
    "CacheDir": "C:/temp",
    "KnownAuthorities": ["login.contoso.com"]
  },
  "DownstreamApi": {
    "Scopes": "openid offline_access"
  }
}

Ausführen und Testen der .NET MAUI-Desktop-App

.NET MAUI-Apps sind für die Ausführung auf mehreren Betriebssystemen und Geräten konzipiert. Sie müssen auswählen, mit welchem Ziel Sie Ihre App testen und debuggen möchten.

Legen Sie das Debugziel in der Visual Studio-Symbolleiste auf das Gerät fest, mit dem Sie debuggen und testen möchten. Die folgenden Schritte veranschaulichen das Festlegen des Debugziels auf Windows:

  1. Wählen Sie die Dropdownliste " Debugziel " aus.
  2. Framework auswählen
  3. net7.0-windows... auswählen

Führen Sie die App aus, indem Sie F5 drücken oder die Wiedergabeschaltfläche oben in Visual Studio auswählen.

  1. Sie können jetzt die .NET MAUI-Beispieldesktopanwendung testen. Nachdem Sie die Anwendung ausgeführt haben, wird automatisch das Fenster der Desktopanwendung angezeigt:

    Screenshot: Anmeldeschaltfläche in der Desktopanwendung

  2. Wählen Sie im daraufhin angezeigten Desktopfenster die Schaltfläche Anmelden aus. Daraufhin wird ein Browserfenster geöffnet, in dem Sie aufgefordert werden, sich anzumelden.

    Screenshot: Benutzereingabeaufforderung zum Eingeben der Anmeldeinformationen in der Desktopanwendung.

    Während des Anmeldevorgangs werden Sie aufgefordert, verschiedene Berechtigungen zu erteilen (damit die Anwendung auf Ihre Daten zugreifen kann). Nach erfolgreicher Anmeldung und Zustimmung wird auf dem Anwendungsbildschirm die Hauptseite angezeigt.

    Screenshot: Hauptseite in der Desktopanwendung nach der Anmeldung.

Nächster Schritt

Tutorial: Hinzufügen von App-Rollen zur .NET MAUI-App und Empfang im ID-Token