EasyNetQ

AsyncSemaphore should be used with a lot of care.

We want to prevent callers hijacking the reader thread; this is a bit nasty, but works; see http://stackoverflow.com/a/22588431/23354 for more information; a huge thanks to Eli Arbel for spotting this (even though it is pure evil; it is *my kind of evil*)

Represents a handler container for events available in .

An event handler for .

Lets you scan assemblies for implementations of so that these will get registrered as subscribers in the bus.

Used when generating the unique SubscriptionId checksum.

Responsible for consuming a message with the relevant message consumer.

Responsible for generating SubscriptionIds, when you use , since it does not let you specify specific SubscriptionIds. Message type and SubscriptionId is the key; which if two equal keys exists, you will get round robin consumption of messages.

Responsible for setting subscription configuration for all auto subscribed consumers . the values may be overriden for particular consumer methods by using an .

Registers all consumers in passed assembly. The actual Subscriber instances is created using . The SubscriptionId per consumer method is determined by or if the method is marked with with a custom SubscriptionId.

The assemblies to scan for consumers.

Registers all types as consumers. The actual Subscriber instances is created using . The SubscriptionId per consumer method is determined by or if the method is marked with with a custom SubscriptionId.

the types to register as consumers.

Registers all async consumers in passed assembly. The actual Subscriber instances is created using . The SubscriptionId per consumer method is determined by or if the method is marked with with a custom SubscriptionId.

The assemblies to scan for consumers.

the types to register as consumers.

The result of the AdvancedBus Get method

True if a message is availabe, false if not.

The message retreived from the queue. This property will throw a MessageNotAvailableException if no message was available. You should check the MessageAvailable property before attempting to access it.

Registers the default EasyNetQ components in our internal super-simple IoC container.

Heartbeat interval seconds. (default is 10)

Operation timeout seconds. (default is 10)

Stolen from SO: http://stackoverflow.com/questions/4596453/create-an-actiont-to-set-a-property-when-i-am-provided-with-the-linq-expres

The default ConsumerDispatcherFactory. It creates a single dispatch queue which all consumers share.

Create the correct implementation of IConsumer based on queue properties

A strategy for dealing with failed messages. When a message consumer thows, HandleConsumerError is invoked. The general priciple is to put all failed messages in a dedicated error queue so that they can be examined and retried (or ignored). Each failed message is wrapped in a special system message, 'Error' and routed by a special exchange named after the orignal message's routing key. This is so that ad-hoc queues can be attached for errors on specific message types. Each exchange is bound to the central EasyNetQ error queue.

This method is fired when an exception is thrown. Implement a strategy for handling the exception here.

The consumer execution context. The exception for processing the original failed message

This method is fired when the task returned from the UserHandler is cancelled. Implement a strategy for handling the cancellation here.

The consumer execution context. for processing the original cancelled message

Add an asynchronous handler

The message type The handler

Add a synchronous handler

The message type The handler

Set to true if the handler collection should throw an EasyNetQException when no matching handler is found, or false if it should return a noop handler. Default is true.

Retrieve a handler from the collection. If a matching handler cannot be found, the handler collection will either throw an EasyNetQException, or return null, depending on the value of the ThrowOnNoMatchingHandler property.

The type of handler to return The handler

Cancel means that an external signal has requested that this consumer should be cancelled. This is _not_ the same as when an internal consumer stops consuming because it has lost its channel/connection.

Add an asychronous message handler to this receiver

The type of message to receive The message handler 'this' for fluent configuration

Add a message handler to this receiver

The type of message to receive The message handler 'this' for fluent configuration

Minimum IoC container inspired by http://ayende.com/blog/2886/building-an-ioc-container-in-15-lines-of-code Note all components are singletons. Only one instance of each will be created.

This event is fired when the logical consumer stops consuming. This is _not_ fired when a connection interruption causes EasyNetQ to re-create a PersistentConsumer.

Allows publish configuration to be fluently extended without adding overloads to IBus e.g. x => x.WithTopic("*.brighton").WithPriority(2)

Sets a priority of the message

The priority to set IPublishConfiguration

Sets a topic for the message

The topic to set IPublishConfiguration

Sets a TTL for the message

The TTL to set in milliseconds IPublishConfiguration

Allows configuration to be fluently extended without adding overloads to IBus e.g. x => x.WithTopic("*.brighton")

