Envoyer des demandes parallèles

Si vous utilisez les classes ServiceClient ou CrmServiceClient, ajoutez les éléments suivants au nœud AppSettings dans le fichier App.config.

<add key="PreferConnectionAffinity" value="false" />

Vous pouvez également définir la valeur de la propriété EnableAffinityCookie avec ServiceClient ou CrmServiceClient

Cela peut également le faire à l’aide du constructeur ServiceClient(ConnectionOptions, Boolean, ConfigurationOptions), en utilisant la propriété ConfigurationOptions.EnableAffinityCookie.

Pour les applications .NET utilisant HttpClient avec l’API web, le code suivant montre comment désactiver les cookies à l’aide d’un HttpMessageHandler personnalisé.

HttpMessageHandler messageHandler = new OAuthMessageHandler(
    config,
    new HttpClientHandler() { UseCookies = false }
    );
HttpClient httpClient = new HttpClient(messageHandler)

Si vous utilisez l’injection de dépendances, vous pouvez utiliser la méthode ConfigurePrimaryHttpMessageHandler pour définir la propriété HttpClientHandler.UseCookies sur false.

IHostBuilder builder = Host.CreateDefaultBuilder();

builder.ConfigureServices(services =>
{
   services.AddHttpClient(
      name: "ClientName",
      configureClient: ConfigureHttpClientDelegate
      )
   .ConfigurePrimaryHttpMessageHandler(() =>
      new HttpClientHandler
      {
            UseCookies = false
      }
   );
});

La valeur de réponse x-ms-dop-hint est disponible via la propriété RecommendedDegreesOfParallelism dans ServiceClient ou CrmServiceClient. Vous devez utiliser cette valeur lors de la définition de ParallelOptions.MaxDegreeOfParallelism lorsque vous utilisez Parallel.ForEach.

Ces exemples montrent également la définition de la propriété EnableAffinityCookie sur false.

Dans les exemples ci-dessous, les valeurs d’ID des réponses sont ajoutées à un ConcurrentBag de Guids. ConcurrentBag fournit une collection d’objets non ordonnée thread-safe lorsque l’ordre n’a pas d’importance. L’ordre des Guids renvoyés par cette méthode peut ne pas correspondre à l’ordre des éléments envoyés dans le paramètre entityList.

Utilisation de ServiceClient avec .NET 6 ou version ultérieure

Avec .NET 6 ou version ultérieure, vous pouvez utiliser la méthode Parallel.ForEachAsync avec les méthodes asynchrones incluses avec ServiceClient, comme CreateAsync.

/// <summary>
/// Creates records in parallel
/// </summary>
/// <param name="serviceClient">The authenticated ServiceClient instance.</param>
/// <param name="entityList">The list of entities to create.</param>
/// <returns>The id values of the created records.</returns>
static async Task<Guid[]> CreateRecordsInParallel(
    ServiceClient serviceClient, 
    List<Entity> entityList)
{
    ConcurrentBag<Guid> ids = new();

    // Disable affinity cookie
    serviceClient.EnableAffinityCookie = false;

    var parallelOptions = new ParallelOptions()
    { MaxDegreeOfParallelism = 
        serviceClient.RecommendedDegreesOfParallelism };

    await Parallel.ForEachAsync(
        source: entityList,
        parallelOptions: parallelOptions,
        async (entity, token) =>
        {
            ids.Add(await serviceClient.CreateAsync(entity, token));
        });

    return ids.ToArray();
}

Utilisation de CrmServiceClient avec .NET Framework

Lors de l’utilisation de .NET Framework, la méthode Clone disponible dans CrmServiceClient permet de dupliquer une connexion existante vers Dataverse afin que vous puissiez utiliser la méthode Parallel.ForEach.

