IMessageBus bus; // injected

await bus.Publish(new SomeMessage())

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

var mbb = MessageBusBuilder
	.Create()
	
	// 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(...)

	// 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 Service Bus provider specific
	);

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

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
   }
}

// 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 topic)
	{
		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 async Task<GenerateThumbnailResponse> OnHandle(GenerateThumbnailRequest request, string topic)
   {
     // 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;
}