Dela via

Självstudie: Anropa Microsoft Graph API från ett UWP-program (Universal Windows Platform)

  • Artikel

I den här självstudien skapar du en inbyggd UWP-app (Universal Windows Platform) som loggar in användare och hämtar en åtkomsttoken för att anropa Microsoft Graph API.

I slutet av den här guiden anropar ditt program ett skyddat API med hjälp av personliga konton. Exempel är outlook.com, live.com och andra. Ditt program anropar även arbets- och skolkonton från alla företag eller organisationer som har Microsoft Entra-ID.

I den här självstudien:

  • Skapa ett UWP-projekt (Universal Windows Platform) i Visual Studio
  • Registrera programmet i Azure-portalen
  • Lägga till kod för att stödja användarinloggning och utloggning
  • Lägga till kod för att anropa Microsoft Graph API
  • Testa appen

Förutsättningar

  • Visual Studio 2019 med utvecklingsarbetsbelastningen Universal Windows Platform installerad

Så här fungerar den här guiden

Visar hur exempelappen som genereras av den här självstudien fungerar

Den här guiden skapar ett UWP-exempelprogram som frågar Microsoft Graph-API:et. I det här scenariot läggs en token till i HTTP-begäranden med hjälp av auktoriseringshuvudet. Microsofts autentiseringsbibliotek hanterar tokenförvärv och förnyelser.

MSAL.NET version 4.61.0 och senare ger inte stöd för UWP (Universal Windows Platform), Xamarin Android och Xamarin iOS. Vi rekommenderar att du migrerar dina UWP-program till moderna ramverk som WINUI. Läs mer om utfasningen i Meddelande om kommande utfasning av MSAL.NET för Xamarin och UWP.

NuGet-paket

Den här guiden använder följande NuGet-paket:

Bibliotek beskrivning
Microsoft.Identity.Client Microsofts autentiseringsbibliotek
Microsoft.Graph Microsoft Graph-klientbibliotek

Konfigurera projektet

Det här avsnittet innehåller stegvisa instruktioner för att integrera ett Windows Desktop .NET-program (XAML) med inloggning med Microsoft. Sedan kan programmet köra frågor mot webb-API:er som kräver en token, till exempel Microsoft Graph API.

Den här guiden skapar ett program som visar en knapp som frågar Microsoft Graph API och en knapp för att logga ut. Den visar också textrutor som innehåller resultatet av anropen.

Dricks

Om du vill se en färdig version av projektet som du skapar i den här självstudien kan du ladda ned den från GitHub.

Skapa ditt program

  1. Öppna Visual Studio och välj Skapa ett nytt projekt.

  2. I Skapa ett nytt projekt väljer du Tom app (Universell Windows) för C# och väljer Nästa.

  3. I Konfigurera ditt nya projekt namnger du appen och väljer Skapa.

  4. Om du uppmanas till det väljer du valfri version för Mål- och Minimiversioner i Nytt universellt Windows-plattformsprojekt och väljer OK.

    Lägsta versioner och målversioner

Lägg till Microsoft-autentiseringsbiblioteket i projektet

  1. I Visual Studio, välj Verktyg>NuGet pakethanterare>Pakethanterarkonsol.

  2. Kopiera och klistra in följande kommandon i fönstret Upravljač za pakete Console:

    Install-Package Microsoft.Identity.Client
Install-Package Microsoft.Graph

    Kommentar

    Det första kommandot installerar Microsoft Authentication Library (MSAL.NET). MSAL.NET hämtar, cachelagrar och uppdaterar användartoken som har åtkomst till API:er som skyddas av Microsoft platforma za identitete. Det andra kommandot installerar Microsoft Graph .NET-klientbiblioteket för att autentisera begäranden till Microsoft Graph och göra anrop till tjänsten.

Skapa programmets användargränssnitt

Visual Studio skapar MainPage.xaml som en del av projektmallen. Öppna den här filen och ersätt sedan programmets Grid-nod med följande kod:

