Table of contents
TOC
Réduire la table des matières
Développer la table des matières
Dernière mise à jour: 20/06/2018

Intégrer les API Office 365 dans des projets .NET Visual Studio

Concerne : Office 365

Après avoir ajouté un service Office 365 à votre projet, vous devrez écrire du code pour authentifier l'utilisateur de l'application et accède à ses données Office 365.

Le processus d'authentification est différent selon que vous créez une application web, telle qu'une MVC, ou une application native, telle qu'une application du Windows Store. Sélectionnez l'un des liens ci-dessous pour accéder à un exemple de création d'une application qui utilise les API Office 365 :

Remarque Ces procédures pas à pas utilisent la dernière version des Outils de développement Office pour Visual Studio. Si vous utilisez des versions antérieures des outils, vous devrez mettre à niveau vers la dernière version pour vous assurer que le code de ces exemples fonctionne correctement pour vous.

Intégration des API Office 365 dans un projet Visual Studio MVC

L'exemple que nous allons créer sera un MVC à tenant unique qui utilise l'authentification unique Azure AD pour authentifier et lire les informations de contact de l'utilisateur à partir d'Office 365. Nous utiliserons pour modèle le Projet MVC Office 365 à tenant unique sur GitHub.

L'application emploiera un cache persistant de jetons de la Bibliothèque d'authentification Active Directory (ADAL) qui utilise une base de données pour la mise en cache. ADAL vous permet d'authentifier les utilisateurs sur Active Directory (AD), dans ce cas Azure AD, puis d'obtenir des jetons d'accès pour sécuriser les appels d'API.

Pour réussir à développer cet exemple, vous devrez avoir défini les autorisations suivantes pour les API Office 365.

  • Pour les API Utilisateurs et groupes, définissez des autorisations à Activer la connexion et lire le profil des utilisateurs.

  • Pour les API Contacts, définissez des autorisations à Lire les contacts des utilisateurs.

Pour ouvrir les outils Office 365 et vous assurez que vous avez défini les autorisations ci-dessus, dans l' Explorateur de solutions, cliquez avec le bouton droit sur le projet et sélectionnez Ajouter > Service connecté.

Le développement de l'exemple se compose ensuite de trois étapes majeures :

Configurer votre projet pour l'authentification avec Azure Active Directory

Puisque l'exemple que nous construisons ne nécessite que l'authentification des informations d'identification Office 365, nous utiliserons OWINKatana et Bibliothèque d'authentification Active Directory (ADAL).

Mais d'abord, configurons le projet pour utiliser Secure Socket Layers (SSL).

Activez SSL pour votre projet

Visual Studio ne configure pas votre projet pour SSL par défaut. Si vous n'avez pas encore activé SSL dans votre projet, vous devez le faire maintenant, puis mettre à jour les services Office 365 avec l'URL de redirection appropriée.

Pour activer SSL :

  1. Dans l'Explorateur de solutions, cliquez sur le projet.
  2. Dans Propriétés, définissez SSL activé à Vrai.

    Visual Studio spécifie une valeur pour l'URL SSL.

Ensuite, nous mettrons à jour l'application pour utiliser le point de terminaison HTTPS pour la page d'accueil :

  1. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet et sélectionnez Propriétés.
  2. Sélectionnez l'onglet Web. Sous Serveurs, définissezURL du projet au point de terminaison HTTPS Visual Studio créé pour l'URL SSL.

Enfin, nous mettrons à jour les services Office 365 :

  1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet et sélectionnez Ajouter > Service connecté. Connectez-vous si nécessaire.

    Visual Studio vous indique qu'une ou plusieurs URL de redirection dans votre projet n'existent pas dans l'entrée de votre application dans Azure AD.

  2. Cliquez sur Oui pour ajouter l'URL de redirection sécurisée à votre entrée d'application dans Azure AD.

  3. Cliquez sur OK pour quitter le Gestionnaire de services.

Gérer les packages NuGet nécessaires à l'authentification

Vous devrez installer les packages Azure AD et OWIN Katana suivants pour l'authentification :

