Commentaires

Démarrage rapide amélioré

  • Article
  • 5 minutes de lecture

Cette rubrique montre comment refactoriser le code dans la rubrique Démarrage rapide en ajoutant HttpClient et des méthodes de traitement des erreurs réutilisables. Complétez les étapes de la rubrique Démarrage rapide pour créer un nouveau projet Visual Studio avant de consulter cette rubrique, ou simplement téléchargez la version MSAL du projet Visual Studio complet.

Si vous êtes bloqué après ce démarrage rapide amélioré, vous pouvez télécharger la solution terminée.

Activer la transmission d'informations d'identification dans une chaîne de connexion

Ajouter à votre code les informations d'identification de l'utilisateur pour l'ouverture de session n'est pas une bonne pratique. Comment vous capturez les informations d'identification utilisateur dépend du type de client que vous créez. Dans le cas de cette console, nous allons définir les informations d'identification dans le fichier App.config, car il s'agit d'un moyen très pratique de déplacer les informations d'identification hors du code. Il s'agit également de la méthode utilisée dans les Exemples d'opérations de données de l'API web (C#), donc si vous comprenez cette méthode, vous pouvez facilement voir comment les autres exemples d'API Web fonctionnent.

L'activation de cela s'effectue en trois étapes :

  1. Ajouter une référence à System.Configuration dans le projet Visual Studio
  2. Modifier le fichier de configuration de l'application
  3. Ajouter une directive using dans Program.cs

Ajouter une référence à System.Configuration dans le projet Visual Studio

  1. Dans Explorateur de solutions, cliquez avec le bouton droit sur Références et sélectionnez Ajouter une référence....
  2. Dans la boîte de dialogue Gestionnaire de références, recherchez System.Configuration et activez la case à cocher pour ajouter cette référence à votre projet.
  3. Cliquez sur OK pour fermer la boîte de dialogue Gestionnaire de références.

Modifier le fichier de configuration de l'application

Dans Explorateur de solutions, ouvrez le fichier App.config. La syntaxe devrait être similaire à ceci :

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.2" />
    </startup>
</configuration>

Modifiez l'élément <configuration> pour ajouter le nœud connectionStrings comme indiqué ci-dessous :

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.2" />
    </startup>
  <connectionStrings>
    <!--Online using Microsoft 365-->
    <add name="Connect"
         connectionString="Url=https://yourorg.api.crm.dynamics.com;Username=yourname@yourorg.onmicrosoft.com;Password=mypassword;" />
  </connectionStrings>
</configuration>

Cela permet de créer une chaîne de connexion qui peut être référencé par son nom, c'est-à-dire Connect, afin de pouvoir définir plus d'une connexion si vous le souhaitez.

Modifiez les valeurs Url, Username et Password de la chaîne de connexion dans le paramètre connectionString pour faire correspondre ce que vous devez connecter à votre environnement de test Microsoft Dataverse.

Ajouter à l'aide de la directive à Program.cs

Dans la partie supérieure de votre fichier Program.cs, ajoutez cela à l'aide de la directive :

using System.Configuration;

Installer le package NuGet MSAL

Dans Visual Studio, cliquez avec le bouton droit sur l'Explorateur de solutions et sélectionnez Gérer les packages NuGet dans le menu contextuel. Recherchez et installez le package Microsoft.Identity.Client dans votre projet. Ce package sera utilisé pour l'authentification du service Web.

Ajouter le code d'assistance

Dans l'exemple Démarrage rapide, tout le code se situe dans le fichier Program.cs. Nous allons déplacer du code qui traite la connexion et créer HttpClient dans un fichier distinct des méthodes d'assistance.

Ces assistances sont également utilisées dans le fichier SampleHelper.cs, utilisé par les Exemples d'opérations de données de l'API web (C#). Si vous comprenez ces assistances, vous comprendrez comment elles sont utilisées dans les exemples.

  1. Dans Explorateur de solutions, cliquez avec le bouton droit sur votre projet et sélectionnez Ajouter > Classer... (ou appuyez sur Shift+Alt+C) pour ouvrir la boîte de dialogue Ajouter un nouvel élément.

  2. Spécifiez un nom pour votre fichier de classe. Pour suivre le modèle utilisé par les Exemples d'opérations de données de l'API web (C#), appelez-la « SampleHelpers.cs ».

Notes

Le nom de la classe détermine comment vous allez référencer ces propriétés et méthodes d'assistance dans votre programme principal. Les instructions restantes supposeront que vous avez nommé la classe SampleHelpers.

  1. Ajoutez le code suivant à votre fichier SampleHelpers.cs.

using System;
using System.Linq;
using System.Net.Http;

namespace EnhancedQuickStart
{
  /// <summary>
  /// Shared code for common operations used by many Power Apps samples.
  /// </summary>
  class SampleHelpers
  {
      //These sample application registration values are available for all online instances.
      //You can use these while running sample code, but you should get your own for your own apps
      public static string clientId = "51f81489-12ee-4a9e-aaae-a2591f45987d";
      public static string redirectUrl = "app://58145B91-0C36-4500-8554-080854F2AC97";

      /// <summary>
      /// Method used to get a value from the connection string
      /// </summary>
      /// <param name="connectionString"></param>
      /// <param name="parameter"></param>
      /// <returns>The value from the connection string that matches the parameter key value</returns>
      public static string GetParameterValueFromConnectionString(string connectionString, string parameter)
      {
          try
          {
              return connectionString.Split(';').Where(s => s.Trim().StartsWith(parameter)).FirstOrDefault().Split('=')[1];
          }
          catch (Exception)
          {
              return string.Empty;
          }
      }

      /// <summary>
      /// Returns an HttpClient configured with an OAuthMessageHandler
      /// </summary>
      /// <param name="connectionString">The connection string to use.</param>
      /// <param name="clientId">The client id to use when authenticating.</param>
      /// <param name="redirectUrl">The redirect Url to use when authenticating</param>
      /// <param name="version">The version of Web API to use. Defaults to version 9.2 </param>
      /// <returns>An HttpClient you can use to perform authenticated operations with the Web API</returns>
      public static HttpClient GetHttpClient(string connectionString, string clientId, string redirectUrl, string version = "v9.2")
      {
          string url = GetParameterValueFromConnectionString(connectionString, "Url");
          string username = GetParameterValueFromConnectionString(connectionString, "Username");
          string password = GetParameterValueFromConnectionString(connectionString, "Password");
          try
          {
              HttpMessageHandler messageHandler = new OAuthMessageHandler(url, clientId, redirectUrl, username, password,
                            new HttpClientHandler());

              HttpClient httpClient = new HttpClient(messageHandler)
              {
                  BaseAddress = new Uri(string.Format("{0}/api/data/{1}/", url, version)),

                  Timeout = new TimeSpan(0, 2, 0)  //2 minutes
              };

              return httpClient;
          }
          catch (Exception)
          {
              throw;
          }
      }

      /// <summary> Displays exception information to the console. </summary>
      /// <param name="ex">The exception to output</param>
      public static void DisplayException(Exception ex)
      {
          Console.WriteLine("The application terminated with an error.");
          Console.WriteLine(ex.Message);
          while (ex.InnerException != null)
          {
              Console.WriteLine("\t* {0}", ex.InnerException.Message);
              ex = ex.InnerException;
          }
      }
  }
}
  1. Ajoutez une classe OAuthMessageHandler dans son propre fichier de classe en utilisant le code fourni ci-dessous.

Cette classe garantit que le jeton d'accès est actualisé chaque fois qu'une opération est effectuée. Chaque jeton d'accès expire au bout d'une heure. Cette classe implémente un DelegatingHandler qui fonctionne avec le contexte d'authentification de la Bibliothèque d'authentification Microsoft (MSAL) pour appeler la variation AcquireToken correcte chaque fois qu'une opération est effectuée, afin que vous n'ayez pas besoin de gérer explicitement l'expiration du jeton.

using Microsoft.Identity.Client;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security;
using System.Threading.Tasks;

namespace EnhancedQuickStart
{
  /// <summary>
  /// Custom HTTP message handler that uses OAuth authentication through 
  /// Microsoft Authentication Library (MSAL).
  /// </summary>
  class OAuthMessageHandler : DelegatingHandler
  {
      private AuthenticationHeaderValue authHeader;

      public OAuthMessageHandler(string serviceUrl, string clientId, string redirectUrl, string username, string password,
              HttpMessageHandler innerHandler)
          : base(innerHandler)
      {

          string apiVersion = "9.2";
          string webApiUrl = $"{serviceUrl}/api/data/v{apiVersion}/";

          //Build Microsoft.Identity.Client (MSAL) OAuth Token Request
          var authBuilder = PublicClientApplicationBuilder.Create(clientId)
                          .WithAuthority(AadAuthorityAudience.AzureAdMultipleOrgs)
                          .WithRedirectUri(redirectUrl)
                          .Build();
          var scope = serviceUrl + "//.default";
          string[] scopes = { scope };

          AuthenticationResult authBuilderResult;
          if (username != string.Empty && password != string.Empty)
          {
              //Make silent Microsoft.Identity.Client (MSAL) OAuth Token Request
              var securePassword = new SecureString();
              foreach (char ch in password) securePassword.AppendChar(ch);
              authBuilderResult = authBuilder.AcquireTokenByUsernamePassword(scopes, username, securePassword)
                          .ExecuteAsync().Result;
          }
          else
          {
              //Popup authentication dialog box to get token
              authBuilderResult = authBuilder.AcquireTokenInteractive(scopes)
                          .ExecuteAsync().Result;
          }

          //Note that an Azure AD access token has finite lifetime, default expiration is 60 minutes.
          authHeader = new AuthenticationHeaderValue("Bearer", authBuilderResult.AccessToken);
      }

      protected override Task<HttpResponseMessage> SendAsync(
                HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)
      {
          request.Headers.Authorization = authHeader;
          return base.SendAsync(request, cancellationToken);
      }
  }
}

Mise à jour Program.cs

Maintenant que vous avez apporté des modifications dans Activer la transmission d'informations d'identification dans une chaîne de connexion et dans Ajouter le code d'assistance, vous pouvez mettre à jour la méthode Main dans votre fichier Program.cs pour qu'elle contienne uniquement ce qui suit :

using Newtonsoft.Json.Linq;
using System;
using System.Configuration;
using System.Net.Http;

namespace EnhancedQuickStart
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                //Get configuration data from App.config connectionStrings
                string connectionString = ConfigurationManager.ConnectionStrings["Connect"].ConnectionString;

                using (HttpClient client = SampleHelpers.GetHttpClient(connectionString, SampleHelpers.clientId, SampleHelpers.redirectUrl))
                {
                    // Use the WhoAmI function
                    var response = client.GetAsync("WhoAmI").Result;

                    if (response.IsSuccessStatusCode)
                    {
                        //Get the response content and parse it.  
                        JObject body = JObject.Parse(response.Content.ReadAsStringAsync().Result);
                        Guid userId = (Guid)body["UserId"];
                        Console.WriteLine("Your UserId is {0}", userId);
                    }
                    else
                    {
                        Console.WriteLine("The request failed with a status of '{0}'",
                                    response.ReasonPhrase);
                    }
                    Console.WriteLine("Press any key to exit.");
                    Console.ReadLine();
                }
            }
            catch (Exception ex)
            {
                SampleHelpers.DisplayException(ex);
                Console.WriteLine("Press any key to exit.");
                Console.ReadLine();
            }
        }
    }
}

