RestClient thread safety

[Clayton sayer]

In our product we have a REST client base class which ends up doing
all the REST calls to the backend. In it, we currently create a new
RestClient for each REST call, although we do reuse cookies and such,
since they're part of the RestRequest itself. I would prefer to change
it so we have 1 RestClient that is reused across calls, but I'm unable
to find any details on the thread safety of RestClient. The only thing
that I have found that supports that is
http://www.stum.de/2009/12/22/using-restsharp-to-consume-restful-web-services/,
which says "The Client handles all the sending of Requests and can be
shared across the whole application if you want (Don’t take my word
for it, but it looks like it is Thread-safe)." Not very encouraging,
to say the least.

Can anyone confirm or deny that RestClient is thread safe?

Thanks,
Clay

[Clayton sayer]

Sorry, I forgot to mention that we're only using Execute<T> in
RestClient.

On Jan 27, 9:57 am, Clayton sayer <cbig...@gmail.com> wrote:
> In our product we have a REST client base class which ends up doing
> all the REST calls to the backend. In it, we currently create a new
> RestClient for each REST call, although we do reuse cookies and such,
> since they're part of the RestRequest itself. I would prefer to change
> it so we have 1 RestClient that is reused across calls, but I'm unable
> to find any details on the thread safety of RestClient. The only thing

> that I have found that supports that ishttp://www.stum.de/2009/12/22/using-restsharp-to-consume-restful-web-...,

[Andrew Young]

From my experience RestClient was designed to be threadsafe. Requests are completely atomic.

Maybe John can put the final word on this?

[John Sheehan]

I honestly have no idea. Never once made any thread safe considerations.

[Adam Ralph]

It seems like it isn't thread safe. When I execute a parallel query
using .AsParallel(), with an invocation of RestClient.Execute(request)
for each item, I get random InvalidOperationExceptions being thrown.
Each thread creates it's own independent request object. If I change
to creating a new RestClient in each thread, everything works
perfectly.

[ayoung]

Ralph,

Just curious: what is the stack trace like when the exceptions are
thrown?

[huntert]

Something like this:

   at System.ThrowHelper.ThrowInvalidOperationException(ExceptionResource resource)

   at System.Collections.Generic.List`1.Enumerator.MoveNext()

   at RestSharp.RestClient.ConfigureHttp(IRestRequest request, IHttp http)

   at RestSharp.RestClient.ExecuteAsync(IRestRequest request, Action`2 callback, String httpMethod, Func`4 getWebRequest)

   at RestSharp.RestClient.ExecuteAsync(IRestRequest request, Action`2 callback)

   at RestSharp.RestClientExtensions.ExecuteAsync(IRestClient client, IRestRequest request, Action`1 callback)

the exception throws at "foreach(var p in DefaultParameters)" in "private void ConfigureHttp(IRestRequest request, IHttp http)"

ayoung於 2012年4月4日星期三UTC+8上午1時59分32秒寫道：

[Keivan Beigi]

I have the exact same issue using 104.1.0.0.

[Henk Punt]

It is not thread-safe,

for instance we found a subtle threading bug when we were trying to use the same single RestClient across multiple threads

AND using the RootElement property of Request object.

Internally the deserializers are cached on the RestClient instance.Then the 'RootElement' property of a Request is

copied to the deserializer RootElement property at the start of a request. This means that if you have 2 simultaneous request

the will potentially overwrite each others root element if they use the same deserializer (for instance the JsonDeserializer).

Regards

Henk Punt

So like John says on 2/2/12, it does not seem to be written with Thread safety in mind.

[Matt Evans]

Anyone know if this is still the case (2018...)

I'd like to implement something like this:

https://westerndevs.com/Deployment/httpclientwrong/

[Alexey Zimarev]

The issue with manipulated RootElement and other serialization attributes is fixed in the code, the package will be released with the new minor version.