IMessageBus bus; // injected

await bus.Publish(new SomeMessage())

public class SomeMessageConsumer : IConsumer<SomeMessage>
{
   public Task OnHandle(SomeMessage message, string name) // name = topic or queue name
   {
       // handle the message
   }
}

var messageResponse = await bus.Send(new MessageRequest());

public class MessageRequestHandler : IRequestHandler<MessageRequest, MessageResponse>
{
   public async Task<MessageResponse> OnHandle(MessageRequest request, string name)
   {
      // handle the request message and return response
   }
}

var builder = MessageBusBuilder.Create()
	
   // Pub/Sub example:
   .Produce<SomeMessage>(x => x.DefaultTopic("some-topic"))
   .Consume<SomeMessage>(x => x
      .Topic("some-topic")
      .WithConsumer<SomeMessageConsumer>()
      //.Group("some-kafka-consumer-group") //  Kafka provider specific
      //.SubscriptionName("some-azure-sb-topic-subscription") // Azure ServiceBus provider specific
   )
	
   // Use JSON for message serialization                
   .WithSerializer(new JsonMessageSerializer())
   // Use DI from ASP.NET Core (or Autofac, Unity, ServiceLocator)
   .WithDependencyResolver(new AspNetCoreMessageBusDependencyResolver(serviceProvider))
	
   // Use Apache Kafka transport provider
   .WithProviderKafka(new KafkaMessageBusSettings("localhost:9092"));
   // Use Azure Service Bus transport provider
   //.WithProviderServiceBus(...)
   // Use Azure Azure Event Hub transport provider
   //.WithProviderEventHub(...)
   // Use Redis transport provider
   //.WithProviderRedis(...)
   // Use in-memory transport provider
   //.WithProviderMemory(...)

// Build the bus from the builder. Message consumers will start consuming messages from the configured topics/queues of the chosen provider.
IMessageBus bus = builder.Build();

// Register bus in your DI

// domain event
public class OrderSubmittedEvent
{
   public Order Order { get; }
   public DateTime Timestamp { get; }

   public OrderSubmittedEvent(Order order) { ... }
}

// domain event handler
public class OrderSubmittedHandler : IConsumer<OrderSubmittedEvent>
{
   public Task OnHandle(OrderSubmittedEvent e, string name)
   {
      Console.WriteLine("Customer {0} {1} just placed an order for:", e.Order.Customer.Firstname, e.Order.Customer.Lastname);
      foreach (var orderLine in e.Order.Lines)
      {
         Console.WriteLine("- {0}x {1}", orderLine.Quantity, orderLine.ProductId);
      }

      Console.WriteLine("Generating a shipping order...");
      return Task.Delay(1000);
   }
}

// aggregate root
public class Order
{
   public Customer Customer { get; }
   private IList<OrderLine> _lines = new List<OrderLine>();
   public OrderState State { get; private set; }

   public IEnumerable<OrderLine> Lines => _lines.AsEnumerable();

   public Order(Customer customer)
   {
      State = OrderState.New;
      Customer = customer;
   }

   public OrderLine Add(string productId, int quantity) { }

   public void Submit()
   {
      State = OrderState.Submitted;

      var e = new OrderSubmittedEvent(this);
      MessageBus.Current.Publish(e).Wait(); // raise domain event
   }
}

var john = new Customer("John", "Whick");

var order = new Order(john);
order.Add("id_machine_gun", 2);
order.Add("id_grenade", 4);

order.Submit(); // events fired here

// Define the recipie how to create our IMessageBus
var mbb = MessageBusBuilder.Create()
   .Produce<OrderSubmittedEvent>(x => x.DefaultTopic(x.MessageType.Name))
   .Consume<OrderSubmittedEvent>(x => x.Topic(x.MessageType.Name).WithConsumer<OrderSubmittedHandler>())
   .WithDependencyResolver(new AutofacMessageBusDependencyResolver())
   .WithProviderMemory(new MemoryMessageBusSettings
   {
      // supress serialization and pass the same event instance to subscribers (events contain domain objects we do not want serialized, also we gain abit on speed)
      EnableMessageSerialization = false
   });

