public async Task Service_uses_internal_client_for_client_streaming_requests([Frozen] Greeter.GreeterClient client, Service sut, [Frozen] HelloReply reply, AsyncClientStreamingCall <HelloRequest, HelloReply> responseCall, string[] names)
{
Mock.Get(client).Setup(p => p.SayHelloClientStream(null, null, default)).Returns(responseCall);
var response = await sut.StreamHellos(names);
Assert.That(response, Is.EqualTo(reply.Message));
}
/// <summary>
/// 全てのリクエストを送信します。
/// </summary>
/// <typeparam name="TRequest">リクエストの型</typeparam>
/// <typeparam name="TResponse">レスポンスの型</typeparam>
/// <typeparam name="TResult">実行結果の型</typeparam>
/// <param name="call">呼び出しオブジェクト</param>
/// <param name="requests">リクエストを取得する処理</param>
/// <param name="converter">実行結果への変換処理</param>
/// <returns>実行結果</returns>
public static async Task <GrpcResult <TResult> > WriteAndCompleteAsync <TRequest, TResponse, TResult>(this AsyncClientStreamingCall <TRequest, TResponse> call, IEnumerable <AsyncFunc <TRequest> > requests, Converter <TResponse, TResult> converter)
where TRequest : class where TResponse : class
{
try
{
foreach (AsyncFunc <TRequest> request in requests)
{
await call.RequestStream.WriteAsync(await request().ConfigureAwait(false)).ConfigureAwait(false);
}
await CompleteAsyncInternal(call).ConfigureAwait(false);
return(GrpcResult.Create <TResult>(converter(await call.ResponseAsync.ConfigureAwait(false)), call.ToInterface()));
}
catch (Exception ex) when(GrpcExceptionUtility.HasRpcException(ex))
{
return(HandleResponseException <TRequest, TResponse, TResult>(call, ex));
}
}
/// <summary>
/// Write the specified requests and send a completion.
/// </summary>
/// <typeparam name="TRequest">The type of the request.</typeparam>
/// <typeparam name="TResponse">The type of the response.</typeparam>
/// <param name="call"></param>
/// <param name="requests">The requests.</param>
/// <returns>The response.</returns>
public static async Task <TResponse> WriteRequestsAndCompleteAsync <TRequest, TResponse>(this AsyncClientStreamingCall <TRequest, TResponse> call, IEnumerable <Task <TRequest> > requests)
{
await call.RequestStream.WriteRequestsAsync(requests).ConfigureAwait(false);
await call.RequestStream.CompleteAsync().ConfigureAwait(false);
return(await call.ResponseAsync.ConfigureAwait(false));
}
/// <summary>
/// Converts the request type.
/// </summary>
/// <typeparam name="TSource">The type before conversion.</typeparam>
/// <typeparam name="TRequest">The type of the request.</typeparam>
/// <typeparam name="TResponse">The type of the response.</typeparam>
/// <param name="call"></param>
/// <param name="requestConverter">Method to convert a request.</param>
/// <returns>A streaming call with request type converted.</returns>
public static AsyncClientStreamingCall <TSource, TResponse> ConvertRequest <TSource, TRequest, TResponse>(this AsyncClientStreamingCall <TRequest, TResponse> call, Func <TSource, TRequest> requestConverter)
{
return(new AsyncClientStreamingCall <TSource, TResponse>(
call.RequestStream.ConvertRequest(requestConverter)
, call.ResponseAsync
, call.ResponseHeadersAsync
, call.GetStatus
, call.GetTrailers
, call.Dispose
));
}
/// <summary>
/// Converts the request type.
/// </summary>
/// <typeparam name="TSource">The type before conversion.</typeparam>
/// <typeparam name="TRequest">The type of the request.</typeparam>
/// <typeparam name="TResponse">The type of the response.</typeparam>
/// <typeparam name="TResult">The type after conversion.</typeparam>
/// <param name="call"></param>
/// <param name="requestConverter">Method to convert a request.</param>
/// <param name="responseConverter">Method to convert a response.</param>
/// <returns>A streaming call with request type converted.</returns>
public static AsyncClientStreamingCall <TSource, TResult> ConvertRequestResponse <TSource, TRequest, TResponse, TResult>(this AsyncClientStreamingCall <TRequest, TResponse> call, Func <TSource, Task <TRequest> > requestConverter, Func <TResponse, Task <TResult> > responseConverter)
{
async Task <TResult> convert(Task <TResponse> response, Func <TResponse, Task <TResult> > converter)
{
return(await converter(await response.ConfigureAwait(false)).ConfigureAwait(false));
}
return(new AsyncClientStreamingCall <TSource, TResult>(
call.RequestStream.ConvertRequest(requestConverter)
, convert(call.ResponseAsync, responseConverter)
, call.ResponseHeadersAsync
, call.GetStatus
, call.GetTrailers
, call.Dispose
));
}
/// <summary>
/// Writes the specified requests.
/// </summary>
/// <typeparam name="TRequest">The type of the request.</typeparam>
/// <typeparam name="TResponse">The type of the response.</typeparam>
/// <param name="call"></param>
/// <param name="requests">The requests.</param>
/// <returns></returns>
public static Task WriteRequestsAsync <TRequest, TResponse>(this AsyncClientStreamingCall <TRequest, TResponse> call, IEnumerable <Task <TRequest> > requests)
{
return(call.RequestStream.WriteRequestsAsync(requests));
}
/// <summary>
/// 指定されたメソッド呼び出しの状態を取得します。
/// </summary>
/// <typeparam name="TRequest">リクエストの型</typeparam>
/// <typeparam name="TResponse">レスポンスの型</typeparam>
/// <param name="call">呼び出しオブジェクト</param>
/// <param name="state">状態オブジェクト</param>
/// <returns>取得できた場合、true を返します。</returns>
internal static bool TryGetState <TRequest, TResponse>(AsyncClientStreamingCall <TRequest, TResponse> call, out GrpcCallState state)
{
return(TryGetStateMain(call, out state));
}
/// <summary>
///
/// </summary>
/// <param name="call"></param>
internal AsyncClientStreamingCallWrapper(AsyncClientStreamingCall <TRequest, TResponse> call)
{
m_Call = call;
}
private static async Task ClientStreamingOperation(StatsService.StatsServiceClient client)
{
AsyncClientStreamingCall <SingleNumber, AverageResponse> call = client.AverageStreaming(default);
/// <summary>
/// 指定されたメソッド呼び出しを登録します。
/// </summary>
/// <typeparam name="TRequest">リクエストの型</typeparam>
/// <typeparam name="TResponse">レスポンスの型</typeparam>
/// <param name="call">呼び出しオブジェクト</param>
/// <param name="method">メソッド</param>
/// <param name="host">ホスト</param>
/// <param name="options">オプション</param>
/// <param name="performanceListener">パフォーマンスリスナー</param>
/// <returns>呼び出しオブジェクト</returns>
internal static AsyncClientStreamingCall <TRequest, TResponse> Regist <TRequest, TResponse>(AsyncClientStreamingCall <TRequest, TResponse> call, Method <TRequest, TResponse> method, string host, CallOptions options, GrpcClientPerformanceListener performanceListener)
{
GrpcCallInvokerContext.Releaser releaser = new GrpcCallInvokerContext.Releaser(delegate()
{
call.Dispose();
});
GrpcCallState state = new GrpcCallState(method, host, options);
AsyncClientStreamingCall <TRequest, TResponse> wrap = new AsyncClientStreamingCall <TRequest, TResponse>(
new RequestStreamWriter <TRequest>(call.RequestStream, method, host, options, state.OnRequestStreamCompleted, performanceListener)
, call.ResponseAsync
, call.ResponseHeadersAsync
, call.GetStatus
, call.GetTrailers
, releaser.Dispose
);
releaser.Target = wrap;
GrpcCallInvokerContext.AddState(wrap, state);
return(wrap);
}
public ClientStreamingResult(AsyncClientStreamingCall <byte[], byte[]> inner, Marshaller <TRequest> requestMarshaller, Marshaller <TResponse> responseMarshaller)
{
this.inner = inner;
this.requestStream = new MarshallingClientStreamWriter <TRequest>(inner.RequestStream, requestMarshaller);
this.responseMarshaller = responseMarshaller;
}
public static IAsyncResponseCall <TResponse> AsResponseCall <TRequest, TResponse>(this AsyncClientStreamingCall <TRequest, TResponse> call)
{
if (call == null)
{
return(null);
}
return(new AsyncClientStreamingCallWrapper <TRequest, TResponse>(call));
}
internal void SetAsyncClientStreamingCall(AsyncClientStreamingCall <TRequest, TResponse> call) => this.AsyncClientStreamingCall = call;
public PiCarClient(PiCar.PiCarClient client)
{
_client = client;
remoteControlCall = _client.RemoteControl();
}
/// <summary>
/// Invokes AsyncClientStreamingCall without type restrictions.
/// </summary>
/// <typeparam name="TRequest">The type of the request.</typeparam>
/// <typeparam name="TResponse">The type of the response.</typeparam>
/// <param name="callInvoker"></param>
/// <param name="method"></param>
/// <param name="host"></param>
/// <param name="options"></param>
/// <returns></returns>
public static AsyncClientStreamingCall <TRequest, TResponse> StructAsyncClientStreamingCall <TRequest, TResponse>(this CallInvoker callInvoker, Method <TRequest, TResponse> method, string host, CallOptions options)
{
AsyncClientStreamingCall <byte[], byte[]> call = callInvoker.AsyncClientStreamingCall(s_StructMethodCache.GetMethod(method), host, options);
return(call.ConvertRequestResponse(method.RequestMarshaller.Serializer, method.ResponseMarshaller.Deserializer));
}
