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;
}