/// <summary>
/// Creates records in parallel
/// </summary>
/// <param name="crmServiceClient">The authenticated CrmServiceClient instance.</param>
/// <param name="entityList">The list of entities to create.</param>
/// <returns>The id values of the created records.</returns>
static Guid[] CreateRecordsInParallel(
    CrmServiceClient crmServiceClient, 
    List<Entity> entityList)
{
   ConcurrentBag<Guid> ids = new ConcurrentBag<Guid>();

    // Disable affinity cookie
    crmServiceClient.EnableAffinityCookie = false;

   Parallel.ForEach(entityList,
      new ParallelOptions()
      {
            MaxDegreeOfParallelism = crmServiceClient.RecommendedDegreesOfParallelism
      },
      () =>
      {
            //Clone the CrmServiceClient for each thread
            return crmServiceClient.Clone();
      },
      (entity, loopState, index, threadLocalSvc) =>
      {
            ids.Add(threadLocalSvc.Create(entity));

            return threadLocalSvc;
      },
      (threadLocalSvc) =>
      {
            //Dispose the cloned crmServiceClient instance
            threadLocalSvc?.Dispose();
      }
   );
   return ids.ToArray();
}

L’exemple de méthode statique suivant montre l’utilisation d’un HttpClient authentifié qui a été configuré avec une propriété BaseAddress définie sur l’URI de l’API Web Dataverse.

Cette méthode envoie d’abord une demande à l’aide de la fonction WhoAmI, mais les données du corps de la réponse ne sont pas utilisées. La valeur de l’en-tête de réponse x-ms-dop-hint est l’élément nécessaire. Cette valeur est utilisée pour définir la propriété ParallelOptions.MaxDegreeOfParallelism. Ensuite, Parallel.ForEachAsync est utilisé pour envoyer les demandes à l’aide de ces options.

La méthode analyse ensuite les valeurs d’ID des enregistrements et les définit dans un ConcurrentBag de Guids. ConcurrentBag fournit une collection d’objets non ordonnée thread-safe lorsque l’ordre n’a pas d’importance. L’ordre des Guids renvoyés par cette méthode peut ne pas correspondre à l’ordre des éléments envoyés dans le paramètre entityList.

/// <summary>
/// Creates account records in parallel
/// </summary>
/// <param name="client">Authenticated HttpClient instance</param>
/// <param name="entityList">List of JObject representing account records</param>
/// <returns>The id values of the created records.</returns>
static async Task<Guid[]> CreateRecordsInParallel(HttpClient client, List<JObject> entityList)
{
   ConcurrentBag<Guid> ids = new ConcurrentBag<Guid>();

   HttpResponseMessage whoAmIResponse = await client.SendAsync(new HttpRequestMessage
   {
         Method = HttpMethod.Get,
         RequestUri = new Uri(
         uriString: "WhoAmI",
         uriKind: UriKind.Relative)
   });

   int recommendedDegreeOfParallelism = int.Parse(whoAmIResponse.Headers.GetValues("x-ms-dop-hint").FirstOrDefault());

   var parallelOptions = new ParallelOptions() { MaxDegreeOfParallelism = recommendedDegreeOfParallelism };

   // Send the requests in parallel
   await Parallel.ForEachAsync(entityList, parallelOptions, async (jObject, token) =>
   {
        // Send the request to create an account record.
         var createResponse = await client.SendAsync(new HttpRequestMessage()
         {
            Method = HttpMethod.Post,
            RequestUri = new Uri(
            uriString: "accounts",
            uriKind: UriKind.Relative),
            Content = new StringContent(
               content: jObject.ToString(),
               encoding: System.Text.Encoding.UTF8,
               mediaType: "application/json")
         });

         string? uri = createResponse.Headers.GetValues("OData-EntityId").FirstOrDefault();

         // Parse the Id from the URI returned
         int firstParen = uri.LastIndexOf('(') + 1;
         int lastParen = uri.LastIndexOf(')');

         if (Guid.TryParse(uri[firstParen..lastParen], out Guid id))
         {
            ids.Add(id);
         }

   });

   return ids.ToArray();
}