MessageReceiver Classe

Définition

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

public abstract class MessageReceiver : Microsoft.ServiceBus.Messaging.MessagingEntityClient
type MessageReceiver = class
    inherit MessagingEntityClient
Public MustInherit Class MessageReceiver
Inherits MessagingEntityClient
Héritage
Dérivé

Remarques

Notez que le mécanisme de remise de messages ne fournit pas par défaut une réception de messages fiable à tout moment. Service Bus supprime le message une fois qu’il sort du système. Pour une livraison garantie, vous pouvez utiliser le mode de remise PeekLock.

//********************************************************************************
//                             Sending messages to a Queue
//********************************************************************************

// Create a sender
MessageSender myMessageSender = myQueueClient.CreateSender(SendMode.Default);

// Send messages
List<string> Issues = new List<string>();
foreach (var issue in Issues)
{
myMessageSender.Send(new BrokeredMessage(issue));
}
//********************************************************************************
//                           Recieving messages from a Queue
//********************************************************************************

// Create a receiver
MessageReceiver myMessageReceiver = 
myQueueClient.CreateReceiver(ReceiveMode.PeekLock);

// Receive messages
for (int count = 0; count < Issues.Count; count++)
{
var message = myMessageReceiver.Receive();
message.Complete();
}
//********************************************************************************
//                    Receiving messages from a particular session
//********************************************************************************

// Create subscription client
SubscriptionClient mySubscriptionClient = factory.CreateSubscriptionClient(mySubscription);

// Create a receiver
MessageReceiver myMessageReceiver = mySubscriptionClient.AcceptMessageSession(ReceiveMode.PeekLock);

// Receive messages
for (int count = 0; count *lt; Issues.Count; count++)
{
var message = myMessageReceiver.Receive();
message.Complete();
}

Propriétés

BatchFlushInterval

Obtient l’intervalle de vidage par lot.

BatchingEnabled

Obtient une valeur indiquant si le traitement par lots est activé.

IsClosed

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

(Hérité de ClientEntity)
LastPeekedSequenceNumber

Obtient ou définit le numéro de séquence du dernier aperçu du message.

Mode

Obtient le mode de réception du message.

Path

Obtient le chemin d’accès de la file d’attente, de la rubrique ou de l’abonnement par rapport à l’adresse de MessagingFactory base.

(Hérité de MessagingEntityClient)
PrefetchCount

Obtient ou définit le nombre de messages que le destinataire des messages peut demander simultanément.

RefreshEntityRuntimeDescription

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

RetryPolicy

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

(Hérité de ClientEntity)
SupportsGetRuntimeEntityDescription

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

ThisLock

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

(Hérité de ClientEntity)

Méthodes

Abandon(Guid)

Ignore le message et abandonne la propriété du verrou de message.

Abandon(Guid, IDictionary<String,Object>)

Ignore le message et abandonne la propriété du verrou de message.

AbandonAsync(Guid)

Ignore de façon asynchrone le message et abandonne la propriété du verrou de message.

AbandonAsync(Guid, IDictionary<String,Object>)

Ignore de façon asynchrone le message et abandonne la propriété du verrou de message.

Abort()

Exécute la fonctionnalité d’abandon sur l’entité de messagerie.

(Hérité de ClientEntity)
Close()

Envoie un message de nettoyage à Service Bus pour signaler la fin de l’utilisation d’une entité.

(Hérité de ClientEntity)
CloseAsync()

Envoie un message de nettoyage de façon asynchrone à Service Bus pour signaler la fin de l’utilisation d’une entité.

(Hérité de ClientEntity)
Complete(Guid)

Termine l’opération de réception sur un message. Si vous utilisez AMQP, cette opération ne peut être effectuée que sur les messages qui ont été reçus par ce récepteur.

CompleteAsync(Guid)

Termine de manière asynchrone l’opération de réception sur un message. Si vous utilisez AMQP, cette opération ne peut être effectuée que sur les messages qui ont été reçus par ce récepteur.

CompleteBatch(IEnumerable<Guid>)

Termine l’opération de réception sur un lot de messages. Si vous utilisez AMQP, cette opération ne peut être effectuée que sur les messages qui ont été reçus par ce récepteur.

CompleteBatchAsync(IEnumerable<Guid>)

Termine de manière asynchrone l’opération de réception sur un lot de messages. Si vous utilisez AMQP, cette opération ne peut être effectuée que sur les messages qui ont été reçus par ce récepteur.

DeadLetter(Guid)

Déplace le message non remis dans la file d’attente de lettres mortes.

DeadLetter(Guid, IDictionary<String,Object>)

Déplace le message non remis dans la file d’attente de lettres mortes.

DeadLetter(Guid, String, String)

Déplace le message non remis dans la file d’attente de lettres mortes.