The message type to be published

Add a topic for the queue binding

The topic to add

Configures the queue's durability

Configures the consumer's priority

Configures the consumer's x-cancel-on-ha-failover attribute

Configures the consumer's prefetch count

Expiry time can be set for a given queue by setting the x-expires argument to queue.declare, or by setting the expires policy. This controls for how long a queue can be unused before it is automatically deleted. Unused means the queue has no consumers, the queue has not been redeclared, and basic.get has not been invoked for a duration of at least the expiration period. This can be used, for example, for RPC-style reply queues, where many queues can be created which may never be drained. The server guarantees that the queue will be deleted, if unused for at least the expiration period. No guarantee is given as to how promptly the queue will be removed after the expiration period has elapsed. Leases of durable queues restart when the server restarts.

The value of the x-expires argument or expires policy describes the expiration period in milliseconds and is subject to the same constraints as x-message-ttl and cannot be zero. Thus a value of 1000 means a queue which is unused for 1 second will be deleted.

Configures the consumer's to be exclusive

Configures the queue's maxPriority

IAdvancedBus is a lower level API than IBus which gives you fined grained control of routing topology, but keeping the EasyNetQ serialisation, persistent connection, error handling and subscription thread.

Consume a stream of messages

The message type The queue to take messages from The message handler A disposable to cancel the consumer

Consume a stream of messages

The message type The queue to take messages from The message handler Fluent configuration e.g. x => x.WithPriority(10) A disposable to cancel the consumer

Consume a stream of messages asynchronously

The message type The queue to take messages from The message handler A disposable to cancel the consumer

Consume a stream of messages asynchronously

The message type The queue to take messages from The message handler Fluent configuration e.g. x => x.WithPriority(10) A disposable to cancel the consumer

Consume a stream of messages. Dispatch them to the given handlers

The queue to take messages from A function to add handlers to the consumer A disposable to cancel the consumer

Consume a stream of messages. Dispatch them to the given handlers

The queue to take messages from A function to add handlers to the consumer Fluent configuration e.g. x => x.WithPriority(10) A disposable to cancel the consumer

Consume raw bytes from the queue.

The queue to subscribe to The message handler. Takes the message body, message properties and some information about the receive context. A disposable to cancel the consumer

Consume raw bytes from the queue.

The queue to subscribe to The message handler. Takes the message body, message properties and some information about the receive context. Fluent configuration e.g. x => x.WithPriority(10) A disposable to cancel the consumer

Consume raw bytes from the queue.

The queue to subscribe to The message handler. Takes the message body, message properties and some information about the receive context. Returns a Task. A disposable to cancel the consumer

Consume raw bytes from the queue.

The queue to subscribe to The message handler. Takes the message body, message properties and some information about the receive context. Returns a Task. Fluent configuration e.g. x => x.WithPriority(10) A disposable to cancel the consumer

Publish a message as a byte array

The exchange to publish to The routing key for the message. The routing key is used for routing messages depending on the exchange configuration. This flag tells the server how to react if the message cannot be routed to a queue. If this flag is true, the server will return an unroutable message with a Return method. If this flag is false, the server silently drops the message. The message properties The message body

Publish a message as a .NET type

Publish a message as a .NET type when the type is only known at runtime. Use the generic version of this method when you know the type of the message at compile time. Task completes after publish has completed. If publisherConfirms=true is set in the connection string, the task completes after an ACK is received. The task will throw on either NACK or timeout.

Publish a message as a .NET type Task completes after publish has completed. If publisherConfirms=true is set in the connection string, the task completes after an ACK is received. The task will throw on either NACK or timeout.

Publish a message as a byte array. Task completes after publish has completed. If publisherConfirms=true is set in the connection string, the task completes after an ACK is received. The task will throw on either NACK or timeout.

Declare a queue. If the queue already exists this method does nothing

The name of the queue Throw an exception rather than create the queue if it doesn't exist Durable queues remain active when a server restarts. Exclusive queues may only be accessed by the current connection, and are deleted when that connection closes. If set, the queue is deleted when all consumers have finished using it. Determines how long a message published to a queue can live before it is discarded by the server. Determines how long a queue can remain unused before it is automatically deleted by the server. Determines the maximum message priority that the queue should support. Determines an exchange's name can remain unused before it is automatically deleted by the server. If set, will route message with the routing key specified, if not set, message will be routed with the same routing keys they were originally published with. The maximum number of ready messages that may exist on the queue. Messages will be dropped or dead-lettered from the front of the queue to make room for new messages once the limit is reached The maximum size of the queue in bytes. Messages will be dropped or dead-lettered from the front of the queue to make room for new messages once the limit is reached The queue