Ces packages peuvent également installer des packages NuGet sélectionnés en tant que dépendances.

Pour télécharger et installer les packages NuGet :

  1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet.
  2. Sélectionnez Gérer les packages NuGet...
  3. Dans Gérer les packages NuGet, cliquez sur En ligne.
  4. Utilisez la zone de recherche pour trouver le package nécessaire.
  5. Sélectionnez le package et cliquez sur Installer.
  6. Dans Sélectionner des projets, cliquez sur OK.
  7. Acceptez les licences aux invites.

Mettez à jour le fichier web.config pour activer l'authentification

Lorsque vous avez ajouté des services Office 365 à votre projet, Visual Studio a ajouté dans votre solution les propriétés suivantes au registre de votre application dans Azure AD, et au fichier web.config :

<add key="ida:ClientId" value="app-azure-ad-client-id" />
<add key="ida:ClientSecret" value="app-azure-ad-password" />
<add key="ida:TenantId" value="azure-tenant-where-app-is-registered" />
<add key="ida:AADInstance" value="https://login.microsoftonline.com/" 

Créer une base de données pour gérer les jetons d'authentification ADAL

Ajoutons maintenant une base de données au projet, qui agira comme notre cache de jetons ADAL.

Pour plus d'informations sur le cache de jetons ADAL, consultez Le nouveau cache de jetons dans ADAL v2.

Pour ajouter la base de données qui servira de cache de jetons ADAL :

  1. Dans l'Explorateur de solutions, cliquez avec le bouton droit de la souris sur le dossier App_Data, puis sélectionnez Ajouter > Nouvel élément...
  2. Assurez-vous que Données est sélectionné, puis sélectionnez Base de données SQL Server. Nommez la base de données ADALTokenCacheDbet cliquez sur Ajouter.

Assurez-vous que la connexion à la base de données a été ajoutée au projet web.config:

  1. Dans l'Explorateur de solutions, double-cliquez sur web.config.
  2. Assurez-vous que la section suivante a été ajoutée au fichier web.config après la section appSettings. Si ce n'est pas le cas, ajoutez-la :
<connectionStrings>
    <add name="DefaultConnection"
     connectionString="Data Source=(LocalDB)\v11.0;AttachDbFilename=|DataDirectory|\ADALTokenCacheDb.mdf;Integrated Security=True" providerName="System.Data.SqlClient" />
</connectionStrings>
  1. Enregistrez le fichier.

Copier les fichiers nécessaires à l'authentification

Ensuite, nous allons importer des fichiers du projet GitHub Projet MVC Office 365 à tenant unique. Nous expliquerons à quoi sert chaque fichier au fur et à mesure.

Pour copier des fichiers du projet GitHub :

  1. Dans un navigateur, accédez au fichier sur lequel vous souhaitez copier. (Les fichiers sont listés ci-dessous).
  2. Faites un clic droit sur le bouton Raw, puis sélectionnez Enregistrer la cible sous...
  3. Enregistrez le fichier sur votre ordinateur.
  4. Dans Visual Studio, dans l'Explorateur de solutionssous le nœud du projet, cliquez avec le bouton droit sur le dossier spécifié comme indiqué ci-dessous et sélectionnez Ajouter > Élément existant...
  5. Sélectionnez le fichier là où vous l'avez enregistré sur votre ordinateur.

Copiez les fichiers suivants dans le dossier Modèles dans le projet. Ces classes montrent comment un cache de jetons ADAL persistant peut être construit et utilisé pour stocker des jetons.

Créez un nouveau dossier, Utils.

  1. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet et sélectionnez Ajouter > Nouveau dossier.
  2. Nommez le dossier Utils.

Copiez le fichier suivant dans ce nouveau dossier. Cette classe d'assistance contient des variables membres qui lisent les valeurs du fichier web.config de votre projet dont vous aurez besoin pour créer l'objet d'authentification ADAL au démarrage.

Enfin, copiez le fichier _LoginPartial.cshtml dans le dossier Vues > Partagées de votre projet.

