Пример #1
0
        private void ProcessIQFeedMessage(IQFeedWrapper feed, Message message)
        {
            switch (message.Type)
            {
            case ExtendedMessageTypes.System:
            {
                var systemMsg = (IQFeedSystemMessage)message;

                switch (systemMsg.Value)
                {
                case "SERVER DISCONNECTED":
                case "SERVER RECONNECT FAILED":
                    SendOutMessage(systemMsg);
                    break;

                default:
                {
                    if (feed == _lookupFeed)
                    {
                        _currSystemType = ExtendedMessageTypes.ListedMarket;
                        _lookupFeed.RequestListedMarkets();
                    }

                    break;
                }
                }

                break;
            }

            case ExtendedMessageTypes.HistoryExtraDayCandle:

                // расширенное сообщение лучше передавать внешнему коду, чтобы ему хоть как-то получить информацию
                //case ExtendedMessageTypes.Data:

                break;

            case ExtendedMessageTypes.ListedMarket:
            {
                var lmMsg = (IQFeedListedMarketMessage)message;
                _markets[lmMsg.Id] = lmMsg.Code;
                break;
            }

            case ExtendedMessageTypes.SecurityType:
            {
                var stMsg = (IQFeedSecurityTypeMessage)message;

                try
                {
                    var secType = stMsg.Code.ToSecurityType();

                    if (secType == null)
                    {
                        this.AddWarningLog(LocalizedStrings.Str2140Params.Put(stMsg.Code));
                    }

                    _securityTypes[stMsg.Id] = secType;
                }
                catch (Exception ex)
                {
                    this.AddErrorLog(ex);
                }

                break;
            }

            case ExtendedMessageTypes.End:
            {
                var type      = feed == _lookupFeed ? _currSystemType : null;
                var requestId = 0L;

                if (_currSystemType == null)
                {
                    requestId = message.GetRequestId();

                    type = _requestsType.TryGetValue2(requestId);

                    if (type == null)
                    {
                        return;
                    }

                    _requestsType.Remove(requestId);
                    _secIds.Remove(requestId);

                    if (type == MessageTypes.CandleTimeFrame ||
                        type == MessageTypes.CandleVolume ||
                        type == MessageTypes.CandleTick ||
                        type == ExtendedMessageTypes.HistoryExtraDayCandle)
                    {
                        _candleParsers.Remove(requestId);
                    }
                }

                switch (type)
                {
                case MessageTypes.Security:
                {
                    var result = _lookupResult.TryGetValue(requestId);

                    if (result == null)
                    {
                        return;
                    }

                    _lookupResult.Remove(requestId);

                    SendOutMessage(new SecurityLookupResultMessage {
                                OriginalTransactionId = requestId
                            });

                    break;
                }

                case ExtendedMessageTypes.ListedMarket:
                {
                    _currSystemType = ExtendedMessageTypes.SecurityType;
                    _lookupFeed.RequestSecurityTypes();
                    break;
                }

                case ExtendedMessageTypes.SecurityType:
                {
                    _currSystemType = null;
                    SendOutMessage(new ConnectMessage());
                    break;
                }

                // для сделок и свечек отправляем фиктивный объект,
                // чтобы сообщить, что получение исторических данных завершено

                case MessageTypes.Execution:
                {
                    SendOutMessage(new Level1ChangeMessage
                            {
                                ExtensionInfo = new Dictionary <object, object>
                                {
                                    { "IsFinished", true },
                                }
                            }.InitRequestId(requestId));
                    break;
                }

                case MessageTypes.CandleTimeFrame:
                case MessageTypes.CandleTick:
                case MessageTypes.CandleVolume:
                case ExtendedMessageTypes.HistoryExtraDayCandle:
                {
                    SendOutMessage(new TimeFrameCandleMessage
                            {
                                IsFinished            = true,
                                OriginalTransactionId = requestId,
                            });
                    break;
                }
                }

                break;
            }

            //case MessageTypes.Security:
            //{
            //	var secMsg = (SecurityMessage)message;

            //	var exchangeRoot = message.GetValue<string>("ExchangeRoot");

            //	switch (secMsg.SecurityType)
            //	{
            //		case SecurityTypes.Future:
            //			secMsg.ExpiryDate = message.GetValue<DateTime>("ExpiryDate");
            //			secMsg.UnderlyingSecurityCode = exchangeRoot;
            //			break;

            //		case SecurityTypes.Option:
            //			secMsg.ExpiryDate = message.GetValue<DateTime>("ExpiryDate");
            //			secMsg.UnderlyingSecurityCode = exchangeRoot;
            //			secMsg.Strike = message.GetValue<decimal>("Strike");
            //			break;
            //	}

            //	SendOutMessage(secMsg);
            //	break;
            //}

            default:
                SendOutMessage(message);
                break;
            }
        }