Declare a queue. If the queue already exists this method does nothing

Declare a transient server named queue. Note, this queue will only last for duration of the connection. If there is a connection outage, EasyNetQ will not attempt to recreate consumers.

The queue

Delete a queue

The queue to delete Only delete if unused Only delete if empty

Purges a queue

The queue to purge

Declare an exchange

The exchange name The type of exchange Throw an exception rather than create the exchange if it doens't exist Durable exchanges remain active when a server restarts. If set, the exchange is deleted when all queues have finished using it. If set, the exchange may not be used directly by publishers, but only when bound to other exchanges. Route messages to this exchange if they cannot be routed. If set, declars x-delayed-type exchange for routing delayed messages. The exchange

Declare an exchange

Delete an exchange

The exchange to delete If set, the server will only delete the exchange if it has no queue bindings.

Bind an exchange to a queue. Does nothing if the binding already exists.

The exchange to bind The queue to bind The routing key A binding

Bind an exchange to a queue. Does nothing if the binding already exists.

The exchange to bind The queue to bind The routing key A binding

Bind two exchanges. Does nothing if the binding already exists.

The source exchange The destination exchange The routing key A binding

Bind two exchanges. Does nothing if the binding already exists.

The source exchange The destination exchange The routing key A binding

Delete a binding

the binding to delete

Get a message from the given queue.

The message type to get The queue from which to retreive the message An IBasicGetResult.

Get the raw message from the given queue.

The queue from which to retreive the message An IBasicGetResult

Counts messages in the given queue

The queue in which to count messages The number of counted messages

True if the bus is connected, False if it is not.

Event fires when the bus has connected to a RabbitMQ broker.

Event fires when the bus has disconnected from a RabbitMQ broker.

Event fires when the bus gets blocked due to the broker running low on resources.

Event fires when the bus is unblocked.

Event fires when a mandatory or immediate message is returned as un-routable

The IoC container that EasyNetQ uses to resolve its services.

The conventions used by EasyNetQ to name its routing topology elements.

Provides a simple Publish/Subscribe and Request/Response API for a message bus.

Publishes a message.

The message type The message to publish

Publishes a message.

The message type The message to publish Fluent configuration e.g. x => x.WithTopic("*.brighton").WithPriority(2)

Publishes a message with a topic

The message type The message to publish The topic string

Publishes a message. When used with publisher confirms the task completes when the publish is confirmed. Task will throw an exception if the confirm is NACK'd or times out.

The message type The message to publish

Publishes a message. When used with publisher confirms the task completes when the publish is confirmed. Task will throw an exception if the confirm is NACK'd or times out.

The message type The message to publish Fluent configuration e.g. x => x.WithTopic("*.brighton").WithPriority(2)

Publishes a message with a topic. When used with publisher confirms the task completes when the publish is confirmed. Task will throw an exception if the confirm is NACK'd or times out.

The message type The message to publish The topic string

Subscribes to a stream of messages that match a .NET type.

The type to subscribe to A unique identifier for the subscription. Two subscriptions with the same subscriptionId and type will get messages delivered in turn. This is useful if you want multiple subscribers to load balance a subscription in a round-robin fashion. The action to run when a message arrives. When onMessage completes the message recipt is Ack'd. All onMessage delegates are processed on a single thread so you should avoid long running blocking IO operations. Consider using SubscribeAsync An Call Dispose on it or on its to cancel the subscription.

Subscribes to a stream of messages that match a .NET type.

The type to subscribe to A unique identifier for the subscription. Two subscriptions with the same subscriptionId and type will get messages delivered in turn. This is useful if you want multiple subscribers to load balance a subscription in a round-robin fashion. The action to run when a message arrives. When onMessage completes the message recipt is Ack'd. All onMessage delegates are processed on a single thread so you should avoid long running blocking IO operations. Consider using SubscribeAsync Fluent configuration e.g. x => x.WithTopic("uk.london") An Call Dispose on it or on its to cancel the subscription.

