Example #1
0
        static async Task Main(string[] args)
        {
            IProgress <int> progress = new Progress <int>(i => Console.WriteLine($"Progress: {i}%"));

            //ReponseReport reponseReport = new ReponseReport(progress);

            var channel = GrpcChannel.ForAddress("https://localhost:5001");

            var client = new Progressor.ProgressorClient(channel);

            using var call = client.RunHistory(new Google.Protobuf.WellKnownTypes.Empty());

            await foreach (var item in call.ResponseStream.ReadAllAsync())
            {
                if (item.ResponseTypeCase == HistoryResponse.ResponseTypeOneofCase.Progress)
                {
                    progress.Report(item.Progress);
                }
                else if (item.ResponseTypeCase == HistoryResponse.ResponseTypeOneofCase.Result)
                {
                    Console.WriteLine(item.Result);
                }
            }

            Console.WriteLine("Hello World!");

            Console.ReadLine();
        }
Example #2
0
        static async Task Main(string[] args)
        {
            var channel = GrpcChannel.ForAddress("https://localhost:5001");
            var client  = new Progressor.ProgressorClient(channel);

            var progress = new Progress <int>(i => Console.WriteLine($"Progress: {i}%"));

            await ServerStreamingCallExample(client, progress);

            Console.WriteLine("Shutting down");
            Console.WriteLine("Press any key to exit ...");

            Console.ReadKey();
        }
Example #3
0
        //private static ResponseProgress<HistoryResult,int> ServerStreamingCallExample(Progressor.ProgressorClient client,IProgress<int> progress)
        //{
        //    var call = client.RunHistory(new Google.Protobuf.WellKnownTypes.Empty());
        //    var historyResponse = call.ResponseStream;//as IAsyncStreamReader<IProgressMessage<HistoryResult, int>>;
        //    return GrpcProgress.Create(historyResponse, progress);
        //}

        //private static ResponseProgress<HistoryResult, int> ServerStreamingCallExample(
        //    Progressor.ProgressorClient client,
        //    IProgress<int> progress)
        //{
        //    var call = client.RunHistory(new Empty());

        //    Debug.Assert(call.ResponseStream is IAsyncStreamReader<HistoryResponse>, "response stream historyResponse");

        //    var result = call.ResponseStream is IAsyncStreamReader<IProgressMessage<HistoryResult, int>>;
        //    Debug.Assert(result, "response stream IAsyncStreamReader<IProgressMessage<HistoryResult, int>>");


        //    //if(call.ResponseStream is IAsyncStreamReader<IProgressMessage<HistoryResult, int>>)
        //    //{
        //    //    Console.WriteLine("response stream IAsyncStreamReader<IProgressMessage<HistoryResult, int>>");
        //    //}

        //    //return new ResponseProgress<HistoryResult, int>(call.ResponseStream as IAsyncStreamReader<IProgressMessage<HistoryResult, int>>, progress);


        //}

        private static async Task ServerStreamingCallExample(
            Progressor.ProgressorClient client,
            IProgress <int> progress)
        {
            var call = client.RunHistory(new Empty());

            var resultTask = Task.Run(async() =>
            {
                HistoryResult result = null;
                await foreach (var item in call.ResponseStream.ReadAllAsync())
                {
                    var progressMessage = item as IProgressMessage <HistoryResult, int>;
                    if (progressMessage == null)
                    {
                        Console.WriteLine("Server write is not Progress Message");
                        continue;
                    }
                    if (progressMessage.IsProgress)
                    {
                        progress?.Report(progressMessage.Progress);
                        continue;
                    }
                    if (progressMessage.IsResult)
                    {
                        result = progressMessage.Result;
                    }
                }

                //throw new Exception("Call completed without a result.");
                return(result);
            });

            var result = await resultTask;

            if (result == null)
            {
                Console.WriteLine("not result.");
                return;
            }
            Console.WriteLine("Preparing results...");
            await Task.Delay(TimeSpan.FromSeconds(2));

            foreach (var item in result.Items)
            {
                Console.WriteLine(item);
            }
        }
Example #4
0
        static async Task Main(string[] args)
        {
            var channel = GrpcChannel.ForAddress("https://localhost:5001");
            var client  = new Progressor.ProgressorClient(channel);

            var progress = new Progress <int>(i => Console.WriteLine($"Progress: {i}%"));

            var result = await ServerStreamingCallExample(client, progress);

            Console.WriteLine("Preparing results...");
            await Task.Delay(TimeSpan.FromSeconds(2));

            foreach (var item in result.Items)
            {
                Console.WriteLine(item);
            }

            Console.WriteLine("Shutting down");
            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }
Example #5
0
        private static ResponseProgress <HistoryResult, int> ServerStreamingCallExample(Progressor.ProgressorClient client, IProgress <int> progress)
        {
            var call = client.RunHistory(new Empty());

            return(GrpcProgress.Create(call.ResponseStream, progress));
        }