C# – Multiple API calls potentially spawning multiple Websockets – Threading vs Async

In systems like this, you always have to consider that as far as your code is powerful, at least a call will be delayed, and if your system is successful, that event will happen hundreds of times making your system slow, then maybe unstable.

I do not know the nature of the integration, maybe game providers, maybe social networks or anything else. But if your application is not academic, and it represents a real business requirements (in production) I think this is part of the things to do:

Before code

1. if possible, all systems that are integrated, they must be aware of the timeouts that are demanded from you (anticipating this from a contractual point of view, it is a good idea mostly because no one guarantees 100% of up-time. It's myth).
2. if point 1 is not possible, be objective and consider what we are willing to make our customers wait in front of the monitor (45 seconds, 10, 5, 2?). Found the value, we know how to set up the rest.
3. Should be considered a constant calls/sub-calls prifile and logging;
4. Should be planned for the possibility of suspending one or more services from the configuration (and not from code);

Technique

As for the technique, I think it is convenient to create a semaphore.

N functions will be called, the callback of each sub-function will be considered only if time set for each integration are respected.

So,

1. A call is made to the main function,
2. This considers what services are enabled to be contacted,
3. The callback functions are configured,
4. The sub-functions are called,
5. While making calls, and while the general timer has not expired, all callbacks are considered to be unified in the response of the main function.

Synchronous calls for this purpose are fine, especially if you need the result of the call to continue processing the request.

You should do that asynchronously if you have a reason to do so. Many people don't realize it but doing something asynchronous or in parallel can create a lot of problems and there is a lot of complexity even it's well hidden (like the C# async/await).

So, if you

• can continue processing the request without having the response from the 3rd party API but that data must be in your response (i.e. you can do other things in parallel with waiting for the response)
• don't really need it to continue but it's nice to have it, however doesn't really matter if it is or isn't in your response (i.e. you can do other things in parallel with it but don't wait for it - if it doesn't return in time, you can send your response anyway)
• don't need it at all for this request and can send it to the client later

you should do it asynchronously. The first case is probably most common.

In your particular case, you probably need the user to be authenticated and authorized before continuing processing the request. So I would do it synchronously. Another question are the 3 successive calls. Can they be in parallel? Then you can do it and wait for all 3 to be completed. If not, can you ask for changing the API to allow for only one call? This would be the 'right thing to do' however it's usually impossible.