Subscribes to a stream of messages that match a .NET type. Allows the subscriber to complete asynchronously.

The type to subscribe to A unique identifier for the subscription. Two subscriptions with the same subscriptionId and type will get messages delivered in turn. This is useful if you want multiple subscribers to load balance a subscription in a round-robin fashion. The action to run when a message arrives. onMessage can immediately return a Task and then continue processing asynchronously. When the Task completes the message will be Ack'd. An Call Dispose on it or on its to cancel the subscription.

Subscribes to a stream of messages that match a .NET type.

The type to subscribe to A unique identifier for the subscription. Two subscriptions with the same subscriptionId and type will get messages delivered in turn. This is useful if you want multiple subscribers to load balance a subscription in a round-robin fashion. The action to run when a message arrives. onMessage can immediately return a Task and then continue processing asynchronously. When the Task completes the message will be Ack'd. Fluent configuration e.g. x => x.WithTopic("uk.london").WithArgument("x-message-ttl", "60") An Call Dispose on it or on its to cancel the subscription.

Makes an RPC style request

The request type. The response type. The request message. The response

Makes an RPC style request.

The request type. The response type. The request message. A task that completes when the response returns

Responds to an RPC request.

The request type. The response type. A function to run when the request is received. It should return the response.

Responds to an RPC request.

The request type. The response type. A function to run when the request is received. It should return the response. A function for responder configuration

Responds to an RPC request asynchronously.

The request type. The response type A function to run when the request is received.

Responds to an RPC request asynchronously.

The request type. The response type A function to run when the request is received. A function for responder configuration

Send a message directly to a queue

The type of message to send The queue to send to The message

Send a message directly to a queue

The type of message to send The queue to send to The message

Receive messages from a queue. Multiple calls to Receive for the same queue, but with different message types will add multiple message handlers to the same consumer.

The type of message to receive The queue to receive from The message handler

Receive messages from a queue. Multiple calls to Receive for the same queue, but with different message types will add multiple message handlers to the same consumer.

The type of message to receive The queue to receive from The message handler Action to configure consumer with

Receive messages from a queue. Multiple calls to Receive for the same queue, but with different message types will add multiple message handlers to the same consumer.

The type of message to receive The queue to receive from The asychronous message handler

Receive messages from a queue. Multiple calls to Receive for the same queue, but with different message types will add multiple message handlers to the same consumer.

The type of message to receive The queue to receive from The asychronous message handler Action to configure consumer with

Receive a message from the specified queue. Dispatch them to the given handlers

The queue to take messages from A function to add handlers Consumer cancellation. Call Dispose to stop consuming

Receive a message from the specified queue. Dispatch them to the given handlers

The queue to take messages from A function to add handlers Action to configure consumer with Consumer cancellation. Call Dispose to stop consuming

True if the bus is connected, False if it is not.

Return the advanced EasyNetQ advanced API.

Provides a strategy for selecting a host from a list of nodes in a cluster

Add a cluster node

Get the currently selected node

Move to the next node

Mark the current node as successfully connected

Did the current node successfully connect?

The current node has disconnected and we want to run the strategy again

An internal pub-sub bus to distribute events within EasyNetQ

The message body as a .NET type. This will return the same underlying object than but will be strongly typed.

The message properties.

The message body return as an object when we only have runtime types and can't use generics.

The message . This is a shortcut to GetBody().GetType().

Combines IServiceProvider and IServiceRegister. Represents an implementation of an IoC container. Implement this interface To wrap your favorite IoC container to work with EasyNetQ. Not all service instances should be defined as singletons.

Provides service instances

Get an instance of the requested services. Note all services are singletons; multiple calls to Resolve will all return the same instance.

The type of serivce to return The single instance of the service

Register a service with a factory method. Note that the first registration wins. All subsequent registrations will be ignored.

The type of the service to be registered A function that can create an instance of the service itself for nice fluent composition

The type of the service to be registered The implementation type itself for nice fluent composition

The result of an Subscribe or SubscribeAsync operation. In order to cancel the subscription, call dispose on this object or on ConsumerCancellation.

The to which is bound.

The that the underlying is consuming.

The cancellation, which can be disposed to cancel the subscription.

noop logger

