private RpcResponse DeserilizeSingleRequest(string json)
{
JToken token = JToken.Parse(json);
JsonSerializer serializer = JsonSerializer.Create(this.JsonSerializerSettings);
switch (token.Type)
{
case JTokenType.Object:
RpcResponse response = token.ToObject <RpcResponse>(serializer);
return(response);
case JTokenType.Array:
return(token.ToObject <List <RpcResponse> >(serializer).SingleOrDefault());
default:
throw new Exception("Cannot parse rpc response from server.");
}
}
/// <summary>
/// Parses and returns the result of the rpc response as the type specified.
/// Otherwise throws a parsing exception
/// </summary>
/// <typeparam name="T">Type of object to parse the response as</typeparam>
/// <param name="response">Rpc response object</param>
/// <param name="returnDefaultIfNull">Returns the type's default value if the result is null. Otherwise throws parsing exception</param>
/// <returns>Result of response as type specified</returns>
public static T GetResult <T>(this RpcResponse response, bool returnDefaultIfNull = true)
{
if (response.Result == null)
{
if (!returnDefaultIfNull && default(T) != null)
{
throw new RpcClientParseException($"Unable to convert the result (null) to type '{typeof(T)}'");
}
return(default(T));
}
try
{
return(response.Result.ToObject <T>());
}
catch (Exception ex)
{
throw new RpcClientParseException($"Unable to convert the result to type '{typeof(T)}'", ex);
}
}
private List <RpcResponse> DeserilizeBulkRequests(string json)
{
JToken token = JToken.Parse(json);
JsonSerializer serializer = JsonSerializer.Create(this.JsonSerializerSettings);
switch (token.Type)
{
case JTokenType.Object:
RpcResponse response = token.ToObject <RpcResponse>(serializer);
return(new List <RpcResponse> {
response
});
case JTokenType.Array:
return(token.ToObject <List <RpcResponse> >(serializer));
default:
throw new Exception("Cannout deserilize rpc response from server.");
}
}
/// <summary>
/// Sends the a http request to the server, posting the request in json format
/// </summary>
/// <param name="request">Request object that will goto the rpc server</param>
/// <param name="route">(Optional) Route that will append to the base url if the request method call is not located at the base route</param>
/// <returns>The response for the sent request</returns>
private async Task <TResponse> SendAsync <TRequest, TResponse>(TRequest request, string route = null)
{
try
{
using (HttpClient httpClient = this.GetHttpClient())
{
httpClient.BaseAddress = this.BaseUrl;
string rpcRequestJson = JsonConvert.SerializeObject(request, this.JsonSerializerSettings);
HttpContent httpContent = new StringContent(rpcRequestJson, this.Encoding ?? Encoding.UTF8, this.ContentType ?? "application/json");
HttpResponseMessage httpResponseMessage = await httpClient.PostAsync(route, httpContent).ConfigureAwait(false);
httpResponseMessage.EnsureSuccessStatusCode();
string responseJson = await httpResponseMessage.Content.ReadAsStringAsync();
try
{
return(JsonConvert.DeserializeObject <TResponse>(responseJson, this.JsonSerializerSettings));
}
catch (JsonSerializationException)
{
RpcResponse rpcResponse = JsonConvert.DeserializeObject <RpcResponse>(responseJson, this.JsonSerializerSettings);
if (rpcResponse == null)
{
throw new RpcClientUnknownException($"Unable to parse response from the rpc server. Response Json: {responseJson}");
}
throw rpcResponse.Error.CreateException();
}
}
}
catch (Exception ex) when(!(ex is RpcClientException) && !(ex is RpcException))
{
throw new RpcClientUnknownException("Error occurred when trying to send rpc requests(s)", ex);
}
}
/// <summary>
/// Sends the a http request to the server, posting the request in json format
/// </summary>
/// <param name="request">Request object that will goto the rpc server</param>
/// <param name="deserializer">Function to deserialize the json response</param>
/// <param name="route">(Optional) Route that will append to the base url if the request method call is not located at the base route</param>
/// <param name="resultTypeResolver">(Optional) Function that will determine the deserialization type for the result based on request id. Otherwise the result will be a json string.</param>
/// <returns>The response for the sent request</returns>
private async Task <List <RpcResponse> > SendAsync(IList <RpcRequest> requests, string route = null, Func <RpcId, Type> resultTypeResolver = null)
{
if (!requests.Any())
{
throw new ArgumentException("There must be at least one rpc request when sending.");
}
try
{
string requestJson;
if (requests.Count == 1)
{
requestJson = this.JsonSerializer.Serialize(requests.Single());
}
else
{
requestJson = this.JsonSerializer.SerializeBulk(requests);
}
Uri uri = new Uri(this.BaseUrl, route);
var requestContext = new RequestEventContext(route, requests.ToList(), requestJson);
ResponseEventContext responseContext = null;
if (this.Events.OnRequestStartAsync != null)
{
await this.Events.OnRequestStartAsync(requestContext);
}
Stopwatch stopwatch = Stopwatch.StartNew();
try
{
string responseJson;
try
{
responseJson = await this.TransportClient.SendRequestAsync(uri, requestJson);
}
finally
{
stopwatch.Stop();
}
if (string.IsNullOrWhiteSpace(responseJson))
{
throw new RpcClientParseException("Server did not return a rpc response, just an empty body.");
}
List <RpcResponse> responses = null;
try
{
if (requests.Count == 1)
{
Type resultType = resultTypeResolver?.Invoke(requests.First().Id);
RpcResponse response = this.JsonSerializer.Deserialize(responseJson, resultType);
responses = new List <RpcResponse> {
response
};
}
else
{
responses = this.JsonSerializer.DeserializeBulk(responseJson, resultTypeResolver);
}
responseContext = new ResponseEventContext(stopwatch.Elapsed, responseJson, responses);
return(responses);
}
catch (Exception ex)
{
responseContext = new ResponseEventContext(stopwatch.Elapsed, responseJson, responses, ex);
throw new RpcClientParseException($"Unable to parse response from server: '{responseJson}'", ex);
}
}
finally
{
if (this.Events.OnRequestCompleteAsync != null)
{
await this.Events.OnRequestCompleteAsync(responseContext, requestContext);
}
}
}
catch (Exception ex) when(!(ex is RpcClientException) && !(ex is RpcException))
{
throw new RpcClientUnknownException("Error occurred when trying to send rpc requests(s)", ex);
}
}
/// <summary>
/// Sends the specified rpc request to the server (Wrapper for other SendRequestAsync)
/// </summary>
/// <param name="method">Rpc method that is to be called</param>
/// <param name="route">(Optional) Route that will append to the base url if the request method call is not located at the base route</param>
/// <param name="paramMap">Map of parameters for the rpc method</param>
/// <typeparam name="T">The deserialization type for the response result.</typeparam>
/// <returns>The rpc response for the sent request</returns>
public async Task <RpcResponse <T> > SendRequestWithMapAsync <T>(string method, string route, IDictionary <string, object> paramMap)
{
return(RpcResponse <T> .FromResponse(await this.SendRequestWithMapAsync(method, route, paramMap, typeof(T))));
}
/// <summary>
/// Sends the specified rpc request to the server (Wrapper for other SendRequestAsync)
/// </summary>
/// <param name="method">Rpc method that is to be called</param>
/// <param name="route">(Optional) Route that will append to the base url if the request method call is not located at the base route</param>
/// <param name="paramList">List of parameters (in order) for the rpc method</param>
/// <typeparam name="T">The deserialization type for the response result.</typeparam>
/// <returns>The rpc response for the sent request</returns>
public async Task <RpcResponse <T> > SendRequestWithListAsync <T>(string method, string route, IList <object> paramList)
{
return(RpcResponse <T> .FromResponse(await this.SendRequestWithListAsync(method, route, paramList, typeof(T))));
}
public List <RpcResponse <T> > GetResponses <T>()
{
return(this.responses
.Select(r => RpcResponse <T> .FromResponse(r.Value))
.ToList());
}
public RpcResponse <T> GetResponse <T>(RpcId id)
{
return(RpcResponse <T> .FromResponse(this.responses[id]));
}