Authentifier avec Azure Active Directory

Maintenant que le projet est configuré pour l'authentification, nous pouvons ajouter la fonctionnalité qui gère l'authentification avec Azure AD.

Configurer l'authentification unique Azure AD

Ensuite, nous aurons besoin d'ajouter une classe de démarrage OWIN au projet, pour gérer réellement l'authentification. Pour ajouter la classe de démarrage OWIN :

  1. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet et sélectionnez Ajouter > Nouvel élément...
  2. Dans Ajouter un nouvel élément, sous Web, sélectionnez Général, puis sélectionnez Classe de démarrage OWIN.
  3. Pour Nom, entrez Startup.
  4. Cliquez sur Ajouter.

Une nouvelle classe de démarrage est ajoutée à votre projet.

Ajoutons ensuite le code qui gère l'authentification :

  1. Remplacez les références d'espace de noms dans le fichier par ce qui suit :
    using Microsoft.IdentityModel.Clients.ActiveDirectory;
    using Microsoft.Owin.Security;
    using Microsoft.Owin.Security.Cookies;
    using Microsoft.Owin.Security.OpenIdConnect;
    using O365_WebApp_SingleTenant.Models;
    using O365_WebApp_SingleTenant.Utils;
    using Owin;
    using System;
    using System.IdentityModel.Claims;
    using System.Threading.Tasks;
    using System.Web;
    using Microsoft.Owin;
  1. Ajoutez la méthode suivante, ConfigureAuth, à la classe Startup.
    public void ConfigureAuth(IAppBuilder app)
    {
        app.SetDefaultSignInAsAuthenticationType(CookieAuthenticationDefaults.AuthenticationType);

        app.UseCookieAuthentication(new CookieAuthenticationOptions());

        app.UseOpenIdConnectAuthentication(
            new OpenIdConnectAuthenticationOptions
            {
                ClientId = SettingsHelper.ClientId,
                Authority = SettingsHelper.Authority,

                Notifications = new OpenIdConnectAuthenticationNotifications()
                {                       
                    // If there is a code in the OpenID Connect response, redeem it for an access token and refresh token, and store those away.
                    AuthorizationCodeReceived = (context) =>
                    {
                        var code = context.Code;
                        ClientCredential credential = new ClientCredential(SettingsHelper.ClientId, SettingsHelper.AppKey);
                        String signInUserId = context.AuthenticationTicket.Identity.FindFirst(ClaimTypes.NameIdentifier).Value;

                        AuthenticationContext authContext = new AuthenticationContext(SettingsHelper.Authority, new ADALTokenCache(signInUserId));
                        AuthenticationResult result = authContext.AcquireTokenByAuthorizationCode(code, new Uri(HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Path)), credential, SettingsHelper.AADGraphResourceId);

                        return Task.FromResult(0);
                    },
                    RedirectToIdentityProvider = (context) =>
                    {
                        // This ensures that the address used for sign in and sign out is picked up dynamically from the request
                        // this allows you to deploy your app (to Azure Web Sites, for example)without having to change settings
                        // Remember that the base URL of the address used here must be provisioned in Azure AD beforehand.
                        string appBaseUrl = context.Request.Scheme + "://" + context.Request.Host + context.Request.PathBase;
                        context.ProtocolMessage.RedirectUri = appBaseUrl + "/";
                        context.ProtocolMessage.PostLogoutRedirectUri = appBaseUrl;

                        return Task.FromResult(0);
                    },
                    AuthenticationFailed = (context) =>
                    {
                        // Suppress the exception if you don't want to see the error
                        context.HandleResponse();
                        return Task.FromResult(0);
                    }
                }

            });
    }
  1. Ajoutez du code à la méthode Startup.Configuration qui appelle la méthode ConfigureAuth.
    public void Configuration(IAppBuilder app)
    {
        ConfigureAuth(app);
    }

Ajouter un contrôleur pour la connexion et la déconnexion d'Office 365

