In my last post I provided a walkthrough that allows you to send a typed Brokered Message from a Console application to a Service Bus Queue, have BizTalk retrieve this message and then write it to disk. I am now going to expand upon that scenario and describe how we can leverage Brokered Message properties within BizTalk to route the message to different locations using BizTalk’s promoted properties.
What is a Brokered Message Property?
In many ways a Brokered Message Property is very similar to a Promoted Property within BizTalk. These properties can be used to capture meta-data outside the body of the message. We can then use these properties for routing within the Service Bus when delivering messages to different Service Bus Topics. It is important to note that we don’t have to use these properties for just routing. We can also use them as part of business logic in downstream systems if we so desire.
Why is this important for BizTalk?
As I mentioned in the previous paragraph we can use Promoted Properties within BizTalk to route messages and we can also use it to capture meta data if we want (although you should look at distinguished fields instead if that is your intent). In the BizTalk 2010 R2 CTP there is now support for transitioning Brokered Messages Properties from Service Bus Queue clients to BizTalk promoted properties. BizTalk applications themselves do not understand a Brokered Message property, but BizTalk will convert these Brokered Message Properties into BizTalk Promoted Properties where they can be used to route messages.
In my previous blog post I used a Power Outage scenario. My client application would pass along customer information to a Service Bus Queue and then BizTalk would pick that message up and write it to disk. In a ‘real life’ scenario I would have routed that message to a Customer Information System (CIS) or a Work Order Management (WOM) system so that a field operations team could address the power outage. In this walkthrough I am going to build upon that scenario. This difference this time around is that I am going to introduce a Brokered Message Property called isCriticalCustomer. I hate to publicly admit it but not all customers are treated equally when it comes to delivering power. An example of a Critical Customer may be a hospital. It is more important for a Power company to get their power on before yours. A patient’s respirator is more important that someone watching the latest American Idol episode.
Within my Console application this isCriticalCustomer property will be set as a Brokered Message Property. When this message is retrieved by BizTalk this property will be converted into a Promoted Property and BizTalk will then use that Promoted Property to route the message to a different destination.
Note: A person with a lot of Service Bus experience may say why don’t you just use Topics? I could have a Topic for regular customers and a Topic for Critical Customers. This is also a valid pattern but for the purposes of demonstrating BizTalk capabilities I will leave the routing to BizTalk.
Modifying Queue Client
I am not going to display all of the code required for this client to work. I am going to be adopting the code I listed in my previous post. So please refer back to that post for the starting point. I will include any areas within this post where I have made changes.
In the code below I am going to create and send two messages. In red you will discover that I am setting a Brokered Message Property called isCriticalCustomer. In the first message I am indicating that this is not a critical customer (aka a regular customer). In the second message I am saying that it will be a Critical Customer. Once we get to the BizTalk section you will see how we can use this property to route the message within BizTalk.
//Create new instance of PowerOut object
//This customer will not be a Critical Customer
PowerOut po = new PowerOut();
po.CustomerName = "Stephen Harper";
po.PhoneNumber = "613-123-4567";
po.Address = "24 Sussex Drive";
BrokeredMessage message = new BrokeredMessage(po, new DataContractSerializer(typeof(PowerOut)));
//Create new instance of PowerOut object
//This customer will be a Critical Customer
po = new PowerOut();
po.CustomerName = "Calgary General Hospital";
po.PhoneNumber = "403-123-4567";
po.Address = "1 Red Mile Drive";
message = new BrokeredMessage(po, new DataContractSerializer(typeof(PowerOut)));
You may recall from my previous post that my BizTalk solution was very simple as I only had a schema that represented this Customer message being sent from my client application. So in order to support our new scenario I only need to add one more artifact to my solution and that is a Property Schema. The reason why I need to add this schema is that I need an artifact within my BizTalk application to “hold” these values as they are being populated when BizTalk receives the message. This is no different than when you want take a value from one of your “regular” BizTalk schemas and turn it into a Promoted Property.
Within our BizTalk solution we need to do the following:
- Add a PropertySchema to our project. Once it has been added there will be a default property that we will rename to isCriticalCustomer and change the data type to be a boolean.
- We now need to re-deploy our application.
- Open up the ReceiveBMfromServiceBus Receive Location, click the Configure button. Now click on the Properties tab. Within this tab we are going to specify our namespace for our PropertySchema. If you are unsure where you can get this namespace from, look in the image above and notice the value of the targetNamespace matches the value that I have put in this text box. We also need to ensure that the Promote Brokered Message Properties checkbox is checked on.
- Next we are going to remove our previous Send Port and create two new Send Ports. One send port will be for Regular Customers and the other will be created for Critical Customers.
- Below is the Send Port for regular customers. Notice that a separate sub-folder called RegularCustomers has been created for these files.
- Click on the Filters label and then add a new Property. You will notice that within the dropdown list you will find the property that we created in our PropertySchema called isCriticalCustomer. We need to select this value and then set the value to false.
Note: When you pull down the Property drop down you will also discover the Out of the Box Service Bus Brokered Message properties. These properties are out of the scope of this post but it is something that may be beneficial down the road.
- We now want to perform similar actions to our other send Port that will be use to send our CriticalCustomer messages.
- Once again we are going to click on the Filters label. We will use the isCriticalCustomer property again but this time we will set the Value to true.
- We can now bounce any affected Host Instance(s) and start our application.
As you my recall, we modified our Console application so that it will send two messages to the same PowerOutage queue. In the first message, we set the isCriticalCustomer Brokered Message property to false. In the second message, for the hospital, we set it to true. The end result is that we should receive one message in our Regular Customers folder and one in our Critical Customers folder.
- As promised when I run the application I will find one message in each corresponding folder:
- If I open the files I will discover that the right message was delivered to the correct folder:
Overall it is a pretty slick, and seamless, experience. I think the BizTalk product team has done a great job in bridging the Service Bus Brokered Messaging Property with BizTalk’s Promoted Property. In my opinion, the Azure Service Bus and BizTalk Server really complement each other by providing robust Hybrid solutions. It is great to see smooth interoperability between these two technology sets.
This concludes this blog post. I am not done yet with this series as I have still just scratched the surface. I plan on writing more about my experience with Sending messages to Service Bus Queues/Topics from BizTalk and perhaps dive into some different messaging patterns.