private TTransport MakeTransport(URL url, TConfiguration configuration)
{
var ipaddress = IPAddress.Loopback;
if (!NetUtil.IsAnyHost(url.Host) && !NetUtil.IsLocalHost(url.Host))
{
ipaddress = IPAddress.Parse(url.Host);
}
// construct endpoint transport
TTransport transport = null;
Transport selectedTransport = GetTransport(url);
{
switch (selectedTransport)
{
case Transport.Tcp:
transport = new TSocketTransport(ipaddress, url.Port, configuration);
break;
case Transport.NamedPipe:
transport = new TNamedPipeTransport(".test", configuration);
break;
case Transport.Http:
transport = new THttpTransport(new Uri($"http://{url.Host}:{url.Port}"), configuration);
break;
case Transport.TcpTls:
transport = new TTlsSocketTransport(ipaddress, url.Port, configuration,
GetCertificate(), CertValidator, LocalCertificateSelectionCallback);
break;
default:
Console.WriteLine("unhandled case");
break;
}
}
// optionally add layered transport(s)
Buffering selectedBuffering = GetBuffering(url);
switch (selectedBuffering)
{
case Buffering.Buffered:
transport = new TBufferedTransport(transport);
break;
case Buffering.Framed:
transport = new TFramedTransport(transport);
break;
default: // layered transport(s) are optional
if (selectedBuffering != Buffering.None)
{
Console.WriteLine("unhandled case");
}
break;
}
return(transport);
}
protected override async Task <TTransport> AcceptImplementationAsync(CancellationToken cancellationToken)
{
if (cancellationToken.IsCancellationRequested)
{
return(await Task.FromCanceled <TTransport>(cancellationToken));
}
if (_server == null)
{
throw new TTransportException(TTransportException.ExceptionType.NotOpen, "No underlying server socket.");
}
try
{
TTransport tSocketTransport = null;
var tcpClient = await _server.AcceptTcpClientAsync();
try
{
tSocketTransport = new TSocketTransport(tcpClient)
{
Timeout = _clientTimeout
};
switch (_buffering)
{
case Buffering.BufferedTransport:
tSocketTransport = new TBufferedTransport(tSocketTransport);
break;
case Buffering.FramedTransport:
tSocketTransport = new TFramedTransport(tSocketTransport);
break;
default:
Debug.Assert(_buffering == Buffering.None);
break;
}
return(tSocketTransport);
}
catch (Exception)
{
if (tSocketTransport != null)
{
tSocketTransport.Dispose();
}
else // Otherwise, clean it up ourselves.
{
((IDisposable)tcpClient).Dispose();
}
throw;
}
}
catch (Exception ex)
{
throw new TTransportException(ex.ToString());
}
}
public ServerConnection()
{
try
{
TTransport transport = new TSocketTransport("localhost", 5000);
TBinaryProtocol protocol = new TBinaryProtocol(transport);
TMultiplexedProtocol multiplexedProtocolConsumer = new TMultiplexedProtocol(protocol, "ConsumerService");
consumerService = new ConsumerService.Client(multiplexedProtocolConsumer);
TMultiplexedProtocol multiplexedProtocolContentCreator = new TMultiplexedProtocol(protocol, "ContentCreatorService");
contentCreatorService = new ContentCreatorService.Client(multiplexedProtocolContentCreator);
TMultiplexedProtocol multiplexeProtocolAlbum = new TMultiplexedProtocol(protocol, "AlbumService");
albumService = new AlbumService.Client(multiplexeProtocolAlbum);
TMultiplexedProtocol multiplexeProtocolTrack = new TMultiplexedProtocol(protocol, "TrackService");
trackService = new TrackService.Client(multiplexeProtocolTrack);
TMultiplexedProtocol multiplexedProtocolPlaylist = new TMultiplexedProtocol(protocol, "PlaylistService");
playlistService = new PlaylistService.Client(multiplexedProtocolPlaylist);
TMultiplexedProtocol multiplexeProtocolLibrary = new TMultiplexedProtocol(protocol, "LibraryService");
libraryService = new LibraryService.Client(multiplexeProtocolLibrary);
}
catch (Exception ex)
{
Console.WriteLine(ex + " in Session class");
}
}
public async static void startClient()
{
TTransport transport = null;
try
{
string ip = "127.0.0.1";
string port = "6667";
string username = "******";
string password = "******";
// Make socket
transport = new TSocketTransport(ip, int.Parse(port));
if (!transport.IsOpen)
{
await transport.OpenAsync();
}
TProtocol protocol = new TCompactProtocol(transport);
TSIService.Client client = new TSIService.Client(protocol);
var result = await client.openSessionAsync(new TSOpenSessionReq()
{
Client_protocol = TSProtocolVersion.IOTDB_SERVICE_PROTOCOL_V2,
Username = username,
Password = password
});
//await client.testInsertTabletAsync(new TSInsertTabletReq()
//{
// DeviceId = "11",
// Measurements = new System.Collections.Generic.List<string>()
// {
// "001"
// },
// SessionId = result.SessionId,
// Size = 10,
// Timestamps =new byte[] { Convert.ToByte(DateTime.Now) },
// Values = new byte[] { Convert.ToByte(2.33d) }
//});
Console.WriteLine("Thrift client result =: " + result.SessionId);
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
}
finally
{
if (null != transport)
{
//close
transport.Close();
}
}
}
private static TTransport GetTransport(string[] args)
{
TTransport transport = new TSocketTransport(IPAddress.Loopback, 9090, Configuration);
// construct endpoint transport
var transportArg = args.FirstOrDefault(x => x.StartsWith("-tr"))?.Split(':')?[1];
if (Enum.TryParse(transportArg, true, out Transport selectedTransport))
{
switch (selectedTransport)
{
case Transport.Tcp:
transport = new TSocketTransport(IPAddress.Loopback, 9090, Configuration);
break;
case Transport.NamedPipe:
transport = new TNamedPipeTransport(".test", Configuration);
break;
case Transport.Http:
transport = new THttpTransport(new Uri("http://localhost:9090"), Configuration);
break;
case Transport.TcpTls:
transport = new TTlsSocketTransport(IPAddress.Loopback, 9090, Configuration,
GetCertificate(), CertValidator, LocalCertificateSelectionCallback);
break;
default:
Debug.Assert(false, "unhandled case");
break;
}
}
// optionally add layered transport(s)
var bufferingArg = args.FirstOrDefault(x => x.StartsWith("-bf"))?.Split(':')?[1];
if (Enum.TryParse <Buffering>(bufferingArg, out var selectedBuffering))
{
switch (selectedBuffering)
{
case Buffering.Buffered:
transport = new TBufferedTransport(transport);
break;
case Buffering.Framed:
transport = new TFramedTransport(transport);
break;
default: // layered transport(s) are optional
Debug.Assert(selectedBuffering == Buffering.None, "unhandled case");
break;
}
}
return(transport);
}
public async Task <ApiResult <PElement> > Get(string name)
{
TSocketTransport transport = new TSocketTransport("server", 5550, new TConfiguration());
TProtocol proto = new TBinaryProtocol(transport);
PElementService.Client client = new PElementService.Client(proto);
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
transport.OpenAsync(default);
public ServerStreamingConnection()
{
try {
TTransport transport = new TSocketTransport("localhost", 8000);
TProtocol protocol = new TBinaryProtocol(transport);
streamingService = new StreamingService.Client(protocol);
} catch (Exception ex) {
Console.WriteLine(ex);
}
}
public TTransport CreateTransport()
{
// endpoint transport
TTransport trans = null;
switch (transport)
{
case TransportChoice.Http:
Debug.Assert(url != null);
trans = new THttpTransport(new Uri(url), Configuration);
break;
case TransportChoice.NamedPipe:
Debug.Assert(pipe != null);
trans = new TNamedPipeTransport(pipe, Configuration);
break;
case TransportChoice.TlsSocket:
var cert = GetClientCert();
if (cert == null || !cert.HasPrivateKey)
{
throw new InvalidOperationException("Certificate doesn't contain private key");
}
trans = new TTlsSocketTransport(host, port, Configuration, 0,
cert,
(sender, certificate, chain, errors) => true,
null, SslProtocols.Tls | SslProtocols.Tls11 | SslProtocols.Tls12);
break;
case TransportChoice.Socket:
default:
trans = new TSocketTransport(host, port, Configuration);
break;
}
// layered transport
switch (layered)
{
case LayeredChoice.Buffered:
trans = new TBufferedTransport(trans);
break;
case LayeredChoice.Framed:
trans = new TFramedTransport(trans);
break;
default:
Debug.Assert(layered == LayeredChoice.None);
break;
}
return(trans);
}
static private async Task Go()
{
Console.WriteLine("Welcome to Thrift elementary Demo. We will check the details of Oxygen:");
var name = "Oxygen";
TSocketTransport transport = new TSocketTransport("127.0.0.1", 5550, new TConfiguration());
TProtocol proto = new TBinaryProtocol(transport);
PElementService.Client client = new PElementService.Client(proto);
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
transport.OpenAsync(default);
public async Task <ApiResponse> GetDataset(ClaimsPrincipal authenticatedUser, DatasetRequestDto requestedDataset)
{
try
{
TTransport transport = null;
transport = new TSocketTransport(IPAddress.Loopback, 9090, null);
transport = new TBufferedTransport(transport);
var protocol = new TBinaryProtocol(transport);
var client = new HelloWorldService.Client(protocol);
HelloWorldStruct test = new HelloWorldStruct
{
Text = "This is a rpc test"
};
await client.OpenTransportAsync(CancellationToken.None);
await client.HelloWorldAsync(test);
var user = await _userManager.FindByIdAsync(authenticatedUser.GetSubjectId());
var dataset = _persistenceManager.Context.DatasetFiles.FirstOrDefault(s =>
s.Id == requestedDataset.Id && s.CreatedById == user.Id);
string path;
if (dataset == null)
{
return(new ApiResponse(Status404NotFound, L["Dataset not found."]));
}
if (requestedDataset.ShortVersion)
{
path = $"{dataset.Path}\\{dataset.BlazorTitle}";
}
else
{
path = $"{dataset.Path}\\{dataset.Title}";
}
DatasetRequestReplyDto replyDto = new DatasetRequestReplyDto
{
Content = await File.ReadAllTextAsync(path)
};
return(new ApiResponse(Status200OK, null, replyDto));
}
catch (Exception ex)
{
_logger.LogError("Error while retrieving dataset: {0}", ex.Message);
return(new ApiResponse(Status400BadRequest, L["Error while retrieving the file."]));
}
}
public static void Connect()
{
try
{
TTransport transport = new TSocketTransport("localhost", 8000);
TProtocol protocol = new TBinaryProtocol(transport);
client = new StreamingService.Client(protocol);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private static TTransport MakeTransport(string[] args)
{
// construct endpoint transport
TTransport transport = null;
Transport selectedTransport = GetTransport(args);
{
switch (selectedTransport)
{
case Transport.Tcp:
transport = new TSocketTransport(IPAddress.Loopback, 9090, Configuration);
break;
case Transport.NamedPipe:
transport = new TNamedPipeTransport(".test", Configuration);
break;
case Transport.Http:
transport = new THttpTransport(new Uri("http://localhost:9090"), Configuration);
break;
case Transport.TcpTls:
transport = new TTlsSocketTransport(IPAddress.Loopback, 9090, Configuration,
GetCertificate(), CertValidator, LocalCertificateSelectionCallback);
break;
default:
Debug.Assert(false, "unhandled case");
break;
}
}
// optionally add layered transport(s)
Buffering selectedBuffering = GetBuffering(args);
switch (selectedBuffering)
{
case Buffering.Buffered:
transport = new TBufferedTransport(transport);
break;
case Buffering.Framed:
transport = new TFramedTransport(transport);
break;
default: // layered transport(s) are optional
Debug.Assert(selectedBuffering == Buffering.None, "unhandled case");
break;
}
return(transport);
}
public TTransport CreateTransport()
{
if (url == null)
{
// endpoint transport
TTransport trans = null;
if (pipe != null)
{
trans = new TNamedPipeTransport(pipe);
}
else
{
if (encrypted)
{
var cert = GetClientCert();
if (cert == null || !cert.HasPrivateKey)
{
throw new InvalidOperationException("Certificate doesn't contain private key");
}
trans = new TTlsSocketTransport(host, port, 0, cert,
(sender, certificate, chain, errors) => true,
null, SslProtocols.Tls | SslProtocols.Tls11 | SslProtocols.Tls12);
}
else
{
trans = new TSocketTransport(host, port);
}
}
// layered transport
if (buffered)
{
trans = new TBufferedTransport(trans);
}
if (framed)
{
trans = new TFramedTransport(trans);
}
return(trans);
}
return(new THttpTransport(new Uri(url), null));
}
protected override async ValueTask <TTransport> AcceptImplementationAsync(CancellationToken cancellationToken)
{
if (cancellationToken.IsCancellationRequested)
{
return(await Task.FromCanceled <TTransport>(cancellationToken));
}
if (_server == null)
{
throw new TTransportException(TTransportException.ExceptionType.NotOpen, "No underlying server socket.");
}
try
{
TTransport tSocketTransport = null;
var tcpClient = await _server.AcceptTcpClientAsync();
try
{
tSocketTransport = new TSocketTransport(tcpClient, Configuration)
{
Timeout = _clientTimeout
};
return(tSocketTransport);
}
catch (Exception)
{
if (tSocketTransport != null)
{
tSocketTransport.Dispose();
}
else // Otherwise, clean it up ourselves.
{
((IDisposable)tcpClient).Dispose();
}
throw;
}
}
catch (Exception ex)
{
throw new TTransportException(ex.ToString());
}
}
public async Task <ITransportClient> CreateClientAsync(EndPoint endPoint)
{
try
{
var ipEndPoint = endPoint as IPEndPoint;
var transport = new TSocketTransport(ipEndPoint.Address.ToString(), ipEndPoint.Port);
var tran = new TFramedTransport(transport);
var protocol = new TBinaryProtocol(tran);
var mp = new TMultiplexedProtocol(protocol, "thrift.surging");
var messageListener = new MessageListener();
var messageSender = new ThriftMessageClientSender(_transportMessageEncoder, protocol);
var result = new TThriftClient(protocol, messageSender, messageListener, new ChannelHandler(_transportMessageDecoder, messageListener, messageSender), _app);
await result.OpenTransportAsync();
return(result);
}
catch
{
throw;
}
}
public async Task <ITransportClient> CreateClientAsync(EndPoint endPoint)
{
var key = endPoint;
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"准备为服务端地址：{key}创建客户端。");
}
try
{
return(await _clients.GetOrAdd(key
, k => new Lazy <Task <ITransportClient> >(async() =>
{
var ipEndPoint = k as IPEndPoint;
var transport = new TSocketTransport(ipEndPoint.Address.ToString(), ipEndPoint.Port);
var tran = new TFramedTransport(transport);
var protocol = new TBinaryProtocol(tran);
var mp = new TMultiplexedProtocol(protocol, "thrift.surging");
var messageListener = new MessageListener();
var messageSender = new ThriftMessageClientSender(_transportMessageEncoder, protocol);
var result = new TThriftClient(protocol, messageSender, messageListener, new ChannelHandler(_transportMessageDecoder, messageListener, messageSender, _logger), _logger);
await result.OpenTransportAsync();
return result;
}
)).Value);//返回实例
}
catch (Exception ex)
{
//移除
_clients.TryRemove(key, out var value);
var ipEndPoint = endPoint as IPEndPoint;
//标记这个地址是失败的请求
if (ipEndPoint != null)
{
await _healthCheckService.MarkFailure(new IpAddressModel(ipEndPoint.Address.ToString(), ipEndPoint.Port));
}
throw;
}
}
private static TProtocol MakeProtocol(Config config)
{
var transport = new TSocketTransport(config.Hostname, config.Port, null);
return(new TBinaryProtocol(transport));
}
/// <summary>
/// Creates a game instance.
/// </summary>
/// <param name="args">If first value is given, it will be considered as Server IP</param>
/// <returns>Task</returns>
static async Task Main(string[] args)
{
string serverIp = "localhost";
if (args.Length > 0)
{
serverIp = args[0];
}
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
Console.SetWindowSize(CLIENT_WINDOW_WIDTH, CLIENT_WINDOW_HEIGHT);
Console.BufferHeight = CLIENT_WINDOW_HEIGHT;
Console.BufferWidth = CLIENT_WINDOW_WIDTH;
}
try {
TTransport transport = new TSocketTransport(serverIp, 5000);
TProtocol protocol = new TBinaryProtocol(transport);
client = new PingPongService.Client(protocol);
while (true)
{
if (!isGameRunning)
{
selfPlayerId = await client.JoinGameAsync();
opponentPlayerId = selfPlayerId % 2 == 0 ? selfPlayerId + 1 : selfPlayerId - 1;
await client.SendPlayerPadPositionAsync(players[selfPlayerId]);
isGameRunning = true;
}
if (!Console.KeyAvailable)
{
try {
var opponentPlayerData = await client.GetLatestPlayerPadPositionAsync(opponentPlayerId);
players[opponentPlayerId] = opponentPlayerData;
hasGameStarted = true;
} catch (PlayerNotFoundException) {
if (hasGameStarted)
{
headerText = "You won!";
hasGameStarted = false;
}
else
{
headerText = "Waiting for an opponent...";
}
}
DrawPads();
if (hasGameFinished)
{
break;
}
if (hasGameStarted)
{
DrawBall();
MoveBall();
}
Thread.Sleep(100);
continue;
}
switch (Console.ReadKey().Key)
{
case ConsoleKey.DownArrow:
if (players[selfPlayerId].Position.Y < (CLIENT_WINDOW_HEIGHT - 4))
{
players[selfPlayerId].Position.Y++;
await client.SendPlayerPadPositionAsync(players[selfPlayerId]);
}
break;
case ConsoleKey.UpArrow:
if (players[selfPlayerId].Position.Y > 0)
{
players[selfPlayerId].Position.Y--;
await client.SendPlayerPadPositionAsync(players[selfPlayerId]);
}
break;
}
}
transport.Close();
Console.Read();
} catch (TApplicationException tApplicationException) {
Console.Clear();
Console.WriteLine(tApplicationException.StackTrace);
Console.Read();
} catch (Exception exception) {
Console.Clear();
Console.WriteLine(">> No hay conexión con el servidor.\n\n> Stack trace:");
Console.WriteLine(exception.StackTrace);
Console.WriteLine(exception.Message);
Console.WriteLine(exception.InnerException);
Console.Read();
}
}
public static void Main()
{
try
{
IPAddress ipaddress = IPAddress.Parse("127.0.0.1");
TTransport transport = new TSocketTransport(ipaddress, 18990, 100000);
TFramedTransport tFrameTransport = new TFramedTransport(transport);
TProtocol protocol = new TBinaryProtocol(tFrameTransport);
TStringBigSetKVService.Client client = new TStringBigSetKVService.Client(protocol);
client.OpenTransportAsync();
Console.WriteLine("transport.IsOpen");
Console.WriteLine(transport.IsOpen);
if (transport.IsOpen)
{
// Book book = new Book();
// book.Author = "Auth";
// book.Category = "Category";
// book.Id = "12123";
// book.Price = 10123;
// book.BookName = "Book Name";
//
// var bookJson = JsonConvert.SerializeObject(book);
// var bJson = Encoding.ASCII.GetBytes(bookJson);;
// var str = Encoding.UTF8.GetString(bJson);
// // Console.WriteLine(bJson);
// Console.WriteLine(str);
// var tItem = new TItem();
// tItem.Key = Encoding.ASCII.GetBytes(book.Id);
// tItem.Value = bJson;
//
// var bsPutItemAsync = client.bsPutItemAsync("Test", tItem);
// Console.WriteLine(bsPutItemAsync.IsCompleted);
// if (bsPutItemAsync.IsCompleted == false)
// {
// bsPutItemAsync.Wait();
// }
// // ========================
// var serializeObject = JsonConvert.SerializeObject(bsPutItemAsync);
// Console.WriteLine(serializeObject);
// Get data from thrift
var bsGetItemAsync = client.bsGetItemAsync("Test", Encoding.ASCII.GetBytes("12123"));
// bsGetItemAsync.Start();
// bsGetItemAsync.RunSynchronously();
Console.WriteLine("serializeObject: ");
Console.WriteLine(bsGetItemAsync.IsCanceled);
Console.WriteLine(bsGetItemAsync.IsFaulted);
Console.WriteLine(bsGetItemAsync.IsCompleted);
if (bsGetItemAsync.IsCompleted == false)
{
Console.WriteLine("bsGetItemAsync.IsCompleted == false");
bsGetItemAsync.Wait();
}
Console.WriteLine(bsGetItemAsync.IsCompletedSuccessfully);
Console.WriteLine(bsGetItemAsync.Status);
Console.WriteLine(bsGetItemAsync.Id);
// bsGetItemAsync.Wait();
Console.WriteLine(bsGetItemAsync.ToString());
// Console.WriteLine(bsGetItemAsync.Result.Item.Value);
var obj = Encoding.UTF8.GetString(bsGetItemAsync.Result.Item.Value);
Console.WriteLine(obj);
// ==========================
//
// int sum = client.add(1, 1);
// Console.WriteLine("1+1={0}", sum);
//
// Work work = new Work();
//
// work.Op = Operation.DIVIDE;
// work.Num1 = 1;
// work.Num2 = 0;
// try
// {
// int quotient = client.calculate(1, work);
// Console.WriteLine("Whoa we can divide by 0");
// }
// catch (InvalidOperation io)
// {
// Console.WriteLine("Invalid operation: " + io.Why);
// }
//
// work.Op = Operation.SUBTRACT;
// work.Num1 = 15;
// work.Num2 = 10;
// try
// {
// int diff = client.calculate(1, work);
// Console.WriteLine("15-10={0}", diff);
// }
// catch (InvalidOperation io)
// {
// Console.WriteLine("Invalid operation: " + io.Why);
// }
//
// SharedStruct log = client.getStruct(1);
// Console.WriteLine("Check log: {0}", log.Value);
}
}
catch (Exception e)
{
Console.WriteLine(e.Data);
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
}
}
static async Task Main(string[] args)
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
Console.SetWindowSize(ANCHO_ESCENARIO, ALTO_ESCENARIO);
Console.BufferHeight = ALTO_ESCENARIO;
Console.BufferWidth = ANCHO_ESCENARIO;
}
posicionPelota = new Posicion {
X = ANCHO_ESCENARIO / 2, Y = ALTO_ESCENARIO / 2
};
jugadores.Add(new Jugador
{
IdJugador = 0,
Posicion = new Posicion {
X = 0, Y = (ALTO_ESCENARIO / 2 - TAMAÑO_PALETA / 2)
}
});
jugadores.Add(
new Jugador
{
IdJugador = 1,
Posicion = new Posicion {
X = ANCHO_ESCENARIO - 1, Y = (ALTO_ESCENARIO / 2 - TAMAÑO_PALETA / 2)
}
});
try
{
TTransport transporte = new TSocketTransport("localhost", 5000);
TProtocol protocolo = new TBinaryProtocol(transporte);
cliente = new ServicioPingPong.Client(protocolo);
while (true)
{
if (!jugando)
{
miId = await cliente.EntrarALaPartidaAsync();
idRival = miId % 2 == 0 ? miId + 1 : miId - 1;
await cliente.EnviarPosicionAsync(jugadores[miId]);
jugando = true;
}
if (!Console.KeyAvailable)
{
try
{
jugadores[idRival] = await cliente.ConsultarPosicionJugadorAsync(idRival);
partidaIniciada = true;
}
catch (JugadorNoEncontrado)
{
if (partidaIniciada)
{
partidaIniciada = false;
}
else
{
marcador = "Esperando un oponente";
}
}
InicializarEscenario();
if (partidaFinalizada)
{
break;
}
if (partidaIniciada)
{
marcador = puntJugador1 + " vs " + puntJugador2;
InicializarEscenario();
Console.SetCursorPosition(posicionPelota.X, posicionPelota.Y);
Console.Write("°");
MoverPelota();
}
Thread.Sleep(70);
continue;
}
switch (Console.ReadKey().Key)
{
case ConsoleKey.UpArrow:
if (jugadores[miId].Posicion.Y > 0)
{
jugadores[miId].Posicion.Y--;
await cliente.EnviarPosicionAsync(jugadores[miId]);
}
break;
case ConsoleKey.DownArrow:
if (jugadores[miId].Posicion.Y < (ALTO_ESCENARIO - TAMAÑO_PALETA))
{
jugadores[miId].Posicion.Y++;
await cliente.EnviarPosicionAsync(jugadores[miId]);
}
break;
}
}
transporte.Close();
Console.Read();
}
catch (TApplicationException tApplicationException)
{
Console.Clear();
Console.WriteLine(tApplicationException.StackTrace);
Console.Read();
}
catch (Exception)
{
Console.Clear();
Console.WriteLine(" Error al conectar con el servidor");
Console.Read();
}
}