Ajoutez un contrôleur de compte pour gérer la connexion et la déconnexion :

  1. Dans l'Explorateur de solutions, faites un clic droit sur le dossier Contrôleurs et sélectionnez Ajouter > Contrôleur...
  2. Sélectionnez Contrôleur MVC 5 - Vide et cliquez sur Ajouter.
  3. Pour le nom du contrôleur, entrez AccountControlleret cliquez sur Ajouter.
  4. Remplacez les références d'espace de noms dans le fichier contrôleur par ce qui suit :
    using Microsoft.IdentityModel.Clients.ActiveDirectory;
    using Microsoft.Owin.Security;
    using Microsoft.Owin.Security.Cookies;
    using Microsoft.Owin.Security.OpenIdConnect;
    using O365_WebApp_SingleTenant.Utils;
    using System.Security.Claims;
    using System.Web;
    using System.Web.Mvc;
  1. Supprimez la méthode Index ().
  2. Ajoutez les méthodes suivantes à la classe AccountController pour gérer la connexion et la déconnexion.
    public void SignIn()
    {
        if (!Request.IsAuthenticated)
        {
            HttpContext.GetOwinContext().Authentication.Challenge(new AuthenticationProperties { RedirectUri = "/" }, OpenIdConnectAuthenticationDefaults.AuthenticationType);
        }
    }
    public void SignOut()
    {
        string callbackUrl = Url.Action("SignOutCallback", "Account", routeValues: null, protocol: Request.Url.Scheme);

        HttpContext.GetOwinContext().Authentication.SignOut(
            new AuthenticationProperties { RedirectUri = callbackUrl },
            OpenIdConnectAuthenticationDefaults.AuthenticationType, CookieAuthenticationDefaults.AuthenticationType);
    }

    public ActionResult SignOutCallback()
    {
        if (Request.IsAuthenticated)
        {
            // Redirect to home page if the user is authenticated.
            return RedirectToAction("Index", "Home");
        }

        return View();
    }

Accéder aux API Office 365

Nous sommes maintenant prêts à ajouter le code qui accèdera aux données Office 365 de l'utilisateur.

Créer le modèle pour la vue d'informations sur les contacts

Nous devons d'abord créer la classe sur laquelle nous baserons la vue Contacts :

  1. Dans l'Explorateur de solutions, faites un clic droit sur le dossier Modèles et sélectionnez Ajouter > Classe...
  2. Sélectionnez Classe, entrez MyContact comme nom, et cliquez sur Ajouter.
  3. Dans la classe, ajoutez la ligne de code suivante.
    public class MyContact
    {
        public string Name { get; set; }
    }
  1. Enregistrez le fichier.

Ajouter un contrôleur pour les informations de contact

Ensuite, ajoutez un contrôleur pour les informations de contact des utilisateurs :

  1. Dans l'Explorateur de solutions, faites un clic droit sur le dossier Contrôleurs et sélectionnez Ajouter > Contrôleur...
  2. Sélectionnez Contrôleur MVC 5 - Vide et cliquez sur Ajouter.
  3. Pour le nom du contrôleur, entrez ContactsController et cliquez sur Ajouter.

    Visual Studio ajoute un nouveau contrôleur vide au projet.

  4. Remplacez les références d'espace de noms dans le fichier contrôleur par ce qui suit :

     using Microsoft.IdentityModel.Clients.ActiveDirectory;
     using Microsoft.Office365.Discovery;
     using Microsoft.Office365.OutlookServices;
     using O365_WebApp_SingleTenant.Models;
     using O365_WebApp_SingleTenant.Utils;
     using System.Collections.Generic;
     using System.Security.Claims;
     using System.Threading.Tasks;
     using System.Web.Mvc;
    
Assurez-vous d'ajouter une référence d'espace de noms pour l'espace de noms Modèles de votre projet :


        using [projectname].Models;
  1. Ajoutez l'attribut [Authorize] à la classe ContactsController.

