HTTP NET client for Nswag generated class to deal with asynchronous issue with Unitywebrequest

        public void Dispose();

    }

    public class BasicHTTPClient : IHttpClient

    {

        public BasicHTTPClient() { }

        public BasicHTTPClient(string baseUri)

        {

            BaseAddress = new Uri(baseUri);

            _httpClient.BaseAddress = BaseAddress; 

        }

        public BasicHTTPClient (Uri baseUri)

        {

            BaseAddress = baseUri;

            _httpClient.BaseAddress = BaseAddress;

        }

        public Uri BaseAddress { get; set; }

        public HttpRequestHeaders DefaultRequestHeaders => _httpClient.DefaultRequestHeaders;

        private readonly HttpClient _httpClient = new HttpClient();

        public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage message, HttpCompletionOption option, CancellationToken token)

        {

            return await _httpClient.SendAsync(message, option, token); 

        }

            public void Dispose()

        {

            _httpClient.Dispose();

            DefaultRequestHeaders.Clear();

            BaseAddress = null;

        }

    }

    public class UnityWebRequestHttpClient : IHttpClient

    {

        public UnityWebRequestHttpClient() { }

// See the License for the specific language governing permissions and

// limitations under the License.

//

// Last change: March 2024

// Last change: May 2024

//

using System;

using System.Collections.Generic;

using System.Threading.Tasks;

using UnityEngine;

using ETSI.ARF.OpenAPI.WorldStorage;

using ETSI.ARF.OpenAPI;

using Newtonsoft.Json;

namespace ETSI.ARF.WorldStorage.REST

{ 

            var httpClient = new UnityWebRequestHttpClient(ws.URI);

            apiClient = new WorldStorageClient(httpClient);

            Debug.Log("Request Reloc Information ..");

            ResponseObject<Response> ro = new ResponseObject<Response>("Request Reloc Inofmration ", func);

            ResponseObject<Response> ro = new ResponseObject<Response>("Request Reloc Information ", func);

            List<Anonymous> anonymous = new List<Anonymous>();

            for (int i = 0;  i< uuids.Count; i++)

            apiClient.GetRelocalizationInformationAsync(token, anonymous, capabilities).ContinueWith(OnReceiveObject<Response>, ro);

            return ro;

        }

        static public Response GetRelocalizationInformation(WorldStorageServer ws, List<Guid> uuids, List<Mode_WorldStorage> modes, List<Capability> capabilities)

        {

            wsServer = ws;

            var httpClient = new BasicHTTPClient(ws.URI);

            apiClient = new MyWorldStorageClient(httpClient);

            List<Anonymous> anonymous = new List<Anonymous>();

            for (int i = 0; i < uuids.Count; i++)

            {

                // Check same size or give anonymous as parameter?

                Anonymous newOne = new Anonymous();

                newOne.Uuid = uuids[i];

                newOne.Mode = modes[i];

                anonymous.Add(newOne);

            }

            Response ro = apiClient.GetRelocalizationInformation(token, anonymous, capabilities);

            return ro;

        }

    }

}

namespace ETSI.ARF.OpenAPI.WorldStorage

{

    public partial class WorldStorageClient

    {

        public ETSI.ARF.OpenAPI.IHttpClient GetHttpClient()

        {

            return _httpClient;

        }

        public string ConvertToString_(object value, System.Globalization.CultureInfo cultureInfo)

        {

            return ConvertToString(value, cultureInfo);

        }

        public void PrepareRequest_(ETSI.ARF.OpenAPI.IHttpClient client, System.Net.Http.HttpRequestMessage request, string url)

        {

            PrepareRequest(client, request, url);

        }

        public void PrepareRequest_(ETSI.ARF.OpenAPI.IHttpClient client, System.Net.Http.HttpRequestMessage request, System.Text.StringBuilder urlBuilder)

        {

            PrepareRequest(client, request, urlBuilder);

        }

        public void ProcessResponse_(ETSI.ARF.OpenAPI.IHttpClient client, System.Net.Http.HttpResponseMessage response)

        {

            ProcessResponse(client, response);

        }

    }

    public partial class MyWorldStorageClient : WorldStorageClient

    {

        public MyWorldStorageClient(IHttpClient httpClient) : base(httpClient)

        {

        }

        /// <summary>