<Grid>
    <StackPanel Background="Azure">
        <StackPanel Orientation="Horizontal" HorizontalAlignment="Right">
            <Button x:Name="CallGraphButton" Content="Call Microsoft Graph API" HorizontalAlignment="Right" Padding="5" Click="CallGraphButton_Click" Margin="5" FontFamily="Segoe Ui"/>
            <Button x:Name="SignOutButton" Content="Sign-Out" HorizontalAlignment="Right" Padding="5" Click="SignOutButton_Click" Margin="5" Visibility="Collapsed" FontFamily="Segoe Ui"/>
        </StackPanel>
        <TextBlock Text="API Call Results" Margin="2,0,0,-5" FontFamily="Segoe Ui" />
        <TextBox x:Name="ResultText" TextWrapping="Wrap" MinHeight="120" Margin="5" FontFamily="Segoe Ui"/>
        <TextBlock Text="Token Info" Margin="2,0,0,-5" FontFamily="Segoe Ui" />
        <TextBox x:Name="TokenInfoText" TextWrapping="Wrap" MinHeight="70" Margin="5" FontFamily="Segoe Ui"/>
    </StackPanel>
</Grid>

Använd Microsoft Authentication Library för att hämta en token för Microsoft Graph API

Det här avsnittet visar hur du använder Microsofts autentiseringsbibliotek för att hämta en token för Microsoft Graph-API:et. Gör ändringar i MainPage.xaml.cs-filen.

  1. Lägg till följande referenser i MainPage.xaml.cs:

    using Microsoft.Identity.Client;
using Microsoft.Graph;
using Microsoft.Graph.Models;
using System.Diagnostics;
using System.Threading.Tasks;
using System.Net.Http.Headers;

  2. Ersätt klassen MainPage med följande kod:

    public sealed partial class MainPage : Page
{

    //Set the scope for API call to user.read
    private string[] scopes = new string[] { "user.read" };

    // Below are the clientId (Application Id) of your app registration and the tenant information.
    // You have to replace:
    // - the content of ClientID with the Application Id for your app registration
    private const string ClientId = "[Application Id pasted from the application registration portal]";

    private const string Tenant = "common"; // Alternatively "[Enter your tenant, as obtained from the Azure portal, e.g. kko365.onmicrosoft.com]"
    private const string Authority = "https://login.microsoftonline.com/" + Tenant;

    // The MSAL Public client app
    private static IPublicClientApplication PublicClientApp;

    private static string MSGraphURL = "https://graph.microsoft.com/v1.0/";
    private static AuthenticationResult authResult;

    public MainPage()
    {
        this.InitializeComponent();
    }

    /// <summary>
    /// Call AcquireTokenAsync - to acquire a token requiring user to sign in
    /// </summary>
    private async void CallGraphButton_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            // Sign in user using MSAL and obtain an access token for Microsoft Graph
            GraphServiceClient graphClient = await SignInAndInitializeGraphServiceClient(scopes);

            // Call the /me endpoint of Graph
            User graphUser = await graphClient.Me.GetAsync();

            // Go back to the UI thread to make changes to the UI
            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
            {
                ResultText.Text = "Display Name: " + graphUser.DisplayName + "\nBusiness Phone: " + graphUser.BusinessPhones.FirstOrDefault()
                                  + "\nGiven Name: " + graphUser.GivenName + "\nid: " + graphUser.Id
                                  + "\nUser Principal Name: " + graphUser.UserPrincipalName;
                DisplayBasicTokenInfo(authResult);
                this.SignOutButton.Visibility = Visibility.Visible;
            });
        }
        catch (MsalException msalEx)
        {
            await DisplayMessageAsync($"Error Acquiring Token:{System.Environment.NewLine}{msalEx}");
        }
        catch (Exception ex)
        {
            await DisplayMessageAsync($"Error Acquiring Token Silently:{System.Environment.NewLine}{ex}");
            return;
        }
    }
            /// <summary>
    /// Signs in the user and obtains an access token for Microsoft Graph
    /// </summary>
    /// <param name="scopes"></param>
    /// <returns> Access Token</returns>
    private static async Task<string> SignInUserAndGetTokenUsingMSAL(string[] scopes)
    {
        // Initialize the MSAL library by building a public client application
        PublicClientApp = PublicClientApplicationBuilder.Create(ClientId)
            .WithAuthority(Authority)
            .WithUseCorporateNetwork(false)
            .WithRedirectUri("https://login.microsoftonline.com/common/oauth2/nativeclient")
             .WithLogging((level, message, containsPii) =>
             {
                 Debug.WriteLine($"MSAL: {level} {message} ");
             }, LogLevel.Warning, enablePiiLogging: false, enableDefaultPlatformLogging: true)
            .Build();

        // It's good practice to not do work on the UI thread, so use ConfigureAwait(false) whenever possible.
        IEnumerable<IAccount> accounts = await PublicClientApp.GetAccountsAsync().ConfigureAwait(false);
        IAccount firstAccount = accounts.FirstOrDefault();

        try
        {
            authResult = await PublicClientApp.AcquireTokenSilent(scopes, firstAccount)
                                              .ExecuteAsync();
        }
        catch (MsalUiRequiredException ex)
        {
            // A MsalUiRequiredException happened on AcquireTokenSilentAsync. This indicates you need to call AcquireTokenAsync to acquire a token
            Debug.WriteLine($"MsalUiRequiredException: {ex.Message}");

            authResult = await PublicClientApp.AcquireTokenInteractive(scopes)
                                              .ExecuteAsync()
                                              .ConfigureAwait(false);

        }
        return authResult.AccessToken;
    }
}

