707 lines
24 KiB
C#
707 lines
24 KiB
C#
using MarketData.MarketDataModel;
|
||
using MarketData.Utils;
|
||
using MarketData.DataAccess;
|
||
using System.Collections.Concurrent;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Threading;
|
||
using System.Linq;
|
||
using System.Threading.Tasks;
|
||
|
||
namespace MarketData.Cache
|
||
{
|
||
/// <summary>
|
||
/// GLPriceCache - Used by Gain/Loss Generator which are usedby MarketDataSErver and the User Interface.
|
||
/// The entire cache evicts every hour so calling Add(PortfolioTrades portfolioTrades) will force price reload
|
||
/// Always ensures that open trade symbols get most recent price from the database.
|
||
/// </summary>
|
||
public class GLPriceCache : IDisposable
|
||
{
|
||
// -- Singleton ------------------------------------------------------------
|
||
private static readonly object instanceLock = new object();
|
||
private static GLPriceCache instance = null;
|
||
|
||
// -- Disposal -------------------------------------------------------------
|
||
private volatile bool disposed = false;
|
||
private int refreshInProgress = 0;
|
||
|
||
/// <summary>
|
||
///
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public static GLPriceCache GetInstance()
|
||
{
|
||
lock (instanceLock)
|
||
{
|
||
if (instance == null)instance = new GLPriceCache();
|
||
return instance;
|
||
}
|
||
}
|
||
|
||
// -- State ----------------------------------------------------------------
|
||
private readonly Dictionary<string, PricesByDate> priceCache = new Dictionary<string, PricesByDate>();
|
||
private readonly ConcurrentDictionary<string, object> symbolFetchLocks = new ConcurrentDictionary<string, object>();
|
||
private readonly object cacheLock = new object();
|
||
private DateTime latestDate = Utility.Epoch;
|
||
|
||
// -- Background refresh ---------------------------------------------------
|
||
private readonly TimeSpan cacheCycle = TimeSpan.FromMinutes(5);
|
||
private Timer refreshTimer = null;
|
||
private int tickCount = 0;
|
||
private const int evictionTickInterval = 12; // every 12 ticks x 5 min = 1 hour
|
||
|
||
// -- Parallelism ----------------------------------------------------------
|
||
private static readonly int maxParallelDbCalls = ResolveMaxParallelDbCalls();
|
||
|
||
private static int ResolveMaxParallelDbCalls()
|
||
{
|
||
return Math.Min(Math.Max(1, Environment.ProcessorCount) * 3, 32);
|
||
// int @default = Math.Min(Math.Max(1, Environment.ProcessorCount) * 3, 32);
|
||
// string configured = Environment.GetEnvironmentVariable("GL_PRICE_CACHE_PARALLEL_DB_CALLS");
|
||
// return int.TryParse(configured, out int parsed) && parsed > 0 ? parsed : @default;
|
||
}
|
||
|
||
// -- Constructor ----------------------------------------------------------
|
||
private GLPriceCache()
|
||
{
|
||
refreshTimer = new Timer(OnCacheRefreshTick, null, cacheCycle, cacheCycle);
|
||
}
|
||
|
||
public void Dispose()
|
||
{
|
||
Dispose(true);
|
||
GC.SuppressFinalize(this);
|
||
}
|
||
|
||
protected virtual void Dispose(bool disposing)
|
||
{
|
||
if (disposed) return;
|
||
disposed = true;
|
||
|
||
if (disposing)
|
||
{
|
||
Timer timerToDispose = null;
|
||
lock (instanceLock)
|
||
{
|
||
timerToDispose = refreshTimer;
|
||
refreshTimer = null;
|
||
instance = null;
|
||
}
|
||
|
||
// Dispose timer immediately; no blocking wait
|
||
timerToDispose?.Dispose();
|
||
|
||
MDTrace.WriteLine(LogLevel.DEBUG, "[GLPriceCache:Dispose] Disposed.");
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Dispoal
|
||
/// </summary>
|
||
//public void Dispose()
|
||
//{
|
||
// Dispose(true);
|
||
// GC.SuppressFinalize(this);
|
||
//}
|
||
|
||
//protected virtual void Dispose(bool disposing)
|
||
//{
|
||
// if (disposed) return;
|
||
// disposed = true;
|
||
|
||
// if (disposing)
|
||
// {
|
||
// Timer timerToDispose;
|
||
// lock (instanceLock)
|
||
// {
|
||
// timerToDispose = refreshTimer;
|
||
// refreshTimer = null;
|
||
// instance = null;
|
||
// }
|
||
// // Block until any in-flight tick completes before disposing
|
||
// using (ManualResetEventSlim waited = new ManualResetEventSlim(false))
|
||
// {
|
||
// if (timerToDispose != null)
|
||
// timerToDispose.Dispose(waited.WaitHandle);
|
||
// waited.Wait(TimeSpan.FromSeconds(10));
|
||
// }
|
||
|
||
// MDTrace.WriteLine(LogLevel.DEBUG, "[GLPriceCache:Dispose] Disposed.");
|
||
// }
|
||
//}
|
||
|
||
// -- Background tick ------------------------------------------------------
|
||
private void OnCacheRefreshTick(object state)
|
||
{
|
||
if (disposed) return;
|
||
try
|
||
{
|
||
lock (cacheLock)
|
||
{
|
||
long count = CountInternal();
|
||
MDTrace.WriteLine(LogLevel.DEBUG,$"[GLPriceCache:Tick] Symbols: {priceCache.Keys.Count}. " + $"Items in cache: {Utility.FormatNumber(count, 0, true)}.");
|
||
}
|
||
if (++tickCount % evictionTickInterval == 0)
|
||
{
|
||
EvictStaleSymbols();
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
MDTrace.WriteLine(LogLevel.DEBUG,$"[GLPriceCache:Tick] [ERROR] Unhandled exception: {ex}");
|
||
}
|
||
}
|
||
|
||
// -- Eviction -------------------------------------------------------------
|
||
private void EvictStaleSymbols()
|
||
{
|
||
if (Interlocked.CompareExchange(ref refreshInProgress, 1, 0) == 1)
|
||
{
|
||
MDTrace.WriteLine(LogLevel.DEBUG, "[GLPriceCache:Evict] Skipped refresh in progress.");
|
||
return;
|
||
}
|
||
try
|
||
{
|
||
int count;
|
||
lock (cacheLock)
|
||
{
|
||
count = priceCache.Count;
|
||
priceCache.Clear();
|
||
symbolFetchLocks.Clear();
|
||
}
|
||
MDTrace.WriteLine(LogLevel.DEBUG,$"[GLPriceCache:Evict] Cache cleared. {count} symbols evicted.");
|
||
}
|
||
finally
|
||
{
|
||
Interlocked.Exchange(ref refreshInProgress, 0);
|
||
}
|
||
}
|
||
|
||
// -- Public API -----------------------------------------------------------
|
||
|
||
// public void Add(PortfolioTrades portfolioTrades)
|
||
// {
|
||
// List<string> symbols = portfolioTrades.Symbols;
|
||
|
||
// Dictionary<string, DateTime> minTradeDates = symbols.ToDictionary(
|
||
// sym => sym, sym => portfolioTrades.GetMinTradeDate(sym));
|
||
|
||
// // Only open positions need an intraday price refresh.
|
||
// // Closed positions, regardless of close date, have immutable prices skip the DB call.
|
||
// HashSet<string> mutableSymbols = new HashSet<string>(
|
||
// symbols.Where(sym => portfolioTrades.HasOpenPositions(sym)));
|
||
|
||
// Dictionary<string, DateTime> minCacheDates;
|
||
// lock (cacheLock)
|
||
// {
|
||
// minCacheDates = symbols.ToDictionary(
|
||
// sym => sym,
|
||
// sym => priceCache.ContainsKey(sym) ? priceCache[sym].MinDate : DateTime.MaxValue);
|
||
// }
|
||
|
||
// ConcurrentDictionary<string, Prices> fetchedPrices = new ConcurrentDictionary<string, Prices>();
|
||
// ConcurrentDictionary<string, Price> latestPrices = new ConcurrentDictionary<string, Price>();
|
||
|
||
// Parallel.ForEach(symbols, new ParallelOptions { MaxDegreeOfParallelism = maxParallelDbCalls }, symbol =>
|
||
// {
|
||
// if (disposed) return;
|
||
|
||
// DateTime minTradeDate = minTradeDates[symbol];
|
||
// DateTime minCacheDate = minCacheDates[symbol];
|
||
|
||
// // Acquire a per-symbol lock to prevent concurrent clients from issuing
|
||
// // duplicate DB fetches for the same symbol. First thread fetches;
|
||
// // subsequent threads for the same symbol block here, then re-check
|
||
// // the cache on entry and skip the fetch if already populated.
|
||
// object symbolLock = symbolFetchLocks.GetOrAdd(symbol, _ => new object());
|
||
// lock (symbolLock)
|
||
// {
|
||
// try
|
||
// {
|
||
// // Re-check cache state after acquiring symbol lock another
|
||
// // client thread may have already fetched this symbol while we waited
|
||
// lock (cacheLock)
|
||
// {
|
||
// if (priceCache.ContainsKey(symbol))
|
||
// minCacheDate = priceCache[symbol].MinDate;
|
||
// }
|
||
|
||
// // Historical fetch only when cache is missing or incomplete
|
||
// Prices prices = null;
|
||
// if (minCacheDate == DateTime.MaxValue)
|
||
// prices = PricingDA.GetPrices(symbol, minTradeDate);
|
||
// else if (minTradeDate < minCacheDate)
|
||
// prices = PricingDA.GetPrices(symbol, minCacheDate, minTradeDate);
|
||
|
||
// if (prices != null && prices.Count > 0)
|
||
// fetchedPrices[symbol] = prices;
|
||
|
||
// // Intraday refresh mutable symbols only
|
||
// if (mutableSymbols.Contains(symbol))
|
||
// {
|
||
// Price latestPrice = PricingDA.GetPrice(symbol);
|
||
// if (latestPrice != null)
|
||
// latestPrices[symbol] = latestPrice;
|
||
// }
|
||
// }
|
||
// catch (Exception ex)
|
||
// {
|
||
// MDTrace.WriteLine(LogLevel.DEBUG,
|
||
// $"[GLPriceCache:Add] [ERROR] Failed fetching prices for {symbol}: {ex.Message}");
|
||
// }
|
||
// }
|
||
// });
|
||
|
||
// lock (cacheLock)
|
||
// {
|
||
// // Historical prices idempotent, will not overwrite existing entries
|
||
// foreach (KeyValuePair<string, Prices> kvp in fetchedPrices)
|
||
// foreach (Price price in kvp.Value)
|
||
// AddInternal(price);
|
||
|
||
// // Latest prices unconditional overwrite to capture intraday updates
|
||
// foreach (KeyValuePair<string, Price> kvp in latestPrices)
|
||
// {
|
||
// PricesByDate pricesByDate;
|
||
// if (!priceCache.TryGetValue(kvp.Key, out pricesByDate))
|
||
// {
|
||
// pricesByDate = new PricesByDate();
|
||
// priceCache[kvp.Key] = pricesByDate;
|
||
// }
|
||
|
||
// if (pricesByDate.ContainsKey(kvp.Value.Date))
|
||
// pricesByDate.Remove(kvp.Value.Date);
|
||
// pricesByDate.Add(kvp.Value.Date, kvp.Value);
|
||
// }
|
||
// }
|
||
|
||
// MDTrace.WriteLine(LogLevel.DEBUG,
|
||
// $"[GLPriceCache:Add] Symbols: {symbols.Count}, Mutable: {mutableSymbols.Count}, " +
|
||
// $"Historical fetches: {fetchedPrices.Count}, Intraday updates: {latestPrices.Count}");
|
||
// }
|
||
|
||
public void Add(PortfolioTrades portfolioTrades)
|
||
{
|
||
List<string> symbols = portfolioTrades.Symbols;
|
||
|
||
// Map each symbol to its earliest trade date
|
||
Dictionary<string, DateTime> minTradeDates = symbols.ToDictionary(symbol => symbol, symbol => portfolioTrades.GetMinTradeDate(symbol));
|
||
|
||
// Only open positions need intraday price refresh
|
||
HashSet<string> mutableSymbols = new HashSet<string>(symbols.Where(sym => portfolioTrades.HasOpenPositions(sym)));
|
||
// Pre-filter symbols to skip fully cached immutable symbols
|
||
List<string> symbolsToProcess = symbols
|
||
.Where(sym =>
|
||
{
|
||
DateTime minCacheDate;
|
||
lock (cacheLock)
|
||
{
|
||
minCacheDate = priceCache.ContainsKey(sym) ? priceCache[sym].MinDate : DateTime.MaxValue;
|
||
}
|
||
DateTime minTradeDate = minTradeDates[sym];
|
||
// Skip if symbol is immutable AND cache already covers all trade dates
|
||
return mutableSymbols.Contains(sym) || minTradeDate < minCacheDate;
|
||
})
|
||
.ToList();
|
||
|
||
if (symbolsToProcess.Count == 0) return; // nothing to do
|
||
ConcurrentDictionary<string, Prices> fetchedPrices = new ConcurrentDictionary<string, Prices>();
|
||
ConcurrentDictionary<string, Price> latestPrices = new ConcurrentDictionary<string, Price>();
|
||
Parallel.ForEach(symbolsToProcess, new ParallelOptions { MaxDegreeOfParallelism = maxParallelDbCalls }, symbol =>
|
||
{
|
||
if (disposed) return;
|
||
DateTime minTradeDate = minTradeDates[symbol];
|
||
DateTime minCacheDate;
|
||
lock (cacheLock)
|
||
{
|
||
minCacheDate = priceCache.ContainsKey(symbol) ? priceCache[symbol].MinDate : DateTime.MaxValue;
|
||
}
|
||
object symbolLock = symbolFetchLocks.GetOrAdd(symbol, _ => new object());
|
||
lock (symbolLock)
|
||
{
|
||
try
|
||
{
|
||
// Re-check cache after acquiring lock
|
||
lock (cacheLock)
|
||
{
|
||
if (priceCache.ContainsKey(symbol))minCacheDate = priceCache[symbol].MinDate;
|
||
}
|
||
Prices prices = null;
|
||
// Historical fetch only if cache is missing or incomplete
|
||
if (minCacheDate == DateTime.MaxValue)prices = PricingDA.GetPrices(symbol, minTradeDate);
|
||
else if (minTradeDate < minCacheDate)prices = PricingDA.GetPrices(symbol, minCacheDate, minTradeDate);
|
||
if (prices != null && prices.Count > 0)fetchedPrices[symbol] = prices;
|
||
// Intraday refresh for mutable symbols only
|
||
if (mutableSymbols.Contains(symbol))
|
||
{
|
||
Price latestPrice = PricingDA.GetPrice(symbol);
|
||
if (latestPrice != null)latestPrices[symbol] = latestPrice;
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
MDTrace.WriteLine(LogLevel.DEBUG,$"[GLPriceCache:Add] [ERROR] Failed fetching prices for {symbol}: {ex.Message}");
|
||
}
|
||
} // lcok(symLock)
|
||
}); // Parallel
|
||
|
||
lock (cacheLock)
|
||
{
|
||
// Historical prices idempotent, do not overwrite existing entries
|
||
foreach (KeyValuePair<string, Prices> kvp in fetchedPrices)
|
||
{
|
||
foreach (Price price in kvp.Value)
|
||
{
|
||
AddInternal(price);
|
||
}
|
||
}
|
||
// Latest prices unconditional overwrite to capture intraday updates
|
||
foreach (KeyValuePair<string, Price> kvp in latestPrices)
|
||
{
|
||
PricesByDate pricesByDate;
|
||
if (!priceCache.TryGetValue(kvp.Key, out pricesByDate))
|
||
{
|
||
pricesByDate = new PricesByDate();
|
||
priceCache[kvp.Key] = pricesByDate;
|
||
}
|
||
if (pricesByDate.ContainsKey(kvp.Value.Date))
|
||
{
|
||
pricesByDate.Remove(kvp.Value.Date);
|
||
}
|
||
pricesByDate.Add(kvp.Value.Date, kvp.Value);
|
||
}
|
||
}
|
||
|
||
// Only log if we actually fetched or updated something
|
||
if (fetchedPrices.Count > 0 || latestPrices.Count > 0)
|
||
{
|
||
MDTrace.WriteLine(LogLevel.DEBUG,$"[GLPriceCache:Add] Symbols processed: {symbolsToProcess.Count}, Mutable: {mutableSymbols.Count}, " +
|
||
$"Historical fetches: {fetchedPrices.Count}, Intraday updates: {latestPrices.Count}");
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Add prices
|
||
/// </summary>
|
||
/// <param name="prices"></param>
|
||
public void Add(Prices prices)
|
||
{
|
||
foreach (Price price in prices)Add(price);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Add(List<string> symbols, DateTime pricingDate)
|
||
/// </summary>
|
||
/// <param name="symbols"></param>
|
||
/// <param name="pricingDate"></param>
|
||
public void Add(List<string> symbols, DateTime pricingDate)
|
||
{
|
||
if (symbols == null || symbols.Count == 0) return;
|
||
ConcurrentDictionary<string, Price> fetchedPrices = new ConcurrentDictionary<string, Price>();
|
||
Parallel.ForEach(symbols, new ParallelOptions { MaxDegreeOfParallelism = maxParallelDbCalls }, symbol =>
|
||
{
|
||
if (disposed) return;
|
||
lock (cacheLock)
|
||
{
|
||
if (ContainsPriceInternal(symbol, pricingDate)) return;
|
||
}
|
||
try
|
||
{
|
||
Price price = PricingDA.GetPrice(symbol, pricingDate);
|
||
if (price != null) fetchedPrices[symbol] = price;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
MDTrace.WriteLine(LogLevel.DEBUG,$"[GLPriceCache:Add] [ERROR] Failed fetching price for {symbol} on {pricingDate:yyyy-MM-dd}: {ex.Message}");
|
||
}
|
||
});
|
||
|
||
lock (cacheLock)
|
||
{
|
||
foreach (KeyValuePair<string, Price> kvp in fetchedPrices)
|
||
{
|
||
AddInternal(kvp.Value);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Add(Price price)
|
||
/// </summary>
|
||
/// <param name="price"></param>
|
||
public void Add(Price price)
|
||
{
|
||
lock (cacheLock)
|
||
{
|
||
AddInternal(price);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Refresh
|
||
/// </summary>
|
||
public void Refresh()
|
||
{
|
||
if (Interlocked.CompareExchange(ref refreshInProgress, 1, 0) == 1)
|
||
{
|
||
MDTrace.WriteLine(LogLevel.DEBUG, "[GLPriceCache:Refresh] Skipped refresh already in progress.");
|
||
return;
|
||
}
|
||
try
|
||
{
|
||
List<string> symbols;
|
||
Dictionary<string, DateTime> currentMaxDates;
|
||
|
||
lock (cacheLock)
|
||
{
|
||
symbols = priceCache.Keys.ToList();
|
||
currentMaxDates = priceCache.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.MaxDate);
|
||
}
|
||
if (symbols.Count == 0) return;
|
||
ConcurrentDictionary<string, PricesByDate> fullReloads = new ConcurrentDictionary<string, PricesByDate>();
|
||
ConcurrentDictionary<string, Price> singleUpdates = new ConcurrentDictionary<string, Price>();
|
||
|
||
// Fetch outside the cache lock no timeout risk holding cacheLock over I/O
|
||
Dictionary<string, DateTime> maxDbDates = PricingDA.GetLatestDates(symbols);
|
||
DateTime latestDateFromDb = PricingDA.GetLatestDate();
|
||
|
||
Parallel.ForEach(symbols, new ParallelOptions { MaxDegreeOfParallelism = maxParallelDbCalls }, symbol =>
|
||
{
|
||
if (disposed) return;
|
||
DateTime cachedMax;
|
||
if (!currentMaxDates.TryGetValue(symbol, out cachedMax)) return;
|
||
try
|
||
{
|
||
DateTime dbMax;
|
||
if (maxDbDates.TryGetValue(symbol, out dbMax) && dbMax.Date != cachedMax.Date)
|
||
{
|
||
Prices prices = PricingDA.GetPrices(symbol, cachedMax);
|
||
if (prices != null) fullReloads[symbol] = prices.GetPricesByDate();
|
||
}
|
||
else
|
||
{
|
||
Price price = PricingDA.GetPrice(symbol, cachedMax);
|
||
if (price != null) singleUpdates[symbol] = price;
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
MDTrace.WriteLine(LogLevel.DEBUG,$"[GLPriceCache:Refresh] [ERROR] Failed refreshing {symbol}: {ex.Message}");
|
||
}
|
||
}); // Parallel
|
||
|
||
lock (cacheLock)
|
||
{
|
||
latestDate = latestDateFromDb;
|
||
foreach (KeyValuePair<string, PricesByDate> kvp in fullReloads)
|
||
{
|
||
PricesByDate existing;
|
||
if (priceCache.TryGetValue(kvp.Key, out existing) && existing.MaxDate == currentMaxDates[kvp.Key])
|
||
{
|
||
priceCache[kvp.Key] = kvp.Value;
|
||
}
|
||
}
|
||
foreach (KeyValuePair<string, Price> kvp in singleUpdates)
|
||
{
|
||
PricesByDate pricesByDate;
|
||
if (priceCache.TryGetValue(kvp.Key, out pricesByDate) && pricesByDate.MaxDate == currentMaxDates[kvp.Key])
|
||
{
|
||
if (pricesByDate.ContainsKey(kvp.Value.Date))
|
||
{
|
||
pricesByDate.Remove(kvp.Value.Date);
|
||
}
|
||
pricesByDate.Add(kvp.Value.Date, kvp.Value);
|
||
}
|
||
}
|
||
} // lock(cacheLock)
|
||
MDTrace.WriteLine(LogLevel.DEBUG,$"[GLPriceCache:Refresh] Full reloads: {fullReloads.Count}, Single updates: {singleUpdates.Count}");
|
||
}
|
||
finally
|
||
{
|
||
Interlocked.Exchange(ref refreshInProgress, 0);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// GetLatestDate
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public DateTime GetLatestDate()
|
||
{
|
||
lock (cacheLock)
|
||
{
|
||
if (Utility.IsEpoch(latestDate))
|
||
{
|
||
latestDate = PricingDA.GetLatestDate();
|
||
}
|
||
return latestDate;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// RefreshLatestDate
|
||
/// </summary>
|
||
public void RefreshLatestDate()
|
||
{
|
||
lock (cacheLock)
|
||
{
|
||
latestDate = PricingDA.GetLatestDate();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// GetMinCacheDate
|
||
/// </summary>
|
||
/// <param name="symbol"></param>
|
||
/// <returns></returns>
|
||
public DateTime GetMinCacheDate(string symbol)
|
||
{
|
||
lock (cacheLock)
|
||
{
|
||
PricesByDate symbolPrices;
|
||
if (!priceCache.TryGetValue(symbol, out symbolPrices) || symbolPrices.Count == 0)
|
||
{
|
||
return Utility.Epoch;
|
||
}
|
||
return symbolPrices.MinDate;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// GetPrices
|
||
/// </summary>
|
||
/// <param name="symbol"></param>
|
||
/// <param name="endDate"></param>
|
||
/// <param name="dayCount"></param>
|
||
/// <returns></returns>
|
||
public Prices GetPrices(string symbol, DateTime endDate, int dayCount)
|
||
{
|
||
lock (cacheLock)
|
||
{
|
||
PricesByDate pricesByDate;
|
||
if (!priceCache.TryGetValue(symbol, out pricesByDate)) return new Prices();
|
||
DateGenerator dateGenerator = new DateGenerator();
|
||
List<DateTime> historicalDates = dateGenerator.GenerateHistoricalDates(endDate, dayCount);
|
||
|
||
Prices result = new Prices();
|
||
foreach (DateTime date in historicalDates)
|
||
{
|
||
if (pricesByDate.ContainsKey(date))
|
||
{
|
||
result.Add(pricesByDate[date]);
|
||
}
|
||
}
|
||
return result;
|
||
} // lock(cacheLock)
|
||
}
|
||
|
||
/// <summary>
|
||
/// GetPrice
|
||
/// </summary>
|
||
/// <param name="symbol"></param>
|
||
/// <param name="date"></param>
|
||
/// <returns></returns>
|
||
public Price GetPrice(string symbol, DateTime date)
|
||
{
|
||
lock (cacheLock)
|
||
{
|
||
PricesByDate pricesByDate;
|
||
if (!priceCache.TryGetValue(symbol, out pricesByDate)) return null;
|
||
Price price;
|
||
return pricesByDate.TryGetValue(date, out price) ? price : null;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// ContainsPrice
|
||
/// </summary>
|
||
/// <param name="symbol"></param>
|
||
/// <param name="date"></param>
|
||
/// <returns></returns>
|
||
public bool ContainsPrice(string symbol, DateTime date)
|
||
{
|
||
lock (cacheLock)
|
||
{
|
||
return ContainsPriceInternal(symbol, date);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// ContainsPrice
|
||
/// </summary>
|
||
/// <param name="symbols"></param>
|
||
/// <param name="date"></param>
|
||
/// <returns></returns>
|
||
public bool ContainsPrice(List<string> symbols, DateTime date)
|
||
{
|
||
if (symbols == null || symbols.Count == 0) return false;
|
||
lock (cacheLock)
|
||
{
|
||
foreach (string symbol in symbols)
|
||
{
|
||
if (!ContainsPriceInternal(symbol, date)) return false;
|
||
}
|
||
return true;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// ContainsSymbol
|
||
/// </summary>
|
||
/// <param name="symbol"></param>
|
||
/// <returns></returns>
|
||
public bool ContainsSymbol(string symbol)
|
||
{
|
||
lock (cacheLock)
|
||
{
|
||
return priceCache.ContainsKey(symbol);
|
||
}
|
||
}
|
||
|
||
// -- Private helpers ------------------------------------------------------
|
||
|
||
// Must be called under cacheLock
|
||
private void AddInternal(Price price)
|
||
{
|
||
if (price == null) return;
|
||
PricesByDate pricesByDate;
|
||
if (!priceCache.TryGetValue(price.Symbol, out pricesByDate))
|
||
{
|
||
pricesByDate = new PricesByDate();
|
||
priceCache[price.Symbol] = pricesByDate;
|
||
}
|
||
if (!pricesByDate.ContainsKey(price.Date))
|
||
{
|
||
pricesByDate.Add(price.Date, price);
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// ContainsPriceInternal - mUST BE CALLED UNDER CACHELOCK
|
||
/// </summary>
|
||
/// <param name="symbol"></param>
|
||
/// <param name="date"></param>
|
||
/// <returns></returns>
|
||
private bool ContainsPriceInternal(string symbol, DateTime date)
|
||
{
|
||
PricesByDate pricesByDate;
|
||
if (!priceCache.TryGetValue(symbol, out pricesByDate)) return false;
|
||
return pricesByDate.ContainsKey(date);
|
||
}
|
||
|
||
/// <summary>
|
||
/// CountInternal - MUST BE CALLED UNDER CACHELOCK
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private long CountInternal()
|
||
{
|
||
long count = 0;
|
||
foreach (PricesByDate pricesByDate in priceCache.Values)
|
||
{
|
||
count += pricesByDate.Count;
|
||
}
|
||
return count;
|
||
}
|
||
}
|
||
}
|