How can I use gRPC properly from 2 different projects?

[Blucky87]

Hello, I am trying to split up your grpc example code. One project is the server another is the client.

The code is essentially the grpc example code but the server and client portions were split.

Am I doing something incorrect when I separated them apart? When I run the client, it seems like no messages are being sent.

My server project code:

  public static int Main(string[] args)
    {
        {
            Action<SerializerSettings> settingsConfig = s =>
                s.UseMemoryCopySerialization()
                    .UseLazyDeserialization()
                    .UseDefaultSharedStringWriter();

            // Update the serializers used for the echo service based on what we configured.
            EchoService.Serializer<SingleMessage>.Value = EchoService.Serializer<SingleMessage>.Value.WithSettings(settingsConfig);
            EchoService.Serializer<MultiMessage>.Value = EchoService.Serializer<MultiMessage>.Value.WithSettings(settingsConfig);
        }

        Server server = new Server();
        server.Ports.Add("127.0.0.1", 50001, ServerCredentials.Insecure);
        server.Services.Add(EchoService.BindService(new ServerImpl()));
        server.Start();

        Log.Information("started Server");
        Thread.Sleep(8000);
        Log.Information("Shutting down...");

        server.ShutdownAsync().GetAwaiter().GetResult();
        return 0;
    }

    private class ServerImpl : EchoService.EchoServiceServerBase
    {
        public override Task<SingleMessage> EchoUnary(SingleMessage request, ServerCallContext callContext)
        {
            return Task.FromResult(request);
        }

        public override async Task<MultiMessage> EchoClientStreaming(IAsyncStreamReader<SingleMessage> requestStream, ServerCallContext callContext)
        {
            MultiMessage response = new()
            {
                Message = new List<string>()
            };

            while (await requestStream.MoveNext(callContext.CancellationToken))
            {
                response.Message.Add(requestStream.Current.Message);
            }

            return response;
        }

        public override async Task EchoServerStreaming(MultiMessage request, IServerStreamWriter<SingleMessage> responseStream, ServerCallContext callContext)
        {
            foreach (string message in request.Message)
            {
                await responseStream.WriteAsync(new SingleMessage { Message = message });
            }
        }

        public override async Task EchoDuplex(IAsyncStreamReader<SingleMessage> requestStream, IServerStreamWriter<SingleMessage> responseStream, ServerCallContext callContext)
        {
            while (await requestStream.MoveNext(callContext.CancellationToken))
            {
                await responseStream.WriteAsync(requestStream.Current);
            }
        }
    }

my client project code:

        {
            Action<SerializerSettings> settingsConfig = s =>
                s.UseMemoryCopySerialization()
                    .UseLazyDeserialization()
                    .UseDefaultSharedStringWriter();

            EchoService.Serializer<SingleMessage>.Value = EchoService.Serializer<SingleMessage>.Value.WithSettings(settingsConfig);
            EchoService.Serializer<MultiMessage>.Value = EchoService.Serializer<MultiMessage>.Value.WithSettings(settingsConfig);
        }



        Thread.Sleep(1000);

        EchoService.EchoServiceClient client = new(new Channel("127.0.0.1", 50001, ChannelCredentials.Insecure));

        InterfaceOperations(client).GetAwaiter().GetResult();

}

  private static async Task InterfaceOperations(IEchoService echoService)
    {

        {
            SingleMessage unaryResponse = await echoService.EchoUnary(new SingleMessage { Message = "hi there" }, default);
            Log.Information($"EchoUnary: {unaryResponse.Message}");
        }

        // Client streaming
        {

            var requestChannel = System.Threading.Channels.Channel.CreateUnbounded<SingleMessage>();

            Task<MultiMessage> responseTask = echoService.EchoClientStreaming(requestChannel.Reader, CancellationToken.None);

            await requestChannel.Writer.WriteAsync(new SingleMessage { Message = "foo" });
            await requestChannel.Writer.WriteAsync(new SingleMessage { Message = "bar" });
            await requestChannel.Writer.WriteAsync(new SingleMessage { Message = "baz" });
            await requestChannel.Writer.WriteAsync(new SingleMessage { Message = "bat" });


            requestChannel.Writer.Complete();

            MultiMessage response = await responseTask;
            Log.Information("EchoClientStreaming: " + string.Join(", ", response.Message));
        }

        // Server Streaming
        {
            var responseChannel = System.Threading.Channels.Channel.CreateBounded<SingleMessage>(1);

            MultiMessage request = new()
            {
                Message = new List<string>
                {
                    "foo", "bar", "baz", "bat"
                }
            };

            Task responseTask = echoService.EchoServerStreaming(request, responseChannel.Writer, CancellationToken.None);

            while (await responseChannel.Reader.WaitToReadAsync())
            {
                while (responseChannel.Reader.TryRead(out SingleMessage? message))
                {
                    Log.Information("EchoServerStreaming: " + message.Message);
                }
            }

            await responseTask;
        }

        // Duplex Streaming
        {
            var requestChannel = System.Threading.Channels.Channel.CreateBounded<SingleMessage>(1);
            var responseChannel = System.Threading.Channels.Channel.CreateBounded<SingleMessage>(1);

            Task call = echoService.EchoDuplex(requestChannel.Reader, responseChannel.Writer, CancellationToken.None);

            for (int i = 1; i < 5; ++i)
            {
                await requestChannel.Writer.WriteAsync(new SingleMessage { Message = $"Item{i}" });

                if (await responseChannel.Reader.WaitToReadAsync())
                {
                    SingleMessage response = await responseChannel.Reader.ReadAsync();
                    Log.Information("[Duplex Streaming] Received: " + response.Message);
                }
            }

            // Complete the request channel when we are finished.
            requestChannel.Writer.Complete();
            await call;
        }
    }