DeadLetterAsync(Guid)

Déplace de manière asynchrone le message non remis dans la file d’attente de lettres mortes.

DeadLetterAsync(Guid, IDictionary<String,Object>)

Déplace de manière asynchrone le message non remis dans la file d’attente de lettres mortes.

DeadLetterAsync(Guid, String, String)

Déplace de manière asynchrone le message non remis dans la file d’attente de lettres mortes.

Defer(Guid)

Indique que le récepteur souhaite différer le traitement du message.

Defer(Guid, IDictionary<String,Object>)

Indique que le récepteur souhaite différer le traitement du message.

DeferAsync(Guid)

Différer de façon asynchrone le traitement du message.

DeferAsync(Guid, IDictionary<String,Object>)

Différer de façon asynchrone le traitement du message.

Fault()

À usage interne uniquement. N’héritez pas de cette classe.

(Hérité de ClientEntity)
GetLockToken(BrokeredMessage)

Obtient le jeton de verrou lié au message.

GetLockTokens(IEnumerable<BrokeredMessage>)

Obtient la collection de jetons de verrouillage de la collection de messages spécifiée.

GetProperty<T>()

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

OnAbandon(TrackingContext, IEnumerable<Guid>, IDictionary<String,Object>, TimeSpan)

Exécute l’action d’abandon.

OnAbort()

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

(Hérité de ClientEntity)
OnBeginAbandon(TrackingContext, IEnumerable<Guid>, IDictionary<String,Object>, Boolean, TimeSpan, AsyncCallback, Object)

S’exécute lors de l’appel de l’opération OnAbandon ou BeginAbandon.

OnBeginClose(TimeSpan, AsyncCallback, Object)

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

(Hérité de ClientEntity)
OnBeginComplete(TrackingContext, IEnumerable<ArraySegment<Byte>>, Boolean, TimeSpan, AsyncCallback, Object)

S’exécute lors de l’appel de l’opération OnComplete ou BeginComplete.

OnBeginComplete(TrackingContext, IEnumerable<Guid>, Boolean, TimeSpan, AsyncCallback, Object)

S’exécute lors de l’appel de l’opération OnComplete ou BeginComplete.

OnBeginDeadLetter(TrackingContext, IEnumerable<Guid>, IDictionary<String,Object>, String, String, Boolean, TimeSpan, AsyncCallback, Object)

S’exécute lors de l’appel de l’opération OnDeadLetter ou BeginDeadLetter.

OnBeginDefer(TrackingContext, IEnumerable<Guid>, IDictionary<String,Object>, Boolean, TimeSpan, AsyncCallback, Object)

S’exécute lors de l’appel de l’opération OnDefer ou BeginDefer.

OnBeginOpen(TimeSpan, AsyncCallback, Object)

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

(Hérité de ClientEntity)
OnBeginPeek(TrackingContext, Int64, Int32, TimeSpan, AsyncCallback, Object)

S’exécute lors de l’appel de l’opération BeginPeek.

OnBeginRenewMessageLocks(TrackingContext, IEnumerable<Guid>, Boolean, TimeSpan, AsyncCallback, Object)

S’exécute lors de l’appel de l’opération OnBegin pour les messages de verrouillage.

OnBeginTryReceive(TrackingContext, IEnumerable<Int64>, TimeSpan, AsyncCallback, Object)

Exécute l’action begin try receive.

OnBeginTryReceive(TrackingContext, Int32, TimeSpan, AsyncCallback, Object)

Exécute l’action begin try receive.

OnBeginTryReceive2(TrackingContext, Int32, TimeSpan, AsyncCallback, Object)

Exécute l’action begin try receive.

OnBeginTryReceiveEventData(TrackingContext, Int32, TimeSpan, AsyncCallback, Object)

S’exécute lors de l’appel de l’opération OnTryReceive ou BeginTryReceive pour les données d’événement.

OnClose(TimeSpan)

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

(Hérité de ClientEntity)
OnClosed()

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

(Hérité de ClientEntity)
OnComplete(TrackingContext, IEnumerable<Guid>, TimeSpan)

Exécute l’action complète.

OnDeadLetter(TrackingContext, IEnumerable<Guid>, IDictionary<String,Object>, String, String, TimeSpan)

Exécute l’action de déplacement vers la file d’attente de lettres mortes.

OnDefer(TrackingContext, IEnumerable<Guid>, IDictionary<String,Object>, TimeSpan)

Exécute l’action de report.

OnEndAbandon(IAsyncResult)

Exécute l’action d’abandon de fin.

OnEndClose(IAsyncResult)

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

(Hérité de ClientEntity)
OnEndComplete(IAsyncResult)

Exécute l’action terminer la fin.

OnEndDeadLetter(IAsyncResult)

Exécute l’action de fin de la file d’attente de lettres mortes.

