private string ToMarketDataLog(USeMarketData data)
{
List <string> filedList = new List <string>();
filedList.Add(data.Instrument.InstrumentCode);
filedList.Add(data.AskPrice.ToString());
filedList.Add(data.AskSize.ToString());
filedList.Add(data.BidPrice.ToString());
filedList.Add(data.BidSize.ToString());
filedList.Add(data.OpenPrice.ToString());
filedList.Add(data.HighPrice.ToString());
filedList.Add(data.LowPrice.ToString());
filedList.Add(data.LastPrice.ToString());
filedList.Add(data.ClosePrice.ToString());
filedList.Add(data.PreClosePrice.ToString());
filedList.Add(data.UpperLimitPrice.ToString());
filedList.Add(data.LowerLimitPrice.ToString());
filedList.Add(data.PreSettlementPrice.ToString());
filedList.Add(data.SettlementPrice.ToString());
filedList.Add(data.OpenInterest.ToString());
filedList.Add(data.Volume.ToString());
filedList.Add(data.Turnover.ToString());
filedList.Add(data.UpdateTime.ToString("yyyy-MM-dd HH:mm:ss"));
filedList.Add(data.QuoteDay.HasValue ? data.QuoteDay.Value.ToString("yyyy-MM-dd") : "");
filedList.Add(data.QuoteTime.HasValue ? data.QuoteTime.Value.ToString(@"hh\:mm\:ss") : "");
return(string.Join(",", filedList));
}
private void ProcessUSeMarketData(USeMarketData marketData)
{
Debug.Assert(marketData.QuoteDay.HasValue);
Debug.Assert(marketData.QuoteTime.HasValue);
if (USeManager.Instance.DayNightType == DayNightType.Night)
{
USeMarket market = USeMarket.Unknown;
if (m_instrumentDic.TryGetValue(marketData.Instrument.InstrumentCode, out market) == false)
{
Debug.Assert(false);
}
if (market == USeMarket.SHFE || market == USeMarket.DCE)// 如果是上期所，大连
{
DateTime preTradeDay = USeManager.Instance.TradeCalendarManager.GetPreTradingDate(marketData.QuoteDay.Value);
if (marketData.QuoteTime.Value > new TimeSpan(20, 45, 0))
{
marketData.UpdateTime = preTradeDay.Add(marketData.QuoteTime.Value);
}
else
{
marketData.UpdateTime = preTradeDay.AddDays(1).Add(marketData.QuoteTime.Value);
}
}
}
}
/// <summary>
/// 读数据线程
/// </summary>
private void DoWork()
{
try
{
while (m_runFlag)
{
while (m_marketDataQueue.Count > 0)
{
USeMarketData marketData = null;
m_marketDataQueue.TryDequeue(out marketData);
Debug.Assert(marketData != null);
FileStorer storer = GetFileStorer(marketData);
try
{
storer.Write(ToMarketDataLog(marketData));
Interlocked.Increment(ref m_sotreCount);
}
catch (Exception ex)
{
Interlocked.Increment(ref m_errorStoreCount);
USeNotifyEventArgs arg = new USeNotifyEventArgs(USeNotifyLevel.Error, "文件保存行情数据失败," + ex.Message);
SafeRaiseNotifyEvent(this, arg);
}
}
Thread.Sleep(1000);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
/// <summary>
/// 计算平仓损益。
/// </summary>
/// <param name="arbitrageOrder"></param>
/// <returns></returns>
private ProfitResult CalculatCloseProfit(USeArbitrageOrder arbitrageOrder)
{
USeOrderDriver orderDriver = USeManager.Instance.OrderDriver;
USeQuoteDriver quoteDriver = USeManager.Instance.QuoteDriver;
Debug.Assert(orderDriver != null);
Debug.Assert(quoteDriver != null);
ArbitrageTaskGroup closeTaskGroup = arbitrageOrder.CloseTaskGroup;
List <USeOrderBook> orderBookList = arbitrageOrder.GetAllOrderBooks();
USeMarketData buyMarketData = USeManager.Instance.QuoteDriver.Query(closeTaskGroup.BuyInstrument);
USeMarketData sellMarketData = USeManager.Instance.QuoteDriver.Query(closeTaskGroup.SellInstrument);
USeInstrumentDetail buyInstrumentDetail = USeManager.Instance.OrderDriver.QueryInstrumentDetail(closeTaskGroup.BuyInstrument);
USeInstrumentDetail sellInstrumentDetail = USeManager.Instance.OrderDriver.QueryInstrumentDetail(closeTaskGroup.SellInstrument);
decimal buyProfit = CalculateProfitByOrderBook(orderBookList, buyInstrumentDetail, buyMarketData);
decimal sellProfit = CalculateProfitByOrderBook(orderBookList, sellInstrumentDetail, sellMarketData);
decimal totalProfit = buyProfit + sellProfit;
ProfitResult result = new ProfitResult()
{
BuyProfit = buyProfit,
SellProfit = sellProfit
};
return(result);
}
public void changeMarketData(USeMarketData market_data)
{
System.Diagnostics.Debug.Assert(market_data != null);
foreach (USeMarketData data in m_marketDataList.Values)
{
if (data.Instrument.InstrumentCode != market_data.Instrument.InstrumentCode)
{
continue;
}
if (market_data.LastPrice > data.HighPrice)
{
market_data.HighPrice = market_data.LastPrice;
}
if (market_data.LastPrice < data.LowPrice)
{
market_data.LowPrice = market_data.LastPrice;
}
market_data.ClosePrice = market_data.LastPrice;
}
lock (m_object)
{
m_marketDataList[market_data.Instrument.InstrumentCode] = market_data;
}
this.FireOnMarketDataChanged(market_data);
}
public USeMarketData ConvertModelData(MarketDataViewModel data_model)
{
USeMarketData market_data = new USeMarketData();
if (data_model == null)
{
return(market_data);
}
market_data.Instrument = data_model.Instrument;
market_data.LastPrice = data_model.LastPrice;
market_data.AskPrice = data_model.AskPrice;
market_data.BidPrice = data_model.BidPrice;
market_data.OpenPrice = data_model.OpenPrice;
market_data.ClosePrice = data_model.ClosePrice;
market_data.HighPrice = data_model.HighPrice;
market_data.LowPrice = data_model.LowPrice;
market_data.PreClosePrice = data_model.PreClosePrice;
market_data.PreSettlementPrice = data_model.PreSettlementPrice;
//随机一个AskSize和BidSize
Random ran = new Random();
int randAskSize = ran.Next(6, 23);
int randBidSize = ran.Next(8, 20);
market_data.AskSize = randAskSize;
market_data.BidSize = randBidSize;
return(market_data);
}
private byte[] CreateMQTTBody(USeMarketData marketData)
{
List <string> filedList = new List <string>();
filedList.Add(marketData.Instrument.InstrumentCode);
filedList.Add(marketData.QuoteDay.HasValue ? marketData.QuoteDay.Value.ToString("yyyy-MM-dd") : "");
filedList.Add(marketData.QuoteTime.HasValue ? marketData.QuoteTime.Value.ToString(@"hh\:mm\:ss") : "");
filedList.Add(marketData.LastPrice.ToString());
filedList.Add(marketData.UpdateTime.ToString("yyyy-MM-dd HH:mm:ss"));
filedList.Add(marketData.AskPrice.ToString());
filedList.Add(marketData.AskSize.ToString());
filedList.Add(marketData.BidPrice.ToString());
filedList.Add(marketData.BidSize.ToString());
filedList.Add(marketData.OpenPrice.ToString());
filedList.Add(marketData.HighPrice.ToString());
filedList.Add(marketData.LowPrice.ToString());
filedList.Add(marketData.OpenInterest.ToString());
filedList.Add(marketData.PreOpenInterest.ToString());
filedList.Add(marketData.SettlementPrice.ToString());
filedList.Add(marketData.PreSettlementPrice.ToString());
filedList.Add(marketData.Volume.ToString());
filedList.Add(marketData.Turnover.ToString());
byte[] byteArray = Encoding.UTF8.GetBytes(string.Join(",", filedList));
return(byteArray);
}
private void cbxSellInstrument_SelectedIndexChanged(object sender, EventArgs e)
{
if (this.cbxSellInstrument.SelectedIndex < 0)
{
//Debug.Assert(false);
return;
}
USeInstrument sellInstrument = GetSellInstrumentFromUI();
if (sellInstrument == null || m_sellInstrument == sellInstrument)
{
return;
}
m_sellInstrument = sellInstrument;
m_sellMarketData = null;
try
{
USeManager.Instance.QuoteDriver.Subscribe(sellInstrument);
USeMarketData marketData = USeManager.Instance.QuoteDriver.QuickQuery(sellInstrument);
UpdateMarketData(marketData);
}
catch (Exception ex)
{
USeFuturesSpiritUtility.ShowWarningMessageBox(this, "订阅行情失败," + ex.Message);
}
SetPriceControlValue();
}
/// <summary>
/// 评估创建套利单需要保证金。
/// </summary>
/// <param name="openArg"></param>
/// <returns></returns>
public decimal EvaluateMargin(ArbitrageOpenArgument openArg)
{
USeOrderDriver orderDriver = USeManager.Instance.OrderDriver;
USeQuoteDriver quoteDriver = USeManager.Instance.QuoteDriver;
USeInstrumentDetail buyInstrumentDetail = orderDriver.QueryInstrumentDetail(openArg.BuyInstrument);
USeInstrumentDetail sellInstrumentDetail = orderDriver.QueryInstrumentDetail(openArg.SellInstrument);
USeMarketData buyMarketData = quoteDriver.Query(openArg.BuyInstrument);
USeMarketData sellMarketData = quoteDriver.Query(openArg.SellInstrument);
USeMargin buyMarginRate = orderDriver.QueryInstrumentMargin(openArg.BuyInstrument);
USeMargin sellMarginRate = orderDriver.QueryInstrumentMargin(openArg.SellInstrument);
decimal buyMargin = (openArg.TotalOrderQty * buyMarginRate.BrokerLongMarginRatioByVolume) +
(buyMarketData.LastPrice * openArg.TotalOrderQty * buyInstrumentDetail.VolumeMultiple * buyMarginRate.BrokerLongMarginRatioByMoney);
decimal sellMargin = (openArg.TotalOrderQty * sellMarginRate.BrokerShortMarginRatioByVolume) +
(sellMarketData.LastPrice * openArg.TotalOrderQty * sellInstrumentDetail.VolumeMultiple * sellMarginRate.BrokerShortMarginRatioByMoney);
if (openArg.BuyInstrument.Market == USeMarket.SHFE && openArg.SellInstrument.Market == USeMarket.SHFE)
{
return(Math.Max(buyMargin, sellMargin));
}
else
{
return(buyMargin + sellMargin);
}
}
/// <summary>
/// 行情更新。
/// </summary>
/// <remarks>行情数据。</remarks>
/// <returns></returns>
public override void UpdateMarketData(USeMarketData marketData)
{
Debug.Assert(m_kLine != null);
Debug.Assert(m_componentDic.ContainsKey(marketData.Instrument.InstrumentCode));
if (m_componentDic.ContainsKey(marketData.Instrument.InstrumentCode))
{
m_componentDic[marketData.Instrument.InstrumentCode] = marketData;
}
else
{
return;
}
if (m_allowCalc == false)
{
CheckIsAllowCalc();
}
if (m_allowCalc == false)
{
return;
}
CalcIndexKLine();
if (DateTime.Now >= m_nextPublishTime || m_kLine.SettlementPrice > 0m)
{
m_publisher.PublishKLine(m_kLine.Clone());
m_nextPublishTime = DateTime.Now.AddTicks(m_publishInterval.Ticks);
}
}
public static List <USeMarketData> GetMarketDataList()
{
List <USeMarketData> list = new List <USeMarketData>();
List <USeInstrument> instrumentList = GetInstrumentList();
foreach (USeInstrument instrument in instrumentList)
{
USeMarketData market = new USeMarketData(instrument);
market.AskPrice = 45400;
market.AskSize = 1;
market.BidPrice = 45420;
market.BidSize = 3;
market.OpenPrice = 45060;
market.HighPrice = 45450;
market.LowPrice = 44800;
market.LastPrice = 45400;
market.ClosePrice = 0;
market.PreClosePrice = 45300;
market.UpperLimitPrice = 47700;
market.LowerLimitPrice = 42360;
market.PreSettlementPrice = 45300;
market.SettlementPrice = 0;
market.OpenInterest = 1000;
market.Volume = 12312;
market.Turnover = 123423334;
market.UpdateTime = DateTime.Now;
list.Add(market);
}
return(list);
}
private List <USeMarketData> ProcessRegionDataToMaretData(string readBody)
{
Debug.Assert(readBody != null && readBody != "");
List <USeMarketData> marketDataList = new List <USeMarketData>();
string[] marketDataArray = readBody.Split('|');
foreach (string str in marketDataArray)
{
string[] strMarketData = str.Split(',');
USeMarketData marketData = new USeMarketData();
marketData.Instrument = new USeInstrument(strMarketData[0], "", USeMarket.LME);
marketData.QuoteDay = DateTime.Now.Date;
TimeSpan quoteTime;
TimeSpan.TryParse(strMarketData[1], out quoteTime);
marketData.UpdateTime = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, quoteTime.Hours, quoteTime.Minutes, quoteTime.Milliseconds);
marketData.QuoteTime = quoteTime;
marketData.OpenPrice = Convert.ToDecimal(strMarketData[2]);
marketData.HighPrice = Convert.ToDecimal(strMarketData[3]);
marketData.LowPrice = Convert.ToDecimal(strMarketData[4]);
marketData.ClosePrice = Convert.ToDecimal(strMarketData[5]);
marketData.Volume = Convert.ToInt32(strMarketData[6]);
marketData.BidPrice = Convert.ToDecimal(strMarketData[7]);
marketData.AskPrice = Convert.ToDecimal(strMarketData[8]);
marketDataList.Add(marketData);
//m_instrumentDic[strMarketData[0]] = marketData;
}
return(marketDataList);
}
/// <summary>
/// 查询产品行情
/// </summary>
/// <param name="product">被查询产品</param>
/// <returns>被查询产品行情信息</returns>
public override USeMarketData QuickQuery(USeInstrument product)
{
try
{
USeMarketData marketData = null;
lock (m_object)
{
m_marketDataDic.TryGetValue(product.InstrumentCode, out marketData);
}
if (marketData != null)
{
return(marketData.Clone());
}
else
{
USeMarketData nullMarketData = new USeMarketData();
nullMarketData.Instrument = product.Clone();
return(nullMarketData);
}
}
catch (Exception ex)
{
m_logger.WriteError(string.Format("{0} QuickQuery failed,Error: {1}.", ToString(), ex.Message));
USeMarketData nullMarketData = new USeMarketData();
nullMarketData.Instrument = product.Clone();
return(nullMarketData);
}
}
private ArbitrageOrderSettlement CalculateSettlementResult()
{
USeArbitrageOrder arbitrageOrder = null;
lock (m_syncObj)
{
arbitrageOrder = m_arbitrageOrder.Clone();
}
List <USeOrderBook> orderBookList = arbitrageOrder.GetAllOrderBooks();
USeInstrument buyInstrument = arbitrageOrder.OpenArgument.BuyInstrument;
USeInstrument sellInstrument = arbitrageOrder.OpenArgument.SellInstrument;
USeMarketData buyMarketData = USeManager.Instance.QuoteDriver.Query(buyInstrument);
USeMarketData sellMarketData = USeManager.Instance.QuoteDriver.Query(sellInstrument);
USeInstrumentDetail buyInstrumentDetail = USeManager.Instance.OrderDriver.QueryInstrumentDetail(buyInstrument);
USeInstrumentDetail sellInstrumentDetail = USeManager.Instance.OrderDriver.QueryInstrumentDetail(sellInstrument);
decimal buyProfit = CalculateProfit(orderBookList, buyInstrumentDetail, buyMarketData);
decimal sellProfit = CalculateProfit(orderBookList, sellInstrumentDetail, sellMarketData);
decimal totalProfit = buyProfit + sellProfit;
ArbitrageOrderSettlement settlemt = new ArbitrageOrderSettlement()
{
BuyInstrumentProfit = buyProfit,
SellInstrumentProfit = sellProfit,
Profit = totalProfit
};
return(settlemt);
}
/// <summary>
/// 行情变更通知
/// </summary>
/// <param name="reportField">回报信息数据结构。</param>
public void OnRtnDepthMarketData(ref DepthMarketDataField?reportField)
{
try
{
if (reportField.HasValue == false)
{
return;
}
string instrumentCode = reportField.Value.InstrumentID;
USeMarketData marketData = null;
lock (m_object)
{
marketData = DepthMarketDataFieldToUSeFuture(reportField.Value);
m_marketDataDic[instrumentCode] = marketData;
}
USeResetEvent resetEvent = GetResetEvent(instrumentCode);
if (resetEvent != null)
{
resetEvent.Set(false);
}
FireOnMarketDataChanged(marketData);
}
catch (Exception ex)
{
m_logger.WriteError(string.Format("{0}.OnRtnDepthMarketData failed ,Error:{1}.",
ToString(), ex.Message));
Debug.Assert(false, ex.Message);
}
}
public void Update(USeMarketData data)
{
if (data.Instrument != this.Instrument)
{
Debug.Assert(false);
return;
}
this.AskPrice = data.AskPrice;
this.AskSize = data.AskSize;
this.BidPrice = data.BidPrice;
this.BidSize = data.BidSize;
this.OpenPrice = data.OpenPrice;
this.HighPrice = data.HighPrice;
this.LowPrice = data.LowPrice;
this.LastPrice = data.LastPrice;
this.ClosePrice = data.ClosePrice;
this.PreClosePrice = data.PreClosePrice;
this.UpperLimitPrice = data.UpperLimitPrice;
this.LowerLimitPrice = data.LowerLimitPrice;
this.PreSettlementPrice = data.PreSettlementPrice;
this.SettlementPrice = data.SettlementPrice;
this.OpenInterest = data.OpenInterest;
this.Volume = data.Volume;
this.Turnover = data.Turnover;
this.UpdateTime = data.UpdateTime;
}
private void InternalSendTotMQTT(USeMarketData marketData)
{
try
{
CreateMQChannel();
byte[] body = CreateMQTTBody(marketData);
if (marketData.Instrument.Market == USeMarket.LME)
{
m_mqttClient.Publish(m_topicLME, body, MqttMsgBase.QOS_LEVEL_AT_MOST_ONCE, false);
Interlocked.Increment(ref m_sotreCount);
}
else
{
m_mqttClient.Publish(m_topic, body, MqttMsgBase.QOS_LEVEL_AT_MOST_ONCE, false);
Interlocked.Increment(ref m_sotreCount);
}
Debug.WriteLine(string.Format("时间:{0} 合约:{1} 最新价:{2} body:{3}", marketData.QuoteTime, marketData.Instrument.InstrumentCode, marketData.ClosePrice, body));
}
catch (Exception ex)
{
Interlocked.Increment(ref m_errorStoreCount);
string text = string.Format("{0}发送MQTT实时行情数据失败,{1}", this, ex.Message);
m_eventLogger.WriteError(text);
USeNotifyEventArgs notify = new USeNotifyEventArgs(USeNotifyLevel.Warning, text);
SafeRaiseNotifyEvent(this, notify);
}
}
/// <summary>
/// 创建KLine。
/// </summary>
/// <param name="marketData"></param>
/// <returns></returns>
private USeKLine CreateFirstKLine(USeMarketData marketData)
{
USeKLine kline = new USeKLine()
{
InstrumentCode = m_instrument.InstrumentCode,
Market = m_instrument.Market,
Cycle = USeCycleType.Day,
DateTime = GetCycleTime(marketData.UpdateTime),
Open = marketData.OpenPrice,
High = marketData.HighPrice,
Low = marketData.LowPrice,
Close = marketData.LastPrice,
Volumn = marketData.Volume,
Turnover = marketData.Turnover,
OpenInterest = marketData.OpenInterest,
SettlementPrice = marketData.SettlementPrice,
PreSettlementPrice = marketData.PreSettlementPrice,
AskVolumn = (int)(marketData.Volume / 2),
BidVolumn = marketData.Volume - (int)(marketData.Volume / 2),
SendimentaryMoney = 0m,
FlowFund = 0m,
SpeculateRadio = 0m
};
return(kline);
}
/// <summary>
/// 更改产品。
/// </summary>
/// <param name="product">产品名称。</param>
public void ChangeProduct(string product)
{
if (string.IsNullOrEmpty(product) || m_productId == product)
{
return;
}
this.cbxBuyInstrument.Items.Clear();
this.cbxSellInstrument.Items.Clear();
m_buyInstrument = null;
m_sellInstrument = null;
m_buyMarketData = null;
m_sellMarketData = null;
m_productId = product;
SetNoticeInfo();
try
{
List <USeInstrumentDetail> instrumentDetailList = USeManager.Instance.OrderDriver.QueryInstrumentDetail(product);
if (instrumentDetailList == null)
{
return;
}
List <USeInstrument> instrumentList = (from e in instrumentDetailList
orderby e.Instrument.InstrumentCode
select e.Instrument).ToList();
USeInstrument emptyInstrument = new USeInstrument("", "选择合约", USeMarket.Unknown);
this.cbxBuyInstrument.Items.Add(emptyInstrument);
this.cbxSellInstrument.Items.Add(emptyInstrument);
foreach (USeInstrument instrument in instrumentList)
{
this.cbxBuyInstrument.Items.Add(instrument);
this.cbxSellInstrument.Items.Add(instrument);
}
this.cbxBuyInstrument.SelectedIndex = 0;
this.cbxSellInstrument.SelectedIndex = 0;
#if DEBUG
if (this.cbxBuyInstrument.Items.Count > 2)
{
this.cbxBuyInstrument.SelectedIndex = 1;
}
if (this.cbxSellInstrument.Items.Count > 3)
{
this.cbxSellInstrument.SelectedIndex = 2;
}
#endif
}
catch (Exception ex)
{
Debug.Assert(false, ex.Message);
}
}
public USeMarketData GetNextMarketData()
{
USeMarketData marketData = null;
if (m_marketDataQueue.TryDequeue(out marketData))
{
Interlocked.Increment(ref m_readCount);
}
return(marketData);
}
/// <summary>
/// 读数据线程
/// </summary>
private void DoWork()
{
lock (m_locker)
{
try
{
var connArgs = new MqttConnectionArgs()
{
ClientId = m_clientId,
Hostname = m_mqttServerAddress,
Port = m_mqttPort,
Keepalive = new TimeSpan(1, 0, 0)
};
using (m_mqttClient = new MqttConnection(connArgs))
{
m_mqttClient.Connect();
while (m_runFlag)
{
USeMarketData marketData = null;
m_marketDataQueue.TryDequeue(out marketData);
if (marketData == null)
{
Thread.Sleep(1000);
continue;
}
Debug.WriteLine(string.Format("当前MQTT链接:{0}", connArgs.ClientId));
//[hanyu]暂时只推送上期的品种行情
if (marketData.Instrument.Market == USeMarket.SHFE || marketData.Instrument.Market == USeMarket.LME)
{
InternalSendTotMQTT(marketData);
}
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
string text = string.Format("** {0}链接MQTT失败,{1}", this.StoreageName, ex.Message);
m_eventLogger.WriteError(text);
USeNotifyEventArgs notify = new USeNotifyEventArgs(USeNotifyLevel.Warning, text);
SafeRaiseNotifyEvent(this, notify);
}
finally
{
m_mqttClient.Disconnect();
DoWork();
}
}
}
/// <summary>
/// 计算持仓损益。
/// </summary>
/// <param name="posItem"></param>
/// <returns></returns>
private decimal CalcHoldingProfit(PositionDetailCalcItem posItem)
{
int volumeMultiple = posItem.InstrumentDetail.VolumeMultiple;
USeMarketData marketData = posItem.MarketData;
decimal holdProfit = 0m; // 持仓盈亏
if (posItem.RemainQty > 0) // 有持仓
{
if (posItem.PositionType == USePositionType.Today && posItem.Direction == USeDirection.Long)
{
// 当日多头持仓盈亏 = (最新价 - 开仓价) × 多头合约持仓量 × 合约乘数
// 当日多头持仓保证金 = 开仓价 × 合约乘数 × 持仓手数 × 多头保证金率
if (marketData.LastPrice > 0)
{
holdProfit += (marketData.LastPrice - posItem.OpenPrice) * posItem.RemainQty * volumeMultiple;
}
}
else if (posItem.PositionType == USePositionType.Today && posItem.Direction == USeDirection.Short)
{
// 当日空头持仓盈亏 = (开仓价 - 最新价) × 空头合约持仓量 × 合约乘数
// 当日持仓保证金 = 开仓价 × 合约乘数 × 持仓手数 × 空头保证金率
if (marketData.LastPrice > 0)
{
holdProfit += (posItem.OpenPrice - marketData.LastPrice) * posItem.RemainQty * volumeMultiple;
}
}
else if (posItem.PositionType == USePositionType.Yestorday && posItem.Direction == USeDirection.Long)
{
// 历史多头持仓盈亏 = (最新价 - 上日结算价) × 多头合约持仓量× 合约乘数
// 历史多头持仓保证金 = 上日结算价 × 合约乘数 × 持仓手数 × 交易所多头保证金率
if (marketData.LastPrice > 0)
{
holdProfit += (marketData.LastPrice - marketData.PreSettlementPrice) * posItem.RemainQty * volumeMultiple;
}
}
else if (posItem.PositionType == USePositionType.Yestorday && posItem.Direction == USeDirection.Short)
{
// 历史空头持仓盈亏 = (上日结算价-最新价)× 空头合约持仓量 × 合约乘数
// 历史空头持仓保证金 = 上日结算价 × 合约乘数 × 持仓手数 × 交易所空头保证金率
if (marketData.LastPrice > 0)
{
holdProfit += (marketData.PreSettlementPrice - marketData.LastPrice) * posItem.RemainQty * volumeMultiple;
}
}
else
{
Debug.Assert(false);
}
}
return(holdProfit);
}
private void PublichMarketDataLess(USeMarketData data, int tick)
{
if (data == null || m_orderDriver == null)
{
return;
}
decimal priceTick = m_orderDriver.QueryInstrumentDetail(data.Instrument).PriceTick;
data.LastPrice = data.LastPrice - priceTick * tick;
data.AskPrice = data.AskPrice - priceTick * tick;
data.BidPrice = data.BidPrice - priceTick * tick;
m_quoterDriver.changeMarketData(data);
}
/// <summary>
/// 获取优先合约下单价格。
/// </summary>
/// <param name="instrument">优先合约。</param>
/// <param name="orderPriceType">下单价格类型。</param>
/// <param name="orderSide">买卖方向。</param>
/// <returns></returns>
private decimal GetFirstInstrumentOrderPrice(USeInstrument instrument, ArbitrageOrderPriceType orderPriceType, USeOrderSide orderSide)
{
USeMarketData marketData = m_quoteDriver.Query(instrument);
Debug.Assert(marketData != null);
switch (orderPriceType)
{
case ArbitrageOrderPriceType.LastPrice: return(marketData.LastPrice);
case ArbitrageOrderPriceType.OpponentPrice:
{
if (orderSide == USeOrderSide.Buy)
{
return(marketData.AskPrice);
}
else if (orderSide == USeOrderSide.Sell)
{
return(marketData.BidPrice);
}
else
{
Debug.Assert(false);
return(0m);
}
}
case ArbitrageOrderPriceType.QueuePrice:
{
if (orderSide == USeOrderSide.Buy)
{
return(marketData.BidPrice);
}
else if (orderSide == USeOrderSide.Sell)
{
return(marketData.AskPrice);
}
else
{
Debug.Assert(false);
return(0m);
}
}
default:
Debug.Assert(false);
return(0m);
}
}
/// <summary>
/// 安全地发布指定的通知事件。
/// </summary>
/// <param name="sender">通知事件发送者对象。</param>
/// <param name="e">通知事件参数对象。</param>
protected void SafeMarketDataEvent(USeMarketData marketData)
{
OutLMEMarketDataReceiveHandel handler = this.OutLMEMarketDataReceiveEvent;
if (handler != null)
{
try
{
handler(marketData);
}
catch (Exception ex)
{
Debug.Assert(false, ex.Message);
}
}
}
private FileStorer GetFileStorer(USeMarketData marketData)
{
string key = string.Format("{0}", marketData.Instrument.InstrumentCode);
FileStorer storer = null;
if (m_fileStorerDic.TryGetValue(key, out storer) == false)
{
//路径待处理
string fileName = Path.Combine(m_marketDataFolderPath, GetTradeDayPath(), key + ".csv");
storer = new FileStorer(fileName);
m_fileStorerDic.Add(key, storer);
}
return(storer);
}
private void SafeOuterMarketDataEvent(USeMarketData marketData)
{
OutLMEMarketDataReceiveHandel handler = this.OutLMEMarketDataReceiveEvent;
if (handler != null)
{
try
{
handler(marketData);
}
catch (Exception ex)
{
string text = String.Format("{0} raise Notify event failed, Error: {1}", this, ex.Message);
m_eventLogger.WriteWarning(text);
}
}
}
/// <summary>
/// 查询产品行情
/// </summary>
/// <param name="product">被查询产品</param>
/// <returns>被查询产品行情信息</returns>
public override USeMarketData Query(USeInstrument product)
{
USeMarketData marketData = null;
if (m_marketDataList.TryGetValue(product.InstrumentCode, out marketData))
{
return(marketData.Clone());
}
else
{
return(new USeMarketData()
{
Instrument = product,
LastPrice = 0
});
}
}
/// <summary>
/// 更新K线。
/// </summary>
/// <param name="kLine"></param>
/// <param name="marketData"></param>
private void UpdateKLine(USeKLine kLine, USeMarketData marketData)
{
if (marketData.Volume < kLine.Volumn)
{
return;
}
int volumeDiff = marketData.Volume - kLine.Volumn;
USeActiveSide activeSide = GetActiveSide(marketData);
int askVolume = 0;
int bidVolume = 0;
if (activeSide == USeActiveSide.Ask)
{
askVolume = volumeDiff;
}
else if (activeSide == USeActiveSide.Bid)
{
bidVolume = volumeDiff;
}
else
{
Debug.Assert(activeSide == USeActiveSide.None);
askVolume = (int)(volumeDiff / 2);
bidVolume = volumeDiff - askVolume;
}
//更新
if (kLine.High < marketData.LastPrice)
{
kLine.High = marketData.LastPrice;
}
if (kLine.Low > marketData.LastPrice)
{
kLine.Low = marketData.LastPrice;
}
kLine.Close = marketData.LastPrice;
kLine.Volumn = marketData.Volume;
kLine.Turnover = marketData.Turnover;
kLine.OpenInterest = marketData.OpenInterest;
kLine.AskVolumn += askVolume;
kLine.BidVolumn += bidVolume;
kLine.AvgPrice = marketData.AvgPrice;
}
/// <summary>
/// 获取指定价格。
/// </summary>
/// <param name="marketData">行情。</param>
/// <param name="priceType">价格类型。</param>
/// <returns></returns>
private decimal GetMarketPrice(USeMarketData marketData, ArbitrageOrderPriceType priceType)
{
if (marketData == null)
{
return(0m);
}
switch (priceType)
{
case ArbitrageOrderPriceType.LastPrice: return(marketData.LastPrice);
case ArbitrageOrderPriceType.OpponentPrice: return(marketData.AskPrice);
case ArbitrageOrderPriceType.QueuePrice: return(marketData.BidPrice);
default: Debug.Assert(false); return(0m);
}
}