Cela représente moins de code et vous avez ajouté le traitement d'erreurs et les moyens d'actualiser le jeton d'accès à chaque utilisation de HttpClient.

Appuyez sur la touche F5 pour exécuter le programme. Tout comme l'exemple Démarrage rapide, le résultat doit ressembler à ce qui suit :

Your UserId is 969effb0-98ae-478c-b547-53a2968c2e75
Press any key to exit.

Créer des méthodes réutilisables

Bien que nous ayons réduit le volume total du code dans la méthode Program.Main , vous n'allez pas entrer un programme pour appeler seulement une opération, et il n'est pas réaliste d'écrire autant de code uniquement pour appeler une seule opération.

Cette section explique comment vous pouvez modifier ce qui suit :

var response = client.GetAsync("WhoAmI").Result;

if (response.IsSuccessStatusCode)
{
  //Get the response content and parse it.  
  JObject body = JObject.Parse(response.Content.ReadAsStringAsync().Result);
  Guid userId = (Guid)body["UserId"];
  Console.WriteLine("Your UserId is {0}", userId);
}
else
{
  Console.WriteLine("The request failed with a status of '{0}'",
      response.ReasonPhrase);
}

en ceci :

WhoAmIResponse response = WhoAmI(client);
      Console.WriteLine("Your system user ID is: {0}", response.UserId);

