Routing

"Routing" is what happens when Rebus, based on some logic that you configure somehow, decide where to send your message.

You don't HAVE to configure anything in order to send messages - you can specify their destination manually, like so:

await bus.SendLocal(someMessage);

in order to send a message directly to yourself, or

await bus.Advanced.Routing.Send("another.queue", someMessage);

to send a message to another.queue. In some cases, this can be fine, but as the size of your system grows, explicitly routing messages is NOT the preferred way. This is mainly due to two facts:

1. Hardcoding message destinations makes your system unflexible.
2. Your application should not care about these things - routing should be implemented by the bus.

(although bus.SendLocal might still make a lot of sense if the sent message is "private" to the endpoint and thus is only used internally)

Therefore, Rebus has an extra level of indirection that helps you route messages by adding some configuration.

How do you use the bus to route things?

The most basic routing mechanism in Rebus is based on "topics", where a topic is just a string, like so: "great topic". This is pretty low level, and as such it is not that useful.

On top of this mechanism, Rebus enables you to route your messages based on their type, which has proven to be such a useful model that it's the default routing mechanism, and is the one most prominently exposed in the API.

In order to configure the type-based routing, you use the Routing part of the configurer, like so:

Configure.With(...)
    .(...)
    .Routing(r => r.TypeBased())
    .(...);

The TypeBased() configuration extension above can then be fluently built upon with more extension methods, e.g. like so:

r.TypeBased()
    .Map<SomeMessage>("owner.of.SomeMessage")

in order to declare that the owner of SomeMessage is the endpoint receiving messages from the owner.of.SomeMessage queue, or

r.TypeBased()
    .MapAssemblyOf<SomeMessage>("owner.of.SomeMessage")

in order to declare that all message types from the assembly containing SomeMessage are owned by owner.of.SomeMessage.

What is this thing about "owning" a message type?

Messages can usually be said to be owned by an endpoint somewhere.

If the message type is a request or a reply, the owner would be the server that is capable of handling that request and sending back that reply.

If the message type is an event, the owner would be the publisher publishing that event.