protected virtual Task <string> ExecuteMetadataQueryAsync(IReactiveServiceCommand command, Expression expression, CancellationToken token)
{
Debug.Assert(command != null);
Debug.Assert(expression != null);
var result = _serviceProvider.Provider.Execute(expression);
return(_commandResponseFactory.CreateResponseAsync(command, Task.FromResult(result), token));
}
private Task <string> ExecuteGetObserverAsync <T>(IReactiveServiceCommand command, Uri uri, CancellationToken token)
{
Debug.Assert(command != null);
Debug.Assert(uri != null);
var result = _serviceProvider.GetObserverAsync <T>(uri, token);
return(_commandResponseFactory.CreateResponseAsync(command, result, token));
}
public async Task <string> CreateResponseAsync(IReactiveServiceCommand command, Task task, CancellationToken token)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
await task.ConfigureAwait(false);
return("OK");
}
public async Task <string> CreateResponseAsync <T>(IReactiveServiceCommand command, Task <T> task, CancellationToken token)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
var result = await task.ConfigureAwait(false);
return(_serializer.Serialize(result));
}
public async Task ParseResponseAsync(IReactiveServiceCommand command, Task <string> request, CancellationToken token)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var response = await request.ConfigureAwait(false);
Debug.Assert(response == "OK");
}
public async Task <T> ParseResponseAsync <T>(IReactiveServiceCommand command, Task <string> request, CancellationToken token)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var response = await request.ConfigureAwait(false);
return(_serializer.Deserialize <T>(response));
}
public Task <string> ExecuteAsync(IReactiveServiceCommand command, CancellationToken token)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
return(command.Verb switch
{
CommandVerb.New => ExecuteNewAsync(command, token),
CommandVerb.Remove => ExecuteRemoveAsync(command, token),
CommandVerb.Get => ExecuteGetAsync(command, token),
_ => ExecuteExtensionAsync(command, token),
});
protected virtual Task <string> ExecuteGetObserverAsync(IReactiveServiceCommand command, Expression expression, CancellationToken token)
{
Debug.Assert(command != null);
Debug.Assert(expression != null);
var genericType = typeof(IAsyncReactiveObserver <>);
var observerType = expression.Type.FindGenericType(genericType);
if (expression is not ParameterExpression parameterExpression || observerType == null)
{
throw new InvalidOperationException(
string.Format(CultureInfo.InvariantCulture, "Expected observer parameter expression of type '{0}'. Expression = '{1}'", genericType, expression.ToString()));
}
var executeGetObserverAsync = s_executeGetObserverAsync.MakeGenericMethod(observerType.GenericTypeArguments);
return((Task <string>)executeGetObserverAsync.Invoke(this, new object[] { command, new Uri(parameterExpression.Name), token }));
}
public ReactiveServiceCommandService(IReactiveServiceCommand obj)
{
_obj = obj;
}
