/// <summary> /// To send data request. /// </summary> /// <param name="series">The candles series for which data receiving should be started.</param> /// <param name="from">The initial date from which you need to get data.</param> /// <param name="to">The final date by which you need to get data.</param> public void Start(CandleSeries series, DateTimeOffset from, DateTimeOffset to) { if (series == null) { throw new ArgumentNullException(nameof(series)); } CandleSeriesInfo info; lock (_info.SyncRoot) { info = _info.TryGetValue(series); if (info != null) { throw new ArgumentException(LocalizedStrings.Str636Params.Put(series), nameof(series)); } info = new CandleSeriesInfo(series, from, to, Sources, OnNewValues, s => { _info.Remove(s); OnStopped(s); }); //Container.Start(series, from, to); _info.Add(series, info); } info.Start(); }
private void ProcessSubscriptionAction(IEnumerator <IMessageAdapter> enumerator, MarketDataMessage message, long originalTransactionId) { if (enumerator.MoveNext()) { enumerator.Current.SendInMessage(message); } else { _subscriptionQueue.RemoveByValue(enumerator); var key = _subscriptionKeys.TryGetValue(message.OriginalTransactionId); if (key == null) { key = message.CreateKey(); } else { _subscriptionKeys.Remove(originalTransactionId); } _subscriptionStates.Remove(key); RaiseMarketDataMessage(null, originalTransactionId, new ArgumentException(LocalizedStrings.Str629Params.Put(key.Item1 + " " + key.Item2), nameof(message)), true); } }
/// <inheritdoc /> protected override bool OnSendInMessage(Message message) { switch (message.Type) { case MessageTypes.Reset: { lock (_sync) { _pending.Clear(); } break; } case MessageTypes.MarketData: { var mdMsg = (MarketDataMessage)message; if (mdMsg.IsSubscribe) { if (mdMsg.SecurityId == default || mdMsg.DoNotBuildOrderBookInrement || mdMsg.To != null) { break; } if (mdMsg.DataType2 != DataType.MarketDepth && mdMsg.DataType2 != DataType.Level1) { break; } lock (_sync) _pending[mdMsg.TransactionId] = mdMsg.TypedClone(); } else { lock (_sync) _pending.Remove(mdMsg.OriginalTransactionId); } break; } case MessageTypes.OrderStatus: case MessageTypes.PortfolioLookup: { var subscrMsg = (ISubscriptionMessage)message; if (subscrMsg.IsSubscribe && subscrMsg.To == null) { lock (_sync) _pending[subscrMsg.TransactionId] = subscrMsg.TypedClone(); } break; } } return(base.OnSendInMessage(message)); }
/// <inheritdoc /> public void Delete(Security security) { if (security is null) { throw new ArgumentNullException(nameof(security)); } if (_inner.Remove(security.ToSecurityId())) { Removed?.Invoke(new[] { security }); } }
public void RemoveElements_Success() { var dic = new SynchronizedDictionary<int, string, string>(); dic.Add(1, "Иванов", "value_1"); dic.Add(2, "Иванов", "value_2"); dic.Add(5, "Иванов", "value_3"); dic.Add(5, "Петров", "value_4"); dic.Remove(5, "Иванов"); dic.Remove(5, "Петров"); Assert.AreEqual(2, dic.Count); }
private void ProcessSubscriptionAction(IEnumerator <IMessageAdapter> enumerator, MarketDataMessage message, long originalTransactionId) { if (enumerator.MoveNext()) { enumerator.Current.SendInMessage(message); } else { _subscriptionQueue.RemoveByValue(enumerator); _subscriptionKeys.Remove(originalTransactionId); RaiseMarketDataMessage(null, originalTransactionId, new ArgumentException(LocalizedStrings.Str629Params.Put(message.SecurityId + " " + message.DataType), "message")); } }
/// <summary> /// Process message. /// </summary> /// <param name="message">Message.</param> protected override void OnProcessMessage(Message message) { var candleMsg = message as CandleMessage; if (candleMsg == null) { base.OnProcessMessage(message); return; } var series = _candleSeries.TryGetValue(candleMsg.OriginalTransactionId); if (series == null) { return; } var candle = candleMsg.ToCandle(series); // сообщение с IsFinished = true не содержит данные по свече, // только флаг, что получение исторических данных завершено if (!candleMsg.IsFinished) { NewCandles.SafeInvoke(series, new[] { candle }); } else { _candleSeries.Remove(candleMsg.OriginalTransactionId); if (candleMsg.IsFinished) { Stopped.SafeInvoke(series); } } }
public void RemoveAuction(Auction auction) { if (auction == null || !auctions.ContainsKey(auction.AuctionId)) { return; } auctions.Remove(auction.ItemLowId); items.Remove(auction.ItemLowId); AuctionMgr instance = Singleton <AuctionMgr> .Instance; ItemRecord record = null; if (instance.AuctionItems.ContainsKey(auction.ItemLowId)) { record = instance.AuctionItems[auction.ItemLowId]; instance.AuctionItems.Remove(auction.ItemLowId); } ServerApp <RealmServer> .IOQueue.AddMessage(() => { if (record != null) { record.IsAuctioned = false; record.Save(); } auction.Delete(); }); }
/// <summary> /// To stop data receiving starting through <see cref="Start"/>. /// </summary> /// <param name="series">Candles series.</param> public override void Stop(CandleSeries series) { if (series == null) { throw new ArgumentNullException(nameof(series)); } var registeredSeries = _registeredSeries.TryGetValue(series.Security); if (registeredSeries == null) { return; } registeredSeries.Remove(series); if (registeredSeries.Count == 0) { UnRegisterSecurity(series.Security); _registeredSeries.Remove(series.Security); } _seriesByDates.RemoveWhere(i => i.Value == series); RaiseStopped(series); }
public void RemoveAuction(Auction auction) { if (auction == null) { return; } if (!auctions.ContainsKey(auction.AuctionId)) { return; } auctions.Remove(auction.ItemLowId); items.Remove(auction.ItemLowId); AuctionMgr mgr = AuctionMgr.Instance; ItemRecord record = null; if (mgr.AuctionItems.ContainsKey(auction.ItemLowId)) { record = mgr.AuctionItems[auction.ItemLowId]; mgr.AuctionItems.Remove(auction.ItemLowId); } //remove from database RealmServer.IOQueue.AddMessage(() => { if (record != null) { record.IsAuctioned = false; record.Save(); } auction.Delete(); }); }
/// <summary> /// Удалить обработчик сообщения. /// </summary> /// <param name="type">Тип сообщения.</param> /// <returns><see langword="true"/>, если обработчик был найден и удален. Иначе, <see langword="false"/>.</returns> public bool Remove(MessageTypes type) { var index = (int)type; if (index < 0 || index >= _allProcessors.Length) { throw new ArgumentOutOfRangeException("type"); } IMessageProcessor processor = null; try { lock (_innerDict.SyncRoot) { processor = _allProcessors[index]; _allProcessors[index] = DefaultProcessor; if (_allProcessors.Contains(processor)) { processor = null; } return(_innerDict.Remove(type)); } } finally { if (processor != null) { processor.Stop(); } } }
/// <inheritdoc /> public override void SendInMessage(Message message) { switch (message.Type) { case MessageTypes.Reset: _depths.Clear(); break; case MessageTypes.MarketData: { var mdMsg = (MarketDataMessage)message; if (mdMsg.DataType == MarketDataTypes.MarketDepth) { if (mdMsg.IsSubscribe) { if (mdMsg.MaxDepth != null) { _depths[mdMsg.SecurityId] = mdMsg.MaxDepth.Value; } } else { _depths.Remove(mdMsg.SecurityId); } } break; } } base.SendInMessage(message); }
private static void RemoveFromCache(int contactID) { lock (_synchronizedObj) { _photoCache.Remove(contactID); } }
/// <inheritdoc /> protected override void OnSendInMessage(Message message) { switch (message.Type) { case MessageTypes.Reset: _states.Clear(); break; case MessageTypes.MarketData: { var mdMsg = (MarketDataMessage)message; if (mdMsg.DataType == MarketDataTypes.MarketDepth) { if (mdMsg.IsSubscribe) { if (IsSupportOrderBookIncrements) { _states.Add(mdMsg.TransactionId, RefTuple.Create(new QuotesDict(new BackwardComparer <decimal>()), new QuotesDict(), _none)); } } else { _states.Remove(mdMsg.OriginalTransactionId); } } break; } } base.OnSendInMessage(message); }
private void OnConnectorNewMessage(Message message) { switch (message.Type) { case MessageTypes.SecurityLookupResult: { var id = ((SecurityLookupResultMessage)message).OriginalTransactionId; var tuple = _lookupMessages.TryGetValue(id); if (tuple != null) { var security = _connector.FilterSecurities(tuple.Item1).FirstOrDefault(); ProcessSecurityMarketData(security, tuple.Item3, tuple.Item2); _lookupMessages.Remove(id); } break; } //TODO убрать подписку на MarketDataSubscriptionSucceeded //case MessageTypes.MarketData: //{ // if (direction == MessageDirections.ToMarketData) // break; // break; //} } }
private void RemoveSubscription(long id) { if (_depths.Remove(id)) { this.AddInfoLog("Unsubscribed {0}.", id); } }
/// <inheritdoc /> protected override void OnInnerAdapterNewOutMessage(Message message) { if (message.IsBack) { base.OnInnerAdapterNewOutMessage(message); return; } switch (message.Type) { case MessageTypes.CandleTimeFrame: case MessageTypes.CandlePnF: case MessageTypes.CandleRange: case MessageTypes.CandleRenko: case MessageTypes.CandleTick: case MessageTypes.CandleVolume: { ProcessCandle((CandleMessage)message); break; } case MessageTypes.MarketDataFinished: { _infos.Remove(((MarketDataFinishedMessage)message).OriginalTransactionId); break; } } base.OnInnerAdapterNewOutMessage(message); }
private void DepthClick(object sender, RoutedEventArgs e) { if (Depth.IsChecked == false) { // create order book window var wnd = new QuotesWindow { Title = SelectedSecurity.Id + " " + LocalizedStrings.MarketDepth }; _quotesWindows.Add(SelectedSecurity, wnd); // subscribe on order book flow Trader.RegisterMarketDepth(SelectedSecurity); wnd.Show(); } else { Trader.UnRegisterMarketDepth(SelectedSecurity); var wnd = _quotesWindows[SelectedSecurity]; _quotesWindows.Remove(SelectedSecurity); wnd.Close(); } if (!_initialized) { TraderOnMarketDepthChanged(Trader.GetMarketDepth(SecurityPicker.SelectedSecurity)); Trader.MarketDepthChanged += TraderOnMarketDepthChanged; _initialized = true; } }
public void TestAddRemoveByKey() { SynchronizedDictionary <int, string> test = new SynchronizedDictionary <int, string>(new IgnoreLocking()); for (int i = 0; i < 10; i++) { test.Add(i, i.ToString()); } for (int i = 0; i < 10; i++) { Assert.IsTrue(test.ContainsKey(i)); } string cmp; for (int i = 0; i < 10; i++) { Assert.IsTrue(test.TryGetValue(i, out cmp) && cmp == i.ToString()); } for (int i = 0; i < 10; i++) { Assert.IsTrue(test.Remove(i)); } }
private static int ChangeSubscribers(SynchronizedDictionary <Security, int> subscribers, Security subscriber, int delta) { if (subscribers == null) { throw new ArgumentNullException("subscribers"); } lock (subscribers.SyncRoot) { var value = subscribers.TryGetValue2(subscriber) ?? 0; value += delta; if (value > 0) { subscribers[subscriber] = value; } else { subscribers.Remove(subscriber); } return(value); } }
internal void UnregisterWorkItemsGroup(IWorkItemsGroup workItemsGroup) { if (_workItemsGroups.Contains(workItemsGroup)) { _workItemsGroups.Remove(workItemsGroup); } }
private void OnNewBar(int row, int rowCount, string smartId, SmartComTimeFrames timeFrame, DateTime time, decimal?open, decimal?high, decimal?low, decimal?close, decimal?volume, decimal?openInt) { this.AddDebugLog("OnNewHistoryTrade row = {0} rowCount = {1} securityId = {2} timeFrame = {3} time = {4} open = {5} high = {6} low = {7} close = {8} volume = {9} openInt = {10}", row, rowCount, smartId, timeFrame, time, open, high, low, close, volume, openInt); var infos = _candleTransactions.TryGetValue(smartId); var timeFrameKey = (TimeSpan)timeFrame; Tuple <long, List <CandleMessage> > transactionInfo; if (infos == null || !infos.TryGetValue(timeFrameKey, out transactionInfo)) { this.AddErrorLog(LocalizedStrings.Str1855Params, smartId, timeFrame); return; } transactionInfo.Item2.Add(new TimeFrameCandleMessage { SecurityId = new SecurityId { Native = smartId }, OpenPrice = open ?? 0, HighPrice = high ?? 0, LowPrice = low ?? 0, ClosePrice = close ?? 0, TotalVolume = volume ?? 0, OpenTime = time.ApplyTimeZone(TimeHelper.Moscow) - (TimeSpan)timeFrame, CloseTime = time.ApplyTimeZone(TimeHelper.Moscow), OpenInterest = openInt, OriginalTransactionId = transactionInfo.Item1, }); if ((row + 1) < rowCount) { return; } row = 0; transactionInfo.Item2.OrderBy(c => c.OpenTime).ForEach(m => { m.IsFinished = ++row == rowCount; if (!m.IsFinished) { m.State = CandleStates.Finished; } SendOutMessage(m); }); infos.Remove(timeFrameKey); if (infos.IsEmpty()) { _candleTransactions.Remove(smartId); } }
void IAlertService.UnRegister(AlertSchema schema) { if (schema == null) { throw new ArgumentNullException("schema"); } _schemas.Remove(schema.EntityType); }
private void UnSubscribe(ICandleSource <Candle> source) { lock (_info.SyncRoot) { var info = _info[source]; info.Dispose(); _info.Remove(source); } }
public void Clear(TKey key) { lock (_snapshots.SyncRoot) { _snapshots.Remove(key); _dirtyKeys.Remove(key); _resetFile = true; } }
/// <summary> /// Remove previously registered by <see cref="Register"/> schema. /// </summary> /// <param name="schema">Schema.</param> public void UnRegister(AlertSchema schema) { if (schema == null) { throw new ArgumentNullException(nameof(schema)); } _schemas.Remove(schema.MessageType); }
public Security ProcessResponse(MarketDataMessage response, out MarketDataMessage originalMsg, out bool unexpectedCancelled) { unexpectedCancelled = false; var tuple = TryGetRequest(response.OriginalTransactionId); if (tuple == null) { originalMsg = null; return(null); } //_requests.Remove(response.OriginalTransactionId); var subscriber = tuple.Item2; originalMsg = tuple.Item1; if (originalMsg.DataType.IsSecurityRequired()) { lock (_subscribers.SyncRoot) { if (originalMsg.IsSubscribe) { if (response.IsOk()) { _subscribers.SafeAdd(originalMsg.DataType).Add(subscriber); } else { var set = _subscribers.TryGetValue(originalMsg.DataType); if (set != null && set.Remove(subscriber)) { unexpectedCancelled = true; } } } else { var dict = _subscribers.TryGetValue(originalMsg.DataType); if (dict != null) { dict.Remove(subscriber); if (dict.Count == 0) { _subscribers.Remove(originalMsg.DataType); } } } } } return(subscriber); }
/// <summary> /// Unregister candles builder. /// </summary> /// <param name="builder">Candles builder.</param> public void UnRegister(ICandleBuilder builder) { if (builder == null) { throw new ArgumentNullException(nameof(builder)); } _builders.Remove(builder.CandleType); }
public static void InvalidateCachedSchema(this IDAC dac) { using (_schemaCache.EnterWriteScope()) { var connectionString = dac.ConnectionString; if (_schemaCache.ContainsKey(connectionString)) { _schemaCache.Remove(connectionString); } } }
private void ProcessInnerAdapterMarketDataMessage(IMessageAdapter adapter, MarketDataMessage message) { var key = Tuple.Create(message.SecurityId, message.DataType); var tuple = _subscriptionQueue.TryGetValue(key); var cancel = tuple != null && tuple.Second; if (message.Error == null) { SessionHolder.AddDebugLog(LocalizedStrings.Str630Params, message.SecurityId, adapter); _subscriptionQueue.Remove(key); RaiseMarketDataMessage(message, null); if (!cancel) { return; } //в процессе подписки пользователь отменил ее - надо отписаться от получения данных var cancelMessage = (MarketDataMessage)message.Clone(); cancelMessage.IsSubscribe = false; SendInMessage(cancelMessage); } else { SessionHolder.AddDebugLog(LocalizedStrings.Str631Params, adapter, message.SecurityId, message.DataType, message.Error); if (cancel) { RaiseSubscriptionFailed(message, new InvalidOperationException(LocalizedStrings.SubscriptionProcessCancelled)); } else if (tuple != null) { ProcessSubscriptionAction(tuple.First, message); } else { RaiseSubscriptionFailed(message, new InvalidOperationException(LocalizedStrings.Str633Params.Put(message.SecurityId, message.DataType))); } } }
public void TestLock() { LockCounterFactory <SimpleReadWriteLocking> factory = new LockCounterFactory <SimpleReadWriteLocking>(); ILockStrategy lck = factory.Create(); SynchronizedDictionary <int, string> test = new SynchronizedDictionary <int, string>(lck); Assert.IsTrue(ReferenceEquals(lck, test.Lock)); test.Add(42, "42"); Assert.AreEqual(1, factory.TotalWriterCount); Assert.AreEqual(0, factory.TotalReaderCount); test[42] = "51"; Assert.AreEqual(2, factory.TotalWriterCount); test.Add(1, "52"); Assert.AreEqual(3, factory.TotalWriterCount); test.Remove(-1); Assert.AreEqual(4, factory.TotalWriterCount); test.Remove(1); Assert.AreEqual(5, factory.TotalWriterCount); Assert.AreEqual("51", test[42]); Assert.AreEqual(1, factory.TotalReaderCount); foreach (KeyValuePair <int, string> i in test) { GC.KeepAlive(i); } Assert.AreEqual(2, factory.TotalReaderCount); Assert.AreEqual(false, test.ContainsKey(-1)); Assert.AreEqual(3, factory.TotalReaderCount); Assert.AreEqual(1, test.Count); Assert.AreEqual(4, factory.TotalReaderCount); string cmp; Assert.IsTrue(test.TryGetValue(42, out cmp) && cmp == "51"); Assert.AreEqual(5, factory.TotalReaderCount); }
public void SynchronizedDictionaryUnitTest() { SynchronizedDictionary<int, string> dictionary = new SynchronizedDictionary<int, string>(); dictionary.Add(1, "one"); dictionary.Add(2, "two"); Assert.IsTrue(dictionary.Count == 2); foreach (KeyValuePair<int, string> keyValuePair in dictionary) { Assert.IsTrue(dictionary.ContainsKey(keyValuePair.Key)); Assert.IsTrue(dictionary.ContainsValue(keyValuePair.Value)); } dictionary.Remove(1); Assert.IsTrue(dictionary.Count == 1); dictionary.Clear(); Assert.IsTrue(dictionary.Count == 0); }
private static int ChangeSubscribers(SynchronizedDictionary<Security, int> subscribers, Security subscriber, int delta) { if (subscribers == null) throw new ArgumentNullException("subscribers"); lock (subscribers.SyncRoot) { var value = subscribers.TryGetValue2(subscriber) ?? 0; value += delta; if (value > 0) subscribers[subscriber] = value; else subscribers.Remove(subscriber); return value; } }