public void CallbackReadMessage(byte[] message)
{
string messageBody = "";
string stTime = "";
//enmTradingEvent te = CMessenger.GetMessageHeaderInfo(ref messageBody, message, ref stTime);
if (bNeedSynchroTime)
{
DateTime tm = Convert.ToDateTime(stTime);
}
//if (te == enmTradingEvent.StockUpadate)
{
CStockClass sc = (CStockClass)CUtil.DeSerializeFromXMLString(messageBody, typeof(CStockClass));
//tempo do normal
if (sc.Isin == "RTS-3.16")
{
sc.Copy(sc.Isin, _outpStockClass);
}
}
// CStockClass sc = (CStockClass) CUtil.DeSerializeFromXMLString(message, typeof(CStockClass));
//CStockClass sc =
}
private void DBGPrintStock(CStockClass sc)
{
string stBids = "bids ";
foreach (var kvp in sc.StockListBids)
{
int prec = kvp.Key;
stBids += String.Format("prec={0}", prec);
foreach (var kvp2 in kvp.Value)
{
stBids += String.Format("({0},{1})",
kvp2.Price.ToString().Replace(",", "."),
kvp2.Volume.ToString().Replace(",", "."));
}
}
string stAsks = "asks ";
foreach (var kvp in sc.StockListAsks)
{
int prec = kvp.Key;
stAsks += String.Format("prec={0}", prec);
foreach (var kvp2 in kvp.Value)
{
stAsks += String.Format("({0},{1})",
kvp2.Price.ToString().Replace(",", "."),
kvp2.Volume.ToString().Replace(",", "."));
}
}
}
public CStockClass CreateStockClass()
{
CStockClass sc = new CStockClass();
sc.StockListBids = new Dictionary <int, List <CStock> >();
sc.StockListAsks = new Dictionary <int, List <CStock> >();
sc.StockListBids[0] = new List <CStock>();
sc.StockListBids[1] = new List <CStock>();
sc.StockListAsks[0] = new List <CStock>();
sc.StockListAsks[1] = new List <CStock>();
return(sc);
}
public void Test()
{
int szDecimals = sizeof(decimal);
int szLong = sizeof(long);
int szDouble = sizeof(double);
int szFloat = sizeof(float);
// int szDateTime = DateTime
sc = CreateStockClass();
InitStockClass();
var bytes = CUtilProto.SerializeProto(sc);
}
public void PrintStock(string instrument, CStockClass stockClass)
{
if (!_isOn)
{
return;
}
foreach (var kvp in stockClass.StockListAsks)
{
Log(instrument, String.Format("prec={0}", kvp.Key));
string st = "";
foreach (var el in kvp.Value)
{
st += String.Format("{0} {1}|", el.Price, el.Volume);
}
Log(instrument, st);
}
Log(instrument, "");
Log(instrument, "");
foreach (var kvp in stockClass.StockListBids)
{
Log(instrument, String.Format("prec={0}", kvp.Key));
string st = "";
foreach (var el in kvp.Value)
{
st += String.Format("{0} {1}|", el.Price, el.Volume);
}
Log(instrument, st);
}
Log(instrument, "=======================================================================================================================================");
}
private void PrintOneStock(string instr, CStockClass stock)
{
foreach (var kvp in stock.StockListBids)
{
int prec = kvp.Key;
Log(instr, String.Format("prec={0}", prec));
string st = "";
if (kvp.Value == null)
{
continue;
}
foreach (var el in kvp.Value)
{
st += String.Format("{0} {1}|", el.Price, el.Volume);
}
Log(instr, st);
}
}
private void ProcessStockUpadate(byte[] arrMsgBody)
{
DateTime dtBefUnpack = DateTime.Now;
CStockClass sc = CUtilProto.DeserializeProto <CStockClass>(arrMsgBody);
DateTime dtAftUnpack = DateTime.Now;
// int sz = sizeof(decimal);
// int sz2 = sizeof(long);
CheckDeltaTimeLim(sc.DtBeforePack, 50, "CDataREciever.ProcessStockUpadate " + sc.Isin);
_dtStockUpdate = (DateTime.Now - sc.DtBeforePack).TotalMilliseconds;
/*Log("[StockUpadate] DtBeforePack=" + sc.DtBeforePack.ToString("hh:mm:ss.fff") + " isin=" +
* sc.Isin + " bid=" + sc.StockListBids[0][0].Price + " ask=" + sc.StockListAsks[0][0].Price +
* " dtBefUnpack=" + dtBefUnpack.ToString("hh:mm:ss.fff") + " dtAftUnpack=" + dtAftUnpack.ToString("hh:mm:ss.fff") +
* " dt=" + _dtStockUpdate);*/
Log("[StockUpadate] DtBeforePack=" + sc.DtBeforePack.ToString("hh:mm:ss.fff") + " isin=" + sc.Isin);
// DBGPrintStock(sc);
// if (sc.Isin == "IOTUSD")
// Thread.Sleep(0);
if (_outpStockClass.ContainsKey(sc.Isin))
{
// sc.Copy(sc.Isin, _outpStockClass[sc.Isin]);
sc.RebuildStock(sc.Isin, _outpStockClass[sc.Isin]);
}
// _kernelTerminal.ViewModelDispatcher.GetMarketViewModel(sc.Isin).ControlMarket.ControlStockInstance.ForceRepaint();
_dbg.PrintData(sc, _outpStockClass[sc.Isin]);
}
/// <summary>
///
/// Create structures - list for deals and stocks
/// for instrument
///
/// Call from -
/// 1)CKernetlTerminal.SubscribeTickersFromConfig - on successfull Authorisation
/// 2)CKernetlTerminal.EditConnectedStock
/// 3)CKernetlTerminal.EditNonConnectedStock
///
/// </summary>
/// <param name="instrument"></param>
public void AddStructuresForSubscribedTicker(string instrument, decimal stepPrice)
{
//if (isin == null)
// return;
lock (OutpListAggrDeals)
if (!OutpListAggrDeals.ContainsKey(instrument))
{
OutpListAggrDeals[instrument] = new List <CDealClass>();
}
lock (OutpStockClass)
if (!OutpStockClass.ContainsKey(instrument))
{
OutpStockClass[instrument] = new CStockClass();
}
//TODO get from GUI
int parPeriod = 30;
if (!_dictDealsAggr.ContainsKey(instrument))
{
_dictDealsAggr[instrument] = new CDealsAgregator(parPeriod, stepPrice);
}
lock (OutpListRawDeals)
if (!OutpListRawDeals.ContainsKey(instrument))
{
OutpListRawDeals[instrument] = new List <CDealClass>();
}
}
public TestBinaryCopy()
{
CStockClass sc = new CStockClass("Si-6.15", new List <int> {
0
});
Random rnd = new Random();
List <CStock> lst = new List <CStock>();
for (int i = 0; i < 100; i++)
{
// sc.StockList[0].Add(new CStock(rnd.Next(80000,85000), rnd.Next(0,1000)));
// sc.StockList[1].Add(new CStock(rnd.Next(80000,85000), rnd.Next(0,1000)));
// lst.Add(new CStock(rnd.Next(80000,85000), rnd.Next(0,1000)));
}
object obj = sc;
Stopwatch sw1 = new System.Diagnostics.Stopwatch();
Stopwatch sw2 = new System.Diagnostics.Stopwatch();
Stopwatch sw3 = new System.Diagnostics.Stopwatch();
MemoryStream ms = new MemoryStream();
const int num = 1000;
long[] arrTicks = new long[num];
long[] arrMs = new long[num];
for (int i = 0; i < num; i++)
{
sw1.Reset(); sw1.Start();
sw2.Reset(); sw2.Start();
sw3.Reset(); sw3.Start();
sw3.Stop();
try
{
BinaryFormatter formatter = new BinaryFormatter();
sw2.Stop();
formatter.Serialize(ms, obj);
// ms.Seek(0, SeekOrigin.Begin);
// BinaryFormatter formatter2 = new BinaryFormatter();
// object obout = formatter2.Deserialize(ms);
sw1.Stop();
arrTicks[i] = sw1.ElapsedTicks;
arrMs[i] = sw1.ElapsedMilliseconds;
if (sw1.ElapsedMilliseconds > 1)
{
// System.Threading.Thread.Sleep(1);
}
// System.Threading.Thread.Sleep(10);
}
catch (Exception e)
{
throw new ApplicationException("SerializeBinary");
}
}
}
public void PrintData(CStockClass source, CStockClass dest)
{
if (!_isOn)
{
return;
}
string instr = source.Isin;
Log(instr, "[SOURCESTOCK]");
PrintOneStock(instr, source);
Log(instr, "instr++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
foreach (var kvp in source.QueueCMDStockChng[Direction.Down])
{
int prec = kvp.Key;
string st = String.Format("prec={0} =>", prec);
if (kvp.Value == null)
{
continue;
}
foreach (var el in kvp.Value)
{
st += String.Format("{0} p={1} v={2}|", el.Code, el.Price, el.Volume);
}
Log(instr, st);
}
Log(instr, "[DSTSTOCK]");
PrintOneStock(instr, dest);
Log(instr, "______________________________________________________________________________________________________________________________________________________________________________");
foreach (var kvp in source.StockListBids)
{
int prec = kvp.Key;
if (source.StockListBids[prec] == null)
{
continue;
}
int cntDest = dest.StockListBids.Count == 0 || dest.StockListBids[prec] == null ? 0 : dest.StockListBids[prec].Count;
for (int i = 0; i < Math.Min(source.StockListBids[prec].Count, cntDest); i++)
{
if (source.StockListBids[prec][i].Price != dest.StockListBids[prec][i].Price ||
source.StockListBids[prec][i].Volume != dest.StockListBids[prec][i].Volume)
{
Log(instr, String.Format("ERROR ! prec={0} i={1} Src.Price={2} Src.Volume={3} dstPrice={4} dstVolume={5} ",
prec, //0
i, //1
source.StockListBids[prec][i].Price, //2
source.StockListBids[prec][i].Volume, //3
dest.StockListBids[prec][i].Price, //4
dest.StockListBids[prec][i].Volume) //5
);
}
}
}
//2018-07-09
//check consitance
foreach (var kvp in source.StockListBids)
{
int prec = kvp.Key;
if (dest.StockListBids[prec] == null)
{
continue;
}
//tempo for FORTS
/*
* decimal maxBidPrice = dest.StockListBids[prec][0].Price;
*
* for (int i = 0; i < dest.StockListAsks[prec].Count; i++)
* if (dest.StockListAsks[prec][i].Price <= maxBidPrice)
* Log(instr, String.Format("ERROR ! ask<=maxBidPrice prec={0} bid={1} ask={2}",
* prec,
* maxBidPrice,
* dest.StockListAsks[prec][i].Price));
*
* decimal minAskPrice = dest.StockListAsks[prec][0].Price;
*
*
* for (int i = 0; i < dest.StockListBids[prec].Count; i++)
* if (dest.StockListBids[prec][i].Price >= minAskPrice)
* Log(instr, String.Format("ERROR ! bid >= minAskPrice prec={0} bid={1} ask={2}",
* prec,
* maxBidPrice,
* dest.StockListAsks[prec][i].Price));
*/
}
Log(instr, "==============================================================================================================================================================================================");
}