L'attribut [Authorize] exige que l'utilisateur soit authentifié avant de pouvoir accéder à ce contrôleur.

    [Authorize]
    public class ContactsController : Controller
  1. Modifiez la méthode Index () pour qu'elle soit asynchrone.
    public async Task<ActionResult> Index()
  1. Ajoutez le code suivant à la méthode Index ().

Ce code crée le contexte d'authentification à l'aide de l'ID utilisateur Office 365 connecté et de l'autorité pour votre location Office 365.

        List<MyContact> myContacts = new List<MyContact>();

        var signInUserId = ClaimsPrincipal.Current.FindFirst(ClaimTypes.NameIdentifier).Value;
        var userObjectId = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/objectidentifier").Value;

        AuthenticationContext authContext = new AuthenticationContext(SettingsHelper.Authority, new ADALTokenCache(signInUserId));
  1. Ajoutez un bloc try-catch directement sous le code ci-dessus dans la méthode Index ().
        try
        {

        }
        catch (AdalException exception)
        {
            //handle token acquisition failure
            if (exception.ErrorCode == AdalError.FailedToAcquireTokenSilently)
            {
                authContext.TokenCache.Clear();

                //handle token acquisition failure
            }
        }

        return View(myContacts);
  1. Dans le bloc try du code ci-dessus, ajoutez le code suivant à la méthode Index ().

Ce code essaie d'acquérir un jeton d'accès au Service de découverte, en transmettant l'ID client et le mot de passe de l'application, ainsi que les informations d'identification de l'utilisateur. Le jeton d'authentification de l'utilisateur a été mis en cache, le contrôleur peut donc acquérir le jeton d'accès nécessaire en mode silencieux, sans avoir à demander de nouveau à l'utilisateur ses informations d'identification.

Avec le jeton d'accès, l'application peut créer un objet client Service de découverte et utiliser l'objet client de découverte pour déterminer le point de terminaison de ressource pour les API Contacts du service Office 365.

            DiscoveryClient discClient = new DiscoveryClient(SettingsHelper.DiscoveryServiceEndpointUri,
                async () =>
                {
                    var authResult = await authContext.AcquireTokenSilentAsync(SettingsHelper.DiscoveryServiceResourceId, new ClientCredential(SettingsHelper.ClientId, SettingsHelper.AppKey), new UserIdentifier(userObjectId, UserIdentifierType.UniqueId));

                    return authResult.AccessToken;
                });

            var dcr = await discClient.DiscoverCapabilityAsync("Contacts");
  1. Enfin, directement sous le code ci-dessus dans le bloc try, ajoutez le code suivant à la méthode Index ().

Ce code contacte le point de terminaison de ressource pour les API Contacts du service Office 365, à nouveau en mode silencieux, en transmettant les informations d'identification de l'application et de l'utilisateur pour acquérir un jeton d'accès au service Outlook.

Une fois le jeton d'accès reçu, le code peut initialiser un objet client Outlook. Le code utilise ensuite la propriété Me de l'objet client Outlook pour récupérer les informations des contacts pour cet utilisateur.

Enfin, le contrôleur lit la liste des contacts de l'utilisateur et renvoie une vue répertoriant leurs noms d'affichage.

            OutlookServicesClient exClient = new OutlookServicesClient(dcr.ServiceEndpointUri,
                async () =>
                {
                    var authResult = await authContext.AcquireTokenSilentAsync(dcr.ServiceResourceId, new ClientCredential(SettingsHelper.ClientId, SettingsHelper.AppKey), new UserIdentifier(userObjectId, UserIdentifierType.UniqueId));

                    return authResult.AccessToken;
                });

            var contactsResult = await exClient.Me.Contacts.ExecuteAsync();

            do
            {
                var contacts = contactsResult.CurrentPage;
                foreach (var contact in contacts)
                {
                    myContacts.Add(new MyContact { Name = contact.DisplayName });
                }

                contactsResult = await contactsResult.GetNextPageAsync();

            } while (contactsResult != null);

