public async Task <string> SayHelloAsync(CancellationToken cancellationToken = default(CancellationToken))
{
await OutputProtocol.WriteMessageBeginAsync(new TMessage("SayHello", TMessageType.Call, SeqId), cancellationToken);
var args = new SayHelloArgs();
await args.WriteAsync(OutputProtocol, cancellationToken);
await OutputProtocol.WriteMessageEndAsync(cancellationToken);
await OutputProtocol.Transport.FlushAsync(cancellationToken);
var msg = await InputProtocol.ReadMessageBeginAsync(cancellationToken);
if (msg.Type == TMessageType.Exception)
{
var x = await TApplicationException.ReadAsync(InputProtocol, cancellationToken);
await InputProtocol.ReadMessageEndAsync(cancellationToken);
throw x;
}
var result = new SayHelloResult();
await result.ReadAsync(InputProtocol, cancellationToken);
await InputProtocol.ReadMessageEndAsync(cancellationToken);
if (result.__isset.success)
{
return(result.Success);
}
throw new TApplicationException(TApplicationException.ExceptionType.MissingResult, "SayHello failed: unknown result");
}
public SayHelloResultArgs SayHello(SayHelloArgs args)
{
//Console.WriteLine(args.Name + Count++);
return(new SayHelloResultArgs {
Message = "Hello " + args.Name
});
}
public async Task SayHello_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot, CancellationToken cancellationToken)
{
var args = new SayHelloArgs();
await args.ReadAsync(iprot, cancellationToken);
await iprot.ReadMessageEndAsync(cancellationToken);
var result = new SayHelloResult();
try
{
result.Success = await _iAsync.SayHelloAsync(cancellationToken);
await oprot.WriteMessageBeginAsync(new TMessage("SayHello", TMessageType.Reply, seqid), cancellationToken);
await result.WriteAsync(oprot, cancellationToken);
}
catch (TTransportException)
{
throw;
}
catch (Exception ex)
{
Console.Error.WriteLine("Error occurred in processor:");
Console.Error.WriteLine(ex.ToString());
var x = new TApplicationException(TApplicationException.ExceptionType.InternalError, " Internal error.");
await oprot.WriteMessageBeginAsync(new TMessage("SayHello", TMessageType.Exception, seqid), cancellationToken);
await x.WriteAsync(oprot, cancellationToken);
}
await oprot.WriteMessageEndAsync(cancellationToken);
await oprot.Transport.FlushAsync(cancellationToken);
}
Task <SayHelloResultArgs> IHello.SayHello(SayHelloArgs args)
{
//logger.LogInformation($"SayHello message received: greeting = '{args}'");
//logger.LogInformation(args.Name + Count++);
return(Task.FromResult(new SayHelloResultArgs {
Message = $"Hello {args.Name}"
}));
}
public SayHelloResultArgs SayHello(SayHelloArgs request)
{
#if SILVERLIGHT
var asyncResult = Begin_SayHello(null, null, request);
return(End_SayHello(asyncResult));
#else
send_SayHello(request);
return(recv_SayHello());
#endif
}
public void send_SayHello(SayHelloArgs request)
{
oprot_.WriteMessageBegin(new TMessage("SayHello", TMessageType.Call, seqid_));
SayHello_args args = new SayHello_args();
args.Request = request;
args.Write(oprot_);
oprot_.WriteMessageEnd();
oprot_.Transport.Flush();
}
public IAsyncResult send_SayHello(AsyncCallback callback, object state, SayHelloArgs request)
{
oprot_.WriteMessageBegin(new TMessage("SayHello", TMessageType.Call, seqid_));
SayHello_args args = new SayHello_args();
args.Request = request;
args.Write(oprot_);
oprot_.WriteMessageEnd();
return(oprot_.Transport.BeginFlush(callback, state));
}
public void Read(TProtocol iprot)
{
iprot.IncrementRecursionDepth();
try
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.Struct)
{
Request = new SayHelloArgs();
Request.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
finally
{
iprot.DecrementRecursionDepth();
}
}
public SayHelloResultArgs Get([FromBody] SayHelloArgs args)
{
return(new SayHelloResultArgs {
Message = $"Hello {args.Name}"
});
}
public IAsyncResult Begin_SayHello(AsyncCallback callback, object state, SayHelloArgs request)
{
return(send_SayHello(callback, state, request));
}