Hämta en användartoken interaktivt

Metoden AcquireTokenInteractive resulterar i ett fönster som uppmanar användarna att logga in. Program kräver vanligtvis att användarna loggar in interaktivt första gången för att få åtkomst till en skyddad resurs. De kan också behöva logga in när en tyst åtgärd för att hämta en token misslyckas. Ett exempel är när en användares lösenord har upphört att gälla.

Hämta en token obevakat

Metoden AcquireTokenSilent hanterar tokenförvärv och förnyelser utan någon användarinteraktion. När AcquireTokenInteractive du har kört för första gången och frågat användaren om autentiseringsuppgifter använder du AcquireTokenSilent metoden för att begära token för senare anrop. Den metoden hämtar token tyst. Microsofts autentiseringsbibliotek hanterar tokencache och förnyelse.

AcquireTokenSilent Så småningom misslyckas metoden. Orsaker till fel är en användare som har loggat ut eller ändrat sitt lösenord på en annan enhet. När Microsofts autentiseringsbibliotek upptäcker att problemet kräver en interaktiv åtgärd utlöser det ett MsalUiRequiredException undantag. Ditt program kan hantera det här undantaget på två sätt:

  • Programmet anropar AcquireTokenInteractive omedelbart. Det här samtalet leder till att användaren uppmanas att logga in. Använd normalt den här metoden för onlineprogram där det inte finns något tillgängligt offlineinnehåll för användaren. Exemplet som genereras av den här guidade installationen följer mönstret. Du ser den i praktiken första gången du kör exemplet.

    Eftersom ingen användare har använt programmet, accounts.FirstOrDefault() innehåller ett null-värde och genererar ett MsalUiRequiredException undantag.

    Koden i exemplet hanterar sedan undantaget genom att anropa AcquireTokenInteractive. Det här samtalet leder till att användaren uppmanas att logga in.

  • Ditt program visar en visuell indikation för användare att de behöver logga in. Sedan kan de välja rätt tid för att logga in. Programmet kan försöka AcquireTokenSilent igen senare. Använd den här metoden när användare kan använda andra programfunktioner utan avbrott. Ett exempel är när offlineinnehåll är tillgängligt i programmet. I det här fallet kan användarna bestämma när de vill logga in. Programmet kan försöka AcquireTokenSilent igen när nätverket inte är tillgängligt för tillfället.

Instansiera Microsoft Graph-tjänstklienten genom att hämta token från metoden SignInUserAndGetTokenUsingMSAL

I projektet skapar du en ny fil med namnet TokenProvider.cs: högerklicka på projektet och välj Lägg till>nytt objekt>tom sida.

Lägg till följande kod i den nyligen skapade filen:

using Microsoft.Kiota.Abstractions.Authentication;
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace UWP_app_MSGraph {
    public class TokenProvider : IAccessTokenProvider {
        private Func<string[], Task<string>> getTokenDelegate;
        private string[] scopes;

        public TokenProvider(Func<string[], Task<string>> getTokenDelegate, string[] scopes) {
            this.getTokenDelegate = getTokenDelegate;
            this.scopes = scopes;
        }

        public Task<string> GetAuthorizationTokenAsync(Uri uri, Dictionary<string, object> additionalAuthenticationContext = default,
            CancellationToken cancellationToken = default) {
            return getTokenDelegate(scopes);
        }

        public AllowedHostsValidator AllowedHostsValidator { get; }
    }
}

Dricks

När du har klistrat in koden kontrollerar du att namnområdet i TokenProvider.cs-filen matchar namnområdet för projektet. På så sätt kan du enklare referera TokenProvider till klassen i projektet.

Klassen TokenProvider definierar en anpassad åtkomsttokenprovider som kör den angivna ombudsmetoden för att hämta och returnera en åtkomsttoken.