La méthode Index () terminée devrait maintenant se lire comme suit :

    public async Task<ActionResult> Index()
    {
        List<MyContact> myContacts = new List<MyContact>();

        var signInUserId = ClaimsPrincipal.Current.FindFirst(ClaimTypes.NameIdentifier).Value;
        var userObjectId = ClaimsPrincipal.Current.FindFirst("http://schemas.microsoft.com/identity/claims/objectidentifier").Value;

        AuthenticationContext authContext = new AuthenticationContext(SettingsHelper.Authority, new ADALTokenCache(signInUserId));

        try
        {
            DiscoveryClient discClient = new DiscoveryClient(SettingsHelper.DiscoveryServiceEndpointUri,
                async () =>
                {
                    var authResult = await authContext.AcquireTokenSilentAsync(SettingsHelper.DiscoveryServiceResourceId, new ClientCredential(SettingsHelper.ClientId, SettingsHelper.AppKey), new UserIdentifier(userObjectId, UserIdentifierType.UniqueId));

                    return authResult.AccessToken;
                });

            var dcr = await discClient.DiscoverCapabilityAsync("Contacts");                

            OutlookServicesClient exClient = new OutlookServicesClient(dcr.ServiceEndpointUri,
                async () =>
                {
                    var authResult = await authContext.AcquireTokenSilentAsync(dcr.ServiceResourceId, new ClientCredential(SettingsHelper.ClientId, SettingsHelper.AppKey), new UserIdentifier(userObjectId, UserIdentifierType.UniqueId));

                    return authResult.AccessToken;
                });

            var contactsResult = await exClient.Me.Contacts.ExecuteAsync();

            do
            {
                var contacts = contactsResult.CurrentPage;
                foreach (var contact in contacts)
                {
                    myContacts.Add(new MyContact { Name = contact.DisplayName });
                }

                contactsResult = await contactsResult.GetNextPageAsync();

            } while (contactsResult != null);
        }
        catch (AdalException exception)
        {
            //handle token acquisition failure
            if (exception.ErrorCode == AdalError.FailedToAcquireTokenSilently)
            {
                authContext.TokenCache.Clear();

                //handle token acquisition failure
            }
        }

        return View(myContacts);
    }

Créer la vue pour les données Contacts

Ensuite, nous pouvons créer la vue pour les informations de contact de l'utilisateur. Nous le ferons en basant la vue sur la classe MyContact que nous avons créée plus tôt.

  1. Dans l'Explorateur de solutions, faites un clic droit sur le dossier Contacts et sélectionnez Ajouter > Vue.
  2. Dans la boîte de dialogue Ajouter une vue, définissez la nouvelle vue :
    • Pour Nom de la vue, entrez Index.
    • Pour Modèle, sélectionnez List.
    • Pour Classe de modèle, sélectionnez MyContact.
    • Cliquez sur Ajouter.
  1. Dans l'Explorateur de solutions, dans le dossier Partagé, double-cliquez sur le fichier _Layout.cshtml.

  2. Ajoutez un lien d'action pour la page MyContacts et injectez la classe partielle pour la connexion de l'utilisateur. Mettez à jour le code HTML de la barre de navigation à partir de ce qui est généré automatiquement :

         <div class="navbar-collapse collapse">
             <ul class="nav navbar-nav">
                 <li>@Html.ActionLink("Home", "Index", "Home")</li>
                 <li>@Html.ActionLink("About", "About", "Home")</li>
                 <li>@Html.ActionLink("Contact", "Contact", "Home")</li>
             </ul>
         </div>
    

Pour ce qui suit, ajoutez un lien d'action pour la page MyContacts et injectez la classe partielle pour la connexion de l'utilisateur :

        <div class="navbar-collapse collapse">
            <ul class="nav navbar-nav">
                <li>@Html.ActionLink("Home", "Index", "Home")</li>
                <li>@Html.ActionLink("About", "About", "Home")</li>
                <li>@Html.ActionLink("Contact", "Contact", "Home")</li>
                <li>@Html.ActionLink("My Contacts", "Index", "Contacts")</li>
            </ul>
            @Html.Partial("_LoginPartial")
        </div>

Déboguer votre application

