Esercitazione: Chiamare l'API Microsoft Graph da un'applicazione UWP (piattaforma UWP (Universal Windows Platform))
In questa esercitazione verrà creata un'app UWP (Universal Windows Platform) nativa che concede l'accesso agli utenti e ottiene un token di accesso per chiamare l'API Microsoft Graph.
Al termine di questa guida, l'applicazione chiama un'API protetta usando account personali. Esempi sono outlook.com, live.com e altri. L'applicazione chiama anche gli account aziendali e dell'istituto di istruzione da qualsiasi azienda o organizzazione con ID Microsoft Entra.
Contenuto dell'esercitazione:
- Creare un progetto Piattaforma UWP (Universal Windows Platform) in Visual Studio
- Registrare l'applicazione nel portale di Azure
- Aggiungere il codice per supportare l'accesso e la disconnessione
- Aggiungere il codice per chiamare l'API Microsoft Graph
- Testare l'app
Prerequisiti
- Visual Studio 2019 con il carico di lavoro Sviluppo di app per la piattaforma UWP (Universal Windows Platform) installato
Come interpretare questa guida
Questa guida crea un'applicazione della piattaforma UWP di esempio che esegue query sull'API Microsoft Graph. Per questo scenario, viene aggiunto un token alle richieste HTTP usando l'intestazione Authorization. Le acquisizioni e i rinnovi di token sono gestiti da Microsoft Authentication Library.
Pacchetti NuGet
Questa guida usa il pacchetto NuGet seguente:
| Libreria | Descrizione |
|---|---|
| Microsoft.Identity.Client | Libreria di Autenticazione Microsoft |
| Microsoft.Graph | Libreria client di Microsoft Graph |
Impostare il progetto
Questa sezione fornisce le istruzioni dettagliate per integrare un'applicazione Windows Desktop .NET (XAML) con Accedi con Microsoft. L'applicazione può quindi eseguire una query sulle API Web che richiedono un token, ad esempio l'API Microsoft Graph.
Questa guida crea un'applicazione che visualizza un pulsante che esegue una query sull'API Microsoft Graph e un pulsante per disconnettersi. Vengono inoltre visualizzate caselle di testo che contengono i risultati delle chiamate.
Suggerimento
Per visualizzare una versione completa del progetto compilato in questa esercitazione, è possibile scaricarla da GitHub.
Creare l'applicazione
Aprire Visual Studio e selezionare Crea un nuovo progetto.
In Crea un nuovo progetto scegliere App vuota (Windows universale) per C# e selezionare Avanti.
In Configura il nuovo progetto assegnare un nome al progetto e selezionare Crea.
Se richiesto, in Nuovo progetto della piattaforma UWP (Universal Windows Platform) selezionare una versione qualsiasi per Destinazione e Minima e fare clic su OK.
Aggiungere Microsoft Authentication Library al progetto
In Visual Studio, seleziona Strumenti>Gestione pacchetti NuGet>Console di gestione pacchetti.
Nella finestra Console di Gestione pacchetti copiare e incollare i comandi seguenti:
Install-Package Microsoft.Identity.Client Install-Package Microsoft.GraphNota
Il primo comando installa Microsoft Authentication Library (MSAL.NET). MSAL.NET acquisisce, memorizza nella cache e aggiorna i token utente che accedono alle API protette da Microsoft Identity Platform. Il secondo comando installa la libreria client di Microsoft Graph per .NET per autenticare le richieste a Microsoft Graph ed effettuare chiamate al servizio.
Creare l'interfaccia utente dell'applicazione
Visual Studio crea il file MainPage.xaml nel modello di progetto. Aprire il file e sostituire il nodo Grid dell'applicazione con il codice seguente:
<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>
Usare Microsoft Authentication Library per ottenere un token per l'API Microsoft Graph
Questa sezione illustra come usare Microsoft Authentication Library per ottenere un token per l'API Microsoft Graph. Apportare le modifiche al file MainPage.xaml.cs.
In MainPage.xaml.cs aggiungere i riferimenti seguenti:
using Microsoft.Identity.Client; using Microsoft.Graph; using Microsoft.Graph.Models; using System.Diagnostics; using System.Threading.Tasks; using System.Net.Http.Headers;Sostituire la classe
MainPagecon il codice seguente: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; } }
Ottenere un token utente in modo interattivo
Con il metodo AcquireTokenInteractive viene visualizzata una finestra in cui viene chiesto agli utenti di eseguire l'accesso. Le applicazioni in genere richiedono agli utenti di eseguire l'accesso in modo interattivo quando accedono per la prima volta a una risorsa protetta. Potrebbe essere necessario eseguire l'accesso anche quando un'operazione invisibile all'utente per l'acquisizione di un token ha esito negativo. Ad esempio, quando scade la password dell'utente.
Ottenere un token utente in modo automatico
Il metodo AcquireTokenSilent gestisce le acquisizioni e i rinnovi dei token senza alcuna interazione da parte dell'utente. Dopo che AcquireTokenInteractive viene eseguito per la prima volta e vengono richieste le credenziali all'utente, usare il metodo AcquireTokenSilent per richiedere i token per le chiamate successive. Questo metodo acquisisce i token in modo invisibile all'utente. La memorizzazione nella cache e il rinnovo dei token sono gestiti da Microsoft Authentication Library.
Il metodo AcquireTokenSilent avrà infine esito negativo. L'errore può dipendere dall'utente che ha eseguito la disconnessione o ha modificato la password in un altro dispositivo. Se Microsoft Authentication Library rileva che per risolvere il problema è necessaria un'azione interattiva, genera un'eccezione MsalUiRequiredException. L'applicazione può gestire questa eccezione in due modi:
L'applicazione chiama immediatamente
AcquireTokenInteractive. e richiedere così all'utente di eseguire l'accesso. Usare in genere questo approccio per le applicazioni online in cui non è disponibile contenuto offline per l'utente. L'esempio generato da questa configurazione guidata segue il modello. Lo si può vedere in azione la prima volta che si esegue l'esempio.Dal momento che nessun utente ha usato l'applicazione,
accounts.FirstOrDefault()contiene un valore Null e viene generata un'eccezioneMsalUiRequiredException.Il codice nell'esempio gestisce quindi l'eccezione chiamando
AcquireTokenInteractive. e richiedere così all'utente di eseguire l'accesso.L'applicazione presenta agli utenti un'indicazione visiva per invitarli a eseguire l'accesso. Possono quindi selezionare il momento adatto per eseguire l'accesso. In alternativa, l'applicazione può provare a eseguire di nuovo
AcquireTokenSilentin un secondo momento. Usare questo approccio quando gli utenti possono usare altre funzionalità dell'applicazione senza interruzioni. Ad esempio, quando il contenuto offline è disponibile nell'applicazione. In questo caso, gli utenti possono decidere quando eseguire l'accesso. L'applicazione può provare a eseguire di nuovoAcquireTokenSilentin un secondo momento nel caso in cui la rete risultasse temporaneamente non disponibile.
Creare un'istanza del client del servizio Microsoft Graph ottenendo il token dal metodo SignInUserAndGetTokenUsingMSAL
Nel progetto creare un nuovo file denominato TokenProvider.cs: fare clic con il pulsante destro del mouse sul progetto, selezionare Aggiungi>nuova pagina vuota elemento>.
Aggiungere al file appena creato il codice seguente:
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; }
}
}
Suggerimento
Dopo aver incollato il codice, assicurarsi che lo spazio dei nomi nel file TokenProvider.cs corrisponda allo spazio dei nomi del progetto. In questo modo sarà possibile fare riferimento più facilmente alla TokenProvider classe nel progetto.
La TokenProvider classe definisce un provider di token di accesso personalizzato che esegue il metodo delegato specificato per ottenere e restituire un token di accesso.
Aggiungere il nuovo metodo seguente a 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);
}
In questo metodo si usa il provider di token di TokenProvider accesso personalizzato per connettere il SignInUserAndGetTokenUsingMSAL metodo a Microsoft Graph .NET SDK e creare un client autenticato.
Per usare BaseBearerTokenAuthenticationProvider, nel file MainPage.xaml.cs aggiungere il riferimento seguente:
using Microsoft.Kiota.Abstractions.Authentication;
Altre informazioni sull'esecuzione di una chiamata REST a un'API protetta
In questa applicazione di esempio il metodo GetGraphServiceClient crea un'istanza di GraphServiceClient usando un token di accesso. Quindi, GraphServiceClient viene usato per ottenere le informazioni sul profilo dell'utente dall'endpoint me.
Aggiungere un metodo per disconnettere l'utente
Per disconnettere l'utente, aggiungere il metodo seguente al file 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 usa metodi asincroni per acquisire i token o modificare gli account. Di conseguenza, supportare le azioni dell'interfaccia utente nel thread dell'interfaccia utente. È per questo motivo che viene effettuata la chiamata a Dispatcher.RunAsync e vengono adottate le precauzioni per chiamare ConfigureAwait(false).
Altre informazioni sulla disconnessione
Il metodo SignOutButton_Click rimuove l'utente dalla cache utente di Microsoft Authentication Library. Questo metodo indica in modo efficace a Microsoft Authentication Library di dimenticare l'utente corrente. Una richiesta futura di acquisizione di un token ha esito positivo solo se è interattiva.
L'applicazione in questo esempio supporta un singolo utente. Microsoft Authentication Library supporta scenari in cui l'utente può accedere a più account. Ad esempio, un'applicazione di posta elettronica in cui un utente gestisce più account.
Visualizzare informazioni di base sui token
Aggiungere il metodo seguente al file MainPage.xaml.cs per visualizzare informazioni di base sul 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;
}
}
Altre informazioni
I token ID acquisiti tramite OpenID Connect includono anche un piccolo subset di informazioni relative all'utente. DisplayBasicTokenInfo visualizza le informazioni di base contenute nel token. Queste informazioni includono il nome visualizzato e l'ID dell'utente, nonché la data di scadenza del token e la stringa che rappresenta il token di accesso stesso. Selezionando più volte il pulsante Chiamare API Microsoft Graph, è possibile notare che lo stesso token è stato riutilizzato per richieste successive. Quando Microsoft Authentication Library stabilisce che è il momento di rinnovare il token, è possibile vedere anche la data di scadenza prolungata.
Visualizza messaggio
Aggiungere il nuovo metodo seguente a 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;
});
}
Registrare l'applicazione
Suggerimento
I passaggi descritti in questo articolo possono variare leggermente in base al portale da cui si inizia.
Registrare ora l'applicazione:
- Accedere all'interfaccia di amministrazione di Microsoft Entra come almeno uno sviluppatore di applicazioni.
- Se si ha accesso a più tenant, usare l'icona Impostazioni nel menu in alto per passare al tenant in cui si vuole registrare l'applicazione dal menu Directory e sottoscrizioni.
- Passare a Applicazioni> di identità>Registrazioni app.
- Seleziona Nuova registrazione.
- In Nome immettere un nome per l'applicazione, ad esempio
UWP-App-calling-MSGraph. Tale nome, che potrebbe essere visualizzato dagli utenti dell'app, può essere modificato in un secondo momento. - In Tipi di account supportati selezionare Account in qualsiasi directory organizzativa (Qualsiasi directory Microsoft Entra - Multi-tenant) e account Microsoft personali (ad esempio Skype, Xbox).
- Selezionare Registra.
- Nella pagina della panoramica individuare il valore di ID applicazione (client) e copiarlo. Tornare a Visual Studio, aprire MainPage.xaml.cs e sostituire il valore di
ClientIdcon questo valore.
Configurare l'autenticazione per l'applicazione:
- Nell'interfaccia di amministrazione di Microsoft Entra selezionare Autenticazione>Aggiungi una piattaforma e quindi selezionare Applicazioni per dispositivi mobili e desktop.
- Nella sezione URI di reindirizzamento immettere
https://login.microsoftonline.com/common/oauth2/nativeclient. - Seleziona Configura.
Configurare le autorizzazioni API per l'applicazione:
- Seleziona Autorizzazioni API>Aggiungi un'autorizzazione.
- Selezionare Microsoft Graph.
- Selezionare Autorizzazioni delegate cercare User.Read e verificare che la voce User.Read sia selezionata.
- Se sono state apportate modifiche, selezionare Aggiungi autorizzazioni per salvarle.
Abilitare l'autenticazione integrata in domini federati (facoltativo)
Per abilitare la autenticazione di Windows integrata quando viene usata con un dominio federato di Microsoft Entra, il manifesto dell'applicazione deve abilitare funzionalità aggiuntive. Tornare all'applicazione in Visual Studio.
Aprire Package.appxmanifest.
Selezionare Funzionalità e abilitare le impostazioni seguenti:
- Autenticazione aziendale
- Reti private (client e server)
- Certificati utente condivisi
Importante
L'Autenticazione integrata di Windows non è configurata per impostazione predefinita per questo esempio. Le applicazioni che richiedono Enterprise Authentication o Shared User Certificates richiedono un livello di verifica superiore in Windows Store. Inoltre, gli sviluppatori desiderano eseguire un livello ulteriore di verifica. Abilitare questa impostazione solo se è necessario integrare autenticazione di Windows con un dominio federato di Microsoft Entra.
Approccio alternativo all'utilizzo di WithDefaultRedirectURI()
Nell'esempio corrente viene usato il metodo WithRedirectUri("https://login.microsoftonline.com/common/oauth2/nativeclient"). Per usare WithDefaultRedirectURI(), seguire questa procedura:
In MainPage.XAML.cs sostituire
WithRedirectUriconWithDefaultRedirectUri:Codice corrente
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();Codice aggiornato
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();Trovare l'URI di callback per l'app aggiungendo il campo
redirectURIin MainPage.xaml.cs e impostando un punto di interruzione su di esso:public sealed partial class MainPage : Page { ... string redirectURI = Windows.Security.Authentication.Web.WebAuthenticationBroker .GetCurrentApplicationCallbackUri().ToString(); public MainPage() { ... } ... }Eseguire l'app e copiare il valore di
redirectUriquando viene raggiunto il punto di interruzione. Il valore dovrebbe essere simile al seguente:ms-app://s-1-15-2-1352796503-54529114-405753024-3540103335-3203256200-511895534-1429095407/È quindi possibile rimuovere la riga di codice perché è necessaria solo una volta, per recuperare il valore.
Nell'interfaccia di amministrazione di Microsoft Entra aggiungere il valore restituito in RedirectUri nel riquadro Autenticazione .
Eseguire test del codice
Per testare l'applicazione, premere F5 per eseguire il progetto in Visual Studio. Verrà visualizzata la finestra principale:
Quando si è pronti per eseguire test, selezionare Call Microsoft Graph API (Chiama API Microsoft Graph). Usare quindi un account aziendale Microsoft Entra o un account Microsoft, ad esempio live.com o outlook.com, per accedere. La prima volta che un utente esegue questo test, l'applicazione visualizza una finestra in cui si richiede all'utente di eseguire l'accesso.
Consenso
La prima volta che si accede all'applicazione, viene visualizzata una schermata di consenso, simile all'immagine seguente. Selezionare Sì per fornire il consenso esplicito all'accesso:
Risultati previsti
Nella schermata Risultati della chiamata API vengono visualizzate le informazioni sul profilo utente restituite dalla chiamata all'API Microsoft Graph:
Nella casella Informazioni sul token vengono visualizzate anche informazioni di base sul token acquisite tramite AcquireTokenInteractive o AcquireTokenSilent:
| Proprietà | Formato | Descrizione |
|---|---|---|
Username |
user@domain.com |
Il nome utente che identifica l'utente. |
Token Expires |
DateTime |
Data e ora in cui scade il token. Microsoft Authentication Library prolunga la data di scadenza rinnovando il token in base alla necessità. |
Altre informazioni sugli ambiti e sulle autorizzazioni delegate
L'API di Microsoft Graph richiede l'ambito user.read per leggere il profilo di un utente. Per impostazione predefinita, questo ambito viene aggiunto in ogni applicazione registrata nel portale di registrazione delle applicazioni. Altre API per Microsoft Graph e le API personalizzate per il server di back-end potrebbero richiedere anche altri ambiti. L'API Microsoft Graph, ad esempio, richiede l'ambito Calendars.Read per elencare i calendari dell'utente.
Per accedere ai calendari dell'utente nel contesto di un'applicazione, aggiungere l'autorizzazione delegata Calendars.Read alle informazioni di registrazione dell'applicazione. Aggiungere quindi l'ambito Calendars.Read alla chiamata ad acquireTokenSilent.
Con l'aumentare del numero di ambiti, è possibile che agli utenti venga chiesto di esprimere anche altri tipi di consenso.
Problemi noti
Problema 1
Quando si accede all'applicazione in un dominio federato di Microsoft Entra, viene visualizzato uno dei seguenti messaggi di errore:
- "Non sono stati trovati certificati client validi nella richiesta."
- "Non sono stati trovati certificati validi nell'archivio certificati dell'utente."
- "Riprovare scegliendo un metodo di autenticazione diverso."
Causa: le funzionalità Enterprise e certificati non sono abilitate.
Soluzione: seguire la procedura descritta in Abilitare l'autenticazione integrata nei domini federati (facoltativo).
Problema 2
Abilitare l'autenticazione integrata in domini federati e provare a usare Windows Hello in un computer Windows 10 per accedere a un ambiente configurato con l'autenticazione a più fattori. Verrà visualizzato l'elenco dei certificati. Se si sceglie di usare il PIN, la finestra PIN non viene mai visualizzata.
Causa: questo problema è una limitazione nota del broker di autenticazione Web nelle applicazioni UWP eseguite nei desktop di Windows 10. Funziona correttamente su Windows 10 Mobile.
Soluzione alternativa: selezionare Accedi con altre opzioni. Selezionare quindi Accedi con nome utente e password. Selezionare Immettere la password. Quindi eseguire il processo di autenticazione del telefono.
Assistenza e supporto
Se è necessaria assistenza, si vuole segnalare un problema o si vogliono ottenere informazioni sulle opzioni di supporto, vedere Assistenza e supporto per gli sviluppatori.
Passaggi successivi
Altre informazioni sull'uso di Microsoft Authentication Library (MSAL) per l'autorizzazione e l'autenticazione in applicazioni .NET: