Skip to main content

Service Bus Topic - Messages processing problems

In the last post about Service Bus Topics we discover how we can write code in such a way that migration from Service Bus Queues from Service Bus Topics can be done only changing the configuration file. Today I want to talk a little about what we should be aware where we process messages from topics using Peek and Lock pattern.
As we have already seen, Service Bus Topics allows us to process messages in two ways:
Receive and Delete – when messages are automatically removed after there are received
Peek and Lock – when messages are removed from the topic only after subscription call the Complete() method
We will talk about the last one. When we are using the Peel and Lock pattern, each message after is received from Service Bus is automatically locked and cannot be consumed by other client from the same subscription. If the client is able to process the message with success, he can call the Complete() method. In that moment the message is automatically removed from Service Bus. Is something happen with the message processing, for example an error occurred, the client can call the Abandon() message. In that moment the message is available once again for the given subscription. In the same time, after a message is send to a client of the given subscription, each client have a specific time when he can call Complete() or Abandon method(). If this method is not called, the message will be available one again for the given subscription. The default value is 60 seconds, but can be configured to any value.
In the next example we will try to process a message from the subscription. If an error occurred, in the catch block we will call the Abandon() method:
BrokeredMessage message = topicClient.Receive();
// process message
} catch(Exception ex)
// log error
We would saw that the solution is okay and we covered this specials case. We have only on half of the solution. In a case of an error we abandon the message, this is great but what happens next? The message will be unlocked and we will be able to process it again.
We should take care about two other things. The first one is what we are doing when we process a message. For example if we insert some information to database or call another service. In these cases we should have a transactional call. We should be able when calling the Abandon() message to rollback all things that we done.
To be able to make the rollback you can image very complicate scenarios ad there will be cases when an external service will not permit a rollback (for ex. if you call an external service). One simple solution involves the MessageId of each message. This id never changes, even if we call the abandon message for 100 times. Because of this we can store the MessageId in a list and check the id before processing it. In this way we will be able to know if we process the message already. We can image a situation when we have some steps for each message. We can store the step in this list. In this way we will not make some calls to different resources more than one. This type of processing is called “At least once processing”.
The other thing that we need to care about is about the messages that cannot be processed and will throw an error each time. For these cases, BrokeredMessage has a property that tells us how many times the client tried to processes the message. The name of the property is DeliveryCount. I gave a solution in another post for Service Bus Queues. The solution is the same for Service Bus Topics also.
    BrokeredMessage message = topicClient.Receive();
if(message == null)

// process our message.
catch(Exception ex)
if( message.DeliveryCount > 3 )
In this post we saw what we should handle some specials case situations when working we are receiving and processing message from Service Bus Topics. We should not ignore these cases because we can create duplicate data in our storage system or to process the same messages over and over again.


Popular posts from this blog

How to check in AngularJS if a service was register or not

There are cases when you need to check in a service or a controller was register in AngularJS.
For example a valid use case is when you have the same implementation running on multiple application. In this case, you may want to intercept the HTTP provider and add a custom step there. This step don’t needs to run on all the application, only in the one where the service exist and register.
A solution for this case would be to have a flag in the configuration that specify this. In the core you would have an IF that would check the value of this flag.
Another solution is to check if a specific service was register in AngularJS or not. If the service was register that you would execute your own logic.
To check if a service was register or not in AngularJS container you need to call the ‘has’ method of ‘inhector’. It will return TRUE if the service was register.
if ($injector.has('httpInterceptorService')) { $httpProvider.interceptors.push('httpInterceptorService&#…

ADO.NET provider with invariant name 'System.Data.SqlClient' could not be loaded

Today blog post will be started with the following error when running DB tests on the CI machine:
threw exception: System.InvalidOperationException: The Entity Framework provider type 'System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer' registered in the application config file for the ADO.NET provider with invariant name 'System.Data.SqlClient' could not be loaded. Make sure that the assembly-qualified name is used and that the assembly is available to the running application. See for more information. at System.Data.Entity.Infrastructure.DependencyResolution.ProviderServicesFactory.GetInstance(String providerTypeName, String providerInvariantName) This error happened only on the Continuous Integration machine. On the devs machines, everything has fine. The classic problem – on my machine it’s working. The CI has the following configuration:

TeamCity.NET 4.51EF 6.0.2VS2013
It seems that there …

Run native .NET application in Docker (.NET Framework 4.6.2)

The main scope of this post is to see how we can run a legacy application written in .NET Framework in Docker.

First of all, let’s define what is a legacy application in our context. By a legacy application we understand an application that runs .NET Framework 3.5 or higher in a production environment where we don’t have any more the people or documentation that would help us to understand what is happening behind the scene.
In this scenarios, you might want to migrate the current solution from a standard environment to Docker. There are many advantages for such a migration, like:

Continuous DeploymentTestingIsolationSecurity at container levelVersioning ControlEnvironment Standardization
Until now, we didn’t had the possibility to run a .NET application in Docker. With .NET Core, there was support for .NET Core in Docker, but migration from a full .NET framework to .NET Core can be costly and even impossible. Not only because of lack of features, but also because once you…