Tutoriel : Appeler l’API Microsoft Graph à partir d’une application de plateforme Windows universelle (UWP)
Dans ce tutoriel, vous allez créer une application Plateforme Windows universelle (UWP) native qui connecte les utilisateurs et obtient un jeton d’accès pour appeler l’API Microsoft Graph.
À la fin de ce guide, votre application appelle une API protégée à l’aide de comptes personnels. Outlook.com, live.com, etc. en sont des exemples. Votre application appelle également des comptes professionnels et scolaires de toute entreprise ou organisation possédant Microsoft Entra ID.
Dans ce tutoriel, vous allez :
- Créer un projet de plateforme Windows universelle (UWP) dans Visual Studio
- Inscrire l’application dans le Portail Azure
- Ajouter du code pour prendre en charge la connexion et la déconnexion des utilisateurs
- Ajouter du code pour appeler l’API Microsoft Graph
- Test de l'application
Prérequis
- Visual Studio 2019 avec la charge de travail plateforme Windows universelle de développement installée
Fonctionnement de ce guide
Ce guide crée un exemple d’application UWP qui interroge l’API Microsoft Graph. Pour ce scénario, un jeton est ajouté à des requêtes HTTP via l’en-tête d’autorisation. La bibliothèque d’authentification Microsoft gère les acquisitions et renouvellements de jetons.
Packages NuGet
Ce guide utilise le package NuGet suivant :
| Bibliothèque | Description |
|---|---|
| Microsoft.Identity.Client | Microsoft Authentication Library |
| Microsoft.Graph | Bibliothèque de client Microsoft Graph |
Configuration de votre projet
Cette section fournit des instructions pas à pas pour intégrer une application Windows Desktop .NET (XAML) à la connexion avec Microsoft. L’application peut alors interroger les API web qui nécessitent un jeton, par exemple l’API Microsoft Graph.
Ce guide crée une application qui affiche un bouton permettant d’interroger l’API Microsoft Graph et un bouton permettant de se déconnecter. Elle affiche aussi des zones de texte qui contiennent les résultats des appels.
Conseil
Pour voir une version finalisée du projet que vous créez dans ce tutoriel, vous pouvez la télécharger à partir de GitHub.
Créer votre application
Ouvrez Visual Studio et sélectionnez Créer un projet.
Dans Créer un nouveau projet, choisissez Application vide (Universal Windows) pour C#, puis sélectionnez Suivant.
Dans Configurer votre nouveau projet, nommez l’application, puis sélectionnez Créer.
Si vous y êtes invité, dans Nouveau projet de plateforme Windows universelle, sélectionnez une version pour les versions Cible et Minimale, puis sélectionnez OK.
Ajouter la bibliothèque d’authentification Microsoft à votre projet
Dans Visual Studio, sélectionnez Outils>Gestionnaire de package NuGet>Console du gestionnaire de package.
Copiez et collez les commandes suivantes dans la fenêtre Console du Gestionnaire de package:
Install-Package Microsoft.Identity.Client Install-Package Microsoft.GraphNotes
La première commande installe la bibliothèque d’authentification Microsoft (MSAL.NET). MSAL.NET acquiert, met en cache et actualise les jetons utilisateur accédant aux API qui sont protégées par la plateforme d’identité Microsoft. La deuxième commande installe la bibliothèque de client .NET Microsoft Graph pour authentifier les requêtes soumises à Microsoft Graph et effectuer des appels au service.
Créer l’interface utilisateur de votre application
Visual Studio crée MainPage.xaml dans votre modèle de projet. Ouvrez ce fichier, puis remplacez le nœud Grid de votre application par le code suivant :
<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>
Utiliser la bibliothèque d’authentification Microsoft afin d’obtenir un jeton pour l’API Microsoft Graph
Cette section montre comment utiliser la bibliothèque d’authentification Microsoft afin d’obtenir un jeton pour l’API Microsoft Graph. Apportez des modifications au fichier MainPage.xaml.cs.
Dans MainPage.xaml.cs, ajoutez les références suivantes :
using Microsoft.Identity.Client; using Microsoft.Graph; using Microsoft.Graph.Models; using System.Diagnostics; using System.Threading.Tasks; using System.Net.Http.Headers;Remplacez votre classe
MainPagepar le code suivant :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; } }
Obtenir un jeton utilisateur de manière interactive
La méthode AcquireTokenInteractive affiche une fenêtre qui invite les utilisateurs à se connecter. Les applications imposent généralement aux utilisateurs de se connecter de manière interactive la première fois qu’ils accèdent à une ressource protégée. Ils peuvent également avoir besoin de se connecter en cas d’échec d’une opération en mode silencieux pour obtenir un jeton, par exemple quand le mot de passe d’un utilisateur est arrivé à expiration.
Obtenir un jeton d’utilisateur en mode silencieux
La méthode AcquireTokenSilent gère les acquisitions et renouvellements de jetons sans aucune interaction de l’utilisateur. Après que la méthode AcquireTokenInteractive s’est exécutée pour la première fois et a demandé à l’utilisateur des informations d’identification, utilisez la méthode AcquireTokenSilent pour demander des jetons pour les appels ultérieurs. Cette méthode acquiert les jetons en mode silencieux. La bibliothèque d’authentification Microsoft gère le cache et le renouvellement des jetons.
La méthode AcquireTokenSilent peut échouer. Cet échec peut notamment être dû à une déconnexion de l’utilisateur ou à la modification de son mot de passe sur un autre appareil. Quand la bibliothèque d’authentification Microsoft détecte que le problème nécessite une action interactive, une exception MsalUiRequiredException est levée. Votre application peut gérer cette exception de deux manières :
Votre application appelle immédiatement
AcquireTokenInteractive. Cet appel invite l’utilisateur à se connecter. Normalement, cette approche est réservée aux applications en ligne qui n’ont pas de contenu hors connexion à la disposition de l’utilisateur. L’exemple créé avec cette installation guidée suit ce modèle. Vous le découvrez en action lors de la première exécution de l’exemple.Comme aucun utilisateur n’a encore utilisé l’application,
accounts.FirstOrDefault()contient une valeur null et lève une exceptionMsalUiRequiredException.Le code contenu dans l’exemple gère alors l’exception en appelant
AcquireTokenInteractive. Cet appel invite l’utilisateur à se connecter.Votre application présente une indication visuelle aux utilisateurs qu’ils doivent se connecter. Ils peuvent alors sélectionner le moment opportun pour se connecter. L’application peut réessayer
AcquireTokenSilentultérieurement. Employez cette approche quand les utilisateurs peuvent utiliser d’autres fonctionnalités de l’application sans interruption de service, par exemple lorsque le contenu hors connexion est disponible dans l’application. Dans ce cas, les utilisateurs peuvent décider à quel moment ils se connectent. L’application peut réessayerAcquireTokenSilentà la suite d’une indisponibilité temporaire du réseau.
Instancier le client du service Microsoft Graph en obtenant le jeton à partir de la méthode SignInUserAndGetTokenUsingMSAL
Dans le projet, créez un fichier nommé TokenProvider.cs : cliquez avec le bouton droit sur le projet, sélectionnez Ajouter>un élément>Page vide.
Insérez le code suivant dans le fichier nouvellement créé :
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; }
}
}
Conseil
Après avoir collé le code, assurez-vous que l’espace de noms dans le fichier TokenProvider.cs correspond à l’espace de noms de votre projet. Cela vous permettra de référencer plus facilement la classe TokenProvider dans votre projet.
La classe TokenProvider définit un fournisseur de jetons d’accès personnalisé qui exécute la méthode déléguée spécifiée pour obtenir et retourner un jeton d’accès.
Ajoutez la nouvelle méthode suivante à 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);
}
Dans cette méthode, vous utilisez le fournisseur de jeton d’accès personnalisé TokenProvider pour connecter la méthode SignInUserAndGetTokenUsingMSAL au Kit de développement logiciel (SDK) .NET Microsoft Graph et créer un client authentifié.
Pour utiliser BaseBearerTokenAuthenticationProvider, dans le fichier MainPage.xaml.cs, ajoutez la référence suivante :
using Microsoft.Kiota.Abstractions.Authentication;
Plus d’informations sur l’envoi d’un appel REST à une API protégée
Dans cet exemple d’application, la méthode GetGraphServiceClient instancie GraphServiceClient à l’aide d’un jeton d’accès. GraphServiceClient est ensuite utilisé pour obtenir les informations de profil de l’utilisateur à partir du point de terminaison me.
Ajouter une méthode pour déconnecter l’utilisateur
Pour déconnecter l’utilisateur, ajoutez la méthode suivante au fichier 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 utilise des méthodes asynchrones pour acquérir des jetons ou manipuler des comptes. Vous devez donc prendre en charge les actions d’interface utilisateur dans le thread d’interface utilisateur. C’est ce qui explique la raison de l’appel Dispatcher.RunAsync et des précautions à observer pour appeler ConfigureAwait(false).
Informations supplémentaires sur la déconnexion
La méthode SignOutButton_Click supprime l’utilisateur du cache utilisateur de la bibliothèque d’authentification Microsoft. Cette méthode indique à la bibliothèque d’authentification Microsoft qu’elle doit oublier l’utilisateur actuel. Une demande ultérieure d’acquisition d’un jeton n’aboutit que si elle est interactive.
L’application de cet exemple prend en charge un seul utilisateur, La bibliothèque d’authentification Microsoft prend en charge les scénarios où l’utilisateur peut se connecter à plusieurs comptes. C’est le cas, par exemple, d’une application de messagerie hébergeant plusieurs comptes d’un même utilisateur.
Afficher les informations de base du jeton
Pour afficher les informations de base du jeton, ajoutez la méthode suivante au fichier MainPage.xaml.cs :
/// <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;
}
}
Informations complémentaires
Les jetons d’ID acquis en utilisant OpenID Connect contiennent aussi une petite partie des informations pertinentes pour l’utilisateur. DisplayBasicTokenInfo affiche les informations de base contenues dans le jeton, Ces informations se composent du nom d’affichage et de l’ID de l’utilisateur. Elles comprennent aussi la date d’expiration du jeton et la chaîne qui représente le jeton d’accès proprement dit. Si vous cliquez plusieurs fois sur le bouton Call Microsoft Graph API (Appeler l’API Microsoft Graph), vous pouvez constater que le même jeton a été réutilisé pour les demandes suivantes. Vous pouvez également voir la date d’expiration différée quand la bibliothèque d’authentification Microsoft détermine qu’il est temps de renouveler le jeton.
Afficher un message
Ajoutez la nouvelle méthode suivante à 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;
});
}
Inscrivez votre application
Conseil
Les étapes décrites dans cet article peuvent varier légèrement en fonction du portail de départ.
À présent, inscrivez votre application :
- Connectez-vous au centre d’administration de Microsoft Entra au minimum en tant que Développeur d’application.
- Si vous avez accès à plusieurs tenants, utilisez l’icône Paramètres
dans le menu supérieur pour basculer vers le tenant dans lequel vous voulez inscrire l’application à partir du menu Répertoires + abonnements. - Accédez à Identité>Applications>Inscriptions d’applications.
- Sélectionnez Nouvelle inscription.
- Entrez un nom pour votre application (par exemple,
UWP-App-calling-MSGraph). Les utilisateurs de votre application peuvent voir ce nom, et vous pouvez le changer ultérieurement. - Sous Types de comptes pris en charge, sélectionnez Comptes dans un répertoire d’organisation (tout répertoire Microsoft Entra - Multilocataire) et comptes Microsoft personnels (par exemple, Skype, Xbox).
- Sélectionnez Inscrire.
- Dans la page Vue d’ensemble, recherchez la valeur ID d’application (client) et copiez-la. Revenez dans Visual Studio, ouvrez MainPage.xaml.cs et remplacez la valeur de
ClientIdpar cette valeur.
Configurez l’authentification pour votre application :
- Dans le centre d’administration de Microsoft Entra, sélectionnez Authentification>Ajouter une plateforme, puis sélectionnez Applications mobiles et de bureau.
- Dans la section URI de redirection, entrez
https://login.microsoftonline.com/common/oauth2/nativeclient. - Sélectionnez Configurer.
Configurez des autorisations d’API pour votre application :
- Sélectionnez Autorisations de l’API>Ajouter une autorisation.
- Sélectionnez Microsoft Graph.
- Sélectionnez Autorisations déléguées, recherchez User.Read, puis vérifiez que User.Read est sélectionné.
- Si vous avez apporté des modifications, sélectionnez Ajouter des autorisations pour les enregistrer.
Activer l’authentification intégrée sur des domaines fédérés (facultatif)
Pour activer l’authentification Windows intégrée avec un domaine Microsoft Entra fédéré, le manifeste de l’application doit activer des fonctionnalités supplémentaires. Revenez dans votre application dans Visual Studio.
Ouvrez Package.appxmanifest.
Sélectionnez Capacités, puis activez les paramètres suivants :
- Authentification en entreprise
- Réseaux privés (client et serveur)
- Certificats utilisateur partagés
Important
L’Authentification Windows intégrée n’est pas configurée par défaut pour cet exemple. Les applications qui demandent des capacités Enterprise Authentication ou Shared User Certificates nécessitent un niveau de vérification supérieur de Microsoft Store. Tous les développeurs ne souhaitent pas effectuer la vérification de niveau supérieur. Activez ce paramètre uniquement si vous avez besoin d’utiliser l’authentification Windows intégrée avec un domaine Microsoft Entra fédéré.
Autre approche de l’utilisation de WithDefaultRedirectURI()
Dans l’exemple actuel, la méthode WithRedirectUri("https://login.microsoftonline.com/common/oauth2/nativeclient") est utilisée. Pour utiliser WithDefaultRedirectURI(), effectuez les étapes suivantes :
Dans MainPage.XAML.cs, remplacez
WithRedirectUriparWithDefaultRedirectUri:Code actuel
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();Code mis à jour
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();Recherchez l’URI de rappel de votre application en ajoutant le champ
redirectURIdans MainPage.xaml.cs et en définissant un point d’arrêt sur celui-ci :public sealed partial class MainPage : Page { ... string redirectURI = Windows.Security.Authentication.Web.WebAuthenticationBroker .GetCurrentApplicationCallbackUri().ToString(); public MainPage() { ... } ... }Exécutez l’application, puis copiez la valeur de
redirectUriquand le point d’arrêt est atteint. La valeur doit ressembler à la valeur suivante :ms-app://s-1-15-2-1352796503-54529114-405753024-3540103335-3203256200-511895534-1429095407/Vous pouvez ensuite supprimer la ligne de code, car elle n’est nécessaire qu’une seule fois, pour extraire la valeur.
Dans le centre d’administration de Microsoft Entra, ajoutez la valeur renvoyée dans RedirectUri dans le volet Authentification.
Test de votre code
Pour tester votre application, appuyez sur la touche F5 afin d’exécuter votre projet dans Visual Studio. Votre fenêtre principale s’affiche :
Lorsque vous êtes prêt à passer aux tests, sélectionnez Call Microsoft Graph API (Appeler l’API Microsoft Graph). Utilisez ensuite un compte professionnel Microsoft Entra ou un compte Microsoft (par exemple, live.com ou outlook.com) pour vous connecter. La première fois qu’un utilisateur exécute ce test, l’application affiche une fenêtre lui demandant de se connecter.
Consentement
La première fois que vous vous connectez à votre application, un écran de consentement semblable l’image suivante s’affiche. Sélectionnez Oui pour donner explicitement votre consentement pour l’accès :
Résultats attendus
Les informations de profil utilisateur retournées par l’appel de l’API Microsoft Graph s’affichent dans l’écran API Call Results (Résultats de l’appel d’API) :
Des informations de base sur le jeton obtenu via AcquireTokenInteractive ou AcquireTokenSilent s’affichent également dans la zone Token Info (Informations sur le jeton) :
| Propriété | Format | Description |
|---|---|---|
Username |
user@domain.com |
Nom qui identifie l’utilisateur. |
Token Expires |
DateTime |
L’heure d’expiration du jeton. La bibliothèque d’authentification Microsoft repousse la date d’expiration en renouvelant le jeton si nécessaire. |
Informations supplémentaires sur les étendues et les autorisations déléguées
L’API Microsoft Graph nécessite l’étendue user.read pour lire le profil d’un utilisateur. Par défaut, cette étendue est ajoutée à toutes les applications inscrites sur le portail d’inscription de l’application. D’autres API pour Microsoft Graph et des API personnalisées pour votre serveur back-end peuvent nécessiter des étendues supplémentaires. Par exemple, l’API Microsoft Graph nécessite l’étendue Calendars.Read pour lister les calendriers de l’utilisateur.
Pour accéder aux calendriers de l’utilisateur dans le contexte d’une application, ajoutez l’autorisation déléguée Calendars.Read aux informations d’inscription de l’application. Ajoutez ensuite l’étendue Calendars.Read à l’appel acquireTokenSilent.
Les utilisateurs peuvent être invités à donner des consentements supplémentaires lorsque vous augmentez le nombre d’étendues.
Problèmes connus
Problème 1
Vous recevez l’un des messages d’erreur suivants quand vous vous connectez à votre application dans un domaine Microsoft Entra fédéré :
- « Aucun certificat client valide trouvé dans la demande. »
- « Aucun certificat valide trouvé dans le magasin de certificats de l’utilisateur. »
- « Réessayez en choisissant une autre méthode d’authentification. »
Cause : les fonctionnalités d’entreprise et de certificats ne sont pas activées.
Solution : Suivez les étapes décrites dans Activer l’authentification intégrée sur des domaines fédérés (facultatif).
Problème 2
Vous activez l’authentification intégrée sur des domaines fédérés et vous essayez d’utiliser Windows Hello sur un ordinateur Windows 10 pour vous connecter à un environnement dans lequel l’authentification multifacteur est configurée. La liste des certificats s’affiche. Si vous choisissez d’utiliser votre code confidentiel, la fenêtre correspondante ne s’affiche jamais.
Cause : Ce problème est une limitation connue du répartiteur d’authentification web dans les applications UWP qui s’exécutent sur des ordinateurs de bureau Windows 10. Il fonctionne correctement sur Windows 10 Mobile.
Solution de contournement : sélectionnez Connexion avec d’autres options, puis Sign in with a username and password (Se connecter avec un nom d’utilisateur et un mot de passe). Sélectionnez Provide your password (Indiquer votre mot de passe), puis passez au processus d’authentification par téléphone.
Aide et support
Si vous avez besoin d’aide, si vous souhaitez signaler un problème ou si vous voulez en savoir plus sur vos options de support, consultez Aide et support pour les développeurs.
Étapes suivantes
En savoir plus sur l’utilisation de la Bibliothèque d’authentification Microsoft (MSAL) pour l’autorisation et l’authentification dans les applications .NET :