public void CallDirectoryService()
{
ThreadPool.QueueUserWorkItem(state =>
{
var req = new ServiceHostRequest()
{
Address = _ip, ServiceType = "intersect"
};
var dirServiceSocket = new RequestSocket();
dirServiceSocket.Connect("tcp://" + _dirSerIp + ":8910");
while (!_stopLoops)
{
try
{
using (var reqStream = new MemoryStream())
{
Serializer.Serialize(reqStream, req);
dirServiceSocket.SendFrame(reqStream.ToArray());
}
var receiveFrame = dirServiceSocket.ReceiveFrameBytes();
var request = Serializer.Deserialize <Message>(new MemoryStream(receiveFrame)) as BooleanResponse;
Console.WriteLine(request.Ok);
if (request.Ok)
{
return;
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
Thread.Sleep(1000);
}
});
}
// Create queue of requests in case multiple have to be handled
private void SimpleRequest(string endpoint, string request)
{
// wait until socket is available
while (!isAvailable)
{
// Debug.Log("Socket unavailable");
}
isAvailable = false;
if (request == null)
{
requestSocket.SendFrame(endpoint);
}
else
{
// Debug.Log(request);
requestSocket.SendMoreFrame(endpoint);
requestSocket.SendFrame(request);
}
var msg = requestSocket.ReceiveFrameBytes();
isAvailable = true;
requestResult = System.Text.Encoding.UTF8.GetString(msg);
//requestResult = JsonUtility.FromJson<T>(msgString);
}
public void RequestReply_Intersect()
{
//ThreadPool.QueueUserWorkItem(state =>
//{
var client = new RequestSocket();
client.Connect("tcp://" + IntersectIP + ":5553");
try
{
var request = new Request()
{
UserId = Id
};
using (var responseStream = new MemoryStream())
{
Serializer.Serialize(responseStream, request);
client.SendFrame(responseStream.ToArray());
}
var receiveFrame = client.ReceiveFrameBytes();
var reply = Serializer.Deserialize <Response>(new MemoryStream(receiveFrame));
var mr = reply as BooleanResponse;
}
catch (Exception e)
{
Console.WriteLine(e);
}
//});
}
private static void Main()
{
using (var worker = new RequestSocket())
{
var random = new Random(DateTime.Now.Millisecond);
var guid = Guid.NewGuid();
worker.Options.Identity = Encoding.Unicode.GetBytes(guid.ToString());
worker.Connect(ServerEndpoint);
worker.ReceiveReady += (s, e) =>
{
// Read and save all frames until we get an empty frame
// In this example there is only 1 but it could be more
byte[] address = worker.ReceiveFrameBytes();
worker.ReceiveFrameBytes(); // empty
byte[] request = worker.ReceiveFrameBytes();
worker.SendMoreFrame(address);
worker.SendMoreFrame(Encoding.Unicode.GetBytes(""));
worker.SendFrame(Encoding.Unicode.GetBytes(Encoding.Unicode.GetString(request) + " WORLD!"));
};
Console.WriteLine("W: {0} worker ready", guid);
worker.SendFrame(Encoding.Unicode.GetBytes(LRUReady));
var cycles = 0;
while (true)
{
cycles += 1;
if (cycles > 3 && random.Next(0, 5) == 0)
{
Console.WriteLine("W: {0} simulating a crash", guid);
Thread.Sleep(5000);
}
else if (cycles > 3 && random.Next(0, 5) == 0)
{
Console.WriteLine("W: {0} simulating CPU overload", guid);
Thread.Sleep(3000);
}
Console.WriteLine("W: {0} normal reply", guid);
worker.Poll(TimeSpan.FromMilliseconds(1000));
}
}
}
private static void Main()
{
using (var worker = new RequestSocket())
{
var random = new Random(DateTime.Now.Millisecond);
var guid = Guid.NewGuid();
worker.Options.Identity = Encoding.Unicode.GetBytes(guid.ToString());
worker.Connect(ServerEndpoint);
worker.ReceiveReady += (s, e) =>
{
// Read and save all frames until we get an empty frame
// In this example there is only 1 but it could be more
byte[] address = worker.ReceiveFrameBytes();
worker.ReceiveFrameBytes(); // empty
byte[] request = worker.ReceiveFrameBytes();
worker.SendMoreFrame(address);
worker.SendMoreFrame(Encoding.Unicode.GetBytes(""));
worker.SendFrame(Encoding.Unicode.GetBytes(Encoding.Unicode.GetString(request) + " WORLD!"));
};
Console.WriteLine("W: {0} worker ready", guid);
worker.SendFrame(Encoding.Unicode.GetBytes(LRUReady));
var cycles = 0;
while (true)
{
cycles += 1;
if (cycles > 3 && random.Next(0, 5) == 0)
{
Console.WriteLine("W: {0} simulating a crash", guid);
Thread.Sleep(5000);
}
else if (cycles > 3 && random.Next(0, 5) == 0)
{
Console.WriteLine("W: {0} simulating CPU overload", guid);
Thread.Sleep(3000);
}
Console.WriteLine("W: {0} normal reply", guid);
worker.Poll(TimeSpan.FromMilliseconds(1000));
}
}
}
static void Main(string[] args)
{
string addr = "tcp://localhost:6666";
Console.WriteLine("Client can connect to: {0}", addr);
using (var rs = new RequestSocket()) // // REQ must be send/recv...send/recv in this order
{
rs.Connect(addr);
while (true)
{
string str = Console.ReadLine();
rs.SendFrame(str);
// read from network
var msg = rs.ReceiveFrameBytes();
// get our Flat Buffer
var order = Order.GetRootAsOrder(new ByteBuffer(msg));
// For C#, unlike other languages, most values (except for vectors and unions) are available as
// properties instead of accessor methods.
// Note: We did not set the `Mana` field explicitly, so we get back the default value.
Console.WriteLine(order.Id);
Console.WriteLine(order.Broker);
Console.WriteLine(order.Stockcode);
Console.WriteLine(order.Side);
Console.WriteLine($"Price {order.Price.Value.Spot}, {order.Price.Value.Open}, {order.Price.Value.Close}");
// Contracts
for (int i = 0; i < order.ContractsLength; i++)
{
Console.WriteLine($"Contract {order.Contracts(i).Value.Name}, {order.Contracts(i).Value.Price}");
}
// Instruments
for (int i = 0; i < order.InstrumentsLength; i++)
{
Console.WriteLine($"Instrument {order.Instruments(i).Value.Tag}, {order.Instruments(i).Value.Value}, {order.Instruments(i).Value.BlobLength}");
byte[] bb = order.Instruments(i).Value.GetBlobBytes().Value.Array;
//foreach (byte b in bb)
//{
// Console.Write($" {b.ToString()}");
//}
//Console.WriteLine();
}
// Get and test the `Equipped` FlatBuffer `union`.
if (order.StrategyType == Strategies.Contract)
{
var strategy = order.Strategy <Contract>().Value;
Console.WriteLine($"Strategy {strategy.Name}, {strategy.Price}");
}
}
}
}
public ReplyData GetReply(InputData data)
{
var inputBuf = ByteArray.CreateFrom(data);
request.SendFrame(inputBuf);
var replyData = request.ReceiveFrameBytes();
return(replyData.ConvertTo <ReplyData>());
}
/// <summary>
/// 长连接发送
/// </summary>
/// <param name="buf"></param>
/// <returns></returns>
public byte[] Send(byte[] buf)
{
if (socket == null)
{
socket = new RequestSocket("tcp://" + Address);
}
socket.SendFrame(buf);
return(socket.ReceiveFrameBytes());
}
public Mmind.Response sendReq(Mmind.Request req)
{
reqbuf = new byte[req.CalculateSize()];
Serialize(reqbuf, req);
client.SendFrame(reqbuf);
resbuf = client.ReceiveFrameBytes();
Mmind.Response rel = Mmind.Response.Parser.ParseFrom(resbuf);
return(rel);
}
private List <Instrument> ReceiveInstrumentSearchResults(RequestSocket s)
{
using (var ms = new MemoryStream())
{
// First we receive the size of the final uncompressed byte[] array
bool hasMore;
var sizeBuffer = s.ReceiveFrameBytes(out hasMore);
if (sizeBuffer.Length == 0)
{
RaiseEvent(Error, this, new ErrorArgs(-1, "Contract request failed, received no reply."));
return(new List <Instrument>());
}
var outputSize = BitConverter.ToInt32(sizeBuffer, 0);
// Then the actual data
var buffer = s.ReceiveFrameBytes(out hasMore);
if (buffer.Length == 0)
{
RaiseEvent(Error, this, new ErrorArgs(-1, "Contract request failed, received no data."));
return(new List <Instrument>());
}
try
{
// Then we process it by first decompressing
ms.SetLength(0);
var decoded = LZ4Codec.Decode(buffer, 0, buffer.Length, outputSize);
ms.Write(decoded, 0, decoded.Length);
ms.Position = 0;
// And finally deserializing
return(Serializer.Deserialize <List <Instrument> >(ms));
}
catch (Exception ex)
{
RaiseEvent(Error, this, new ErrorArgs(-1, "Error processing instrument data: " + ex.Message));
return(new List <Instrument>());
}
}
}
/// <summary>
///
/// </summary>
/// <param name="address"></param>
/// <param name="buf"></param>
/// <returns></returns>
public byte[] Send(string address, byte[] buf)
{
var client = new RequestSocket(">tcp://" + address); // connect
client.SendFrame(buf);
byte[] result = client.ReceiveFrameBytes();
client.Close();
client.Dispose();
return(result);
}
public Task <ServiceReply> CallService(ServiceRequest srq)
{
// Convert serviceRequest into byte array which is then sent to server as frame
byte[] buffer = srq.ToByteArray();
socket.SendFrame(buffer);
// Receive, return Task
promise = new TaskCompletionSource <ServiceReply>();
promise.TrySetResult(ServiceReply.Parser.ParseFrom(socket.ReceiveFrameBytes()));
return(promise.Task);
}
public void ReceiveBeforeSending()
{
using (var rep = new ResponseSocket())
using (var req = new RequestSocket())
{
var port = rep.BindRandomPort("tcp://localhost");
req.Connect("tcp://localhost:" + port);
Assert.Throws <FiniteStateMachineException>(() => req.ReceiveFrameBytes());
}
}
public Task <byte[]> RequestResponse(byte[] data)
{
return
(Task <byte[]> .Factory.StartNew(() =>
{
lock (_socketlock)
{
_client.SendFrame(data);
return _client.ReceiveFrameBytes();
}
}));
}
private void ProcessMessageFrame <T>() where T : IMessageFrame, new()
{
if (!running)
{
throw new OpenDiablo2Exception("You have made a terrible mistake. Cannot get a message frame if you are not connected.");
}
using (var ms = new MemoryStream(requestSocket.ReceiveFrameBytes()))
using (var br = new BinaryReader(ms))
{
var messageFrame = getMessageFrame((eMessageFrameType)br.ReadByte());
if (messageFrame.GetType() != typeof(T))
{
throw new OpenDiablo2Exception("Recieved unexpected message frame!");
}
messageFrame.LoadFrom(br);
lock (getGameState().ThreadLocker)
messageFrame.Process(requestSocket.GetHashCode(), this);
}
}
private void ProcessMessageFrame <T>() where T : IMessageFrame, new()
{
if (!running)
{
throw new OpenDiablo2Exception("You have made a terrible mistake. Cannot get a message frame if you are not connected.");
}
var bytes = requestSocket.ReceiveFrameBytes();
var frameType = (eMessageFrameType)bytes[0];
var frameData = bytes.Skip(1).ToArray(); // TODO: Can we maybe use pointers? This seems wasteful
var messageFrame = getMessageFrame(frameType);
if (messageFrame.GetType() != typeof(T))
{
throw new OpenDiablo2Exception("Recieved unexpected message frame!");
}
messageFrame.Data = frameData;
lock (getGameState().ThreadLocker)
{
messageFrame.Process(requestSocket.GetHashCode(), this);
}
}
static void Main(string[] args)
{
using (var client = new RequestSocket())
{
client.Connect("tcp://localhost:5555");
int i = 1;
while (i <= 100000000)
{
var data = new byte[i];
client.SendFrame(data);
Console.WriteLine($"Send {i} bytes");
i *= 10;
client.ReceiveFrameBytes();
}
}
}
public byte[] sendReq(string request)
{
try
{
reqbuf = System.Text.Encoding.Default.GetBytes(request);;
client.SendFrame(reqbuf);
resbuf = client.ReceiveFrameBytes();
return(resbuf);
}
catch (Exception e)
{
Console.WriteLine("Network Error. Please check your ip address and network connection!");
System.Environment.Exit(0);
}
return(null);
}
private Out RequestToRemoteResponseSocket(In din)
{
try
{
//向远端Rep 服务器请求并获取数据
using (var req = new RequestSocket(ResponseHostString)
{
Options = { }
})
{
req.Options.Identity = Encoding.UTF8.GetBytes(Guid.NewGuid().ToString("N"));
req.SendFrame(din.ToProtobuf());
return(req.ReceiveFrameBytes().FromProtobuf <Out>());
//if (req.TrySendFrame(TimeSpan.FromMilliseconds(200),din.ToProtobuf()))
//{
// if (req.TryReceiveFrameBytes(DefaultTimeOuTimeSpan, out var responseBytes))
// return responseBytes.FromProtobuf<Out>();
// else
// {
// if (Logger.IsWarnEnabled)
// Logger.Warn("request to remote TryReceive timeout");
// }
//}
//else
//{
// if (Logger.IsWarnEnabled)
// Logger.Warn("request to remote TrySend timeout");
//}
}
}
catch (Exception e)
{
if (Logger.IsErrorEnabled)
{
Logger.Error(e);
}
return(null);
}
return(null);
}
public Account RequestAccount(int strategyID)
{
using (var requestSocket = new RequestSocket(requestSocketConnectionString))
{
var msg = new NetMQMessage(1);
msg.Append(BitConverter.GetBytes((byte)RequestMessageType.AccountRequest));
msg.Append(BitConverter.GetBytes(strategyID));
requestSocket.SendMultipartMessage(msg);
// requestSocket.SendFrame(BitConverter.GetBytes(strategyID));
logger.Info(() => "Waiting for account ID from server.");
var response = requestSocket.ReceiveFrameBytes();
using (var ms = new MemoryStream(response))
{
logger.Info(() => "Account ID received from server.");
return(MyUtils.ProtoBufDeserialize <Account>(ms));
}
}
}
public byte[] SendData(byte[] data)
{
try
{
socket.SendFrame(data);
if (!isAsync)
{
byte[] response = socket.ReceiveFrameBytes();
return(response);
}
}
catch (NetMQException e)
{
Logger.Error("Error sending data to ZeroMQ Socket address : {0} : {1}", new object[] { address, e.Message });
Console.WriteLine();
}
return(null);
}
public void RequestReply_Render()
{
ThreadPool.QueueUserWorkItem(state =>
{
List <int[]> players = new List <int[]>();
var client = new RequestSocket();
client.Connect("tcp://" + RenderIP + ":5558");
try
{
var request = new Request()
{
UserId = Id
};
using (var responseStream = new MemoryStream())
{
Serializer.Serialize(responseStream, request);
client.SendFrame(responseStream.ToArray());
}
var receiveFrame = client.ReceiveFrameBytes();
var reply = Serializer.Deserialize <RenderResponse>(new MemoryStream(receiveFrame));
var mr = reply as RenderResponse; //TODO: Change to render response
for (int i = 0; i < mr.Players.Count; i++)
{
players.Add(mr.Players[i]);
}
_gw.players.Clear();
for (int i = 0; i < players.Count; i++)
{
_gw.players.Add(players[i]);
}
_gw.RefreshGame();
_gw.DrawPlayers();
}
catch (Exception e)
{
Console.WriteLine(e);
}
});
}
/// <summary>
/// Add an instrument to QDMS.
/// </summary>
/// <param name="instrument"></param>
/// <returns>The instrument with its ID set if successful, null otherwise.</returns>
public Instrument AddInstrument(Instrument instrument)
{
if (!Connected)
{
RaiseEvent(Error, this, new ErrorArgs(-1, "Could not add instrument - not connected."));
return(null);
}
if (instrument == null)
{
RaiseEvent(Error, this, new ErrorArgs(-1, "Could not add instrument - instrument is null."));
return(null);
}
using (var s = new RequestSocket(_instrumentServerConnectionString))
{
using (var ms = new MemoryStream())
{
s.SendMoreFrame(MessageType.AddInstrument); // First we send an "ADD" request
// Then we need to serialize and send the instrument
s.SendFrame(MyUtils.ProtoBufSerialize(instrument, ms));
// Then get the reply
var result = s.ReceiveFrameString();
if (!result.Equals(MessageType.Success, StringComparison.InvariantCultureIgnoreCase))
{
RaiseEvent(Error, this, new ErrorArgs(-1, "Instrument addition failed: received no reply."));
return(null);
}
// Addition was successful, receive the instrument and return it
var serializedInstrument = s.ReceiveFrameBytes();
return(MyUtils.ProtoBufDeserialize <Instrument>(serializedInstrument, ms));
}
}
}
public MessageFrame <THeader, TPayload> SendRequest(MessageFrame <THeader, TPayload> requestMessage)
{
var endPoint = Binding + "://" + _ipAddress + ":" + _tcpPort.ToString();
using (var requester = new RequestSocket(endPoint))
{
// Connect
requester.Connect(endPoint);
// Send
requester.SendFrame(ObjectToByteArray(requestMessage), false);
// Receive
//TODO: Implement time-out
byte[] response = requester.ReceiveFrameBytes();
requestMessage = Deserialize <MessageFrame <THeader, TPayload> >(response);
requester.Disconnect(endPoint);
}
return(requestMessage);
}
public void CallDirectoryService()
{
ThreadPool.QueueUserWorkItem(state =>
{
var req = new ServiceProvideRequest()
{
ServiceType = "move"
};
var dirServiceSocket = new RequestSocket();
dirServiceSocket.Connect("tcp://" + _dirSerIp + ":8910");
while (!_stopLoops)
{
try
{
using (var reqStream = new MemoryStream())
{
Serializer.Serialize(reqStream, req);
dirServiceSocket.SendFrame(reqStream.ToArray());
}
var receiveFrame = dirServiceSocket.ReceiveFrameBytes();
var request = Serializer.Deserialize <Message>(new MemoryStream(receiveFrame)) as ServiceProviderResponse;
//Console.WriteLine(request.Address);
if (!String.IsNullOrEmpty(request.Address))
{
IP = request.Address;
PubSub();
RequestReply();
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
Thread.Sleep(1000);
}
});
}
public static async Task <int> Main(string[] args)
{
if (args.Length != 1)
{
await Console.Error.WriteLineAsync("Please specify the client name!");
return(1);
}
string clientName = args[0];
using (RequestSocket client = new RequestSocket())
{
await Console.Out.WriteLineAsync($"Starting client '{clientName}'");
Message message = new Message();
message.Name = clientName;
client.Connect("tcp://localhost:5556");
while (true)
{
message.Timestamp = DateTime.UtcNow.Ticks;
message.Body = "update received";
byte[] clientMsg = message.ToByteArray();
client.SendFrame(clientMsg);
await Console.Out.WriteLineAsync($"{message.ShowString()}");
byte[] reply = client.ReceiveFrameBytes();
Message replyMsg = Message.Parser.ParseFrom(reply);
await Console.Out.WriteLineAsync($"{replyMsg.ShowString()}");
Thread.Sleep(5000);
}
}
}
// Continuously prompts the user for input and relays it to the echo server
static async Task RelayConsoleToEchoServer()
{
// TODO
Console.WriteLine("Relaying console prompts to echo server");
using var req = new RequestSocket(">" + echoAddress);
// continuously prompt for user input
while (true)
{
// Read the console without blocking
var userInput = await Task.Run(() => Console.ReadLine());
var txBytes = Encoding.UTF8.GetBytes(userInput);
req.SendFrame(txBytes);
Console.WriteLine("console sent: " + userInput);
// wait for echo response
var rxBytes = req.ReceiveFrameBytes();
var rx = Encoding.UTF8.GetString(rxBytes);
Console.WriteLine("console got: " + rx);
await Task.Delay(200);
}
}
static void DoClientRequest(RequestSocket cl, int idx, long loopCount)
{
cl.SendFrame(i64tobytes(loopCount + 1));
cl.ReceiveFrameBytes();
}
public override bool ReceivePacket(out byte[] data)
{
data = Client.ReceiveFrameBytes();
return(true);
}
//!
//! receiver function, receiving the initial scene from the katana server (executed in separate thread)
//!
public void sceneReceiver()
{
AsyncIO.ForceDotNet.Force();
using (var sceneReceiver = new RequestSocket())
{
print("Trying to receive scene.");
OnProgress(0.1f, "Init Scene Receiver..");
sceneReceiver.Connect("tcp://" + VPETSettings.Instance.serverIP + ":5565");
print("Server set up.");
byte[] byteStream;
// HEader
print("header");
sceneReceiver.SendFrame("header");
byteStream = sceneReceiver.ReceiveFrameBytes();
print("byteStreamHeader size: " + byteStream.Length);
if (doWriteScene)
{
writeBinary(byteStream, "header");
}
sceneLoader.SceneDataHandler.HeaderByteData = byteStream;
OnProgress(0.15f, "..Received Header..");
#if TRUNK
// Materials
print("materials");
sceneReceiver.SendFrame("materials");
byteStream = sceneReceiver.ReceiveFrameBytes();
print("byteStreamMatrilas size: " + byteStream.Length);
if (doWriteScene)
{
writeBinary(byteStream, "materials");
}
sceneLoader.SceneDataHandler.MaterialsByteData = byteStream;
OnProgress(0.20f, "..Received Materials..");
#endif
// Textures
if (VPETSettings.Instance.doLoadTextures)
{
print("textures");
sceneReceiver.SendFrame("textures");
byteStream = sceneReceiver.ReceiveFrameBytes();
print("byteStreamTextures size: " + byteStream.Length);
if (doWriteScene)
{
writeBinary(byteStream, "textures");
}
sceneLoader.SceneDataHandler.TexturesByteData = byteStream;
OnProgress(0.33f, "..Received Texture..");
}
// Objects
print("objects");
sceneReceiver.SendFrame("objects");
byteStream = sceneReceiver.ReceiveFrameBytes();
print("byteStreamObjects size: " + byteStream.Length);
if (doWriteScene)
{
writeBinary(byteStream, "objects");
}
sceneLoader.SceneDataHandler.ObjectsByteData = byteStream;
OnProgress(0.80f, "..Received Objects..");
// Nodes
print("nodes");
sceneReceiver.SendFrame("nodes");
byteStream = sceneReceiver.ReceiveFrameBytes();
print("byteStreamNodes size: " + byteStream.Length);
if (doWriteScene)
{
writeBinary(byteStream, "nodes");
}
sceneLoader.SceneDataHandler.NodesByteData = byteStream;
OnProgress(0.9f, "..Received Nodes..");
// Characters
print("characters");
sceneReceiver.SendFrame("characters");
byteStream = sceneReceiver.ReceiveFrameBytes();
print("byteStreamCharacters size: " + byteStream.Length);
if (doWriteScene)
{
writeBinary(byteStream, "characters");
}
sceneLoader.SceneDataHandler.CharactersByteData = byteStream;
OnProgress(0.9f, "..Received Characters..");
sceneReceiver.Disconnect("tcp://" + VPETSettings.Instance.serverIP + ":5565");
sceneReceiver.Close();
sceneReceiver.Dispose();
}
//NetMQConfig.Cleanup();
print("done receive scene");
m_sceneTransferDirty = true;
OnProgress(1.0f, "..Building Scene..");
}
public void RequestReply()
{
ThreadPool.QueueUserWorkItem(state => {
var client = new RequestSocket();
client.Connect("tcp://" + IP + ":5555");
while (!_stopLoops)
{
var key = Console.ReadLine();
if (key == "w" || key == "a" || key == "s" || key == "d")
{
try
{
var request = new MoveRequest {
};
switch (key)
{
case "w":
request = new MoveRequest
{
UserId = Id,
Direction = new List <int> {
1, -1, 0
}
};
break;
case "a":
request = new MoveRequest
{
UserId = Id,
Direction = new List <int> {
1, -1, 0
}
};
break;
case "s":
request = new MoveRequest
{
UserId = Id,
Direction = new List <int> {
1, 0, -1
}
};
break;
case "d":
request = new MoveRequest
{
UserId = Id,
Direction = new List <int> {
1, 1, 0
}
};
break;
default:
break;
}
/*var request = new MoveRequest
* {
* UserId = Id,
* Direction = new List<int> {
* 1,
* _random.Next(),
* _random.Next()
* }
* };*/
using (var responseStream = new MemoryStream())
{
Serializer.Serialize(responseStream, request);
client.SendFrame(responseStream.ToArray());
}
var receiveFrame = client.ReceiveFrameBytes();
var reply = Serializer.Deserialize <Response>(new MemoryStream(receiveFrame));
var mr = reply as BooleanResponse;
if (++counter % 30000 == 0)
{
Console.WriteLine("response {1}; Client: {0}", mr != null && mr.Ok, counter);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
});
}