Creates a generic and returns it casted as so it can be used in scenarios where we only have a runtime available.

MIME Content type

MIME content encoding

message header field table

non-persistent (1) or persistent (2)

message priority, 0 to 9

application correlation identifier

destination to reply to

message expiration specification

application message identifier

message timestamp

message type name

creating user id

creating application id

intra-cluster routing identifier

Marker interface to indicate that a message supersedes a previous version.

Requires that and are registered in the to take advantage of message version support. The tpye of the message being superseded. In the following code, MessageV2 extends and supersedes MessageV1. When MessageV2 is published, it will also be routed to any MessageV1 subscribers.


            
            {
            	public DateTime SomeOtherProperty { get; set; }
            }
            ]]>

A collection that hands out the next item until success, or until every item has been tried.

Initialization method that should be called only once, usually right after the implementation constructor has run.

A connection that attempts to reconnect if the inner connection is closed.

Collection of precondition methods for qualifying method arguments.

Ensures that is not null.

The value to check, must not be null. The name of the parameter the value is taken from, must not be blank. Thrown if is null. Thrown if is blank.

Ensures that is not null.

The value to check, must not be null. The name of the parameter the value is taken from, must not be blank. The message to provide to the exception if is null, must not be blank. Thrown if is null. Thrown if or are blank.

Ensures that is not blank.

The value to check, must not be blank. The name of the parameter the value is taken from, must not be blank. The message to provide to the exception if is blank, must not be blank. Thrown if , , or are blank.

Ensures that is not blank.

The value to check, must not be blank. The name of the parameter the value is taken from, must not be blank. Thrown if or are blank.

Ensures that contains at least one item.

The collection to check, must not be null or empty. The name of the parameter the collection is taken from, must not be blank. The message to provide to the exception if is empty, must not be blank. Thrown if is empty, or if or are blank.

Ensures that is true.

The value to check, must be true. The name of the parameter the value is taken from, must not be blank. The message to provide to the exception if is false, must not be blank. Thrown if is false, or if or are blank.

Ensures that is false.

The value to check, must be false. The name of the parameter the value is taken from, must not be blank. The message to provide to the exception if is true, must not be blank. Thrown if is true, or if or are blank.

Invokes client commands on a single channel. All commands are marshalled onto a single thread.

Responsible for invoking client commands.

An RPC style request-response pattern

Make a request to an RPC service

The request type The response type The request message Returns a task that yields the result when the response arrives

Set up a responder for an RPC service.

The request type The response type A function that performs the response

Set up a responder for an RPC service.

The request type The response type A function that performs the response A function that performs the configuration

Send a message to the specified queue

The type of message to send The queue to send the message to The message to send

Send a message to the specified queue

The type of message to send The queue to send the message to The message to send

Receive a message from the specified queue

The type of message to receive The queue to receive from The synchronous function that handles the message Consumer cancellation. Call Dispose to stop consuming

Receive a message from the specified queue

The type of message to receive The queue to receive from The synchronous function that handles the message Action to configure consumer with Consumer cancellation. Call Dispose to stop consuming

Receive a message from the specified queue

The type of message to receive The queue to receive from The asynchronous function that handles the message Consumer cancellation. Call Dispose to stop consuming

Receive a message from the specified queue

The type of message to receive The queue to receive from The asynchronous function that handles the message Action to configure consumer with Consumer cancellation. Call Dispose to stop consuming

Receive a message from the specified queue. Dispatch them to the given handlers

The queue to take messages from A function to add handlers Consumer cancellation. Call Dispose to stop consuming

Receive a message from the specified queue. Dispatch them to the given handlers

The queue to take messages from A function to add handlers Action to configure consumer with Consumer cancellation. Call Dispose to stop consuming

Default implementation of EasyNetQ's request-response pattern

Static methods to create EasyNetQ core APIs.

Set the container creation function. This allows you to replace EasyNetQ's default internal IoC container. Note that all components should be registered as singletons. EasyNetQ will also call Dispose on components that are no longer required.

Creates a new instance of . The RabbitMQ broker is defined in the connection string named 'rabbit'.

A new instance.

Creates a new instance of . The RabbitMQ broker is defined in the connection string named 'rabbit'.

Override default services. For example, to override the default : RabbitHutch.CreateBus("host=localhost", x => x.Register{IEasyNetQLogger}(_ => myLogger)); A new instance.

