Exemplo n.º 1
0
 static async ValueTask WriteBufferedMessages(GrpcCall <TRequest, TResponse> call, Stream requestStream, ReadOnlyMemory <byte>[] bufferedMessages)
 {
     foreach (var writtenMessage in bufferedMessages)
     {
         await call.WriteMessageAsync(requestStream, writtenMessage, call.CancellationToken).ConfigureAwait(false);
     }
 }
Exemplo n.º 2
0
        protected override async Task SerializeToStreamAsync(Stream stream, TransportContext?context)
        {
            if (_payload == null)
            {
                _payload = SerializePayload();
            }

            await _call.WriteMessageAsync(
                stream,
                _payload,
                _call.Options).ConfigureAwait(false);

            GrpcEventSource.Log.MessageSent();
        }
Exemplo n.º 3
0
        protected override Task SerializeToStreamAsync(Stream stream, TransportContext?context)
        {
#pragma warning disable CA2012 // Use ValueTasks correctly
            var writeMessageTask = _call.WriteMessageAsync(
                stream,
                _content,
                _call.Method.RequestMarshaller.ContextualSerializer,
                _call.Options);
#pragma warning restore CA2012 // Use ValueTasks correctly
            if (writeMessageTask.IsCompletedSuccessfully())
            {
                GrpcEventSource.Log.MessageSent();
                return(Task.CompletedTask);
            }

            return(WriteMessageCore(writeMessageTask));
        }
Exemplo n.º 4
0
        private PushStreamContent <TRequest, TResponse> CreatePushStreamContent(GrpcCall <TRequest, TResponse> call, HttpContentClientStreamWriter <TRequest, TResponse> clientStreamWriter)
        {
            return(new PushStreamContent <TRequest, TResponse>(clientStreamWriter, async requestStream =>
            {
                ValueTask writeTask;
                lock (Lock)
                {
                    Log.SendingBufferedMessages(Logger, BufferedMessages.Count);

                    if (BufferedMessages.Count == 0)
                    {
#if NETSTANDARD2_0
                        writeTask = Task.CompletedTask;
#else
                        writeTask = default;
#endif
                    }
                    else if (BufferedMessages.Count == 1)
                    {
                        writeTask = call.WriteMessageAsync(requestStream, BufferedMessages[0], call.CancellationToken);
                    }
                    else
                    {
                        // Copy messages to a new collection in lock for thread-safety.
                        var bufferedMessageCopy = BufferedMessages.ToArray();
                        writeTask = WriteBufferedMessages(call, requestStream, bufferedMessageCopy);
                    }
                }

                await writeTask.ConfigureAwait(false);

                if (ClientStreamComplete)
                {
                    await call.ClientStreamWriter !.CompleteAsync().ConfigureAwait(false);
                }
            }));