// Create the IMessageBus instance from the builder
IMessageBus bus = mbb.Build();

// Set the provider to resolve our bus - this setup will work as a singleton.
MessageBus.SetProvider(() => bus);

private readonly IRequestResponseBus _bus;
// ...
[Route("{fileId}")]
public async Task<HttpResponseMessage> GetImageThumbnail(string fileId, ThumbnailMode mode, int w, int h)
{
   var thumbFileContent = // ... try to load content for the desired thumbnail w/h/mode/fileId
   if (thumbFileContent == null)
   {
      // Task will await until response comes back (or timeout happens). The HTTP request will be queued and IIS processing thread released.
      var thumbGenResponse = await _bus.Send(new GenerateThumbnailRequest(fileId, mode, w, h));
      thumbFileContent = await _fileStore.GetFile(thumbGenResponse.FileId);
   }
   return ServeStream(thumbFileContent);
}

public class GenerateThumbnailRequestHandler : IRequestHandler<GenerateThumbnailRequest, GenerateThumbnailResponse>
{
   public Task<GenerateThumbnailResponse> OnHandle(GenerateThumbnailRequest request, string name)
   {
      // some processing
      return new GenerateThumbnailResponse { FileId = thumbnailFileId };
   }
}

var thumbGenResponse = await _bus.Send(new GenerateThumbnailRequest(fileId, mode, w, h));

private IMessageBus BuildMessageBus()
{
   // unique id across instances of this application (e.g. 1, 2, 3)
   var instanceId = Configuration["InstanceId"];
   var kafkaBrokers = Configuration["Kafka:Brokers"];

   var instanceGroup = $"webapi-{instanceId}";
   var instanceReplyTo = $"webapi-{instanceId}-response";

   var mbb = MessageBusBuilder.Create()
      .Produce<GenerateThumbnailRequest>(x =>
      {
         //x.DefaultTimeout(TimeSpan.FromSeconds(10)); // Default response timeout for this request type
         x.DefaultTopic("thumbnail-generation"); // Use this topic as default when topic is not specified in IMessageBus.Publish() for that message type
      })
      .ExpectRequestResponses(x =>
      {
         x.ReplyToTopic(instanceReplyTo); // Expect all responses to my reqests replied to this topic
         x.Group(instanceGroup); // Kafka consumer group	    
         x.DefaultTimeout(TimeSpan.FromSeconds(30)); // Default global response timeout
      })
      .WithDependencyResolver(new AutofacMessageBusDependencyResolver())
      .WithSerializer(new JsonMessageSerializer())
      .WithProviderKafka(new KafkaMessageBusSettings(kafkaBrokers));

   var messageBus = mbb.Build();
   return messageBus;
}

private static IMessageBus BuildMessageBus()
{
   // unique id across instances of this application (e.g. 1, 2, 3)
   var instanceId = Configuration["InstanceId"];
   var kafkaBrokers = Configuration["Kafka:Brokers"];

   var instanceGroup = $"worker-{instanceId}";
   var sharedGroup = "workers";

   var mbb = MessageBusBuilder.Create()
      .Handle<GenerateThumbnailRequest, GenerateThumbnailResponse>(s =>
      {
         s.Topic("thumbnail-generation", t =>
         {
            t.WithHandler<GenerateThumbnailRequestHandler>()
               .Group(sharedGroup) // kafka consumer group
               .Instances(3);
         });
      })
      .WithDependencyResolver(new AutofacMessageBusDependencyResolver())
      .WithSerializer(new JsonMessageSerializer())
      .WithProviderKafka(new KafkaMessageBusSettings(kafkaBrokers));

   var messageBus = mbb.Build();
   return messageBus;
}