// 按因子对象初始因子数据缓存集
public bool InitDataCaches(IData_Factors infoFactors, IData_Factor infoFactor, bool useEvent = false)
{
if (_isInited == false)
{
return(false);
}
IDataCaches_Manage dataManage = this.GetDataCaches_Manage(infoFactors);
if (dataManage == null)
{
return(false);
}
if (dataManage.GetDataCaches(infoFactor, false) == null)
{
DataCaches dataCaches = (DataCaches)dataManage.GetDataCaches(infoFactor, true);
//注册检查集初始事件
if (useEvent)
{
dataCaches.DataChecks_Initial += new DataCachesChecksInitial_EventHandler(EventHandler_DataCachesChecksInitial);
dataCaches.Event_DataChecks_Initial();
}
return(this._IndexFactors(infoFactors, infoFactor));
}
return(true);
}
/// <summary>按因子对象初始因子数据缓存对象
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="infoFactors">因子对象集</param>
/// <param name="infoFactor">因子对象</param>
/// <param name="tagName">标识</param>
/// <param name="typeTimeFrequency">数据频率</param>
/// <param name="cacheNums">缓存数据数量</param>
/// <returns></returns>
public bool InitDataCache <T>(IData_Factors infoFactors, IData_Factor infoFactor, string tagName, typeTimeFrequency typeTimeFrequency, int cacheNums, bool useEvent = false)
{
if (_isInited == false)
{
return(false);
}
DataCaches dataCaches = (DataCaches)this.GetDataCaches(infoFactors, infoFactor);
if (dataCaches == null)
{
return(false);
}
if (dataCaches.GetDataCache <T>(tagName, typeTimeFrequency) == null)
{
DataCache <T> dataCache = (DataCache <T>)dataCaches.GetDataCache <T>(tagName, typeTimeFrequency, true, cacheNums);
//注册事件
if (useEvent)
{
dataCache.DataCache_Load += new DataCacheLoad_EventHandler(EventHandler_DataCacheLoad);
dataCache.DataChecks_Initial += new DataCacheChecksInitial_EventHandler(EventHandler_DataCacheChecksInitial);
dataCache.DataCache_Change += new DataCacheChange_EventHandler(EventHandler_DataCacheChange);
dataCache.Event_DataCache_Load();
dataCache.Event_DataChecks_Initial();
}
return(this._IndexFactors(infoFactors, infoFactor));
}
return(true);
}
// 按因子对象初始因子数据缓存集
public bool InitDataCaches(IData_Factors infoFactors, IData_Factor infoFactor)
{
//提取管理类
IDataCaches_Manage dataManage = this.GetDataCaches_Manage(infoFactors, true);
return(this._IndexFactors(infoFactors, infoFactor) && dataManage.InitDataCaches(infoFactor));
}
public int InitDataCache_Data <T>(IData_Factors infoFactors, IData_Factor infoFactor, string tagName, typeTimeFrequency typeTimeFrequency, Dictionary <DateTime, T> datas, bool useEvent = false)
{
if (_isInited == false)
{
return(-1);
}
DataCaches dataCaches = (DataCaches)this.GetDataCaches(infoFactors, infoFactor);
if (dataCaches == null)
{
return(-1);
}
if (dataCaches.GetDataCache <T>(tagName, typeTimeFrequency) == null)
{
DataCache <T> dataCache = (DataCache <T>)dataCaches.GetDataCache <T>(tagName, typeTimeFrequency, true, 0);
//注册事件
if (useEvent)
{
dataCache.DataCache_Load += new DataCacheLoad_EventHandler(EventHandler_DataCacheLoad);
dataCache.DataChecks_Initial += new DataCacheChecksInitial_EventHandler(EventHandler_DataCacheChecksInitial);
dataCache.DataCache_Change += new DataCacheChange_EventHandler(EventHandler_DataCacheChange);
dataCache.Event_DataCache_Load();
dataCache.Event_DataChecks_Initial();
}
return(dataCache.InitDatas(datas));
}
return(-1);
}
/// <summary>
/// </summary>
/// <param name="dtBase">基时间</param>
public DataCaches_Manage(IData_Factors info_Factors, IDataCache_Set srcDataCache_Set, IDataChecks dataChecks = null)
{
Tag = info_Factors.ID;
_DataCache_Set = new DataCache_Set(Tag, srcDataCache_Set.Time_Base, typeTimeFrequency.None, 0, info_Factors, srcDataCache_Set);
_DataChecks = dataChecks;
_DataCaches = new Dictionary <string, IDataCaches>();
}
//设置正数据对象-修正为同时间频率数据
public virtual bool SetData(CacheInfo <Data_Quote> pCacheInfo, typeTimeFrequency timeFrequency, typeTimeFrequency timeFrequency2)
{
Data_Quote pData = pCacheInfo.Data;
if (pData == null)
{
return(false);
}
StockInfo pStockInfo = pData.GetStockInfo();
if (pStockInfo == null)
{
return(false);
}
//获取当前时间频率数据
DateTime dtEnd = zxcTimeHelper.CheckTime(pData.DateTime, typeTimeFrequency.m1, true);
Data_Quote pDataNew = QuoteQuery._Query.Query(pStockInfo, pData.DateTime, timeFrequency, null);
if (pDataNew == null)
{
return(false);
}
bool bResult = this.SetData(pDataNew, timeFrequency);
return(bResult);
//非时间频率数据，重新修正
if (pData.QuoteTimeType != timeFrequency)
{
string exType = pStockInfo.StockExchange.ToString();
IData_Factors pFactors = _managerCaches._GetFactors(exType);
if (pFactors != null)
{
IData_Factor pFactor = pFactors.GetData_Factor(pStockInfo.StockID_Tag);
DataCache <Data_Quote> pDataCache = (DataCache <Data_Quote>)_managerCaches.GetDataCache <Data_Quote>(pFactors, pFactor, "", timeFrequency);
//查询最后有效步长数据总数
int nCount = pDataCache.DataCaches.Values.Count(e => e.Data.IsDel == true);
//获取最数据
List <Data_Quote> lstQuotes = QuoteQuery._Query.Query(pStockInfo.StockID_Tag, pDataNew.DateTime, nCount, timeFrequency, true);
if (lstQuotes != null)
{
foreach (var item in lstQuotes)
{
int nSum = pDataCache.DataCaches.Values.Count(e => e.DateTime == item.DateTime && e.Data.IsDel != true);
if (nSum == 0)
{
item.SetStockInfo(pStockInfo);
bResult = bResult && this.SetData(item, timeFrequency);
}
}
}
}
}
return(bResult);
}
/// <summary>按因子对象初始因子数据缓存对象
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="infoFactors">因子对象集</param>
/// <param name="infoFactor">因子对象</param>
/// <param name="tagName">标识</param>
/// <param name="typeTimeFrequency">数据频率</param>
/// <param name="cacheNums">缓存数据数量</param>
/// <returns></returns>
public bool InitDataCache <T>(IData_Factors infoFactors, IData_Factor infoFactor, string tagName, typeTimeFrequency typeTimeFrequency, int cacheNums)
{
//提取管理类
IDataCaches_Manage dataManage = this.GetDataCaches_Manage(infoFactors, true);
return(this._IndexFactors(infoFactors, infoFactor) &&
dataManage.InitDataCache <T>(infoFactor, tagName, typeTimeFrequency, cacheNums));
}
//设置缓存数据对象-修正
//public virtual Data_Quote SetData_ValueCheck(Data_Quote pData, typeTimeFrequency timeFrequency)
//{
// pData.QuoteTimeType = timeFrequency;
// return pData;
//}
//初始规则信息集合-Caches-弃用
private bool InitDataChecks_Caches(IData_Factors pFactors, IData_Factor pFactor)
{
IDataCaches dataCaches = _managerCaches.GetDataCaches(pFactors, pFactor);
IDataChecks poDataChecks_Caches = new DataChecks_Quote(dataCaches.ID, dataCaches);
bool bResult = dataCaches.InitDataChecks(poDataChecks_Caches);
return(bResult);
}
public IData_Factor _GetFactor(string strTagFactors, string strTag)
{
IData_Factors pFactors = _GetFactors(strTagFactors);
if (pFactors == null)
{
return(null);
}
return(pFactors.GetData_Factor(strTag));
}
/// <summary>按因子对象集、因子对象等提取缓存数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="infoFactors">因子对象集</param>
/// <param name="infoFactor">因子对象</param>
/// <param name="strTag">自定义标识</param>
/// <param name="dtTime">数据时间</param>
/// <param name="typeTimeFrequency">时间频率</param>
/// <returns></returns>
public T GetData <T>(IData_Factors infoFactors, IData_Factor infoFactor, string strTag, DateTime dtTime, typeTimeFrequency typeTimeFrequency = typeTimeFrequency.none)
{
IDataCache <T> dataCache = this.GetDataCache <T>(infoFactors, infoFactor, strTag, typeTimeFrequency);
if (dataCache == null)
{
return(default(T));
}
return(dataCache.GetData(dtTime));
}
/// <summary>按因子对象集、因子对象等提取缓存数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="infoFactors">因子对象集标识</param>
/// <param name="infoFactor">因子对象标识</param>
/// <param name="strTag">自定义标识</param>
/// <param name="dtTime">数据时间</param>
/// <param name="typeTimeFrequency">时间频率</param>
/// <returns></returns>
public T GetData <T>(string tagFactors, string tagFactor, string strTag, DateTime dtTime, typeTimeFrequency typeTimeFrequency = typeTimeFrequency.none)
{
IData_Factors dataFactors = this._GetFactors(tagFactors);
if (dataFactors != null)
{
IData_Factor dataFactor = dataFactors.GetData_Factor(tagFactor);
return(GetData <T>(dataFactors, dataFactor, strTag, dtTime, typeTimeFrequency));
}
return(default(T));
}
/// <summary>按因子对象集、因子对象等设置缓存数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="infoFactors">因子对象集</param>
/// <param name="infoFactor">因子对象</param>
/// <param name="strTag">自定义标识</param>
/// <param name="dtTime">数据时间</param>
/// <param name="data">数据(int等或class对象)</param>
/// <param name="typeTimeFrequency">时间频率</param>
/// <returns></returns>
public bool SetData <T>(IData_Factors infoFactors, IData_Factor infoFactor, string strTag, DateTime dtTime, T data, typeTimeFrequency typeTimeFrequency = typeTimeFrequency.none)
{
IDataCache <T> dataCache = this.GetDataCache <T>(infoFactors, infoFactor, strTag, typeTimeFrequency);
if (dataCache == null)
{
return(false);
}
return(dataCache.SetData(dtTime, data));
}
/// <summary>索引因子集对象（便于用标识查找因子集）
/// </summary>
/// <param name="infoFactors">因子对象集</param>
/// <param name="infoFactor">因子对象</param>
/// <returns></returns>
protected bool _IndexFactors(IData_Factors infoFactors, IData_Factor infoFactor)
{
if (infoFactors == null)
{
return(false);
}
if (this._GetFactors(infoFactors.ID) == null)
{
_Data_Factorss.Add(infoFactors.ID, infoFactors);
}
return(infoFactors.IndexData_Factor(infoFactor));
}
public int InitDataCache_Data <T>(IData_Factors infoFactors, IData_Factor infoFactor, string tagName, typeTimeFrequency typeTimeFrequency, Dictionary <DateTime, T> datas)
{
//提取管理类
IDataCache <T> dataCache = GetDataCache <T>(infoFactors, infoFactor, tagName, typeTimeFrequency);
if (dataCache == null)
{
return(-1);
}
return(dataCache.InitDatas(datas));
}
/// <summary>提取指定因子对象集、因子对象的数据缓存集
/// </summary>
/// <param name="infoFactors">因子对象集</param>
/// <param name="infoFactor">因子对象</param>
/// <param name="autoInit">是否自动初始</param>
/// <returns></returns>
public IDataCaches GetDataCaches(IData_Factors infoFactors, IData_Factor infoFactor, bool autoInit = false)
{
//提取管理类
IDataCaches_Manage dataManage = this.GetDataCaches_Manage(infoFactors, autoInit);
if (dataManage == null)
{
return(null);
}
return(dataManage.GetDataCaches(infoFactor, autoInit));
}
/// <summary>按因子对象集、因子对象提取缓存数据对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="infoFactors">因子对象集</param>
/// <param name="infoFactor">因子对象</param>
/// <param name="strTag">自定义标识</param>
/// <param name="typeTimeFrequency">时间频率</param>
/// <param name="autoInit">不存在时是否自定初始</param>
/// <param name="cacheNums">缓存数据数量，autoInit为false时无效</param>
/// <returns></returns>
public IDataCache <T> GetDataCache <T>(IData_Factors infoFactors, IData_Factor infoFactor, string strTag = "", typeTimeFrequency typeTimeFrequency = typeTimeFrequency.None, bool autoInit = false, int cacheNums = 1)
{
IDataCaches dataCaches = this.GetDataCaches(infoFactors, infoFactor, autoInit);
if (dataCaches == null)
{
return(null);
}
IDataCache <T> data = dataCaches.GetDataCache <T>(strTag, typeTimeFrequency, autoInit, cacheNums);
return(data);
}
// 初始单个数据缓存集管理类（集中管理，如数采仪为一个集中管理类）
public bool InitDataCaches_Manage(IData_Factors infoFactors)
{
if (_isInited == false)
{
return(false);
}
if (this.GetDataCaches_Manage(infoFactors) == null)
{
DataCaches_Manage dataManage = new DataCaches_Manage(infoFactors, _DataCache_Set);
_DataCaches_Manages[dataManage.Tag] = dataManage;
return(true);
}
return(false);
}
public bool InitDataCheck <T>(string tagFactors, string tagFactor, string strTag, typeTimeFrequency typeTimeFrequency, string tagDataCheck, IDataCheck <T> dataCheck, bool isCanCover = false)
{
if (tagFactors + "" == "")
{
return(false);
}
//DataCaches_Manage
IData_Factors infoFactors = this._GetFactors(tagFactors);
if (infoFactors == null)
{
return(false);
}
IDataCaches_Manage dataCaches_Manage = this.GetDataCaches_Manage(infoFactors);
if (dataCaches_Manage == null)
{
return(false);
}
if (tagFactor + "" == "")
{
return(dataCaches_Manage.InitDataCheck <T>(tagDataCheck, dataCheck, isCanCover));
}
//DataCaches
IData_Factor infoFactor = infoFactors.GetData_Factor(tagFactor);
if (infoFactor == null)
{
return(false);
}
IDataCaches dataCaches = this.GetDataCaches(infoFactors, infoFactor);
if (dataCaches == null)
{
return(false);
}
IDataCache dataCache = dataCaches.GetDataCache <T>(strTag, typeTimeFrequency);
if (dataCache == null)
{
return(dataCaches.InitDataCheck <T>(tagDataCheck, dataCheck, isCanCover));
}
else
{
return(dataCache.InitDataCheck(tagDataCheck, dataCheck, isCanCover));
}
}
/// <summary>提取指定标识的因子集对象
/// </summary>
/// <param name="strTag"></param>
/// <returns></returns>
public IData_Factors _GetFactors(string strTag)
{
if (strTag + "" == "")
{
return(null);
}
IData_Factors pFactors = null;
if (_Data_Factorss.TryGetValue(strTag, out pFactors))
{
}
return(pFactors);
}
/// <summary>按因子对象集、因子对象等设置缓存数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="infoFactors">因子对象集标识</param>
/// <param name="infoFactor">因子对象标识</param>
/// <param name="strTag">自定义标识</param>
/// <param name="dtTime">数据时间</param>
/// <param name="data">数据(int等或class对象)</param>
/// <param name="typeTimeFrequency">时间频率</param>
/// <returns></returns>
public bool SetData <T>(string tagFactors, string tagFactor, string strTag, DateTime dtTime, T data, typeTimeFrequency typeTimeFrequency = typeTimeFrequency.none)
{
IData_Factors dataFactors = this._GetFactors(tagFactors);
if (dataFactors != null)
{
IData_Factor dataFactor = dataFactors.GetData_Factor(tagFactor);
if (dataFactor != null)
{
return(SetData <T>(dataFactors, dataFactor, strTag, dtTime, data, typeTimeFrequency));
}
}
return(false);
}
//初始规则信息集合-Cache-弃用
private bool InitDataChecks_Cache(IData_Factors pFactors, IData_Factor pFactor, Data_Quote data)
{
//数据缓存集检查
IDataCaches dataCaches = _managerCaches.GetDataCaches(pFactors, pFactor);
if (dataCaches == null)
{
return(false);
}
//初始检查集
bool bResult = this.InitDataChecks_CheckAll(dataCaches);
return(bResult);
}
/// <summary>提取指定因子对象集的数据缓存集管理对象
/// </summary>
/// <param name="infoFactors">因子对象集</param>
/// <param name="autoInit">是否自动初始</param>
/// <returns></returns>
public IDataCaches_Manage GetDataCaches_Manage(IData_Factors infoFactors, bool autoInit = false)
{
IDataCaches_Manage dataManage = null;
if (_DataCaches_Manages.TryGetValue(infoFactors.ID, out dataManage))
{
//What ever you gonna do next...
}
if (autoInit && dataManage == null)
{
if (this.InitDataCaches_Manage(infoFactors, autoInit))
{
return(GetDataCaches_Manage(infoFactors));
}
}
return(dataManage);
}
// 初始单个数据缓存集管理类（集中管理，如数采仪为一个集中管理类）
public bool InitDataCaches_Manage(IData_Factors infoFactors, bool useEvent = false)
{
if (_isInited == false)
{
return(false);
}
if (this.GetDataCaches_Manage(infoFactors) == null)
{
DataCaches_Manage dataManage = new DataCaches_Manage(infoFactors, _DataCache_Set);
_DataCaches_Manages[dataManage.Tag] = dataManage;
//注册检查集初始事件
if (useEvent)
{
dataManage.DataChecks_Initial += new DataCachesManageChecksInitial_EventHandler(EventHandler_DataCachesManageChecksInitial);
dataManage.Event_DataChecks_Initial();
}
return(true);
}
return(true);
}
/// <summary>提取指定因子对象集、因子对象的数据缓存集
/// </summary>
/// <param name="infoFactors">因子对象集</param>
/// <param name="infoFactor">因子对象</param>
/// <param name="autoInit">是否自动初始</param>
/// <returns></returns>
public IDataCaches GetDataCaches(IData_Factors infoFactors, IData_Factor infoFactor, bool autoInit = false)
{
//提取管理类
IDataCaches_Manage dataManage = this.GetDataCaches_Manage(infoFactors, autoInit);
if (dataManage == null)
{
return(null);
}
IDataCaches dataCaches = dataManage.GetDataCaches(infoFactor, false);
if (autoInit && dataCaches == null)
{
if (this.InitDataCaches(infoFactors, infoFactor, autoInit))
{
return(GetDataCaches(infoFactors, infoFactor));
}
}
return(dataCaches);
}
/// <summary>按因子对象集、因子对象提取缓存数据对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="infoFactors">因子对象集</param>
/// <param name="infoFactor">因子对象</param>
/// <param name="strTag">自定义标识</param>
/// <param name="typeTimeFrequency">时间频率</param>
/// <param name="autoInit">不存在时是否自定初始</param>
/// <param name="cacheNums">缓存数据数量，autoInit为false时无效</param>
/// <returns></returns>
public IDataCache <T> GetDataCache <T>(IData_Factors infoFactors, IData_Factor infoFactor, string strTag = "", typeTimeFrequency typeTimeFrequency = typeTimeFrequency.none, bool autoInit = false, int cacheNums = 1)
{
IDataCaches dataCaches = this.GetDataCaches(infoFactors, infoFactor, autoInit);
if (dataCaches == null)
{
return(null);
}
IDataCache <T> dataCache = dataCaches.GetDataCache <T>(strTag, typeTimeFrequency);
if (autoInit && dataCache == null)
{
if (this.InitDataCache <T>(infoFactors, infoFactor, strTag, typeTimeFrequency, cacheNums, autoInit))
{
return(GetDataCache <T>(infoFactors, infoFactor, strTag, typeTimeFrequency));
}
}
//事件触发
return(dataCache);
}
//统一初始数据缓存相关
public virtual bool InitDataCache(Data_Quote pData)
{
if (pData == null)
{
return(false);
}
StockInfo stockInfo = pData.GetStockInfo();
if (stockInfo == null)
{
return(false);
}
string exType = stockInfo.StockExchange.ToString();
bool bExist = true, bResult = true;
IData_Factors pFactors = _managerCaches._GetFactors(exType);
if (pFactors == null)
{
//提取信息
pFactors = new Data_Factors(exType, exType, "", "");
pFactors.DateTime = pData.DateTime;
bExist = false;
}
IData_Factor pFactor = pFactors.GetData_Factor(stockInfo.StockID_Tag);
if (bExist == false || pFactor == null)
{
//提取信息
pFactor = new Data_Factor(stockInfo.StockID_Tag, stockInfo.StockID_Tag, stockInfo.StockName, "");
pFactor.DateTime = pFactors.DateTime;
//初始数据所有缓存对象
if (this._managerCaches.DataCaches_Manages.Count < 1)
{
this._managerCaches.Init(pFactors.DateTime);
}
foreach (var item in _setsDataCache)
{
//提取数据缓存对象、及检查对象集
IDataCache <Data_Quote> poDataCache = _managerCaches.GetDataCache <Data_Quote>(pFactors, pFactor, "", item.Key, true, item.Value);
//IDataCache poDataCache = null;
//if (item.Key == typeTimeFrequency.real)
// poDataCache = _managerCaches.GetDataCache<Data_Quote>(pFactors, pFactor, "", item.Key, true, item.Value);
//else
// poDataCache = _managerCaches.GetDataCache<Data_Quote>(pFactors, pFactor, "", item.Key, true, item.Value);
//_managerCaches.InitDataCache<Data_Quote_Swap>(pFactors, pFactor, "", item.Key, item.Value);
}
//初始规则信息集合-Caches
//bResult = this.InitDataChecks_Caches(pFactors, pFactor);
//初始规则信息集合-Cache
//bResult = bResult && this.InitDataChecks_Cache(pFactors, pFactor, data);
_dictQuotes[_getTag(pData)] = true;
return(bResult);
}
return(false);
}
