// 按因子对象初始因子数据缓存集 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); }