Der AWS SDK für .NET V3 ist in den Wartungsmodus übergegangen.

Wir empfehlen Ihnen, auf [AWS SDK für .NET V4](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/welcome.html) zu migrieren. Weitere Einzelheiten und Informationen zur Migration finden Sie in unserer [Ankündigung zum Wartungsmodus](https://aws.amazon.com/blogs/developer/aws-sdk-for-net-v3-maintenance-mode-announcement/).

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Nachrichten mit dem AWS Message Processing Framework for .NET konsumieren
<a name="msg-proc-fw-consume"></a>

Das AWS Message Processing Framework für.NET ermöglicht es Ihnen, Nachrichten zu verarbeiten, die mithilfe des Frameworks oder eines der Messaging-Dienste [veröffentlicht](msg-proc-fw-publish.md) wurden. Die Nachrichten können auf verschiedene Arten konsumiert werden, von denen einige im Folgenden beschrieben werden.

## Nachrichten-Handler
<a name="handle-a-message"></a>

Um Nachrichten zu verarbeiten, implementieren Sie einen Message-Handler, der die `IMessageHandler` Schnittstelle für jeden Nachrichtentyp verwendet, den Sie verarbeiten möchten. Die Zuordnung zwischen Nachrichtentypen und Nachrichtenhandlern wird beim Start des Projekts konfiguriert.

```
await Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        // Register the AWS Message Processing Framework for .NET
        services.AddAWSMessageBus(builder =>
        {
            // Register an SQS Queue that the framework will poll for messages.
            // NOTE: The URL given below is an example. Use the appropriate URL for your SQS Queue.
            builder.AddSQSPoller("https://sqs.us-west-2.amazonaws.com/012345678910/MyAppProd");

            // Register all IMessageHandler implementations with the message type they should process. 
            // Here messages that match our ChatMessage .NET type will be handled by our ChatMessageHandler
            builder.AddMessageHandler<ChatMessageHandler, ChatMessage>();
        });
    })
    .Build()
    .RunAsync();
```

Der folgende Code zeigt ein Beispiel für einen Nachrichtenhandler für eine `ChatMessage` Nachricht. 

```
public class ChatMessageHandler : IMessageHandler<ChatMessage>
{
    public Task<MessageProcessStatus> HandleAsync(MessageEnvelope<ChatMessage> messageEnvelope, CancellationToken token = default)
    {
        // Add business and validation logic here.
        if (messageEnvelope == null)
        {
            return Task.FromResult(MessageProcessStatus.Failed());
        }

        if (messageEnvelope.Message == null)
        {
            return Task.FromResult(MessageProcessStatus.Failed());
        }

        ChatMessage message = messageEnvelope.Message;

        Console.WriteLine($"Message Description: {message.MessageDescription}");

        // Return success so the framework will delete the message from the queue.
        return Task.FromResult(MessageProcessStatus.Success());
    }
}
```

Der äußere `MessageEnvelope` enthält Metadaten, die vom Framework verwendet werden. Seine `message` Eigenschaft ist der Nachrichtentyp (in diesem Fall`ChatMessage`).

Sie können zurückkehren, `MessageProcessStatus.Success()` um anzugeben, dass die Nachricht erfolgreich verarbeitet wurde und das Framework die Nachricht aus der Amazon SQS SQS-Warteschlange löscht. Bei der Rücksendung verbleibt die Nachricht in der Warteschlange`MessageProcessStatus.Failed()`, wo sie erneut verarbeitet oder, sofern konfiguriert, in eine [Warteschlange für unzustellbare Briefe](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html) verschoben werden kann.

## Umgang mit Nachrichten in einem lang andauernden Prozess
<a name="long-running-process"></a>

Sie können `AddSQSPoller` mit einer URL für die SQS-Warteschlange aufrufen, um einen Long-Running zu starten, der kontinuierlich [https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.hosting.backgroundservice](https://learn.microsoft.com/en-us/dotnet/api/microsoft.extensions.hosting.backgroundservice)die Warteschlange abfragt und Nachrichten verarbeitet.

```
await Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        // Register the AWS Message Processing Framework for .NET
        services.AddAWSMessageBus(builder =>
        {
            // Register an SQS Queue that the framework will poll for messages.
            // NOTE: The URL given below is an example. Use the appropriate URL for your SQS Queue.
            builder.AddSQSPoller("https://sqs.us-west-2.amazonaws.com/012345678910/MyAppProd", options => 
            {
                // The maximum number of messages from this queue that the framework will process concurrently on this client.
                options.MaxNumberOfConcurrentMessages = 10;

                // The duration each call to SQS will wait for new messages.
                options.WaitTimeSeconds = 20; 
            });

            // Register all IMessageHandler implementations with the message type they should process.
            builder.AddMessageHandler<ChatMessageHandler, ChatMessage>();
        });
    })
    .Build()
    .RunAsync();
```

### Den SQS Message Poller konfigurieren
<a name="config-msg-poller"></a>

Der SQS-Nachrichtenabfrage kann beim Aufrufen konfiguriert werden. `SQSMessagePollerOptions` `AddSQSPoller`
+ `MaxNumberOfConcurrentMessages`- Die maximale Anzahl von Nachrichten aus der Warteschlange, die gleichzeitig verarbeitet werden sollen. Der Standardwert lautet 10.
+ `WaitTimeSeconds`- Die Dauer (in Sekunden), für die der `ReceiveMessage` SQS-Aufruf darauf wartet, dass eine Nachricht in der Warteschlange eintrifft, bevor er zurückkehrt. Wenn eine Nachricht verfügbar ist, kehrt der Anruf früher als zurück. `WaitTimeSeconds` Der Standardwert ist 20.

**Behandlung von Timeouts bei der Sichtbarkeit von Nachrichten**

SQS-Nachrichten haben ein [Zeitlimit für die Sichtbarkeit](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html). Wenn ein Verbraucher mit der Bearbeitung einer bestimmten Nachricht beginnt, verbleibt sie in der Warteschlange, wird aber vor anderen Verbrauchern verborgen, um zu vermeiden, dass sie mehr als einmal verarbeitet wird. Wenn die Nachricht nicht bearbeitet und gelöscht wird, bevor sie wieder sichtbar wird, versucht möglicherweise ein anderer Verbraucher, dieselbe Nachricht zu bearbeiten.

Das Framework verfolgt Nachrichten, die es gerade bearbeitet, und versucht, das Sichtbarkeits-Timeout zu verlängern. Sie können dieses Verhalten `SQSMessagePollerOptions` beim Aufrufen `AddSQSPoller` konfigurieren.
+ `VisibilityTimeout`- Die Dauer in Sekunden, für die empfangene Nachrichten vor nachfolgenden Abrufanfragen verborgen sind. Der Standardwert lautet 30.
+ `VisibilityTimeoutExtensionThreshold`- Wenn das Sichtbarkeits-Timeout einer Nachricht innerhalb dieser Sekunden abläuft, verlängert das Framework das Sichtbarkeits-Timeout (um weitere `VisibilityTimeout` Sekunden). Der Standardwert ist 5.
+ `VisibilityTimeoutExtensionHeartbeatInterval`- Gibt an, wie oft (in Sekunden) das Framework nach Nachrichten sucht, deren Ablauffrist innerhalb von `VisibilityTimeoutExtensionThreshold` Sekunden abläuft, und dann deren Sichtbarkeits-Timeout verlängert. Der Standardwert lautet 1.

 Im folgenden Beispiel sucht das Framework alle 1 Sekunde nach Nachrichten, die noch bearbeitet werden. Für Nachrichten innerhalb von 5 Sekunden, nachdem sie wieder sichtbar werden, verlängert das Framework automatisch das Sichtbarkeits-Timeout jeder Nachricht um weitere 30 Sekunden.

```
// NOTE: The URL given below is an example. Use the appropriate URL for your SQS Queue.
builder.AddSQSPoller("https://sqs.us-west-2.amazonaws.com/012345678910/MyAppProd", options => 
{
    options.VisibilityTimeout = 30;
    options.VisibilityTimeoutExtensionThreshold = 5;
    VisibilityTimeoutExtensionHeartbeatInterval = 1;
});
```

## Umgang mit Nachrichten in Funktionen AWS Lambda
<a name="lambda-functions"></a>

Sie können das AWS Message Processing Framework für.NET mit der [Integration von SQS mit Lambda](https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html) verwenden. Dies wird durch das Paket bereitgestellt. `AWS.Messaging.Lambda` Lesen Sie die [README-Datei](https://github.com/aws/aws-dotnet-messaging/blob/main/src/AWS.Messaging.Lambda/README.md), um loszulegen.