Course info
Sep 17, 2012
4h 43m

NServiceBus is an open source service bus built on the .NET platform. It combines the durability of store-and-forward queuing technologies like MSMQ with reliability-enhancing features such as retries and error queues. With durable publish and subscribe facilities, NServiceBus is a perfect fit as the communication backbone for your event driven architectures, enabling you to build robust systems able to withstand the harsh reality of production environments.

About the author
About the author

Andreas Öhlund is the lead developer for the popular open source service bus NServiceBus.

Section Introduction Transcripts
Section Introduction Transcripts

Hello, this is Andreas Ohlund from Pluralsight and I'm here to introduce you to NServiceBus. NServiceBus is an open-source communication framework that focus mainly on asynchronous one way messaging. We are going to cover a broad range of topics so this will be interesting for both beginners and more advanced users. This first module is going to walk you through how you go about installing the framework. We are going to set up a new project and we'll round this first module off by introducing a sample system that we'll together build out throughout the course. So with that, let's get started.

One Way Messaging Basics
Andreas Ohland: Hello. This is Andreas Ohland from Pluralsight. In this module we'll go through the basics of one-way messaging and how messaging compares to other communications styles like remote procedure call, RPC. We'll also see how the fallacies of distributed computing effects how we build IT system. We'll move on and start building out our sample application to add a one-way messaging direction between our API and our backend. And we'll see how NServiceBus interacts with the queuing system to help you build robust solutions. And after this module, you will know how to define a message and send it off using NServiceBus and write code and to process them as such on the receiving side. ( Pause )

Advanced One Way Messaging
This is Andreas Ohlund from Pluralsight. In this module we'll talk about some of the more advanced aspects of one-way messaging. We'll start off by talking about exception management, and how managing exceptions is quite different in message-based solutions than it is in more traditional ones. We'll see how distributed transactions can help us build consistent solutions that doesn't lose or corrupt business data during a failure or high load conditions. We'll move on and talk about the penance injection and how that can help you keep your message handlers clean from infrastructure related code. And finally, we'll wrap up by looking at the support for unit of work management in NServiceBus.

Customized Messaging
This is Andreas Ohlund from Pluralsight. In this module, we'll look at how we can customize the NServiceBus framework. We'll start off by building an authentication mechanism for our BusStop sample application. To do that, we will look at the ways we can manipulate the message pipeline that NServiceBus built for us; how we can use more than one message handler for a given message and how we can control the order of which those handlers are invoked. We'll move on and talk about changing the message content; how we can use both incoming and outgoing message mutators to alter both contents and headers of messages going in and out of endpoints. We'll see how we can use auditing to get a centralized view of what's going on in our fully distributed system, and then look into how we can integrate NServiceBus on the web API; how we can configure a way API to resolve all of its controllers through the NServiceBus container. And finally, we'll look at different ways to manipulate the NServiceBus configuration system.

Full Duplex Messaging
This is Andreas Ohlund from Pluralsight. In this module, we'll talk about full duplex messaging. We'll see how you can use a service pass to do request/response style interactions between clients and servers. We'll dig deeper into the fallacy that latency is the problem. And we'll see how messaging will force you to not make any assumptions in this area. We'll start introducing billing into our sample application and that will lead us into talking about how we can use messaging to help out in integration scenarios. And we'll wrap up with refactoring the billing solution to take the theory lesson into account and make a more robust version of the billing integration. ( pause )

Publish and Subscribe
This is Andreas Ohlund from Pluralsight. In this module, we'll talk about the publish and subscribed pattern, the Rolls Royce of all the messaging patterns. And, we'll see how that is the preferred way to transport data between different services in your service oriented architecture; how pubsub flows those event across different services. We'll, then, take a closer look at the mechanics of the pattern itself, how the advertise phase, subscribe phase and published phase, all together, forms the pubsub pattern. We'll see how NServiceBus supports this in detail. And, with all this knowledge, we'll then go back to our bus stop sample application and refractor it a bit to make billing a service of its own, and we'll use NServiceBus to transport events between our sales and billing service. Finally, we'll take a closer look at the iEvent and iCommand interfaces that come with NServiceBus that will help you reveal more the intent of the message to NServiceBus, so that the framework itself can help you to enforce messaging best practices. At last, but not least, we'll talk about the unobtrusive mode of NServiceBus, where we can define messages without having any references to NServiceBus at all. ( Silence )