La version 4 (V4) du AWS SDK pour .NET est sortie \$1 Pour plus d'informations sur les modifications majeures et la migration de vos applications, consultez la [rubrique relative à la migration](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html). [https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html) Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # À l'aide du AWS SDK pour .NET Cette section fournit des informations sur les fonctionnalités AWS SDK pour .NET que vous devrez peut-être prendre en compte lors de la création de vos applications. Avant de commencer, assurez-vous d'avoir [configuré votre environnement](net-dg-config.md) [et votre projet](configuring-the-sdk.md). Pour plus d'informations sur le développement de logiciels pour des AWS services spécifiques ainsi que des exemples de code, consultez[ AWS Services d'appels](working-with-aws-services.md). Pour des exemples de code supplémentaires, voir[SDK pour .NET exemples de code (v4)](csharp_code_examples.md). **Topics** + [Programmation asynchrone](sdk-net-async-api.md) + [Pagination](paginators.md) + [Support pour HTTP 2](http2-support.md) + [Outils supplémentaires](sdk-features-additional-tools.md) # Programmation asynchrone à l'aide du AWS SDK pour .NET AWS SDK pour .NET utilise le *modèle asynchrone basé sur les tâches (TAP) pour son implémentation asynchrone*. Pour en savoir plus sur le TAP, consultez la section [Modèle asynchrone basé sur les tâches (TAP)](https://learn.microsoft.com/en-us/dotnet/standard/asynchronous-programming-patterns/task-based-asynchronous-pattern-tap) sur docs.microsoft.com. Cette rubrique vous donne un aperçu de la façon d'utiliser le TAP dans vos appels aux clients AWS du service. Les méthodes asynchrones de l' AWS SDK pour .NET API sont des opérations basées sur la `Task` classe ou la `Task` classe. [Consultez le site docs.microsoft.com pour obtenir des informations sur ces classes : [classe Task, Task< > class](https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task). TResult](https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.task-1) Lorsque ces méthodes d'API sont appelées dans votre code, elles doivent être appelées dans une fonction déclarée avec le `async` mot clé, comme indiqué dans l'exemple suivant. ``` static async Task Main(string[] args) { ... // Call the function that contains the asynchronous API method. // Could also call the asynchronous API method directly from Main // because Main is declared async var response = await ListBucketsAsync(); Console.WriteLine($"Number of buckets: {response.Buckets.Count}"); ... } // Async method to get a list of Amazon S3 buckets. private static async Task ListBucketsAsync() { ... var response = await s3Client.ListBucketsAsync(); return response; } ``` Comme indiqué dans l'extrait de code précédent, la portée préférée de la `async` déclaration est la `Main` fonction. La définition de cette `async` étendue garantit que tous les appels aux clients du AWS service doivent être asynchrones. Si vous ne pouvez pas `Main` déclarer que vous êtes asynchrone pour une raison quelconque, vous pouvez utiliser le `async` mot clé sur des fonctions autres que `Main` puis appeler les méthodes de l'API à partir de là, comme indiqué dans l'exemple suivant. ``` static void Main(string[] args) { ... Task response = ListBucketsAsync(); Console.WriteLine($"Number of buckets: {response.Result.Buckets.Count}"); ... } // Async method to get a list of Amazon S3 buckets. private static async Task ListBucketsAsync() { ... var response = await s3Client.ListBucketsAsync(); return response; } ``` Notez la `Task<>` syntaxe spéciale requise `Main` lorsque vous utilisez ce modèle. En outre, vous devez utiliser le **`Result`**membre de la réponse pour obtenir les données. Vous pouvez voir des exemples complets d'appels asynchrones à des clients AWS de service dans la [Création d'une application simple](quick-start.md) section ([Application multiplateforme simple](quick-start-s3-1-cross.md)et[Application simple basée sur Windows](quick-start-s3-1-winvs.md)) et dans. [Exemples de code guidésBibliothèques et frameworks de haut niveau](tutorials-examples.md) # Utilisation de résultats paginés dans le AWS SDK pour .NET Certains AWS services collectent et stockent une grande quantité de données, que vous pouvez récupérer à l'aide des appels d'API du AWS SDK pour .NET. Si la quantité de données que vous souhaitez récupérer devient trop importante pour un seul appel d'API, vous pouvez diviser les résultats en éléments plus faciles à gérer grâce à la *pagination*. Pour vous permettre d'effectuer la pagination, les objets de demande et de réponse de nombreux clients de service du SDK fournissent un *jeton de continuation* (généralement nommé`NextToken`). Certains de ces clients de services fournissent également des **paginateurs**. Les paginateurs vous permettent d'éviter la surcharge liée au jeton de continuation, qui peut impliquer des boucles, des variables d'état, plusieurs appels d'API, etc. Lorsque vous utilisez un paginateur, vous pouvez récupérer les données d'un AWS service par le biais d'une seule ligne de code, la déclaration d'une `foreach` boucle. Si plusieurs appels d'API sont nécessaires pour récupérer les données, le paginateur s'en charge pour vous. ## Où puis-je trouver des paginateurs ? Tous les services ne proposent pas de paginateurs. L'un des moyens de déterminer si un service fournit un paginateur pour une API particulière consiste à examiner la définition d'une classe de client de service dans la référence d'[AWS SDK pour .NET API](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/). Par exemple, si vous examinez la définition de la [AmazonCloudWatchLogsClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudWatchLogs/TCloudWatchLogsClient.html)classe, vous voyez une `Paginators` propriété. Il s'agit de la propriété qui fournit un paginateur pour Amazon CloudWatch Logs. ## Que m'apportent les paginateurs ? Les paginateurs contiennent des propriétés qui vous permettent de voir les réponses complètes. Ils contiennent également généralement une ou plusieurs propriétés qui vous permettent d'accéder aux parties les plus intéressantes des réponses, que nous appellerons les *résultats clés*. Par exemple, dans ce qui `AmazonCloudWatchLogsClient` a été mentionné précédemment, l'`Paginator`objet contient une `Responses` propriété contenant l'[DescribeLogGroupsResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudWatchLogs/TDescribeLogGroupsResponse.html)objet complet issu de l'appel d'API. Cette `Responses` propriété contient, entre autres, un ensemble de groupes de journaux. L'objet Paginator contient également un résultat clé nommé. `LogGroups` Cette propriété contient uniquement la partie de la réponse consacrée aux groupes de journaux. L'obtention de ce résultat clé vous permet de réduire et de simplifier votre code dans de nombreuses circonstances. ## Pagination synchrone ou asynchrone Les paginateurs fournissent des mécanismes de pagination synchrones et asynchrones. La pagination synchrone est disponible dans les projets .NET Framework 4.7.2 (ou version ultérieure). La pagination asynchrone est disponible dans les projets .NET Core (.NET Core 3.1, .NET 5, etc.). Les opérations asynchrones et .NET Core étant recommandées, l'exemple suivant montre la pagination asynchrone. Des informations sur la façon d'effectuer les mêmes tâches à l'aide de la pagination synchrone et de .NET Framework 4.7.2 (ou version ultérieure) sont présentées après l'exemple dans. [Considérations supplémentaires pour les paginateurs](#paginators-additional) ## exemple L'exemple suivant montre comment utiliser le pour AWS SDK pour .NET afficher une liste de groupes de journaux. Pour le contraste, l'exemple montre comment procéder avec et sans paginateurs. Avant d'examiner le code complet, présenté plus loin, considérez les extraits suivants. **Obtenir des groupes de CloudWatch logs sans paginateurs** ``` // Loop as many times as needed to get all the log groups var request = new DescribeLogGroupsRequest{Limit = LogGroupLimit}; do { Console.WriteLine($"Getting up to {LogGroupLimit} log groups..."); var response = await cwClient.DescribeLogGroupsAsync(request); foreach(var logGroup in response.LogGroups) { Console.WriteLine($"{logGroup.LogGroupName}"); } request.NextToken = response.NextToken; } while(!string.IsNullOrEmpty(request.NextToken)); ``` **Obtenir des groupes de CloudWatch journaux à l'aide de paginateurs** ``` // No need to loop to get all the log groups--the SDK does it for us behind the scenes var paginatorForLogGroups = cwClient.Paginators.DescribeLogGroups(new DescribeLogGroupsRequest()); await foreach(var logGroup in paginatorForLogGroups.LogGroups) { Console.WriteLine(logGroup.LogGroupName); } ``` Les résultats de ces deux extraits étant exactement les mêmes, l'avantage de l'utilisation de paginateurs est clairement visible. **Note** Avant d'essayer de créer et d'exécuter le code complet, assurez-vous d'avoir [configuré votre environnement et votre projet](net-dg-config.md). Vous pourriez également avoir besoin du [Microsoft.Bcl. AsyncInterfaces](https://www.nuget.org/packages/Microsoft.Bcl.AsyncInterfaces/) NuGet package car les paginateurs asynchrones utilisent l'interface. `IAsyncEnumerable` ### Code complet Cette section présente les références pertinentes et le code complet de cet exemple. #### Références du SDK NuGet colis : + [AWSSDK.CloudWatch](https://www.nuget.org/packages/AWSSDK.CloudWatch) Eléments de programmation : + Espace de noms [Amazon. CloudWatch](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudWatch/NCloudWatch.html) Classe [AmazonCloudWatchLogsClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudWatchLogs/TCloudWatchLogsClient.html) + Espace de noms [Amazon. CloudWatchLogs.Modèle](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudWatchLogs/NCloudWatchLogsModel.html) Classe [DescribeLogGroupsRequest](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudWatchLogs/TDescribeLogGroupsRequest.html) Classe [DescribeLogGroupsResponse](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudWatchLogs/TDescribeLogGroupsResponse.html) Classe [LogGroup](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/CloudWatchLogs/TLogGroup.html) #### Code complet ``` using System; using System.Threading.Tasks; using Amazon.CloudWatchLogs; using Amazon.CloudWatchLogs.Model; namespace CWGetLogGroups { class Program { // A small limit for demonstration purposes private const int LogGroupLimit = 3; // // Main method static async Task Main(string[] args) { var cwClient = new AmazonCloudWatchLogsClient(); await DisplayLogGroupsWithoutPaginators(cwClient); await DisplayLogGroupsWithPaginators(cwClient); } // // Method to get CloudWatch log groups without paginators private static async Task DisplayLogGroupsWithoutPaginators(IAmazonCloudWatchLogs cwClient) { Console.WriteLine("\nGetting list of CloudWatch log groups without using paginators..."); Console.WriteLine("------------------------------------------------------------------"); // Loop as many times as needed to get all the log groups var request = new DescribeLogGroupsRequest{Limit = LogGroupLimit}; do { Console.WriteLine($"Getting up to {LogGroupLimit} log groups..."); DescribeLogGroupsResponse response = await cwClient.DescribeLogGroupsAsync(request); foreach(LogGroup logGroup in response.LogGroups) { Console.WriteLine($"{logGroup.LogGroupName}"); } request.NextToken = response.NextToken; } while(!string.IsNullOrEmpty(request.NextToken)); } // // Method to get CloudWatch log groups by using paginators private static async Task DisplayLogGroupsWithPaginators(IAmazonCloudWatchLogs cwClient) { Console.WriteLine("\nGetting list of CloudWatch log groups by using paginators..."); Console.WriteLine("-------------------------------------------------------------"); // Access the key results; i.e., the log groups // No need to loop to get all the log groups--the SDK does it for us behind the scenes Console.WriteLine("\nFrom the key results..."); Console.WriteLine("------------------------"); IDescribeLogGroupsPaginator paginatorForLogGroups = cwClient.Paginators.DescribeLogGroups(new DescribeLogGroupsRequest()); await foreach(LogGroup logGroup in paginatorForLogGroups.LogGroups) { Console.WriteLine(logGroup.LogGroupName); } // Access the full response // Create a new paginator, do NOT reuse the one from above Console.WriteLine("\nFrom the full response..."); Console.WriteLine("--------------------------"); IDescribeLogGroupsPaginator paginatorForResponses = cwClient.Paginators.DescribeLogGroups(new DescribeLogGroupsRequest()); await foreach(DescribeLogGroupsResponse response in paginatorForResponses.Responses) { Console.WriteLine($"Content length: {response.ContentLength}"); Console.WriteLine($"HTTP result: {response.HttpStatusCode}"); Console.WriteLine($"Metadata: {response.ResponseMetadata}"); Console.WriteLine("Log groups:"); foreach(LogGroup logGroup in response.LogGroups) { Console.WriteLine($"\t{logGroup.LogGroupName}"); } } } } } ``` ## Considérations supplémentaires pour les paginateurs + **Les paginateurs ne peuvent pas être utilisés plus d'une fois** Si vous avez besoin des résultats d'un AWS paginateur spécifique à plusieurs endroits de votre code, vous ne devez pas utiliser un objet de pagination plusieurs fois. Créez plutôt un nouveau paginateur chaque fois que vous en avez besoin. Ce concept est illustré dans l'exemple de code précédent de la `DisplayLogGroupsWithPaginators` méthode. + **Pagination synchrone** La pagination synchrone est disponible pour les projets .NET Framework 4.7.2 (ou version ultérieure). Pour ce faire, créez un projet .NET Framework 4.7.2 (ou version ultérieure) et copiez-y le code précédent. Il suffit ensuite de supprimer le `await` mot clé des deux appels de `foreach` pagination, comme indiqué dans l'exemple suivant. ``` /*await*/ foreach(var logGroup in paginatorForLogGroups.LogGroups) { Console.WriteLine(logGroup.LogGroupName); } ``` Créez et exécutez le projet pour obtenir les mêmes résultats que ceux obtenus avec la pagination asynchrone. # Support du protocole HTTP 2 dans AWS SDK pour .NET Certains AWS services et opérations nécessitent le protocole HTTP 2. Par exemple, le streaming bidirectionnel dans Amazon Transcribe Streaming n'est pas possible via HTTP 1.1 et nécessite donc le protocole HTTP 2 à la place. La version 4 de la prise en charge du protocole HTTP 2 AWS SDK pour .NET a été ajoutée afin que vous puissiez utiliser ces opérations dans vos applications. Pour une opération HTTP 2 bidirectionnelle, le comportement du SDK lors de la réception de flux est similaire à celui du protocole HTTP 1.1. En d'autres termes, lorsque les applications qui utilisent le SDK envoient des événements au service, un éditeur est attribué par le développeur à la demande. Pour voir ce comportement en action, considérez l'exemple suivant pour Amazon Transcribe Streaming. Il utilise l'[Amazon. TranscribeStreaming](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/TranscribeStreaming/NTranscribeStreaming.html)et [Amazon. TranscribeStreaming.Espaces de noms du modèle](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/TranscribeStreaming/NTranscribeStreamingModel.html). Dans cet exemple, le développeur définit la `StartStreamTranscriptionRequest.AudioStreamPublisher` propriété avec une fonction de rappel, qui est un .NET`Func`. Le SDK utilise le for `Func` défini `AudioStreamPublisher` pour extraire les événements du code de l'utilisateur afin de les diffuser à l'utilisateur. Le SDK appelle le `Func` jusqu'à ce qu'il renvoie null. Le code montre comment le son d'un fichier peut être diffusé dans Amazon Transcribe Streaming pour y être traité. ``` using Amazon; using Amazon.TranscribeStreaming; using Amazon.TranscribeStreaming.Model; CancellationTokenSource cancelSource = new CancellationTokenSource(); var client = new AmazonTranscribeStreamingClient(RegionEndpoint.USEast1); var startRequest = new StartStreamTranscriptionRequest { LanguageCode = LanguageCode.EnUS, MediaEncoding = MediaEncoding.Flac, MediaSampleRateHertz = 44100, NumberOfChannels = 2, EnableChannelIdentification = true }; Stream fileStream = File.OpenRead("hello-world.flac"); var buffer = new byte[1024 * 10]; startRequest.AudioStreamPublisher += async () => { var bytesRead = await fileStream.ReadAsync(buffer, 0, buffer.Length); if (bytesRead == 0) return null; var audioEvent = new AudioEvent { AudioChunk = new MemoryStream(buffer, 0, bytesRead) }; return audioEvent; }; using var response = await client.StartStreamTranscriptionAsync(startRequest); Console.WriteLine(response.HttpStatusCode); response.TranscriptResultStream.ExceptionReceived += TranscriptResultStream_ExceptionReceived; response.TranscriptResultStream.TranscriptEventReceived += TranscriptResultStream_TranscriptEventReceived; void TranscriptResultStream_ExceptionReceived(object? sender, Amazon.Runtime.EventStreams.EventStreamExceptionReceivedArgs e) { Console.WriteLine(e.EventStreamException.Message); cancelSource.Cancel(); } void TranscriptResultStream_TranscriptEventReceived(object? sender, Amazon.Runtime.EventStreams.EventStreamEventReceivedArgs e) { foreach (var result in e.EventStreamEvent.Transcript.Results) { if (!string.Equals("ch_0", result.ChannelId, StringComparison.OrdinalIgnoreCase)) continue; var text = result.Alternatives[0].Transcript; if (!string.IsNullOrEmpty(text)) { Console.WriteLine(text); } } } _ = response.TranscriptResultStream.StartProcessingAsync(); try { await Task.Delay(10000, cancelSource.Token); } catch (TaskCanceledException) { } ``` **Avertissement** [Certaines opérations HTTP 2 bidirectionnelles, telles que la `InvokeModelWithBidirectionalStreamAsync` méthode d'Amazon Bedrock, Amazon. BedrockRuntime](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/BedrockRuntime/NBedrockRuntime.html)espace de noms, ne renvoyez pas de réponse depuis l'appel initial sur le client de service tant que certains événements n'ont pas été publiés. Ce comportement peut entraîner le blocage de votre application. Pour éviter cette situation, séparez le code de l'application qui fournit les événements à l'éditeur et exécutez-le sur un thread différent du thread qui appelle les opérations sur le client de service. ## Considérations supplémentaires + AWS SDK pour .NET la prise en charge de HTTP 2 n'est disponible que dans les versions qui ciblent .NET 8 et versions ultérieures. Il n'est pas disponible dans les versions qui ciblent .NET Framework. + Pour des informations plus détaillées, voir [PR 3730](https://github.com/aws/aws-sdk-net/pull/3730) dans le [aws-sdk-net](https://github.com/aws/aws-sdk-net) GitHubréférentiel. # Outils supplémentaires Voici quelques outils supplémentaires que vous pouvez utiliser pour faciliter le développement, le déploiement et la maintenance de vos applications .NET. ## AWS Outil de déploiement Après avoir développé votre application .NET Core native pour le cloud sur une machine de développement, vous pouvez utiliser l'outil de AWS déploiement pour la CLI .NET afin de déployer plus facilement votre application sur AWS. Pour de plus amples informations, veuillez consulter [Déployez des applications pour AWS](deploying.md). ## AWS Framework de traitement des messages pour .NET Si vous utilisez des services tels qu'Amazon SQS, Amazon SNS ou EventBridge Amazon, vous pouvez peut-être tirer parti de l'infrastructure de traitement AWS des messages pour .NET. Pour de plus amples informations, veuillez consulter [AWS Framework de traitement des messages pour .NET](msg-proc-fw.md). ## Intégrations avec .NET Aspire Vous pouvez tirer parti des intégrations avec .NET Aspire pour améliorer la boucle de développement interne. Pour de plus amples informations, veuillez consulter [Intégration AWS à .NET Aspire dans le AWS SDK pour .NET](aspire-integrations.md).