Avant de commencer, il est conseillé d'accéder à la référence de l'API Web et d'examiner ces rubriques :

Remarquez comment WhoAmI Function retourne une WhoAmIResponse ComplexType et le WhoAmIResponse ComplexType comporte GUID trois propriétés : BusinessUnitId, UserId et OrganizationId ;

Le code que nous allons ajouter suffit pour modéliser ces derniers en une méthode réutilisable qui accepte HttpClient comme paramètre.

Notes

Comment procéder exactement est une affaire de préférence personnelle. Cette conception est fournie car elle est assez simple.

Dans votre projet Visual Studio procédez comme suit :

  1. Modifiez la classe Program pour en faire une classe partielle.

    En haut, remplacez ceci :

    class Program

    À cet effet :

    partial class Program

  2. Créez un fichier de classe, appelé ProgramMethods.cs

    Dans ProgramMethods.cs, remplacez ceci :

    class ProgramMethods

    À cet effet :

    partial class Program

    Ainsi, la classe Program dans le fichier ProgramMethods.cs est simplement une extension de la classe Program d'origine dans le fichier Program.cs.

  3. Ajoutez ce qui suite à l'aide des directives en haut du fichier ProgramMethods.cs.

    using Newtonsoft.Json.Linq;
using System;
using System.Net.Http;

  4. Ajoutez la méthode suivante sous la classe Program du fichier ProgramMethods.cs.

    public static WhoAmIResponse WhoAmI(HttpClient client) {
  WhoAmIResponse returnValue = new WhoAmIResponse();
  //Send the WhoAmI request to the Web API using a GET request. 
  HttpResponseMessage response = client.GetAsync("WhoAmI",
          HttpCompletionOption.ResponseHeadersRead).Result;
  if (response.IsSuccessStatusCode)
  {
      //Get the response content and parse it.
      JObject body = JObject.Parse(response.Content.ReadAsStringAsync().Result);
      returnValue.BusinessUnitId = (Guid)body["BusinessUnitId"];
      returnValue.UserId = (Guid)body["UserId"];
      returnValue.OrganizationId = (Guid)body["OrganizationId"];
  }
  else
  {
      throw new Exception(string.Format("The WhoAmI request failed with a status of '{0}'",
              response.ReasonPhrase));
  }
  return returnValue;
}

  5. Ajoutez la classe suivante en dehors de la classe Program mais dans l'espace de noms du fichier ProgramMethods.cs.

    public class WhoAmIResponse
{
    public Guid BusinessUnitId { get; set; } 
    public Guid UserId { get; set; }
    public Guid OrganizationId { get; set; }
}

  6. Dans la méthode Program.Main dans le fichier Program.cs d'origine :

    Remplacez ceci :

    var response = client.GetAsync("WhoAmI").Result;

