TFTomSun
commented
4 years ago Ok i created more tests to figure out what is actually working and what not. The API seems to have a severe problems with generic data, even if I use json serialization. Some things are only supported between native - native, but not between core/grpc web/ - native. Actually I need the possibility to transfer generic data between GRPC web and Native Server. Is there any possibility to achieve that? Here's the test code and the test results:
[ServiceContract]
public interface IService<T>
{
IAsyncEnumerable<T> Relay(IAsyncEnumerable<T> data, CancellationToken cancel);
IAsyncEnumerable<GenericJsonData<T>> RelayWrapped(IAsyncEnumerable<GenericJsonData<T>> data, CancellationToken cancel);
IAsyncEnumerable<T> Stream(T[] testData, CancellationToken cancel);
}
public class Service<T>: IService<T>
{
public async IAsyncEnumerable<GenericJsonData<T>> RelayWrapped(IAsyncEnumerable<GenericJsonData<T>> data, [EnumeratorCancellation] CancellationToken cancel)
{
await foreach (var element in data)
{
if (cancel.IsCancellationRequested)
{
yield break;
}
yield return element;
}
}
public async IAsyncEnumerable<T> Relay(IAsyncEnumerable<T> data, [EnumeratorCancellation] CancellationToken cancel)
{
await foreach (var element in data)
{
if (cancel.IsCancellationRequested)
{
yield break;
}
yield return element;
}
}
public async IAsyncEnumerable<T> Stream(T[] testData, [EnumeratorCancellation] CancellationToken cancel)
{
for (int i = 0; i < testData.Length; ++i)
{
yield return await Task.FromResult(testData[i]);
}
}
}
//[DataContract]
public class JsonData
{
//[DataMember(Order = 1)]
public int Value { get; set; }
}
public class GenericJsonData<T>
{
public T Value { get; set; }
}
public enum ClientMode
{
Native,
Core,
Web
}
public enum TestMethod
{
Relay,
RelayWrapped,
Stream
}
[Pairwise]
[Test]
public async Task Issue_X_ReferenceType(
[Values(ClientMode.Native,ClientMode.Core,ClientMode.Web)] ClientMode mode,
[Values(TestMethod.Relay)] TestMethod testMethod)
{
// serialization
var jsonFactory = Api.Global.JsonClientFactory();
await this.DoTest(jsonFactory, mode, testMethod, x => new JsonData { Value = x }, x => x.Value);
}
[Pairwise]
[Test]
public async Task Issue_X_Generic_ReferenceType(
[Values(ClientMode.Native, ClientMode.Core, ClientMode.Web)] ClientMode mode,
[Values(TestMethod.Relay)] TestMethod testMethod)
{
// serialization
var jsonFactory = Api.Global.JsonClientFactory();
await this.DoTest(jsonFactory, mode, testMethod, x => new GenericJsonData<JsonData> { Value = new JsonData { Value = x } }, x => x.Value.Value);
}
[Pairwise]
[Test]
public async Task Issue_X_Generic_ValueType(
[Values(ClientMode.Native, ClientMode.Core, ClientMode.Web)] ClientMode mode,
[Values(TestMethod.Relay)] TestMethod testMethod)
{
// serialization
var jsonFactory = Api.Global.JsonClientFactory();
await this.DoTest(jsonFactory, mode, testMethod, x => new GenericJsonData<int> { Value = x }, x => x.Value);
}
[Pairwise]
[Test]
public async Task Issue_X_ValueType(
[Values(ClientMode.Native, ClientMode.Core, ClientMode.Web)] ClientMode mode,
[Values(TestMethod.Relay)] TestMethod testMethod)
{
// serialization
var jsonFactory = Api.Global.JsonClientFactory();
await this.DoTest(jsonFactory, mode, testMethod, x => x, x => x);
}
private async Task DoTest<T>(ClientFactory factory,
ClientMode mode, TestMethod testMethod,
Func<int, T> convertToT, Func<T, int> convertToInt)
{
var serviceClient = this.CreateClient<T>(mode, factory);
// server
var server = new Server
{
Ports = { new ServerPort("localhost", 10042, ServerCredentials.Insecure) }
};
try
{
server.Services.AddCodeFirst(new Service<T>(), factory);
server.Start();
// client
var cancelSource = new CancellationTokenSource();
var input = new[] { 1, 2, 3 };
T[] output;
switch (testMethod)
{
default:
throw new NotImplementedException();
case TestMethod.RelayWrapped:
{
var wrappedInput = input.Select(convertToT).Select(
x => new GenericJsonData<T> { Value = x });
var response = serviceClient.RelayWrapped(
wrappedInput.ToAsyncEnumerable(), cancelSource.Token);
output = (await response.ToArrayAsync()).Select(x => x.Value).ToArray();
break;
}
case TestMethod.Relay:
{
var response = serviceClient.Relay(
input.Select(convertToT).ToAsyncEnumerable(), cancelSource.Token);
output = await response.ToArrayAsync();
break;
}
case TestMethod.Stream:
{
var streamResponse = serviceClient.Stream(input.Select(convertToT).ToArray(), cancelSource.Token);
output = await streamResponse.ToArrayAsync();
break;
}
}
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, output.Select(convertToInt));
}
finally
{
await server.KillAsync();
}
}
private IService<T> CreateClient<T>(ClientMode mode, ClientFactory factory)
{
GrpcClientFactory.AllowUnencryptedHttp2 = true;
var address = $"http://localhost:10042";
if (mode == ClientMode.Native)
{
var channel = new Channel("localhost",10042, ChannelCredentials.Insecure);
var service = channel.CreateGrpcService<IService<T>>(factory);
return service;
}
else
{
var client = mode == ClientMode.Web ? new HttpClient(new GrpcWebHandler(GrpcWebMode.GrpcWeb, new HttpClientHandler())) : new HttpClient();
var channel = GrpcChannel.ForAddress(address, new GrpcChannelOptions { HttpClient = client, });
return channel.CreateGrpcService<IService<T>>(factory);
}
}
Actually I would expect no issues and no differences in the behavior of the API, if I take over the serialization / deserialization of the parameters / return values. So I wonder what's going on there. Why does the API care about the data structures?
mgravell
I read somewhere, that I need to use GRPC web for blazor webassembly. But when I configure my client like that, the communication to the native serrver doesn't work anymore. Is there anything that I need to do on the server side as well? Are async streams supported between those 2 endpoints?