void SetInstrumentRate(CZQThostFtdcInstrumentCommissionRateField instrumentCommissionRate)
{
if (string.IsNullOrEmpty(instrumentCommissionRate.InstrumentID))
{
return;
}
//保存手续费信息
CTPStockInstrument ctpInstrument = this.GetInstrument(instrumentCommissionRate.InstrumentID);
if (ctpInstrument != null)
{
//单合约手续费
ctpInstrument.SetNativeValue(instrumentCommissionRate);
}
else
{
//该品种手续费
foreach (CTPStockInstrument item in this.instrumentDictionary.Values)
{
if (string.Compare(instrumentCommissionRate.InstrumentID, item.ProductID, true) == 0)
{
item.SetNativeValue(instrumentCommissionRate);
}
}
}
}
public CZQThostFtdcInputOrderField InsertOrder(string symbolCode, CTPStockDirectionType direct, double price, int volume)
{
CTPStockInstrument inst = GetInstrument(symbolCode);
if (inst == null)
{
throw new Exception("unknow symbol:" + symbolCode);
}
return(InsertOrder(inst.ExchangeID, symbolCode, direct, price, volume));
}
protected override void ProcessBusinessResponse(CTPStockResponseType responseType, IntPtr pData, CTPResponseInfo rspInfo, int requestID)
{
Trace.WriteLine(string.Format("{0} [{1}]:{2},{3},{4}", this.wallTimeStopwatch.ElapsedMilliseconds, this.UserKey, "ProcessBusinessResponse", responseType, requestID));
switch (responseType)
{
#region 当客户端与交易后台建立起通信连接时（还未登录前），该方法被调用。
case CTPStockResponseType.FrontConnectedResponse:
{
this.isConnect = true;
this.UserLogin();
//调用事件
OnEventHandler(CTPStockResponseType.FrontConnectedResponse, new CTPEventArgs());
break;
}
#endregion
#region 通信中断
case CTPStockResponseType.FrontDisconnectedResponse:
/// 当客户端与交易后台通信连接断开时，该方法被调用。当发生这个情况后，API会自动重新连接，客户端可不做处理。
///@param nReason 错误原因
/// 0x1001 网络读失败
/// 0x1002 网络写失败
/// 0x2001 接收心跳超时
/// 0x2002 发送心跳失败
/// 0x2003 收到错误报文
{
this.isConnect = false;
//调用事件
OnEventHandler(CTPStockResponseType.FrontDisconnectedResponse, new CTPEventArgs());
}
break;
#endregion
#region 心跳超时警告
case CTPStockResponseType.HeartBeatWarningResponse:
{
/// <summary>
///心跳超时警告。当长时间未收到报文时，该方法被调用。
///@param nTimeLapse 距离上次接收报文的时间
/// </summary>
/// <param name="nTimeLapse"></param>
Trace.WriteLine("CTPTrader:OnHeartBeatWarning!! " + pData.ToString());
break;
}
#endregion
#region 客户端认证响应
case CTPStockResponseType.AuthenticateResponse:
{
CTPEventArgs <CZQThostFtdcRspAuthenticateField> args = CreateEventArgs <CZQThostFtdcRspAuthenticateField>(requestID, rspInfo);
this.OnEventHandler(CTPStockResponseType.AuthenticateResponse, args);
break;
}
#endregion
#region 用户登录
case CTPStockResponseType.UserLoginResponse:
{
CTPEventArgs <CZQThostFtdcRspUserLoginField> args = CreateEventArgs <CZQThostFtdcRspUserLoginField>(requestID, rspInfo);
CZQThostFtdcRspUserLoginField userLogin = args.Value;
if (rspInfo.ErrorID == 0)
{
this.BrokerID = userLogin.BrokerID;
this.FrontID = userLogin.FrontID;
this.SessionID = userLogin.SessionID;
this.isLogin = true;
this.loginTime = userLogin.LoginTime;
//最大报单引用
int orderRef = 0;
if (int.TryParse(userLogin.MaxOrderRef, out orderRef) == false)
{
orderRef = 0;
}
this.currentOrderRef = orderRef;
//this.currentOrderRef++;
DateTime.TryParseExact(userLogin.TradingDay, "yyyyMMdd", null, System.Globalization.DateTimeStyles.AllowWhiteSpaces, out this.tradingDate);
TimeSpan.TryParse(userLogin.DCETime, out this.loginTimeDCE);
TimeSpan.TryParse(userLogin.CZCETime, out this.loginTimeCZCE);
TimeSpan.TryParse(userLogin.SHFETime, out this.loginTimeSHFE);
//TimeSpan.TryParse(userLogin.DCETime, out this.currentTimeDCE);
this.wallTimeStopwatch.Start();
this.timer.Change(0, 1000);
}
this.OnEventHandler(CTPStockResponseType.UserLoginResponse, args);
}
break;
#endregion
#region 登出请求响应
case CTPStockResponseType.UserLogoutResponse:
{
this.isLogin = false;
//调用事件
OnEventHandler(CTPStockResponseType.UserLogoutResponse, new CTPEventArgs());
break;
}
#endregion
#region 用户口令更新请求响应
case CTPStockResponseType.UserPasswordUpdateResponse:
/// <summary>
/// 用户口令更新请求响应
/// </summary>
{
CTPEventArgs <CZQThostFtdcUserPasswordUpdateField> args = CreateEventArgs <CZQThostFtdcUserPasswordUpdateField>(requestID, rspInfo);
this.OnEventHandler(CTPStockResponseType.UserPasswordUpdateResponse, args);
break;
}
#endregion
#region 报单录入请求响应
case CTPStockResponseType.OrderInsertResponse:
{
CTPEventArgs <CZQThostFtdcInputOrderField> args = CreateEventArgs <CZQThostFtdcInputOrderField>(requestID, rspInfo);
//调用事件
OnEventHandler(CTPStockResponseType.OrderInsertResponse, args);
break;
}
#endregion
#region 改单响应
case CTPStockResponseType.OrderActionResponse:
{
CTPEventArgs <CZQThostFtdcInputOrderActionField> args = CreateEventArgs <CZQThostFtdcInputOrderActionField>(requestID, rspInfo);
//调用事件
OnEventHandler(CTPStockResponseType.OrderActionResponse, args);
break;
}
#endregion
#region 查询最大报单数量响应
case CTPStockResponseType.QueryMaxOrderVolumeResponse:
{
CTPEventArgs <CZQThostFtdcQueryMaxOrderVolumeField> args = CreateEventArgs <CZQThostFtdcQueryMaxOrderVolumeField>(requestID, rspInfo);
this.OnEventHandler(CTPStockResponseType.QueryMaxOrderVolumeResponse, args);
break;
}
#endregion
#region 查询报单响应
case CTPStockResponseType.QueryOrderResponse:
{
CTPEventArgs <List <CZQThostFtdcOrderField> > args = CreateListEventArgs <CZQThostFtdcOrderField>(requestID, rspInfo);
lock (this.OrderList)
{
this.OrderList.Clear();
this.OrderList.AddRange(args.Value);
}
//调用事件
OnEventHandler(CTPStockResponseType.QueryOrderResponse, args);
break;
}
#endregion
#region 查询成交单响应
case CTPStockResponseType.QueryTradeResponse:
{
CTPEventArgs <List <CZQThostFtdcTradeField> > args = CreateListEventArgs <CZQThostFtdcTradeField>(requestID, rspInfo);
this.TradeList = args.Value;
//调用事件
OnEventHandler(CTPStockResponseType.QueryTradeResponse, args);
break;
}
#endregion
#region 查询投资者持仓响应
case CTPStockResponseType.QueryInvestorPositionResponse:
{
CTPEventArgs <List <CZQThostFtdcInvestorPositionField> > args = CreateListEventArgs <CZQThostFtdcInvestorPositionField>(requestID, rspInfo);
this.PositionList = args.Value;
//调用事件
OnEventHandler(CTPStockResponseType.QueryInvestorPositionResponse, args);
break;
}
#endregion
#region 查询资金账户响应
case CTPStockResponseType.QueryTradingAccountResponse:
{
/// 查询资金账户响应
CTPEventArgs <CZQThostFtdcTradingAccountField> args = CreateEventArgs <CZQThostFtdcTradingAccountField>(requestID, rspInfo);
this.tradingAccount = args.Value;
this.OnEventHandler(CTPStockResponseType.QueryTradingAccountResponse, args);
break;
}
#endregion
#region 查询投资者响应
case CTPStockResponseType.QueryInvestorResponse:
{
CTPEventArgs <CZQThostFtdcInvestorField> args = CreateEventArgs <CZQThostFtdcInvestorField>(requestID, rspInfo);
this.investor = args.Value;
this.OnEventHandler(CTPStockResponseType.QueryInvestorResponse, args);
break;
}
#endregion
#region 请求查询交易编码响应
case CTPStockResponseType.QueryTradingCodeResponse:
{
CTPEventArgs <CZQThostFtdcTradingCodeField> args = CreateEventArgs <CZQThostFtdcTradingCodeField>(requestID, rspInfo);
this.OnEventHandler(CTPStockResponseType.QueryTradingCodeResponse, args);
break;
}
#endregion
#region 查询手续费响应
case CTPStockResponseType.QueryInstrumentCommissionRateResponse:
{
CTPEventArgs <CZQThostFtdcInstrumentCommissionRateField> args = CreateEventArgs <CZQThostFtdcInstrumentCommissionRateField>(requestID, rspInfo);
this.SetInstrumentRate(args.Value);
//调用事件
OnEventHandler(CTPStockResponseType.QueryInstrumentCommissionRateResponse, args);
break;
}
#endregion
#region 查询交易所响应
case CTPStockResponseType.QueryExchangeResponse:
{
CTPEventArgs <CZQThostFtdcExchangeField> args = CreateEventArgs <CZQThostFtdcExchangeField>(requestID, rspInfo);
//保存市场信息
//CTPExchange ctpExchange = new CTPExchange();
//ctpExchange.SetNativeValue(args.Value);
//this.Exchanges.Add(args.Value.ExchangeID, ctpExchange);
//调用事件
OnEventHandler(CTPStockResponseType.QueryExchangeResponse, args);
break;
}
#endregion
#region 查询合约响应
case CTPStockResponseType.QueryInstrumentResponse:
{
CTPEventArgs <List <CZQThostFtdcInstrumentField> > values = CreateListEventArgs <CZQThostFtdcInstrumentField>(requestID, rspInfo);
foreach (var instrument in values.Value)
{
if (instrument.ProductClass == CTPStockProductClassType.EFP ||
instrument.ProductClass == CTPStockProductClassType.Futures ||
instrument.ProductClass == CTPStockProductClassType.Options)
{
continue;
}
CTPStockInstrument ctpInstrument = new CTPStockInstrument();
ctpInstrument.SetNativeValue(instrument);
//加入到市场列表
//if (this.Exchanges.ContainsKey(ctpInstrument.ExchangeID))
//{
// this.Exchanges[instrument.ExchangeID].Instruments.Add(ctpInstrument);
//}
//if (this.SymbolProducts.ContainsKey(ctpInstrument.ProductID.ToUpper()) == false)
//{
// this.SymbolProducts.Add(ctpInstrument.ProductID.ToUpper(), new CTPSymbolProduct(instrument));
//}
//加入到合约表
if (this.InstrumentDictionary.ContainsKey(ctpInstrument.ID) == false)
{
this.InstrumentDictionary.Add(ctpInstrument.ID, ctpInstrument);
}
}
//创建新的事件参数
List <CTPStockInstrument> list = new List <CTPStockInstrument>(this.InstrumentDictionary.Values);
CTPEventArgs <List <CTPStockInstrument> > args = new CTPEventArgs <List <CTPStockInstrument> >(list);
//调用事件
//OnEventHandler(CTPStockResponseType.QueryInstrumentResponse, args);
OnEventHandler(CTPStockResponseType.QueryInstrumentResponse, values);
break;
}
#endregion
#region 查询行情响应
case CTPStockResponseType.QueryDepthMarketDataResponse:
{
CTPEventArgs <CZQThostFtdcDepthMarketDataField> args = CreateEventArgs <CZQThostFtdcDepthMarketDataField>(requestID, rspInfo);
//调用事件
OnEventHandler(CTPStockResponseType.QueryDepthMarketDataResponse, args);
break;
}
#endregion
#region 查询投资者持仓明细响应
case CTPStockResponseType.QueryInvestorPositionDetailResponse:
{
CTPEventArgs <List <CZQThostFtdcInvestorPositionDetailField> > args = CreateListEventArgs <CZQThostFtdcInvestorPositionDetailField>(requestID, rspInfo);
this.PositionDetailList = args.Value;
//调用事件
OnEventHandler(CTPStockResponseType.QueryInvestorPositionDetailResponse, args);
break;
}
#endregion
#region 错误回报
case CTPStockResponseType.ErrorResponse:
{
this.OnEventHandler(CTPStockResponseType.ErrorResponse, new CTPEventArgs(rspInfo));
break;
}
#endregion
#region 报单回报
case CTPStockResponseType.ReturnOrderResponse:
{
CTPEventArgs <CZQThostFtdcOrderField> args = CreateEventArgs <CZQThostFtdcOrderField>(pData, rspInfo);
lock (this.orderList)
{
CTPStockOrderConvert.AppendOrReplaceOrder(this.orderList, args.Value);
}
if (this.filterRestart == true && this.isInitialized == false)
{
}
else
{
//调用事件
OnEventHandler(CTPStockResponseType.ReturnOrderResponse, args);
}
break;
}
#endregion
#region 成交回报
case CTPStockResponseType.ReturnTradeResponse:
{
CTPEventArgs <CZQThostFtdcTradeField> args = CreateEventArgs <CZQThostFtdcTradeField>(pData, rspInfo);
//插入到列表中
CTPStockOrderConvert.AppendOrReplaceOrder(this.tradeList, args.Value);
if (this.filterRestart == true && this.isInitialized == false)
{
}
else
{
//调用事件
OnEventHandler(CTPStockResponseType.ReturnTradeResponse, args);
}
break;
}
#endregion
#region 错单回报
case CTPStockResponseType.ErrorReturnOrderInsertResponse:
{
if (this.filterRestart == true && this.isInitialized == false)
{
}
else
{
CTPEventArgs <CZQThostFtdcInputOrderField> args = CreateEventArgs <CZQThostFtdcInputOrderField>(pData, rspInfo);
//调用事件
OnEventHandler(CTPStockResponseType.ErrorReturnOrderInsertResponse, args);
}
break;
}
#endregion
#region 报单操作错误回报
case CTPStockResponseType.ErrorReturnOrderActionResponse:
{
if (this.filterRestart == true && this.isInitialized == false)
{
}
else
{
CTPEventArgs <CZQThostFtdcOrderActionField> args = CreateEventArgs <CZQThostFtdcOrderActionField>(pData, rspInfo);
//调用事件
OnEventHandler(CTPStockResponseType.ErrorReturnOrderActionResponse, args);
}
break;
}
#endregion
#region 合约交易状态通知
case CTPStockResponseType.ReturnInstrumentStatusResponse:
{
CTPEventArgs <CZQThostFtdcInstrumentStatusField> args = CreateEventArgs <CZQThostFtdcInstrumentStatusField>(pData, rspInfo);
CZQThostFtdcInstrumentStatusField instrumentStatus = args.Value;
Trace.WriteLine(string.Format("{0}:{1}", instrumentStatus.ExchangeID, instrumentStatus.InstrumentStatus));
//交易所状态
if (this.exchangeStatus.ContainsKey(instrumentStatus.ExchangeID) == false)
{
this.exchangeStatus.Add(instrumentStatus.ExchangeID, instrumentStatus.InstrumentStatus);
}
//更新交易所状态
this.exchangeStatus[instrumentStatus.ExchangeID] = instrumentStatus.InstrumentStatus;
this.tradingStatus = instrumentStatus.InstrumentStatus;
//调用事件
OnEventHandler(CTPStockResponseType.ReturnInstrumentStatusResponse, args);
break;
}
#endregion
default:
break;
}
}