/// <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;
}
}