Lägg till följande nya metod i MainPage.xaml.cs:

      /// <summary>
     /// Sign in user using MSAL and obtain a token for Microsoft Graph
     /// </summary>
     /// <returns>GraphServiceClient</returns>
     private async static Task<GraphServiceClient> SignInAndInitializeGraphServiceClient(string[] scopes)
     {
         var tokenProvider = new TokenProvider(SignInUserAndGetTokenUsingMSAL, scopes);
         var authProvider = new BaseBearerTokenAuthenticationProvider(tokenProvider);
         var graphClient = new GraphServiceClient(authProvider, MSGraphURL);

         return await Task.FromResult(graphClient);
     }

I den här metoden använder du providern TokenProvider för anpassad åtkomsttoken för att ansluta metoden till Microsoft Graph .NET SDK och skapa en autentiserad SignInUserAndGetTokenUsingMSAL klient.

Om du vill använda BaseBearerTokenAuthenticationProvider, i filen MainPage.xaml.cs lägger du till följande referens:

using Microsoft.Kiota.Abstractions.Authentication;

Mer information om hur du gör ett REST-anrop mot ett skyddat API

I det här exempelprogrammet GetGraphServiceClient instansierar GraphServiceClient metoden med hjälp av en åtkomsttoken. GraphServiceClient Sedan används för att hämta användarens profilinformation från mig-slutpunkten.

Lägga till en metod för att logga ut användaren

Om du vill logga ut användaren lägger du till följande metod i MainPage.xaml.cs:

/// <summary>
/// Sign out the current user
/// </summary>
private async void SignOutButton_Click(object sender, RoutedEventArgs e)
{
    IEnumerable<IAccount> accounts = await PublicClientApp.GetAccountsAsync().ConfigureAwait(false);
    IAccount firstAccount = accounts.FirstOrDefault();

    try
    {
        await PublicClientApp.RemoveAsync(firstAccount).ConfigureAwait(false);
        await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
        {
            ResultText.Text = "User has signed out";
            this.CallGraphButton.Visibility = Visibility.Visible;
                this.SignOutButton.Visibility = Visibility.Collapsed;
            });
        }
        catch (MsalException ex)
        {
            ResultText.Text = $"Error signing out user: {ex.Message}";
        }
    }

MSAL.NET använder asynkrona metoder för att hämta token eller manipulera konton. Därför stöder du användargränssnittsåtgärder i användargränssnittstråden. Det här är orsaken till anropet Dispatcher.RunAsync och försiktighetsåtgärderna för att anropa ConfigureAwait(false).

Mer information om att logga ut

Metoden SignOutButton_Click tar bort användaren från användarcachen för Microsoft-autentiseringsbiblioteket. Den här metoden talar effektivt om för Microsofts autentiseringsbibliotek att den aktuella användaren ska glömmas bort. En framtida begäran om att hämta en token lyckas bara om den är interaktiv.

Programmet i det här exemplet stöder en enskild användare. Microsofts autentiseringsbibliotek stöder scenarier där användaren kan logga in på fler än ett konto. Ett exempel är ett e-postprogram där en användare har flera konton.

Visa grundläggande tokeninformation

Lägg till följande metod för att MainPage.xaml.cs för att visa grundläggande information om token:

/// <summary>
/// Display basic information contained in the token. Needs to be called from the UI thread.
/// </summary>
private void DisplayBasicTokenInfo(AuthenticationResult authResult)
{
    TokenInfoText.Text = "";
    if (authResult != null)
    {
        TokenInfoText.Text += $"User Name: {authResult.Account.Username}" + Environment.NewLine;
        TokenInfoText.Text += $"Token Expires: {authResult.ExpiresOn.ToLocalTime()}" + Environment.NewLine;
    }
}

Mer information

ID-token som hämtas med hjälp av OpenID Connect innehåller också en liten delmängd information som är relevant för användaren. DisplayBasicTokenInfo visar grundläggande information som finns i token. Den här informationen innehåller användarens visningsnamn och ID. Den innehåller också förfallodatumet för token och strängen som representerar själva åtkomsttoken. Om du väljer knappen Anropa Microsoft Graph API flera gånger ser du att samma token återanvänddes för senare begäranden. Du kan också se att förfallodatumet förlängs när Microsofts autentiseringsbibliotek bestämmer sig för att det är dags att förnya token.

Visa meddelande