        /// Override Nswag generated function to access relocalization information : deal with parameters in the query

        /// </summary>

        /// <param name="token"></param>

        /// <param name="uuids"></param>

        /// <param name="capabilities"></param>

        /// <param name="cancellationToken"></param>

        /// <returns></returns>

        /// <exception cref="System.ArgumentNullException"></exception>

        /// <exception cref="ApiException"></exception>

        /// <exception cref="ApiException{string}"></exception>

        /// <exception cref="ApiException{Error}"></exception>

        public override async System.Threading.Tasks.Task<Response> GetRelocalizationInformationAsync(string token, System.Collections.Generic.IEnumerable<Anonymous> uuids, System.Collections.Generic.IEnumerable<Capability> capabilities, System.Threading.CancellationToken cancellationToken)

        {

            if (uuids == null)

                throw new System.ArgumentNullException("uuids");

            if (capabilities == null)

                throw new System.ArgumentNullException("capabilities");

            var client_ = GetHttpClient();

            var disposeClient_ = false;

            try

            {

                using (var request_ = new System.Net.Http.HttpRequestMessage())

                {

                    if (token != null)

                        request_.Headers.TryAddWithoutValidation("token", ConvertToString_(token, System.Globalization.CultureInfo.InvariantCulture));

                    request_.Method = new System.Net.Http.HttpMethod("GET");

                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("application/json"));

                    var urlBuilder_ = new System.Text.StringBuilder();

                    urlBuilder_.Append("relocalizationInformation");

                    urlBuilder_.Append('?');

                    foreach (var item_ in uuids) { urlBuilder_.Append(System.Uri.EscapeDataString("uuids")).Append('=').Append(System.Uri.EscapeDataString(JsonConvert.SerializeObject(item_))).Append('&'); }

                    foreach (var item_ in capabilities) { urlBuilder_.Append(System.Uri.EscapeDataString("capabilities")).Append('=').Append(System.Uri.EscapeDataString(JsonConvert.SerializeObject(item_))).Append('&'); }

                    urlBuilder_.Length--;

                    PrepareRequest_(client_, request_, urlBuilder_);

                    var url_ = urlBuilder_.ToString();

                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);

                    PrepareRequest_(client_, request_, url_);

                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);

                    var disposeResponse_ = true;

                    try

                    {

                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();

                        foreach (var item_ in response_.Headers)

                            headers_[item_.Key] = item_.Value;

                        if (response_.Content != null && response_.Content.Headers != null)

                        {

                            foreach (var item_ in response_.Content.Headers)

                                headers_[item_.Key] = item_.Value;

                        }

                        ProcessResponse_(client_, response_);

                        var status_ = (int)response_.StatusCode;

                        if (status_ == 200)

                        {

                            var objectResponse_ = await ReadObjectResponseAsync<Response>(response_, headers_, cancellationToken).ConfigureAwait(false);

                            if (objectResponse_.Object == null)

                            {

                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);

                            }

                            return objectResponse_.Object;

                        }

                        else

                        if (status_ == 400)

                        {

                            var responseData_ = response_.Content == null ? null : await response_.Content.ReadAsStringAsync().ConfigureAwait(false);

                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));

                            throw new ApiException<string>("Invalid UUID supplied.", status_, responseData_, headers_, result_, null);

                        }

                        else

                        if (status_ == 404)

                        {

                            var responseData_ = response_.Content == null ? null : await response_.Content.ReadAsStringAsync().ConfigureAwait(false);

                            var result_ = (string)System.Convert.ChangeType(responseData_, typeof(string));

                            throw new ApiException<string>("Not found, could not find UUID in database.", status_, responseData_, headers_, result_, null);

                        }

                        else

                        {

                            var objectResponse_ = await ReadObjectResponseAsync<Error>(response_, headers_, cancellationToken).ConfigureAwait(false);

                            if (objectResponse_.Object == null)

                            {

                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);

                            }

                            throw new ApiException<Error>("Unexpected error.", status_, objectResponse_.Text, headers_, objectResponse_.Object, null);

                        }

                    }

                    finally

                    {

                        if (disposeResponse_)

                            response_.Dispose();

                    }

                }

            }

            finally

            {

                if (disposeClient_)

                    client_.Dispose();

            }

        }

    }

}

 No newline at end of file