Is ServiceClient thread-safe

[8ggmaker]

Create a ServiceClient is expensive, is it thread-safe? so we can reuse the same client for multi thread

[MattB-msft]

Yes and yes, though depending on your use case you may want or o consider using clones of the connection per thread and using the async versions of the calls.

[8ggmaker]

@MattB-msft Thanks for your reply, let me describe more about my scenario, we now have a asp.net core service, and we are now using this constructor

because we need to access different dataverse environments. I have check the blog you mentioned before https://colinvermander.wordpress.com/2020/03/26/cdsserviceclient-with-asp-net-core/
which is useful when the application just needs to access a single environment.

I am now trying to create a factory like this to create ServiceClient for difference instanceuri

public class ServiceClientFactory
{
    public ServiceClient Create(Uri instanceUrl, Func<string, Task<string>> tokenProviderFunction)
    {
       return new ServiceClient(instanceUrl,tokenProviderFunction);
    }
}

I have some questions here:
1 can we use useUniqueInstance = false in this situation?
2. because we want to make the creation as fast as possible, how can we achive this, is it ok to have a static dictionary here to store the root ServiceClient and return cloned client every time

public class ServiceClientFactory
{
    private static ConcurrentDictionary<Uri,ServiceClient> cache = new ConcurrentDictionary<Uri,ServiceClient>();
    public ServiceClient Create(Uri instanceUrl, Func<string, Task<string>> tokenProviderFunction)
    {
       if(cache.TryGetValue(instanceUrl, out ServiceClient root))
      {
          return root.Clone();
      }
       var tempRoot = new ServiceClient(instanceUrl,tokenProviderFunction);
       var newRoot = cache.GetOrAdd(instanceUrl,tempRoot);
       if(newRoot!=tempRoot)
       {
           tempRoot.Dispose();
       }
       return newRoot.Clone();
    }
}

3. What is the benefit of use cloned ServiceClient here, will it create a new connection? If it does, every http request hit our server will create a new connection to the dataverse?
4. And we also want to manage the lifetime of the root ServiceClient, because if there is no more access to one environment, we can release the connection of the root Client. If we try to do this, do we need to ensure that all cloned ServiceClient is unused before we dispose the root ServiceClient.

I am really appreciate if you could give me some best practices in our scenario.
Thanks

[MattB-msft]

Moving this to discussions => Q/A as that's more appropriate for this.

Clone is effective in creating a new independent connection to the API endpoints that the host client (the parent of the clone) is already connected to. It useful in WebApplications and SDK Services where you are dealing with variable load, but not high or extreme load, where you want to provide quick and efficient calls to the server.

If you expect high load on your service, you should in turn use connection pooling to allow for a controlled growth of connections to Dataverse to provide you a means to control API utilization to manage costs.

What high / extreme load means to you has a lot to do with your instance and scaling. for the 95% population Clone is just fine and any throttling is handled internally.

Clone is not appropriate for Multi environment scenarios, as it's bound to the host connections environment.

If you have to work with multiple environments, where there are repeated calls to the web service or api endpoint over a short period of time, you will want to use a variation of connection caching, where you keep a connection for each environment in local cache for a short period of time ( 5 min or so with a sliding refresh ).

In answer to your questions:

1. No, you MUST use useUniqueInstance = true. useUniqueInstance is a work optimization for websites and SDK apps that are connected to a single environment..
2. As I said above, you want to create a memory cache ( likely using System.Runtime.Caching ) and use an index that allows you to manage a connection per environment, this should be on a sliding refresh so as to not unduly sit on server memory. Effectivly the first use of a connection to an environment creates a connection to it and places it into cache, subsequent calls use that as the source of clone and update the expiration on the cache.
3. see 2
4. see 2

[8ggmaker]

@MattB-msft Thanks for your explaniation, I am new to this sdk, so let me double confirm here

Effectivly the first use of a connection to an environment creates a connection to it and places it into cache, subsequent calls use that as the source of clone and update the expiration on the cache.

The connection you mean here is ServiceClient, right? And subsequent calls use ServiceClient.Clone() to get a instance to use.
For a parent(source) connection in the cache, is it safe to remove and dispose it at anytime, since there maybe serveral cloned connections are used by other threads at the same time.

[MattB-msft]

That is correct,
1 Connection == 1 Distinct instance of the ServiceClient.
You should not delete or remove the parent of a clone until the clone itself is disposed or not going to be used any longer. The clones use shared resources from the parent to expedite processing vis doing a full copy of the parent. That is why I suggested using a slide expiration as that will allow for the system to process whatever its doing and then move on. How long the expiration is really up to your use case.

[8ggmaker]

Thanks, Got it