public override async Task EchoServerStreaming(MultiStringMessage request, IServerStreamWriter <StringMessage> responseStream, ServerCallContext callContext)
{
foreach (var item in request.Value)
{
await responseStream.WriteAsync(new StringMessage { Value = item });
}
}
private async Task <int> SharedStringsTest_Common()
{
int length = 0;
await this.EchoTest(async client =>
{
var requestStream = SChannel.CreateUnbounded <StringMessage>();
byte[] random = new byte[1024];
new Random().NextBytes(random);
string randomB64 = Convert.ToBase64String(random);
for (int i = 0; i < 100; ++i)
{
await requestStream.Writer.WriteAsync(new StringMessage {
Value = randomB64
});
}
requestStream.Writer.Complete();
MultiStringMessage response = await((IEchoService)client).EchoClientStreaming(requestStream, default);
// Test that the string is only written once. This confirms that our update to the serializer worked as intended.
Assert.IsAssignableFrom <IFlatBufferDeserializedObject>(response);
IFlatBufferDeserializedObject obj = (IFlatBufferDeserializedObject)response;
length = obj.InputBuffer.Length;
});
return(length);
}
public Task EchoServerStreaming_Interface()
{
return(this.EchoTest_Interface(async client =>
{
MultiStringMessage message = new MultiStringMessage
{
Value = Enumerable.Range(0, 100).Select(x => Guid.NewGuid().ToString()).ToList()
};
var channel = SChannel.CreateUnbounded <StringMessage>();
var task = client.EchoServerStreaming(message, channel, CancellationToken.None);
int i = 0;
while (await channel.Reader.WaitToReadAsync())
{
Assert.True(channel.Reader.TryRead(out var item));
Assert.Equal(message.Value[i++], item.Value);
}
Assert.Equal(100, i);
await task;
Assert.True(channel.Reader.Completion.IsCompleted);
Assert.True(channel.Reader.Completion.IsCompletedSuccessfully);
}));
}
public Task EchoClientStreaming_Interface()
{
return(this.EchoTest_Interface(async client =>
{
var requestChannel = SChannel.CreateUnbounded <StringMessage>();
List <string> messages = new();
for (int i = 0; i < 100; ++i)
{
string msg = Guid.NewGuid().ToString();
await requestChannel.Writer.WriteAsync(new StringMessage {
Value = msg
});
messages.Add(msg);
}
requestChannel.Writer.Complete();
MultiStringMessage response = await client.EchoClientStreaming(requestChannel, CancellationToken.None);
Assert.Equal(100, response.Value.Count);
for (int i = 0; i < 100; ++i)
{
Assert.Equal(messages[i], response.Value[i]);
}
}));
}
public Task EchoClientStreaming()
{
return(this.EchoTest(async client =>
{
var streamingCall = client.EchoClientStreaming();
List <string> messages = new();
for (int i = 0; i < 100; ++i)
{
string msg = Guid.NewGuid().ToString();
await streamingCall.RequestStream.WriteAsync(new StringMessage {
Value = msg
});
messages.Add(msg);
}
await streamingCall.RequestStream.CompleteAsync();
MultiStringMessage response = await streamingCall;
Assert.Equal(100, response.Value.Count);
for (int i = 0; i < 100; ++i)
{
Assert.Equal(messages[i], response.Value[i]);
}
}));
}
public Task EchoServerStreaming()
{
return(this.EchoTest(async client =>
{
MultiStringMessage message = new MultiStringMessage
{
Value = Enumerable.Range(0, 100).Select(x => Guid.NewGuid().ToString()).ToList()
};
var streamingCall = client.EchoServerStreaming(message);
int i = 0;
while (await streamingCall.ResponseStream.MoveNext())
{
Assert.Equal(message.Value[i++], streamingCall.ResponseStream.Current.Value);
}
Assert.Equal(100, i);
}));
}
public Task EchoServerStreaming_Interface_Canceled()
{
return(this.EchoTest_Interface(async client =>
{
MultiStringMessage message = new MultiStringMessage
{
Value = Enumerable.Range(0, 100).Select(x => Guid.NewGuid().ToString()).ToList()
};
var channel = SChannel.CreateUnbounded <StringMessage>();
CancellationTokenSource cts = new();
var task = client.EchoServerStreaming(message, channel, cts.Token);
int i = 0;
while (await channel.Reader.WaitToReadAsync(cts.Token))
{
Assert.True(channel.Reader.TryRead(out var item));
Assert.Equal(message.Value[i++], item.Value);
if (i == 50)
{
cts.Cancel();
await this.AssertCanceled(
async() => await channel.Reader.WaitToReadAsync(cts.Token));
break;
}
}
await this.AssertCanceled(() => task);
Assert.True(channel.Reader.Completion.IsCompleted);
Assert.False(channel.Reader.Completion.IsCompletedSuccessfully);
}));
}