Lägg till följande nya metod i MainPage.xaml.cs:

/// <summary>
/// Displays a message in the ResultText. Can be called from any thread.
/// </summary>
private async Task DisplayMessageAsync(string message)
{
     await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal,
         () =>
         {
             ResultText.Text = message;
         });
     }

Registrera ditt program

Dricks

Stegen i den här artikeln kan variera något beroende på vilken portal du börjar från.

Registrera nu ditt program:

  1. Logga in på administrationscentret för Microsoft Entra som minst programutvecklare.
  2. Om du har åtkomst till flera klienter använder du ikonen Inställningar på den översta menyn för att växla till den klientorganisation där du vill registrera programmet från menyn Kataloger + prenumerationer.
  3. Bläddra till Appregistreringar för identitetsprogram>>.
  4. Välj Ny registrering.
  5. Ange ett namn för ditt program, till exempel UWP-App-calling-MSGraph. Användare av din app kan se det här namnet och du kan ändra det senare.
  6. Under Kontotyper som stöds väljer du Konton i valfri organisationskatalog (Alla Microsoft Entra-kataloger – Multitenant) och personliga Microsoft-konton (t.ex. Skype, Xbox).
  7. Välj Registrera.
  8. På översiktssidan hittar du värdet program-ID (klient) och kopierar det. Gå tillbaka till Visual Studio, öppna MainPage.xaml.cs och ersätt värdet ClientId för med det här värdet.

Konfigurera autentisering för ditt program:

  1. I administrationscentret för Microsoft Entra väljer du Autentisering>Lägg till en plattform och väljer sedan Mobil- och skrivbordsprogram.
  2. I avsnittet Omdirigerings-URI:er anger du https://login.microsoftonline.com/common/oauth2/nativeclient.
  3. Välj Konfigurera.

Konfigurera API-behörigheter för ditt program:

  1. Välj API-behörigheter>Lägg till en behörighet.
  2. Välj Microsoft Graph.
  3. Välj Delegerade behörigheter, sök efter User.Read och kontrollera att User.Read är valt.
  4. Om du har gjort några ändringar väljer du Lägg till behörigheter för att spara dem.

Aktivera integrerad autentisering på federerade domäner (valfritt)

För att aktivera integrerad Windows-autentisering när den används med en federerad Microsoft Entra-domän måste programmanifestet aktivera ytterligare funktioner. Gå tillbaka till ditt program i Visual Studio.

  1. Öppna Package.appxmanifest.

  2. Välj Funktioner och aktivera följande inställningar:

    • Företagsautentisering
    • Privata nätverk (klient och server)
    • Certifikat för delad användare

Viktigt!

Integrerad Windows-autentisering har inte konfigurerats som standard för det här exemplet. Program som begär Enterprise Authentication eller Shared User Certificates funktioner kräver en högre verifieringsnivå av Windows Store. Dessutom vill inte alla utvecklare utföra den högre verifieringsnivån. Aktivera endast den här inställningen om du behöver integrerad Windows-autentisering med en federerad Microsoft Entra-domän.

Alternativ metod för att använda WithDefaultRedirectURI()

I det aktuella exemplet WithRedirectUri("https://login.microsoftonline.com/common/oauth2/nativeclient") används metoden. Utför följande steg för att använda WithDefaultRedirectURI():

  1. I MainPage.XAML.cs ersätter du WithRedirectUri med WithDefaultRedirectUri:

    Aktuell kod

    
PublicClientApp = PublicClientApplicationBuilder.Create(ClientId)
    .WithAuthority(Authority)
    .WithUseCorporateNetwork(false)
    .WithRedirectUri("https://login.microsoftonline.com/common/oauth2/nativeclient")
    .WithLogging((level, message, containsPii) =>
     {
         Debug.WriteLine($"MSAL: {level} {message} ");
     }, LogLevel.Warning, enablePiiLogging: false, enableDefaultPlatformLogging: true)
    .Build();

    Uppdaterad kod

    
PublicClientApp = PublicClientApplicationBuilder.Create(ClientId)
    .WithAuthority("https://login.microsoftonline.com/common")
    .WithUseCorporateNetwork(false)
    .WithDefaultRedirectUri()
    .WithLogging((level, message, containsPii) =>
     {
         Debug.WriteLine($"MSAL: {level} {message} ");
     }, LogLevel.Warning, enablePiiLogging: false, enableDefaultPlatformLogging: true)
    .Build();

  2. Hitta återanrops-URI:n för din app genom att lägga till redirectURI fältet i MainPage.xaml.cs och ange en brytpunkt på den:

    