OnEndDefer(IAsyncResult)

Exécute l’action de report de fin.

OnEndOpen(IAsyncResult)

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

(Hérité de ClientEntity)
OnEndPeek(IAsyncResult)

Exécute l’opération EndPeek.

OnEndRenewMessageLocks(IAsyncResult)

Exécute l’action EndRenew pour les verrous de message.

OnEndTryReceive(IAsyncResult, IEnumerable<BrokeredMessage>)

Exécute l’action de fin d’essai de réception.

OnEndTryReceive2(IAsyncResult, IEnumerable<BrokeredMessage>)

Exécute l’action de fin d’essai de réception.

OnEndTryReceiveEventData(IAsyncResult, IEnumerable<EventData>)

Exécute l’action EndTryReceive pour les données d’événement.

OnFaulted()

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

(Hérité de ClientEntity)
OnMessage(Action<BrokeredMessage>, OnMessageOptions)

Traite un message dans une pompe de messages pilotée par les événements.

OnMessageAsync(Func<BrokeredMessage,Task>, OnMessageOptions)

Traite de manière asynchrone un message dans une pompe de messages pilotée par les événements.

OnOpen(TimeSpan)

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

(Hérité de ClientEntity)
OnOpened()

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

(Hérité de ClientEntity)
OnPeek(TrackingContext, Int64, Int32, TimeSpan)

S’exécute lors de l’appel de l’opération Peek.

OnRenewMessageLocks(TrackingContext, IEnumerable<Guid>, TimeSpan)

Exécute l’action Renouveler pour les messages de verrouillage.

OnTryReceive(TrackingContext, IEnumerable<Int64>, TimeSpan, IEnumerable<BrokeredMessage>)

Exécute l’action essayer de recevoir.

OnTryReceive(TrackingContext, Int32, TimeSpan, IEnumerable<BrokeredMessage>)

Exécute l’action essayer de recevoir.

Peek()

Lit le message suivant sans modifier l’état du récepteur ou de la source du message.

Peek(Int64)

Lit le message suivant sans modifier l’état du récepteur ou de la source du message.

PeekAsync()

Lit de façon asynchrone le message suivant sans modifier l’état du récepteur ou de la source du message.

PeekAsync(Int64)

Lit de façon asynchrone le message suivant sans modifier l’état du récepteur ou de la source du message.

PeekBatch(Int32)

Lit le lot de message suivant sans modifier l’état du récepteur ou de la source du message.

PeekBatch(Int64, Int32)

Lit le lot de message suivant sans modifier l’état du récepteur ou de la source du message.

PeekBatchAsync(Int32)

Lit de manière asynchrone le lot de message suivant sans modifier l’état du récepteur ou de la source du message.

PeekBatchAsync(Int64, Int32)

Lit de manière asynchrone le lot de message suivant sans modifier l’état du récepteur ou de la source du message.

Receive()

Reçoit un BrokeredMessage de la file d’attente ou de la rubrique active.

Receive(Int64)

Reçoit un message différé de la file d’attente ou de la rubrique actuelle. Cette méthode fonctionne uniquement pour les messages différés, et non pour les messages réguliers.

Receive(TimeSpan)

Reçoit un BrokeredMessage de la file d’attente ou de la rubrique active.

ReceiveAsync()

Reçoit de manière asynchrone un message de la file d’attente ou de la rubrique actuelle.

ReceiveAsync(Int64)

Reçoit de façon asynchrone un message différé de la file d’attente ou de la rubrique actuelle. Cette méthode fonctionne uniquement pour les messages différés, et non pour les messages réguliers.

ReceiveAsync(TimeSpan)

Reçoit de manière asynchrone un message de la file d’attente ou de la rubrique actuelle.

ReceiveBatch(IEnumerable<Int64>)

Reçoit un lot de messages.

ReceiveBatch(Int32)

Reçoit un lot de messages.

ReceiveBatch(Int32, TimeSpan)

Reçoit un lot de messages.

ReceiveBatchAsync(IEnumerable<Int64>)

Reçoit de façon asynchrone un lot de messages.

ReceiveBatchAsync(Int32)

Reçoit de façon asynchrone un lot de messages.

ReceiveBatchAsync(Int32, TimeSpan)

Reçoit de façon asynchrone un lot de messages.

ThrowIfClosed()

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

(Hérité de ClientEntity)
ThrowIfDisposed()

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

(Hérité de ClientEntity)
ThrowIfDisposedOrImmutable()

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

(Hérité de ClientEntity)
ThrowIfDisposedOrNotOpen()

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

(Hérité de ClientEntity)
ThrowIfFaulted()

La classe MessageReceiver est utilisée pour recevoir des messages du conteneur de messages et les accuser de réception.

(Hérité de ClientEntity)

S’applique à