public override void OnMessage(object sender, WebSocket4Net.MessageReceivedEventArgs args)
{
try
{
base.OnMessage(sender, args);
dynamic obj = Newtonsoft.Json.JsonConvert.DeserializeObject(args.Message);
foreach (dynamic item in obj)
{
if (item.channel == "ok_sub_spot_btc_usdt_ticker")
{
long timestamp = item.data.timestamp * 10000;
var timeStr = StartDate.AddTicks(timestamp).DateTimeToDBString();
string price = item.data.buy;
this.Insert(price, timeStr);
}
}
}
catch (Exception ex)
{
System.IO.File.AppendAllText(System.Environment.CurrentDirectory + $"/{DateTime.Now.ToString("yyyyMMdd")}.log", $"[{Platform}] throw a error : {ex.Message}\r\n");
}
}
public override void OnMessage(object sender, WebSocket4Net.MessageReceivedEventArgs args)
{
try
{
base.OnMessage(sender, args);
dynamic obj = Newtonsoft.Json.JsonConvert.DeserializeObject(args.Message);
if (obj["table"] == "trade")
{
foreach (dynamic item in obj.data)
{
DateTime dt = item.timestamp;
dt = dt.AddHours(8);
string price = item.price;
this.Insert(price, dt.DateTimeToDBString());
}
}
}
catch (Exception ex)
{
System.IO.File.AppendAllText(System.Environment.CurrentDirectory + $"/{DateTime.Now.ToString("yyyyMMdd")}.log", $"[{Platform}] throw a error : {ex.Message}\r\n");
}
}
// This is actually another layer of message here, consider !! The message we receive here is some
// result of the serialized message object that we use internally. The "Message" event should thus
// redirect the received message to the de-serializer which then de-serializes the received string
// to the SINFONI.Message - object
void HandleMessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
if (Message != null)
{
Message(sender, new TransportMessageEventArgs(e.Message));
}
}
public override void OnMessage(object sender, WebSocket4Net.MessageReceivedEventArgs args)
{
try
{
base.OnMessage(sender, args);
dynamic obj = Newtonsoft.Json.JsonConvert.DeserializeObject(args.Message);
if (obj["event"] == "created")
{
string strData = obj.data;
var data = Newtonsoft.Json.JsonConvert.DeserializeObject <QuoinexDetail>(strData);
long created_at = data.created_at;
string created_str = StartDate.AddTicks(created_at * 10000000).ToString("yyyy-MM-dd HH:mm:ss,ms");
string price = data.price;
this.Insert(price, created_str);
}
}
catch (Exception ex)
{
System.IO.File.AppendAllText(System.Environment.CurrentDirectory + $"/{DateTime.Now.ToString("yyyyMMdd")}.log", $"[{Platform}] throw a error : {ex.Message}\r\n");
}
}
/// <summary>
/// Occurs when a message is received from taskt server.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
socketLogger.Information("Socket Message Received: " + e.Message);
//server responded with script
if (e.Message.Contains("?xml"))
{
//execute scripts
RunXMLScript(e.Message);
}
//server wants the client status
else if (e.Message.Contains("CLIENT_STATUS"))
{
SendMessage("CLIENT_STATUS=Ping Request Received, " + Client.ClientStatus);
}
//server send a new public key
else if (e.Message.Contains("ACCEPT_KEY"))
{
var authPublicKey = e.Message.Replace("ACCEPT_KEY=", "");
publicKey = authPublicKey;
//add public key to app settings and save
var appSettings = new Core.ApplicationSettings().GetOrCreateApplicationSettings();
appSettings.ServerSettings.ConnectToServerOnStartup = true;
appSettings.ServerSettings.ServerConnectionEnabled = true;
appSettings.ServerSettings.ServerPublicKey = authPublicKey;
appSettings.Save(appSettings);
}
}
private void OnWsMessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
if (null != m_AsyncActionQueue)
{
m_AsyncActionQueue.QueueActionWithDelegation((MyAction <string>) this.OnMessageReceived, e.Message);
}
}
private void WebSocket_OnMessage(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
messages.Enqueue(new QueuedWebSocketMessage {
Data = Encoding.UTF8.GetBytes(e.Message), IsBinary = false
});
messageEvent.Set();
}
void w_RAMData(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
JSONResponse value = JsonConvert.DeserializeObject <JSONResponse>(e.Message);
Hashtable diskData = value.parameters["GetRamUsage"];
m = JsonConvert.DeserializeObject <MEMORYSTATUSEX>(diskData["ramUsage"].ToString());
}
public override void OnMessage(object sender, WebSocket4Net.MessageReceivedEventArgs args)
{
try
{
base.OnMessage(sender, args);
dynamic obj = Newtonsoft.Json.JsonConvert.DeserializeObject(args.Message);
if (obj["event"] == "trade")
{
dynamic data = Newtonsoft.Json.JsonConvert.DeserializeObject(obj.data.Value);
string timestamp = data.timestamp;
var timeStr = StartDate.AddTicks(long.Parse(timestamp) * 10000000).DateTimeToDBString();
string price = data.price_str;
this.Insert(price, timeStr);
}
}
catch (Exception ex)
{
System.IO.File.AppendAllText(System.Environment.CurrentDirectory + $"/{DateTime.Now.ToString("yyyyMMdd")}.log", $"[{Platform}] throw a error : {ex.Message}\r\n");
}
}
private void _socket_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
var msgTypeName = GetMessageTypeName(e.Message);
// deserialize
switch (msgTypeName)
{
case "LoginResponse":
// send DataFeedListRequest
Send(new DataFeedListRequest());
break;
case "DataFeedListResponse":
ProcessDataFeedListResponse(DeserializeResponse <DataFeedListResponse>(e.Message));
break;
case "NewTickResponse":
ProcessNewTickResponse(DeserializeResponse <NewTickResponse>(e.Message));
break;
case "HistoryResponse":
ProcessHistoryResponse(DeserializeResponse <HistoryResponse>(e.Message));
break;
}
}
void w_CPUData(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
JSONResponse value = JsonConvert.DeserializeObject <JSONResponse>(e.Message);
processSet.Clear();
processSet = value.parameters["StartMonitoring"];
CPU_Response_Recieved = true;
}
void w_DiskData(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
JSONResponse value = JsonConvert.DeserializeObject <JSONResponse>(e.Message);
Hashtable diskData = value.parameters["GetDiskUsage"];
diskDataValues = JsonConvert.DeserializeObject <DiskDataValues>(diskData["diskUsage"].ToString());
Disk_Response_Recieved = true;
}
private void OnMessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
string msg = e.Message;
if (null != msg)
{
LogSystem.Info("Receive Lobby Message:{0}", msg);
JsonMessageDispatcher.HandleNodeMessage(msg);
}
}
private static void Websocket_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
WriteLine("Message received.");
if (WebSocketHelper.TryParse(e.Message, out var msg))
{
if (msg is HeartbeatEvent hb)
{
WriteLine($"Sequence: {hb.Sequence}, Last Trade Id: {hb.LastTradeId}");
}
}
}
private void _ws_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
Received?.Invoke(this, e.Message);
//var arr = e.Message.Split(new[] { "\r\n" }, StringSplitOptions.None);
//foreach (var message in arr)
//{
// if (string.IsNullOrEmpty(message))
// continue;
// var result = Tools.Parse(message);
// Received?.Invoke(this, result);
//}
}
private void RawSocket_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
Console.WriteLine(e.Message);
Debug.WriteLine(e.Message);
if (WebSocketHelper.TryParse(e.Message, out var msg))
{
if (msg is HeartbeatEvent hbe)
{
hbe.Dump();
}
}
}
private void DesenharCanvas(WebSocket4Net.MessageReceivedEventArgs e)
{
List <Element> elements = Newtonsoft.Json.JsonConvert.DeserializeObject <List <Element> >(e.Message);
if (elements.Count > 1000)
{
ReiniciarPartida();
}
foreach (var element in elements.Where(element => element.Value != 0))
{
DesenharPersonagens(element);
}
}
private void websocket_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
if (e.Message.Contains("connectionID"))
{
//set connection ID to display locally
webSocketConnectionID = e.Message;
UpdateServerConnectionInfo(e.Message);
}
else if (e.Message.Contains("?xml"))
{
//code is being sent from the server so run it
streamedXMLData = e.Message;
RunXMLScript();
}
}
//VALUE
// 0
// 1 e 2 jogador
// 3 parede
void websocket_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
Dispatcher.BeginInvoke(() =>
{
if (e.Message.Contains("winner"))
{
Jogador jogador = Newtonsoft.Json.JsonConvert.DeserializeObject <Jogador>(e.Message);
FalarMensagem(jogador);
}
else if (_mostrarCanvas)
{
DesenharCanvas(e);
}
});
}
private void websocket_Opened(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
try
{
var da = JsonConvert.DeserializeObject <dynamic>(e.Message.Replace("event", "Event"));
if (da.Event.Value == "add_items")
{
var countAddItems = da.data.Count;
Program.Mess.Enqueue(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff") + "|Добавлено предметов на сайт:" + countAddItems);
ClickItem(da);
}
}
catch (Exception ex)
{
string ss = "";
}
}
public override void OnMessage(object sender, WebSocket4Net.MessageReceivedEventArgs args)
{
base.OnMessage(sender, args);
try
{
dynamic obj = Newtonsoft.Json.JsonConvert.DeserializeObject(args.Message);
long ticks = obj.E * 10000;
string timeStr = StartDate.AddTicks(ticks).DateTimeToDBString();
string price = obj.p;
this.Insert(price, timeStr);
}
catch (Exception ex)
{
System.IO.File.AppendAllText(System.Environment.CurrentDirectory + $"/{DateTime.Now.ToString("yyyyMMdd")}.log", $"[{Platform}] throw a error : {ex.Message}\r\n");
}
}
public override void OnMessage(object sender, WebSocket4Net.MessageReceivedEventArgs args)
{
try
{
base.OnMessage(sender, args);
object obj = null;
obj = Newtonsoft.Json.JsonConvert.DeserializeObject(args.Message);
if (obj is JArray arr && arr[1].Type == JTokenType.String)
{
string price = string.Empty;
long timestamp = 0;
switch (arr[1].Value <string>())
{
case "te":
timestamp = arr[3].Value <long>();
price = arr[4].Value <string>();
break;
case "tu":
timestamp = arr[4].Value <long>();
price = arr[5].Value <string>();
break;
}
if (!string.IsNullOrEmpty(price) && timestamp != 0)
{
var timeStr = StartDate.AddTicks(timestamp * 10000000L).DateTimeToDBString();
this.Insert(price, timeStr);
}
}
}
catch (Exception ex)
{
System.IO.File.AppendAllText(System.Environment.CurrentDirectory + $"/{DateTime.Now.ToString("yyyyMMdd")}.log", $"[{Platform}] throw a error : {ex.Message}\r\n");
}
}
private void Socket_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
dynamic data;
try
{
data = JsonConvert.DeserializeObject <dynamic>(e.Message);
}
catch (Exception ex)
{
//Todo: log error
return;
}
_dateLastUpdated = DateTime.UtcNow;
var type = (string)data.type;
switch (type)
{
case "snapshot":
Snapshot(data);
snapShotCount++;
break;
case "l2update":
L2Update(data);
break;
case "heartbeat":
break;
case "subscriptions":
break;
default:
Console.WriteLine(e.Message);
break;
}
}
public override void OnMessage(object sender, WebSocket4Net.MessageReceivedEventArgs args)
{
try
{
base.OnMessage(sender, args);
var obj = Newtonsoft.Json.JsonConvert.DeserializeObject <ZBModel>(args.Message);
if (obj.dataType == "trades")
{
var list = obj.data.Distinct(new ZBDetail()).ToList();
foreach (var item in list)
{
this.Insert(item.price, item.date_string);
}
}
}
catch (Exception ex)
{
System.IO.File.AppendAllText(System.Environment.CurrentDirectory + $"/{DateTime.Now.ToString("yyyyMMdd")}.log", $"[{Platform}] throw a error : {ex.Message}\r\n");
}
}
private void OnWebsocketMessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
var receivedMessage = e.Message;
string data;
if (receivedMessage.Length < 8)
{
return;
}
else if (this.UseSockJs)
{
receivedMessage = receivedMessage.Substring(3, receivedMessage.Length - 5);
data = receivedMessage.Substring(2);
data = data.Replace("\\\"", "\"");
}
else
{
data = receivedMessage.Substring(2);
}
string messageType = MessageType.GetTypeOfMessage(receivedMessage);
Log.Debug($"WebsocketMessage [{messageType}]: {receivedMessage}");
switch (messageType)
{
case MessageType.PING:
this.webSocket.Send(MessageGenerator.GeneratePingAnswerMessage(this.UseSockJs));
break;
case MessageType.IO_CONNECTED:
this.receivedIOConnected = true;
this.reconnectInProgress = false;
Task.Run(() =>
{
foreach (var registeredService in this.RegisteredServices.Values)
{
Log.Debug($"Re-registering service '{registeredService.Uuid}'");
this.RegisterAsync(registeredService).Wait();
}
foreach (var cacheEntry in this.EventCache)
{
foreach (var cachedEventData in cacheEntry.Value.ToArray())
{
if (this.PublishAsync(cacheEntry.Key, cachedEventData).Result)
{
cacheEntry.Value.Remove(cachedEventData);
}
}
}
});
this.Connected?.Invoke(this, EventArgs.Empty);
break;
case MessageType.NIO_ALREADY_CONNECTED:
this.ConnectionFailed?.Invoke(this, EventArgs.Empty);
break;
case MessageType.NIO_UNAUTHORIZED_CONNECTION:
this.ConnectionFailed?.Invoke(this, EventArgs.Empty);
break;
case MessageType.IO_REGISTERED:
this.receivedIORegistered = true;
this.Registered?.Invoke(this, EventArgs.Empty);
break;
case MessageType.NIO_REGISTRATION_ERROR:
this.RegistrationFailed?.Invoke(this, EventArgs.Empty);
break;
case MessageType.NIO_UNEXPECTED_REGISTRATION_ERROR:
this.RegistrationFailed?.Invoke(this, EventArgs.Empty);
break;
case MessageType.IO_PUBLISHED:
this.receivedIOPublished = true;
this.EventPublished?.Invoke(this, EventArgs.Empty);
break;
case MessageType.NIO_EVENT_FORWARDING_ERROR:
this.EventPublishingFailed?.Invoke(this, EventArgs.Empty);
break;
case MessageType.NIO_UNEXPECTED_EVENT_FORWARDING_ERROR:
this.EventPublishingFailed?.Invoke(this, EventArgs.Empty);
break;
case MessageType.FUNCTION_CALLBACK:
// Simple fix for https://cb.ipa.fraunhofer.de/cb/issue/164519 (Invalid escape of nested JSON trough websocket)
data = data.Replace("\\\\", "\\");
var functionCall = JsonConvert.DeserializeObject <FunctionCall>(data);
this.HandleFunctionCall(functionCall);
break;
case MessageType.CONFIG:
var configMessage = JsonConvert.DeserializeObject <Dictionary <string, object> >(data);
string serviceUuid = configMessage["uuid"].ToString();
if (this.RegisteredServices.ContainsKey(serviceUuid))
{
var service = this.RegisteredServices[serviceUuid];
var configParameters = ((JObject)configMessage["params"]).ToObject <Dictionary <string, object> >();
ConfigurationParameterReceivedEventArgs eventArgs = new ConfigurationParameterReceivedEventArgs(service, configParameters);
this.ConfigurationParameterReceived?.Invoke(this, eventArgs);
}
else
{
Log.Error($"Service '{serviceUuid}' not registered via this MsbClient");
}
break;
default:
Log.Error($"Unknown type of message: {receivedMessage}");
break;
}
}
void SuperSocket_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
//ShowMsg(e.Message, false);
}
private void _socket_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
var msgTypeName = GetMessageTypeName(e.Message);
// deserialize
switch (msgTypeName)
{
case "LoginResponse":
// send DataFeedListRequest
//Send(new DataFeedListRequest());
var loginRespinse = JsonConvert.DeserializeObject <LoginResponse>(e.Message);
if (string.IsNullOrEmpty(loginRespinse.Error))
{
AppendToLog("Connected");
}
else
{
AppendToLog(loginRespinse.Error);
}
break;
//case "Execution":
case "OrderPlaceResponse":
var ordRes = JsonConvert.DeserializeObject <OrderPlaceResponse>(e.Message);
if (ordRes.Expiry != null)
{
AppendToLog(ordRes.Expiry.ToString());
AppendToLog(((DateTime)ordRes.Expiry).ToUniversalTime().ToString());
}
if (String.IsNullOrEmpty(ordRes.Error))
{
AppendToLog(ordRes.SrvOrdID);
}
else
{
AppendToLog(ordRes.Error);
}
break;
case "OrderExecutionResponse":
// send DataFeedListRequest
//Send(new DataFeedListRequest());
var execution = JsonConvert.DeserializeObject <OrderExecutionResponse>(e.Message);
if (execution.Status == OrderState.Executed)
{
AppendToLog(execution.OrderID + execution.Status + execution.MsgType);
}
else
{
AppendToLog(execution.Status.ToString() + "Message = " + execution.Message);
}
break;
case "AssetsGetResponse":
// send DataFeedListRequest
//Send(new DataFeedListRequest());
var assets = JsonConvert.DeserializeObject <AssetsGetResponse>(e.Message);
if (assets.Assets.Count > 0)
{
if (this.InvokeRequired)
{
this.Invoke(new NewAssetMsgHandler(AssetsRecieved), assets.Assets);
}
AppendToLog(assets.Assets.Count.ToString());
}
else
{
AppendToLog("0");
}
break;
case "AccountInfoGetResponse":
// send DataFeedListRequest
//Send(new DataFeedListRequest());
var acount = JsonConvert.DeserializeObject <AccountInfoGetResponse>(e.Message);
if (acount.AccountData != null)
{
if (this.InvokeRequired)
{
this.Invoke(new AccountMsgHandler(AccountDataRecieved), acount.AccountData);
}
AppendToLog("Account ID : " + acount.AccountData.ID.ToString() + " Balance: " + acount.AccountData.Balance.ToString());
}
break;
case "OpenOrdersSubscribeResponse":
// send DataFeedListRequest
//Send(new DataFeedListRequest());
var openOrder = JsonConvert.DeserializeObject <OpenOrdersSubscribeResponse>(e.Message);
//if (acount.AccountData != null)
//{
// if (this.InvokeRequired)
// {
// this.Invoke(new AccountMsgHandler(AccountDataRecieved), acount.AccountData);
// }
// AppendToLog("Account ID : " + acount.AccountData.ID.ToString() + " Balance: " + acount.AccountData.Balance.ToString());
//}
break;
case "AccountInfoSubscribeResponse":
// send DataFeedListRequest
//Send(new DataFeedListRequest());
var account = JsonConvert.DeserializeObject <AccountInfoSubscribeResponse>(e.Message);
if (account.AccountData != null)
{
if (this.InvokeRequired)
{
this.Invoke(new AccountMsgHandler(AccountDataRecieved), account.AccountData);
}
AppendToLog("Account ID : " + account.AccountData.ID.ToString() + " Balance: " + account.AccountData.Balance.ToString());
}
break;
//case "DataFeedListResponse":
// ProcessDataFeedListResponse(DeserializeResponse<DataFeedListResponse>(e.Message));
// break;
////case "NewTickResponse":
//// ProcessNewTickResponse(DeserializeResponse<NewTickResponse>(e.Message));
//// break;
//case "HistoryResponse":
// ProcessHistoryResponse(DeserializeResponse<HistoryResponse>(e.Message));
// break;
case "ErrorResponse":
var errorRes = JsonConvert.DeserializeObject <ErrorResponse>(e.Message);
AppendToLog(errorRes.Error);
break;
}
}
private void WebSocket_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
if (e.Message.Contains("subscribed"))
{
if (e.Message.Contains("currency"))
{
var items = JsonConvert.DeserializeObject <Subscribe>(e.Message);
MapSymbolChannel mapSymbol = new MapSymbolChannel();
mapSymbol.ChannelId = items.chanId;
mapSymbol.Symbol = "f" + items.currency;
list.Add(mapSymbol);
var objForms = listForms.Where(m => m.symbol.IndexOf("f" + items.currency) > -1).ToList();
foreach (var item in objForms)
{
item.channelId.Add(items.chanId);
item.form.Invoke((Action) delegate()
{
item.form.ObjTrading.Add(new FinexTicker {
Id = items.chanId, broker = Broker.BitFinex.ToString().ToUpper(), pair = Broker.BitFinex.ToString().ToUpper() + "." + items.currency.Replace("t", ""), bid = "0", ask = "0", last_price = "", volume = ""
});
item.form.dataGridMarketData.DataSource = item.form.ObjTrading;
});
}
}
else
{
var items = JsonConvert.DeserializeObject <Subscribe>(e.Message);
MapSymbolChannel mapSymbol = new MapSymbolChannel();
mapSymbol.ChannelId = items.chanId;
mapSymbol.Symbol = "t" + items.pair;
list.Add(mapSymbol);
var objForms = listForms.Where(m => m.symbol.IndexOf(items.pair) > -1).ToList();
foreach (var item in objForms)
{
item.channelId.Add(items.chanId);
item.form.Invoke((Action) delegate()
{
item.form.ObjTrading.Add(new FinexTicker {
Id = items.chanId, broker = Broker.BitFinex.ToString().ToUpper(), pair = Broker.BitFinex.ToString().ToUpper() + "." + items.pair.Replace("t", ""), bid = "0", ask = "0", last_price = "", volume = ""
});
item.form.dataGridMarketData.DataSource = item.form.ObjTrading;
});
}
}
}
if (e.Message.Contains("hb"))
{
return;
}
if (e.Message.Contains("["))
{
try
{
var data = e.Message.Split('[');
if (data.Count() > 2) //snapshot
{
var instrument = data[1].Replace(",", string.Empty);
var objForms = listForms.Where(m => m.channelId.Contains(Convert.ToInt32(instrument))).ToList();
foreach (var item in objForms)
{
var ObjTrading = item.form.ObjTrading as BindingList <FinexTicker>;
var p = ObjTrading.Where(m => m.Id == Convert.ToInt32(instrument)).FirstOrDefault();
if (p != null)
{
var items = data[2].Split(',');
GridColumnDataChanges(items, p, ObjTrading, item.form);
}
else
{
var listSymbol = list.Where(m => m.ChannelId == Convert.ToInt32(instrument)).FirstOrDefault().Symbol;
var items = data[2].Split(',');
item.form.Invoke((Action) delegate()
{
item.form.ObjTrading.Add(new FinexTicker {
Id = Convert.ToInt32(instrument), broker = Broker.BitFinex.ToString().ToUpper(), pair = Broker.BitFinex.ToString().ToUpper() + "." + listSymbol.Replace("t", "").Replace("f", ""), bid = items[0], ask = items[2], last_price = items[6], volume = items[7]
});
item.form.dataGridMarketData.DataSource = item.form.ObjTrading;
});
}
}
}
else
{
var items = JsonConvert.DeserializeObject <string[]>(e.Message);
if (items.Count() > 3)
{
var instrument = data[1].Replace(",", string.Empty);
var objForms = listForms.Where(m => m.channelId.Contains(Convert.ToInt32(instrument))).ToList();
foreach (var item in objForms)
{
var ObjTrading = item.form.ObjTrading as BindingList <FinexTicker>;
var p = ObjTrading.Where(m => m.Id == Convert.ToInt32(items[0])).FirstOrDefault();
if (p != null)
{
GridColumnDataChanges(items, p, ObjTrading, item.form);
}
else
{
var listSymbol = list.Where(m => m.ChannelId == Convert.ToInt32(instrument)).FirstOrDefault().Symbol;
item.form.Invoke((Action) delegate()
{
item.form.ObjTrading.Add(new FinexTicker {
Id = Convert.ToInt32(instrument), broker = Broker.BitFinex.ToString().ToUpper(), pair = Broker.BitFinex.ToString().ToUpper() + "." + listSymbol.Replace("t", "").Replace("f", ""), bid = items[0], ask = items[2], last_price = items[6], volume = items[7]
});
item.form.dataGridMarketData.DataSource = item.form.ObjTrading;
});
}
}
}
}
}
catch (Exception ex)
{
}
}
}
private void _ws_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
Received?.Invoke(this, e.Message);
}
void SuperSocket_MessageReceived(object sender, WebSocket4Net.MessageReceivedEventArgs e)
{
Mediator.ShowMsg("系统消息:" + e.Message);
}
