Microsoft.ServiceBus.Messaging Microsoft.ServiceBus.Messaging Namespace

The Microsoft.ServiceBus.Messaging namespace contains classes that provide reliable message queuing and a durable publish-subscribe mechanism on Azure Service Bus.

Classes

Represents the rule to allow.

Defines the Azure Service Bus authorization rule that is used to determine whether an operation is permissible or not.

Represents a collection of AuthorizationRule.

Represents the unit of communication between Service Bus clients.

Represents the property bag for a BrokeredMessage.

A data structure that represents the events sent and received from an Event Hub stream.

Represents a description of the consumer group.

Represents the correlation filter expression. For more information about filters, see the Topic Filters sample.

Represents the factory for the default event processor.

Exception for signaling message duplicate errors.

Represents the description of an entity.

Represents the event sent and received from an Event Hubs stream. It contains the body of the event, a user-defined property bag, and various metadata describing the event, such as its offset in the partition and its number in the stream sequence. Partitions are filled with a sequence of event data.

Provides the names (as fields) of all the system properties that Service Bus automatically updates.

An anchor class used to send and receive events to and from an Event Hub.

Represents the consumer group within an Event Hub. This class creates receivers for a specific consumer group within an Event Hub. This can be the default consumer group or another user-created consumer group.

Represents the metadata description of an Event Hub.

A client class used in receive operations related to an Event Hub consumer group. Represents a logical receiver connection to a specific Event Hub partition within a consumer group.

Returns Event Hubs runtime information, which is required for creating EventHubSender or EventHubReceiver objects.

A client class used in send operations for an Event Hub. Represents a logical sender connection to a specific Event Hub partition.

A very simple host for processing EventHub messages. It takes care of distributing EventHub partitions among EventProcessorHost instances. It creates an Azure Block Blob for each partition in EventHub and use these blobs for managing lease for a partition. Every EventProcessorHost instance is performing the following two tasks: 1) Renew Leases: It keeps track of leases currently owned by the host and continuously keeps on renewing the leases. 2) Acquire Leases: Each instance continuously polls all the lease blobs to check if there are any leases it should acquire for the system to get into balanced state. Client application needs to implement IEventProcessor and register processor implementation with EventProcessorHost.

Defines the runtime options when registering an IEventProcessor interface with an EventHubConsumerGroup. This is also the mechanism for catching exceptions from an IEventProcessor instance used by an EventProcessorHost object.

Provides data for the ExceptionReceived event.

Represents the false filter expression.

Describes a filter expression that is evaluated against a BrokeredMessage.

The exception that is thrown for signaling filter action errors.

Contains partition ownership information.

Represents an exception that occurs when the service lease has been lost.

Provides string constants used in Microsoft Azure Service Bus Messaging.

This class contains properties that enable you to retrieve details of messages from sub-queues of primary messaging entities (queues, topics, subscriptions).

The exception that is thrown to signal message lock lost errors.

The exception that is thrown to signal message not found errors.

The MessageReceiver class is used to receive messages from the message container and acknowledge them.

The MessageSender class is used to send messages from the Service Bus.

Represents a message session that allows grouping of related messages for processing in a single transaction.

Represents the asynchronous handler associated with the message session.

Represents the handler associated with the message session.

Represents an exception occurred when the size of the message exceeded the maximum allowed size.

Represents the exception that is thrown for signaling message store lock lost errors.

The exception that is thrown to signal messaging communication errors.

Represents the exception that is thrown for signaling messaging entity already exists errors.

Exception for signaling messaging entity disabled errors.

The exception that is thrown for signaling messaging entity not found errors.

Represents the exception that is thrown for signaling messaging errors.

Provides the details of the messaging exception.

The MessagingFactory class is the anchor class used for run time operations to send and receive to and from queues, topics, or subscriptions.

Represents the messaging factory settings.

Represents the binding that is used for net messaging.

Represents the binding element used to specify a net messaging transport for transmitting messages on the Service Bus.

Represents .NET messaging transport settings.

