public async ValueTask DisposeAsync() { channelReconnectTimer?.DisposeAsync().ConfigureAwait(false); channelReconnectTimer = null; if (m_DuplexStream != null) { try { await m_DuplexStream.RequestStream.CompleteAsync().ConfigureAwait(false); } catch (Exception e) { //Completeの例外発生はすでにComplete不可能な状態であることを示しているので、そのままDisposeへ進む log.Trace($"{nameof(m_DuplexStream)} Complete Exception, {e}"); } finally { m_DuplexStream.Dispose(); m_DuplexStream = null; } } m_Channel?.Dispose(); m_Channel = null; }
private async Task Disconnect() { outgoingMessages.CompleteAdding(); await sendingTask; if (call != null) { await call.RequestStream.CompleteAsync(); } if (receivingTask != null) { await receivingTask; } outgoingMessages.CompleteAdding(); if (call != null) { // Dispose because i dispose everything. It should not cancel here if we did everything right call.Dispose(); call = null; } // Just to be sure :) cancellationTokenSource.Cancel(); cancellationTokenSource.Dispose(); userId = null; userName = null; }
public void Dispose() { if (!isDisposed) { isDisposed = true; _call.Dispose(); } }
public async ValueTask DisposeAsync() { await streamingCall_.RequestStream.CompleteAsync(); await readerTask_; streamingCall_.Dispose(); }
public async Task StartAsync() { if (cancellationTokenSource != null) { throw new InvalidOperationException("The event loop has already been started."); } try { // Reset the termination exception Exception = null; // Create the cancellation token source cancellationTokenSource = new CancellationTokenSource(); endTaskCompletionSource = new TaskCompletionSource <bool>(); var token = cancellationTokenSource.Token; using (feed = startFunction(token)) { // Trigger the start completion source startTaskCompletionSource?.TrySetResult(true); // While the feed has not been cancelled while (!token.IsCancellationRequested) { // Get a single result from the stream var result = await feed.ResponseStream.MoveNext(token).ConfigureAwait(false); if (!result) { break; } resultAction(feed.ResponseStream.Current); } } } catch (RpcException ex) when(ex.StatusCode == StatusCode.Cancelled) { // Ignore cancellation exceptions } catch (Exception ex) { // All event loop exception are caught because exceptions don't propagate well on the background thread. // Instead, the exception is logged here. Exception = ex; exceptionHandler?.Invoke(ex); endTaskCompletionSource.TrySetException(ex); } finally { feed?.Dispose(); feed = null; cancellationTokenSource?.Dispose(); cancellationTokenSource = null; endTaskCompletionSource?.TrySetResult(true); endTaskCompletionSource = null; endAction?.Invoke(); } }
public override async ValueTask DisposeAsync() { if (await DisposeBase()) { await requestStream.CompleteAsync(); duplexStream?.Dispose(); } }
public async Task DisconnectAsync() { if (_call != null) { await _call.RequestStream.CompleteAsync(); _call.Dispose(); } await _channelFactory.DisposeAsync(_channel !); }
/// <summary> /// 使用しているリソースを解放します。 /// </summary> /// <param name="disposing">dispose メソッドから呼び出されたかどうか</param> protected override void Dispose(bool disposing) { try { if (m_DisposableCall) { m_Call.Dispose(); } } finally { base.Dispose(disposing); } }
private async void windowClosing(object sender, System.ComponentModel.CancelEventArgs e) { if (CancellationToken != null) { if (StreamCall != null) { await StreamCall.RequestStream.CompleteAsync(); StreamCall.Dispose(); } CancellationToken.Cancel(); WriteLine($" Chat cancelled (id: {ID})"); } }
public async ValueTask DisposeAsync() { try { await _duplexStreaming.RequestStream.CompleteAsync().ConfigureAwait(false); await _readTask.ConfigureAwait(false);; } finally { await Task.Delay(TimeSpan.FromSeconds(5)); _duplexStreaming.Dispose(); } }
public async ValueTask DisposeAsync() { if (disposed) { return; } disposed = true; cancellationTokenSource.Cancel(); await await receivingLoopTask; await requestStream.CompleteAsync(); duplexStream?.Dispose(); }
private async void OnRecordingStopped(object sender, StoppedEventArgs e) { Debug.WriteLine(nameof(OnRecordingStopped) + ": Start"); try { await _call.RequestStream.CompleteAsync(); } catch (Exception ex) { Debug.WriteLine(nameof(OnEndOfAudioEvent) + ": " + ex.Message); } await _responseRenderTask; _call.Dispose(); _timer.Stop(); ButtonStartRecord.IsEnabled = true; Debug.WriteLine(nameof(OnRecordingStopped) + ": Start"); }
public async ValueTask DisposeAsync() { _cancellationTokenSource.Cancel(); try { await _duplexStream.RequestStream.CompleteAsync().ConfigureAwait(false); await _responseTask.ConfigureAwait(false); await _duplexStream2.RequestStream.CompleteAsync().ConfigureAwait(false); await _responseTask2.ConfigureAwait(false); } finally { _duplexStream.Dispose(); } }
public override AsyncDuplexStreamingCall <TRequest, TResponse> AsyncDuplexStreamingCall <TRequest, TResponse>(Method <TRequest, TResponse> method, string host, CallOptions options) { var session = m_channel.GetSession(); var rpc = new RpcTunnel <TRequest, TResponse>(session, method); var ret = new AsyncDuplexStreamingCall <TRequest, TResponse>(rpc); try { // Send request rpc.StartRequest(); // Wait response return(ret); } catch (Exception) { // Failed to request: unregister rpc ret.Dispose(); throw; } }
public static void Main(string[] args) { initializeGrpc(); connectServer(); while (true) { string data = Console.ReadLine(); sendMessage("CLIENT", data); Thread.Sleep(100); } Console.WriteLine("Press any key to exit..."); Console.ReadKey(); _call.Dispose(); //// Create a channel //var channel = new Channel(Host + ":" + Port, ChannelCredentials.Insecure); //// Create a client with the channel //var client = new GreetingService.GreetingServiceClient(channel); //// Create a request //var request = new HelloRequest //{ // Name = "Mete - on C#", // Age = 34, // Sentiment = Sentiment.Happy //}; //// Send the request //Console.WriteLine("GreeterClient sending request"); //var response = client.greeting(request); //Console.WriteLine("GreeterClient received response: " + response.Greeting); //// Shutdown //channel.ShutdownAsync().Wait(); //Console.WriteLine("Press any key to exit..."); //Console.ReadKey(); }
public void Dispose() { channelReconnectTimer?.Dispose(); channelReconnectTimer = null; m_ResponseWaitCancel?.Cancel(); m_ResponseWaitCancel = null; if (m_DuplexStream != null) { try { if (!m_DuplexStream.RequestStream.CompleteAsync().Wait(m_DisposeTimeout)) { log.Warn($"Dispose CompleteAsync Timeout"); } } catch (Exception e) { //Completeの例外発生はすでにComplete不可能な状態であることを示しているので、そのままDisposeへ進む log.Trace($"{nameof(m_DuplexStream)} Complete Exception, {e}"); } finally { m_DuplexStream.Dispose(); m_DuplexStream = null; } } if (m_Channel != null) { if (!m_Channel.ShutdownAsync().Wait(m_DisposeTimeout)) { log.Warn($"Dispose ShutdownAsync Timeout"); } m_Channel = null; } }
private async void ResetRecognition() { Debug.WriteLine(nameof(ResetRecognition) + ": Start"); _canWrite = false; _call?.Dispose(); _call = _client.StreamingRecognize(); await ComboBoxLanguage.Dispatcher.BeginInvoke(new Action((async() => { try { await _call.RequestStream.WriteAsync(ConfigRequestFactory(ComboBoxLanguage.Text, RecognitionConfig.Types.AudioEncoding.Linear16, SAMPLING_RATE)); _canWrite = true; } catch (Exception ex) { Debug.WriteLine(nameof(ResetRecognition) + ": " + ex.Message); } }))); Debug.WriteLine(nameof(ResetRecognition) + ": End"); }
/// <summary> /// 指定されたメソッド呼び出しを登録します。 /// </summary> /// <typeparam name="TRequest">リクエストの型</typeparam> /// <typeparam name="TResponse">レスポンスの型</typeparam> /// <param name="call">呼び出しオブジェクト</param> /// <param name="method">メソッド</param> /// <param name="host">ホスト</param> /// <param name="options">オプション</param> /// <param name="performanceListener">パフォーマンスリスナー</param> /// <returns>呼び出しオブジェクト</returns> internal static AsyncDuplexStreamingCall <TRequest, TResponse> Regist <TRequest, TResponse>(AsyncDuplexStreamingCall <TRequest, TResponse> call, Method <TRequest, TResponse> method, string host, CallOptions options, GrpcClientPerformanceListener performanceListener) { GrpcCallInvokerContext.Releaser releaser = new GrpcCallInvokerContext.Releaser(delegate() { call.Dispose(); }); GrpcCallState state = new GrpcCallState(method, host, options); AsyncDuplexStreamingCall <TRequest, TResponse> wrap = new AsyncDuplexStreamingCall <TRequest, TResponse>( new RequestStreamWriter <TRequest>(call.RequestStream, method, host, options, state.OnRequestStreamCompleted, performanceListener) , new ResponseStreamReader <TResponse>(call.ResponseStream, method, host, options, state.OnEndResponse, performanceListener) , call.ResponseHeadersAsync , call.GetStatus , call.GetTrailers , releaser.Dispose ); releaser.Target = wrap; GrpcCallInvokerContext.AddState(wrap, state); return(wrap); }
/// <inheritdoc cref="IDisposable.Dispose"/> public void Dispose() { if (Interlocked.CompareExchange(ref _isDisposed, 1, 0) == 1) { return; } _tokenSource.Cancel(); try { _duplexStream.RequestStream.CompleteAsync().Wait(); _channel.ShutdownAsync().Wait(); } finally { _duplexStream.Dispose(); //_channel.Dispose(); _tokenSource.Dispose(); MessageReceived = null; } _subscription.WaitSafely(); }
public void Dispose() { duplexCall.Dispose(); }
public void Dispose() { m_Call.Dispose(); }
public void Logout() { // Close stream ! _stream?.Dispose(); StreamClosed?.Invoke(); }
public void Dispose() { _stream.Dispose(); }
public void Dispose() { _call?.Dispose(); _call = null; }