public sealed partial class MainPage : Page
{
        ...

        string redirectURI = Windows.Security.Authentication.Web.WebAuthenticationBroker
                            .GetCurrentApplicationCallbackUri().ToString();
        public MainPage()
        {
            ...
        }
       ...
}

    Kör appen och kopiera sedan värdet redirectUri för när brytpunkten nås. Värdet bör se ut ungefär så här: ms-app://s-1-15-2-1352796503-54529114-405753024-3540103335-3203256200-511895534-1429095407/

    Du kan sedan ta bort kodraden eftersom den bara krävs en gång för att hämta värdet.

  3. I administrationscentret för Microsoft Entra lägger du till det returnerade värdet i RedirectUri i fönstret Autentisering .

Testa koden

Om du vill testa programmet väljer du F5-nyckeln för att köra projektet i Visual Studio. Huvudfönstret visas:

Programmets användargränssnitt

När du är redo att testa väljer du Anropa Microsoft Graph API. Använd sedan ett Microsoft Entra-organisationskonto eller ett Microsoft-konto, till exempel live.com eller outlook.com, för att logga in. Första gången en användare kör det här testet visar programmet ett fönster där användaren uppmanas att logga in.

Första gången du loggar in på ditt program visas en medgivandeskärm som liknar följande bild. Välj Ja för att uttryckligen samtycka till åtkomst:

Åtkomstmedgivandeskärm

Förväntat resultat

Du ser användarprofilinformation som returneras av Microsoft Graph API-anropet på skärmen API-anropsresultat :

Skärmen API-anropsresultat

Du ser också grundläggande information om token som hämtas via AcquireTokenInteractive eller AcquireTokenSilent i rutan Tokeninformation :

Property Format beskrivning
Username user@domain.com Användarnamnet som identifierar användaren.
Token Expires DateTime Tiden då token upphör att gälla. Microsofts autentiseringsbibliotek förlänger förfallodatumet genom att förnya token efter behov.

Mer information om omfång och delegerade behörigheter

Microsoft Graph API kräver omfånget user.read för att läsa en användares profil. Det här omfånget läggs till som standard i varje program som är registrerat i programregistreringsportalen. Andra API:er för Microsoft Graph och anpassade API:er för serverdelsservern kan kräva ytterligare omfång. Till exempel kräver Microsoft Graph-API:et omfånget Calendars.Read för att visa användarens kalendrar.

Om du vill komma åt användarens kalendrar i kontexten för ett program lägger du till den Calendars.Read delegerade behörigheten i programregistreringsinformationen. Lägg sedan till omfånget Calendars.Read i anropet acquireTokenSilent .

Användare kan uppmanas att ange ytterligare medgivanden när du ökar antalet omfång.

Kända problem

Problem 1

Du får något av följande felmeddelanden när du loggar in på ditt program på en federerad Microsoft Entra-domän:

  • "Inget giltigt klientcertifikat hittades i begäran."
  • "Inga giltiga certifikat hittades i användarens certifikatarkiv."
  • "Försök igen med att välja en annan autentiseringsmetod."

Orsak: Företags- och certifikatfunktioner är inte aktiverade.

Lösning: Följ stegen i Aktivera integrerad autentisering på federerade domäner (valfritt).

Problem 2

Du aktiverar integrerad autentisering på federerade domäner och försöker använda Windows Hello på en Windows 10-dator för att logga in i en miljö med multifaktorautentisering konfigurerad. Listan över certifikat visas. Om du väljer att använda din PIN-kod visas aldrig PIN-fönstret.

Orsak: Det här problemet är en känd begränsning för webbautentiseringskoordinatorn i UWP-program som körs på Windows 10-skrivbord. Det fungerar bra på Windows 10 Mobile.

Lösning: Välj Logga in med andra alternativ. Välj sedan Logga in med ett användarnamn och lösenord. Välj Ange ditt lösenord. Gå sedan igenom processen för telefonautentisering.

Hjälp och support

Om du behöver hjälp, vill rapportera ett problem eller vill lära dig mer om dina supportalternativ kan du läsa Hjälp och support för utvecklare.

Nästa steg

Läs mer om att använda Microsoft Authentication Library (MSAL) för auktorisering och autentisering i .NET-program:

Översikt över Microsoft autentiseringsbibliotek (MSAL)