if (response.IsSuccessStatusCode)
{
  //Get the response content and parse it.  
  JObject body = JObject.Parse(response.Content.ReadAsStringAsync().Result);
  Guid userId = (Guid)body["UserId"];
  Console.WriteLine("Your UserId is {0}", userId);
}
else
{
  Console.WriteLine("The request failed with a status of '{0}'",
              response.ReasonPhrase);
}

    Par ceci :

    WhoAmIResponse response = WhoAmI(client);
Console.WriteLine("Your system user ID is: {0}", response.UserId);

  7. Appuyez sur F5 pour exécuter l'exemple et vous devriez obtenir les mêmes résultats qu'avant.

Dépannage

Si vous rencontrez des problèmes en exécutant cet exemple, vous pouvez télécharger tous les exemples Power Apps provenant du référentiel GitHub à l'adresse https://github.com/Microsoft/PowerApps-Samples.

Important

Tous les exemples du référentiel GitHub sont configurés pour utiliser un fichier App.config commun qui se trouve dans PowerApps-Samples:cds\App.config. Lorsque vous définissez votre chaîne de connexion, vous devez modifier ce fichier. Une fois terminé, vous pouvez exécuter tous les exemples sans définir vos informations d'identification à nouveau.

Créer un modèle de projet

Avant de quitter cette rubrique, pensez à enregistrer votre projet comme modèle de projet. Vous pouvez ensuite réutiliser ce modèle pour de futurs projets de formation et économiser ainsi du temps et des efforts lors de la configuration de nouveaux projets. Pour cela, tandis que votre projet est ouvert dans Microsoft Visual Studio, dans le menu Fichier sélectionnez Exporter le modèle. Suivez les instructions de l'Assistant Exporter le modèle pour créer le modèle.

Étapes suivantes

Utilisez les ressources suivantes pour en savoir plus :

Effectuer des opérations à l'aide de l'API Web

Essayer les exemples d'opérations de données de l'API Web (C#)

Examiner les exemples de l'API Web (C#) sur GitHub

Notes

Pouvez-vous nous indiquer vos préférences de langue pour la documentation ? Répondez à un court questionnaire. (veuillez noter que ce questionnaire est en anglais)

Le questionnaire vous prendra environ sept minutes. Aucune donnée personnelle n’est collectée (déclaration de confidentialité).