Partager via


MessageSender Classe

Définition

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

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

Remarques

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

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

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

// Send messages
List<object> Issues = new List<object>();
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();
}

Propriétés

BatchFlushInterval

Obtient l’intervalle de vidage par lots.

BatchingEnabled

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

IsClosed

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

(Hérité de ClientEntity)
Path

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

(Hérité de MessagingEntityClient)
RefreshEntityRuntimeDescription

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

RetryPolicy

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

(Hérité de ClientEntity)
SupportsGetRuntimeEntityDescription

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

ThisLock

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

(Hérité de ClientEntity)

Méthodes

Abort()

Effectue 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 manière asynchrone à Service Bus pour signaler la fin de l’utilisation d’une entité.

(Hérité de ClientEntity)
Fault()

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

(Hérité de ClientEntity)
OnAbort()

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

(Hérité de ClientEntity)
OnBeginCancelScheduledMessage(TrackingContext, IEnumerable<Int64>, TimeSpan, AsyncCallback, Object)

Cela permet aux implémentations concrètes de remplacer (si nécessaire) ce qui doit être fait pour annuler les envois planifiés

OnBeginClose(TimeSpan, AsyncCallback, Object)

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

(Hérité de ClientEntity)
OnBeginOpen(TimeSpan, AsyncCallback, Object)

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

(Hérité de ClientEntity)
OnBeginScheduleMessage(TrackingContext, IEnumerable<BrokeredMessage>, TimeSpan, AsyncCallback, Object)

Cela permet aux implémentations concrètes de remplacer (si nécessaire) ce qui doit être fait pour planifier les envois

OnBeginSend(TrackingContext, IEnumerable<BrokeredMessage>, Boolean, TimeSpan, AsyncCallback, Object)

Exécute l’action d’envoi de début. Cette méthode est destinée à la consommation interne et ne peut pas être implémentée dans une classe concrète par l’utilisateur.

OnBeginSendEventData(TrackingContext, IEnumerable<EventData>, TimeSpan, AsyncCallback, Object)

Exécute l’action begin send event data . Cette méthode est destinée à la consommation interne et ne peut pas être implémentée dans une classe concrète par l’utilisateur.

OnClose(TimeSpan)

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

(Hérité de ClientEntity)
OnClosed()

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

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

Déclenche un événement lors de la fin de l’annulation du message planifié.

OnEndClose(IAsyncResult)

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

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

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

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

Déclenche un événement lors de la fin de la planification des messages.

OnEndSend(IAsyncResult)

Exécute l’action d’envoi de fin. Cette méthode est destinée à la consommation interne et ne peut pas être implémentée dans une classe concrète par l’utilisateur.

OnEndSendEventData(IAsyncResult)

Exécute l’action de fin de l’envoi de données d’événement. Cette méthode est destinée à la consommation interne et ne peut pas être implémentée dans une classe concrète par l’utilisateur.

OnFaulted()

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

(Hérité de ClientEntity)
OnOpen(TimeSpan)

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

(Hérité de ClientEntity)
OnOpened()

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

(Hérité de ClientEntity)
OnSend(TrackingContext, IEnumerable<BrokeredMessage>, TimeSpan)

Cela permet aux implémentations concrètes de remplacer (si nécessaire) ce qui doit être fait lors de l’envoi messages de manière synchrone.

Send(BrokeredMessage)

Envoie le message réparti spécifié.

SendAsync(BrokeredMessage)

Envoie de manière asynchrone le message réparti spécifié.

SendBatch(IEnumerable<BrokeredMessage>)

Envoie un ensemble de messages réparti (pour le traitement par lots).

SendBatchAsync(IEnumerable<BrokeredMessage>)

Envoie de manière asynchrone un ensemble de messages répartités (pour le traitement par lots).

ThrowIfClosed()

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

(Hérité de ClientEntity)
ThrowIfDisposed()

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

(Hérité de ClientEntity)
ThrowIfDisposedOrImmutable()

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

(Hérité de ClientEntity)
ThrowIfDisposedOrNotOpen()

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

(Hérité de ClientEntity)
ThrowIfFaulted()

La classe MessageSender est utilisée pour envoyer des messages à partir de Service Bus.

(Hérité de ClientEntity)

S’applique à