Creates a new instance of . The RabbitMQ broker is defined in the connection string named 'rabbit'.

An instance which is used to add handlers to the events of the newly created . As attempts to connect during instantiation, specifying a before instantiation is the only way to catch the first event. Override default services. For example, to override the default : RabbitHutch.CreateBus("host=localhost", x => x.Register{IEasyNetQLogger}(_ => myLogger)); A new instance.

Creates a new instance of . The RabbitMQ broker is defined in the connection string named 'rabbit'.

Creates a new instance of .

The EasyNetQ connection string. Example: host=192.168.1.1;port=5672;virtualHost=MyVirtualHost;username=MyUsername;password=MyPassword;requestedHeartbeat=10 The following default values will be used if not specified: host=localhost;port=5672;virtualHost=/;username=guest;password=guest;requestedHeartbeat=10 An instance which is used to add handlers to the events of the newly created . As attempts to connect during instantiation, specifying a before instantiation is the only way to catch the first event. A new instance.

Creates a new instance of .

The EasyNetQ connection string. Example: host=192.168.1.1;port=5672;virtualHost=MyVirtualHost;username=MyUsername;password=MyPassword;requestedHeartbeat=10 The following default values will be used if not specified: host=localhost;port=5672;virtualHost=/;username=guest;password=guest;requestedHeartbeat=10 Override default services. For example, to override the default : RabbitHutch.CreateBus("host=localhost", x => x.Register{IEasyNetQLogger}(_ => myLogger)); A new instance.

Creates a new instance of .

The RabbitMQ broker. The RabbitMQ broker port. The RabbitMQ virtualHost. The username to use to connect to the RabbitMQ broker. The password to use to connect to the RabbitMQ broker. The initially requested heartbeat interval, in seconds; zero for none. An instance which is used to add handlers to the events of the newly created . As attempts to connect during instantiation, specifying a before instantiation is the only way to catch the first event. Override default services. For example, to override the default : RabbitHutch.CreateBus("host=localhost", x => x.Register{IEasyNetQLogger}(_ => myLogger)); A new instance.

Creates a new instance of .

An instance. Override default services. For example, to override the default : RabbitHutch.CreateBus("host=localhost", x => x.Register{IEasyNetQLogger}(_ => myLogger)); A new instance.

Creates a new instance of .

An instance. An instance which is used to add handlers to the events of the newly created . As attempts to connect during instantiation, specifying a before instantiation is the only way to catch the first event. Override default services. For example, to override the default : RabbitHutch.CreateBus("host=localhost", x => x.Register{IEasyNetQLogger}(_ => myLogger)); A new instance.

A factory method that creates an instance of using a public parameterless constructor. If no such constructor is found on , a will be thrown.

A factory method that creates an instance of the specified using a public constructor that accepts one argument of the type of . If no such constructor is found on type of , a will be thrown.

A factory method that creates an instance of the specified using a public constructor that accepts two arguments of the type of and in that order. If no such constructor is found on type of , a will be thrown.

Schedule a message to be published at some time in the future. This required the EasyNetQ.Scheduler service to be running.

The message type The IBus instance to publish on The time at which the message should be sent (UTC) The message to response with

Schedule a message to be published at some time in the future. This required the EasyNetQ.Scheduler service to be running.

The message type The IBus instance to publish on The time at which the message should be sent (UTC) The message to response with The topic string

Schedule a message to be published at some time in the future. This required the EasyNetQ.Scheduler service to be running.

The message type The IBus instance to publish on The time at which the message should be sent (UTC) An identifier that can be used with CancelFuturePublish to cancel the sending of this message at a later time The message to response with

Schedule a message to be published at some time in the future. This required the EasyNetQ.Scheduler service to be running.

Schedule a message to be published at some time in the future, using bare RabbitMQ's capabilites (message time-to-live and dead letter exchange).

The message type The IBus instance to publish on The delay time for message to publish in future The message to response with

Schedule a message to be published at some time in the future, using bare RabbitMQ's capabilites (message time-to-live and dead letter exchange).

The message type The IBus instance to publish on The delay time for message to publish in future The message to response with The topic string

Unschedule all messages matching the cancellationKey.

The IBus instance to publish on The identifier that was used when originally scheduling the message with FuturePublish