The exception that is thrown when subscription matching resulted no match.

Provides options associated with message pump processing using OnMessage(Action<BrokeredMessage>) and OnMessage(Action<BrokeredMessage>).

Represents the available options for the shard message.

Represents the exception occurred for the paired messaging factory.

Represents the event arguments associated with paired namespace for the service bus messaging.

Represents the options for the paired namespace for the service bus messaging.

Encapsulates information related to an Event Hubs partition used by IEventProcessor.

Represents the metadata and approximate runtime information for a logical partition of an Event Hub.

Options to control various aspects of partition distribution happening within EventProcessorHost instance.

Represents the exception that is thrown for signaling partition not owned errors.

Represents the approximate runtime information for a logical partition of an Event Hub.

Exception for signaling revoked publisher errors.

Represents the queue client object.

Represents the metadata description of the queue.

The exception that is thrown for signaling quota exceeded errors.

This exception is thrown if two or more EventHubReceiver objects connect to the same Event Hubs partition with different epoch values.

Represents a relay description.

Represents the filter actions which are allowed for the transformation of a message that have been matched by a filter expression.

The exception that is thrown for signaling filter action errors and is thrown when a filter related operation fails.

Represents a description of a rule.

Represents the exception occurred during the sending of availability backlogs.

Represents the exceptions occurred during the sending the availability for the messaging.

Represents the options for the sending the availability of paired namespace.

Represents the exception that is thrown when a server is overloaded with logical operations.

Represents the exception that is thrown when a message cannot acquire lock on a session.

Represents the options for the session handler.

The exception that is thrown to signal session lock lost errors.In the case of partitioned messaging entities, partitions sometimes move to achieve load balancing across Service Bus nodes; for example, when a node restarts or new nodes are added to share the load. When that happens, session locks can be lost, but messages are never lost. If a partition moves after the session is locked, then the acknowledge/complete message processing call fails, because the lock is lost. However, the message remains and you can try to read it again. Thus, you may receive a SessionLockLostException exception even though the message itself is not lost. In this case, you can retry the message processing operation.

Defines the authorization rule for shared access operation.

Represents a filter, which is a combination of an expression and an action that is executed in the publish/subscribe pipeline. For information about the SQLFilter syntax, see SQLFilter syntax.

Represents a set of actions written in SQL language-based syntax that is performed against a BrokeredMessage. For information about SQLRuleAction syntax, see SQLRuleAction syntax.

Represents the anchor class used in run-time operations related to a topic subscription.

Represents a description of the subscription.

An anchor class used to access a TopicDescription to perform run-time operations.

Represents a description of the topic.

Represents an exception when the transaction size exceeds.

Matches a filter expression.

Interfaces

Provides methods for running checkpoint asynchronously. Extensibility is provided to specify host-specific storage for storing the offset. This is provided when RegisterProcessorAsync<T>(Lease, ICheckpointManager) is called, to checkpoint the offset position using CheckpointAsync(EventData).

Provides methods for event processors. Applications must implement this interface, which enables the handling of events from Event Hubs. This interface is the main extensibility point for the EventProcessorHost and RegisterProcessor<T>(Lease, ICheckpointManager).

An interface that provides a factory for creating instances of IEventProcessor.

Represents an interface for the asynchronous handler for the message session.

Represents an interface for the handler factory associated with the message session.

Represents an interface for the handler associated with the message session.

Represents an interface for the handler factory associated with the message session.

Enums

Specifies the possible access rights for a user.

Specifies an enumeration of AllowRuleClaim type.

Enumerates the reason for closing of session.

Enumerates the type of messaging cursor.

Enumerates the status of the entity availability.

Enumerates the possible values for the status of a messaging entity.

Enumerates a message state.

Enumerates the types of error level for the messaging communication.

Enumerates the values for the receive mode. The default is PeekLock.

Enumerates types of messaging tile.

Enumerates the types of image and text for toast notification.

An enumeration that sets the messaging protocol to either NetMessaging (a proprietary protocol to Azure Service Bus) or AMQP (an industry standard).