sbmp | OBSOLETE - USE TinyFrame instead! (Simple Binary Messaging Protocol - USART protocol for microcontr | Networking library

Basically the rule is like this:

If you open it, you should close it. However:

• if IDisposable is implemented this is often done implicit
• some IDisposables work better if kept alive (HttpClient)
• opening and closing cost a significant amount of time
• this is with respect to the lifetime scope.

So,

Since you have a singleton (application life time scope), you should keep it open unless you hit issues.

Besides that, in general, bus connections are typically always left open.

It would be nice to close it on application exit, but even this isn't mandantory.

side note: the topic client in your Singleton might not be thread safe. I would double check that.

So when would you close this bus connection?

There will be scenarios where you might want a explicit call to close.

E.g.: - your connection is unstable (satelite or long wave radio). In this case, if you send every now and then you might want to open, send and close. - your total amount of connections is reaching maximum. - if you send something at a very low interval (like once an hour, than it would just save some resources) - high amount of concurrent tasks (if the client isnt thread safe)

There are many more, but its always depending on the use case. Its a good thing to keep in mind, that if you run into problems, it might be due to using only one connection.

• You can use fresco lib for circular image.

• You will need just add attribute fresco:roundAsCircle="true" in the xml layout as per the documentation.

• Also this library is useful for asynchronous image loading from the web.

I was able to successfully send a brokered message using your sendAsync() method implementation.

In addition, I was able to reproduce the same error stated in your question when the queue DOES NOT exist (e.g. taskqueue1).

Basically you're processing messages much faster than Service Bus can deliver new ones. Azure SB is relatively slow on an individual-message basis. Verify this by adding a Task.Delay before completion and log the thread IDs, and you should see multiple copies spin up.

My answer refers to the Azure Service Bus SDK which runs over AMQP (Link -> https://github.com/Azure/azure-service-bus-java ).

The MessageReceiver object is used to receive messages from a queue whenever you need one.

This class has a receive function which takes in a server wait time as parameter (Default is 30 seconds ).

This means that if there are no messages in the queue , it will not return immediately , but will wait for 30 seconds or whatever time you specified for new messages.

If there is a new message earlier , then it will return at that point.

This is basically called long polling.

It saves the client from continuously polling the queue.