예제 #1
0
        /// <summary>
        /// Отправить входящее сообщение.
        /// </summary>
        /// <param name="message">Сообщение.</param>
        public virtual void SendInMessage(Message message)
        {
            //if (!CheckLicense(message))
            //	return;

            if (message.Type == MessageTypes.Connect)
            {
                if (!Platform.IsCompatible())
                {
                    SendOutMessage(new ConnectMessage
                    {
                        Error = new InvalidOperationException(LocalizedStrings.Str169Params.Put(GetType().Name, Platform))
                    });

                    return;
                }
            }

            //месседжи с заявками могут складываться из потока обработки
            var force = message.Type == MessageTypes.OrderRegister ||
                        message.Type == MessageTypes.OrderReplace ||
                        message.Type == MessageTypes.OrderPairReplace ||
                        message.Type == MessageTypes.OrderCancel ||
                        message.Type == MessageTypes.OrderGroupCancel;

            InitMessageLocalTime(message);

            _inMessageProcessor.EnqueueMessage(message, this, force);
        }
예제 #2
0
        /// <summary>
        /// Добавить <see cref="Message"/> в исходящую очередь <see cref="IMessageAdapter"/>.
        /// </summary>
        /// <param name="message">Сообщение.</param>
        public virtual void SendOutMessage(Message message)
        {
            InitMessageLocalTime(message);

            _outMessageProcessor.EnqueueMessage(message, this, false);

            switch (message.Type)
            {
            case MessageTypes.Connect:
            {
                if (((ConnectMessage)message).Error == null)
                {
                    lock (_timeSync)
                        _prevState = _currState = ConnectionStates.Connected;

                    StartMarketTimer();
                }
                else
                {
                    lock (_timeSync)
                        _prevState = _currState = ConnectionStates.Failed;
                }

                break;
            }

            case MessageTypes.Disconnect:
            {
                lock (_timeSync)
                    _prevState = _currState = ConnectionStates.Disconnected;

                StopMarketTimer();
                break;
            }

            default:
            {
                if (_prevTime != DateTime.MinValue)
                {
                    var diff = message.LocalTime - _prevTime;

                    if (message.Type != MessageTypes.Time && diff >= SessionHolder.MarketTimeChangedInterval)
                    {
                        SendOutMessage(new TimeMessage
                            {
                                LocalTime  = message.LocalTime,
                                ServerTime = message.GetServerTime(),
                            });
                    }

                    _secLookupTimeOut
                    .ProcessTime(diff)
                    .ForEach(id => SendOutMessage(new SecurityLookupResultMessage {
                            OriginalTransactionId = id
                        }));

                    _pfLookupTimeOut
                    .ProcessTime(diff)
                    .ForEach(id => SendOutMessage(new PortfolioLookupResultMessage {
                            OriginalTransactionId = id
                        }));

                    ProcessReconnection(diff);
                }

                _prevTime = message.LocalTime;
                break;
            }
            }
        }