public void Dispose()
{
DisposeSaveTimer();
DisposeUpdateTimer();
syncRoot.Dispose();
savingSemaphore.Dispose();
PriceHistoryManager.Dispose();
}
public void Dispose()
{
syncRoot?.Dispose();
syncRoot = null;
savingSemaphore?.Dispose();
savingSemaphore = null;
saveTimer?.Stop();
saveTimer?.Dispose();
saveTimer = null;
updateTimer?.Stop();
updateTimer?.Dispose();
updateTimer = null;
PriceHistoryManager?.Dispose();
PriceHistoryManager = null;
TradesHistoryManager = null;
}
private async void UpdateTimer_Elapsed(object sender, ElapsedEventArgs e)
{
await syncRoot.WaitAsync();
try
{
PriceHistoryManager.Update();
await MarketTickersManager.Update();
updateTimer.Start();
OnUpdate?.Invoke();
}
catch (Exception exc)
{
OnError?.Invoke(exc);
}
finally
{
syncRoot.Release();
}
}
public async Task OnUpdates(ExchangeUpdate updates)
{
await syncRoot.WaitAsync();
try
{
AnalyticsExchange.OnUpdates(updates);
await PriceHistoryManager.OnTrade(updates);
TradesHistoryManager.OnTrade(updates);
MarketDepthsManager.OnOrderUpdates(updates);
}
catch (Exception exc)
{
//TODO: add support for delayed trades, now it failes during rising
OnError?.Invoke(exc);
logger.Error(exc);
}
finally
{
syncRoot.Release();
}
}
public async Task SaveUpdates(IAnalyticsStorage analyticsStorage, int maxAttempts = 5)
{
await savingSemaphore.WaitAsync();
try
{
var frames = PriceHistoryManager.PullUpdates();
if (frames.Count < 1)
{
return;
}
var attempt = 0;
while (attempt < maxAttempts)
{
try
{
var frameModels = frames.Select(f => f.ToFrameModel()).ToList();
await analyticsStorage.SaveAnalytics(frameModels);
break;
}
catch
{
attempt++;
if (attempt == maxAttempts)
{
throw;
}
Thread.Sleep(attempt * 500);
}
}
}
finally
{
savingSemaphore.Release();
}
}
public async Task SaveUpdates(IAnalyticsStorage analyticsStorage, int numberOfTries = 5)
{
await savingSemaphore.WaitAsync();
try
{
var frames = PriceHistoryManager.PullUpdates();
if (frames.Count < 1)
{
return;
}
var currentTry = 0;
while (currentTry < numberOfTries)
{
try
{
var frameModels = frames.Select(f => f.ToFrameModel()).ToList();
await analyticsStorage.SaveAnalytics(frameModels);
break;
}
catch
{
currentTry++;
if (currentTry == numberOfTries)
{
throw;
}
Thread.Sleep(currentTry * 500);
}
}
}
finally
{
savingSemaphore.Release();
}
}
public async Task Restore(DateTime dateTime)
{
await PriceHistoryManager.Restore(dateTime);
MarketDepthsManager.Restore(dateTime);
}
public MarketTickersManager(List <int> markets, PriceHistoryManager framesManager)
{
this.framesManager = framesManager ?? throw new ArgumentNullException(nameof(framesManager));
period = Enum.GetValues(typeof(PriceHistoryPeriod)).Cast <PriceHistoryPeriod>().Min();
this.markets = markets;
}