Vous êtes maintenant prêt à exécuter la solution. Appuyez sur F5 pour déboguer votre application web.

S'il s'agit d'un nouvel environnement de développement, Visual Studio peut vous inviter à configurer le certificat SSL IIS. Cliquez sur Oui deux fois pour continuer.

  1. Visual Studio lancera l'application web dans le navigateur que vous avez sélectionné dans Visual Studio.

  2. Cliquez sur Se connecter, dans l'angle supérieur droit de la page, et connectez-vous à votre tenant Office 365 sur lequel vous avez enregistré votre application Web.

    Étant donné que seuls les utilisateurs de votre organisation sont autorisés à se connecter à une application de tenant unique, il n'y a pas de consentement nécessaire. Si votre application était multi-tenant, Azure AD afficherait une page de consentement répertoriant les autorisations demandées à l'application, afin que vous puissiez consentir à accorder ces autorisations à l'application.

  3. Une fois que vous êtes connecté, vous devriez voir votre adresse e-mail et Déconnexion s'afficher dans la barre de navigation en haut de la page d'accueil.

  4. Cliquez sur MyContacts

    La page MyContacts récupérera et affichera les noms de tous les contacts Exchange de votre tenant.

Vous avez maintenant un projet d'application web que vous pouvez personnaliser et y intégrer les API Office 365.

Étapes suivantes

Intégration des API Office 365 dans un projet Windows Visual Studio

Pour obtenir un exemple d'intégration des API Office 365 dans une application client native, telle qu'une application Windows Store ou Phone, vous pouvez vous reporter à Projet d'application Windows Office 365 sur GitHub. Le projet récupère une liste des fichiers de l'utilisateur.

La classe AuthenticationHelper.cs contient le code permettant d'authentifier et d'acquérir des jetons à partir des ressources Azure AD pour Office 365. Dans l'exemple, nous acquérons un jeton pour la ressource My Files.

Cela se produit dans la méthode GetAccessToken : afin d'acquérir des jetons, nous interrogeons d'abord Office 365 Discovery Service pour découvrir les fonctionnalités de l'application. Lorsque nous avons configuré l'application pour demander des autorisations sur My Files, le service de découverte Office 365 renvoie des informations sur la fonctionnalité My Files, telles que l'ID de ressource et l'URI de point de terminaison. Avec ces informations, nous obtenons alors un jeton d'accès pour la ressource My Files.

Stockage de l'Id du dernier tenant

Comme les applications d'appareil sont des applications multi-tenant par défaut, l'application ne sait pas initialement à partir de quel utilisateur le tenant se connecte avant que l'utilisateur ne se connecte et ne donne son consentement.

Notez que les applications à tenants multiples permettent aux utilisateurs Office 365 externes de se connecter et d'utiliser l'application. Si l'application est publiée sur le Windows Store, les utilisateurs peuvent télécharger l'application, se connecter à leurs clients Office 365 et utiliser l'application. Azure AD enregistrera l'application Windows au nom de l'utilisateur dans le tenant respectif de l'utilisateur connecté.

Une fois que l'utilisateur a donné son accord, l'application peut obtenir l'ID de tenant des utilisateurs connectés, qu'elle enregistre dans les paramètres de l'application. L'application peut ensuite utiliser cet ID de tenant pour initialiser le contexte d'authentification lorsque l'utilisateur ouvre à nouveau l'application ou fait une requête. Ceci élimine le besoin pour l'utilisateur de consentir chaque fois qu'une requête est faite ; il n'a besoin de donner son consentement qu'une seule fois, lorsqu'il accède pour la première fois à l'application. Cela est vrai jusqu'à l'expiration du jeton d'accès.

Étapes suivantes

Après avoir accédé aux API Office 365, vous pouvez ensuite utiliser les ressources utilisateur disponibles via les API. Pour plus d'informations et des extraits de code montrant comment effectuer des tâches courantes à l'aide de bibliothèques client fournies par Visual Studio, consultez :

Ressources supplémentaires

Exemples de code

Développement Visual Studio

Référence

© 2018 Microsoft