public void Subscribe()
        {
            AppContext.SetSwitch(
                "System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);

            m_Channel = GrpcChannel.ForAddress("http://localhost:51232");

            m_ResponseWaitCancel = new CancellationTokenSource();
            var client = new WindowsServiceToUserSessionGrpcService.WindowsServiceToUserSessionGrpcServiceClient(m_Channel);

            m_DuplexStream = client.Subscribe(cancellationToken: m_ResponseWaitCancel.Token);

            log.Trace($"Subscribe End, Stream={m_DuplexStream},{m_DuplexStream.GetHashCode()}");

            //TODO:一定時間での再接続タイマー
            //channelReconnectTimer = new Timer(ChannelAndSessionReconnect, null, ReconnectTimeSpan, new TimeSpan(0, 0, 0, 0, -1));

            Task.Run(async() =>
            {
                var stream = m_DuplexStream.ResponseStream;

                await foreach (var command in stream.ReadAllAsync(m_ResponseWaitCancel.Token))
                {
                    log.Trace($"Read, {command.ActionCase}");

                    m_CountForTestException++;
                    if (m_IsEnableTestException && 2 < m_CountForTestException)
                    {
                        throw new Exception("over");
                    }

                    switch (command.ActionCase)
                    {
                    case ServiceToUserSessionResponse.ActionOneofCase.None:
                        break;

                    case ServiceToUserSessionResponse.ActionOneofCase.GetDataResponse:
                        {
                            var val = command.GetDataResponse;
                            OnGetDataResponse?.Invoke(val.Data);
                        }
                        break;

                    case ServiceToUserSessionResponse.ActionOneofCase.SendDataRequest:
                        {
                            var val = command.SendDataRequest;
                            var ret = OnSendDataRequest?.Invoke(val.Data);
                            await m_DuplexStream.RequestStream.WriteAsync(new UserSessionToServiceRequest
                            {
                                SendDataResponse = new SendDataResponseParam
                                {
                                    Result = ret ?? false,
                                }
                            });
                        }
                        break;

                    default:
                        throw new ArgumentOutOfRangeException();
                    }
                }
            });
        }
        public void Subscribe()
        {
            m_Channel            = new Channel("localhost:51232", ChannelCredentials.Insecure);
            m_ResponseWaitCancel = new CancellationTokenSource();
            var client = new WindowsServiceToUserSessionGrpcService.WindowsServiceToUserSessionGrpcServiceClient(m_Channel);

            m_DuplexStream = client.Subscribe(cancellationToken: m_ResponseWaitCancel.Token);

            log.Info($"Subscribe End, Stream={m_DuplexStream},{m_DuplexStream.GetHashCode()}");


            //TODO:一定時間での再接続タイマー
            //channelReconnectTimer = new Timer(ChannelAndSessionReconnect, null, ReconnectTimeSpan, new TimeSpan(0, 0, 0, 0, -1));


            var stream = m_DuplexStream.ResponseStream;

            _ = stream.ForEachAsync(command =>
            {
                return(Task.Run(async() =>
                {
                    log.Trace($"Read, {command.ActionCase}");

                    m_CountForTestException++;
                    if (m_IsEnableTestException && 2 < m_CountForTestException)
                    {
                        throw new Exception("over");
                    }

                    switch (command.ActionCase)
                    {
                    case ServiceToUserSessionResponse.ActionOneofCase.None:
                        break;

                    case ServiceToUserSessionResponse.ActionOneofCase.GetDataResponse:
                        {
                            var val = command.GetDataResponse;
                            OnGetDataResponse?.Invoke(val.Data);
                        }
                        break;

                    case ServiceToUserSessionResponse.ActionOneofCase.SendDataRequest:
                        {
                            var val = command.SendDataRequest;
                            var ret = OnSendDataRequest?.Invoke(val.Data);
                            await m_DuplexStream.RequestStream.WriteAsync(new UserSessionToServiceRequest
                            {
                                SendDataResponse = new SendDataResponseParam
                                {
                                    Result = ret ?? false,
                                }
                            });
                        }
                        break;

                    default:
                        throw new ArgumentOutOfRangeException();
                    }
                }));
            });
        }