/// <summary>
 /// Initializes a new instance of ImmediateNotificationRegister class.
 /// </summary>
 /// <param name="context">an instance of DbContext is used to get an ObjectQuery object</param>
 /// <param name="query">an instance of IQueryable is used to get ObjectQuery object, and then get
 /// connection string and command string to register SqlDependency nitification. </param>
 public ImmediateSqlNotificationRegister(IDbContextBase context, IQueryable query, CacheInfo cacheInfo)
 {
     Init(context, query, cacheInfo);
 }
        private void Init(IDbContextBase context, IQueryable query, int delayForRetryOnError, CacheInfo cacheInfo)
        {
            try
            {
                StartMonitor(context);
                this.iquery = query;

                // Get the ObjectQuery directly or convert the DbQuery to ObjectQuery.
                Core.Cmn.Extensions.QueryableExt.GetSqlCommand <TEntity>(context, query, ref connection, ref command);
                RegisterSqlDependency();
            }
            catch (Exception ex)
            {
                try
                {
                    using (var trace = new Trace.TraceDto())
                    {
                        trace.TraceKey          = "CacheSqlDependency";
                        trace.Data["CacheName"] = cacheInfo.Name;
                        trace.Data["DateTime"]  = DateTime.Now.ToString();
                        trace.Data["Exception"] = ex.ToString();
                        trace.Message           = $"CacheSql Dependency {cacheInfo.Name} has faced with an exception at {DateTime.Now.ToString()} ...";
                        trace.Data["State"]     = "initialize";
                        Core.Cmn.AppBase.TraceWriter.SubmitData(trace);
                    }

                    Core.Cmn.AppBase.LogService.Handle(ex, $"Exception on initialize ImmediateNotificationRegister for cache on SqlDependency, the query is {iquery}...");
                }
                catch
                {
                }

                Task.Delay(delayForRetryOnError).Wait();
                Init(context, query, delayForRetryOnError + 1000, cacheInfo);
            }
        }
Esempio n. 3
0
        public static T MergeFreshDataByOldCache <T>(T oldData, T newData, CacheInfo cacheInfo, bool isQueryableCache, out List <ObjectBase> entitiesForDeletion, out List <ObjectBase> entitiesForAddition, out List <ObjectBase> entitiesForUpdates)
        {
            entitiesForDeletion = null;
            entitiesForAddition = null;
            entitiesForUpdates  = null;
            var nlst       = (newData as IList);
            T   resultList = oldData;

            if (oldData == null)
            {
                resultList = newData;
            }
            else
            {
                if (!cacheInfo.DisableToSyncDeletedRecord_JustIfEnableToFetchOnlyChangedDataFromDB && !cacheInfo.IsFunctionalCache)
                {
                    var deletedRecords = CacheConfig.CacheManagementRepository.
                                         GetDeletedRecordsByTable(cacheInfo.Repository.Schema + "." + cacheInfo.Repository.TableName,
                                                                  cacheInfo.MaxTimeStampForDeletedRecord, cacheInfo.CacheRefreshingKind != CacheRefreshingKind.SqlDependency);

                    if (deletedRecords.Count > 0)
                    {
                        var maxDeletedRecordItem       = (ObjectBase)deletedRecords.OrderByDescending(item => ((ObjectBase)item).TimeStampUnit).First();
                        var maxTimeStampDeletedRecords = ((ObjectBase)maxDeletedRecordItem).TimeStampUnit;
                        var oldEntityBaseLst           = (oldData as IList).Cast <ObjectBase>().ToList();
                        var oldLst = oldData as IList;
                        entitiesForDeletion = new List <ObjectBase>();
                        foreach (var record in deletedRecords)
                        {
                            if (nlst != null && nlst.Count > 0)
                            {
                                var newItemToRemove = nlst.Cast <ObjectBase>().FirstOrDefault(item => item.CacheId == record.DeletedEntityId);
                                if (newItemToRemove != null)
                                {
                                    nlst.Remove(newItemToRemove);
                                    newItemToRemove.IsDeletedForCache = true;
                                }
                            }

                            var itemToRemove = oldEntityBaseLst.FirstOrDefault(item => item.CacheId == record.DeletedEntityId);
                            if (itemToRemove != null)
                            {
                                entitiesForDeletion.Add(itemToRemove);
                                oldLst.Remove(itemToRemove);
                                itemToRemove.IsDeletedForCache = true;

                                foreach (var inf in cacheInfo.InfoAndEntityListForFillingNavigationPropertyDic.ToList())
                                {
                                    List <ObjectBase> entities;
                                    /// attention: Added Tolist Here
                                    //lock (inf.Value)
                                    //{
                                    entities = inf.Value.Where(en =>
                                    {
                                        var thisPropertyValue = en[inf.Key.ThisEntityRefrencePropertyName];
                                        return(thisPropertyValue != null && thisPropertyValue.Equals(itemToRemove[inf.Key.OtherEntityRefrencePropertyName]));
                                    }).ToList();
                                    //}
                                    //Where(en => en[inf.Key.ThisEntityRefrencePropertyName].Equals(itemToRemove[inf.Key.OtherEntityRefrencePropertyName])).ToList()
                                    entities.ForEach((Action <ObjectBase>)((ObjectBase parentEntity) =>
                                    {
                                        object navContainer;
                                        if (parentEntity.NavigationPropertyDataDic.TryGetValue(inf.Key.PropertyInfo.Name, out navContainer))
                                        {
                                            if (inf.Key.IsEnumerable)
                                            {
                                                // var navContainer = parentEntity.NavigationPropertyDataDic[inf.Key.PropertyInfo.Name];
                                                var navPropList = navContainer as IList;
                                                if (navPropList.Count > 0)
                                                {
                                                    IList newNavProp = Activator.CreateInstance(navContainer.GetType()) as IList;
                                                    navPropList.Cast <ObjectBase>().ToList().ForEach((ObjectBase entity) =>
                                                    {
                                                        if (!entity.Equals(itemToRemove))
                                                        {
                                                            newNavProp.Add(entity);
                                                        }
                                                    });

                                                    parentEntity.NavigationPropertyDataDic.TryUpdate(inf.Key.PropertyInfo.Name, newNavProp, navContainer);
                                                    parentEntity.CallNavigationPropertyChangedByCache(parentEntity, inf.Key.PropertyInfo.Name);
                                                }
                                                // (en.NavigationPropertyDataDic[inf.Key.PropertyInfo.Name] as IList).Remove(itemToRemove);
                                            }
                                            else
                                            {
                                                //en[inf.Key.PropertyInfo.Name] = null;
                                                object tmp;
                                                parentEntity.NavigationPropertyDataDic.TryRemove(inf.Key.PropertyInfo.Name, out tmp);
                                                parentEntity.CallNavigationPropertyChangedByCache(parentEntity, inf.Key.PropertyInfo.Name);
                                            }
                                        }
                                        else
                                        {
                                            parentEntity.CallNavigationPropertyChangedByCache(parentEntity, inf.Key.PropertyInfo.Name);
                                        }
                                    }));
                                }
                            }
                        }



                        cacheInfo.MaxTimeStampUintForDeletedRecord  = cacheInfo.MaxTimeStampUintForDeletedRecord2;
                        cacheInfo.MaxTimeStampUintForDeletedRecord2 = maxTimeStampDeletedRecords;
                        cacheInfo.MaxTimeStampForDeletedRecord      = cacheInfo.MaxTimeStampForDeletedRecord2;
                        cacheInfo.MaxTimeStampForDeletedRecord2     = maxDeletedRecordItem.TimeStamp;
                    }
                }


                if (nlst.Count > 0)
                {
                    entitiesForAddition = new List <ObjectBase>();
                    entitiesForUpdates  = new List <ObjectBase>();
                    var newLst           = nlst.Cast <ObjectBase>().ToList();
                    var oldLst           = (oldData as IList);
                    var oldEntityBaseLst = (oldData as IList).Cast <ObjectBase>().ToList();
                    var result           = Activator.CreateInstance <T>() as IList;
                    foreach (var item in oldEntityBaseLst)
                    {
                        result.Add(item);
                    }

                    foreach (var newItem in newLst)
                    {
                        var oldItem = oldEntityBaseLst.FirstOrDefault(item => item.Equals(newItem));
                        if (oldItem != null)
                        {
                            UpdateNavigationProperties(cacheInfo, newItem, oldItem);
                            oldItem.UpdateAllProps(newItem);
                            entitiesForUpdates.Add(oldItem);
                        }
                        else
                        {
                            entitiesForAddition.Add(newItem);
                            result.Add(newItem);
                            UpdateNavigationProperties(cacheInfo, newItem, null);

                            // newItem.EnableFillNavigationProperyByCache = true;
                        }
                    }

                    resultList = (T)result;
                }
            }

            if (entitiesForUpdates != null && entitiesForUpdates.Count > 0)
            {
                cacheInfo.CallOnUpdateEntities(entitiesForUpdates);
            }

            if (entitiesForAddition != null && entitiesForAddition.Count > 0)
            {
                cacheInfo.CallOnAddEntities(entitiesForAddition);
            }

            if (entitiesForDeletion != null && entitiesForDeletion.Count > 0)
            {
                cacheInfo.CallOnDeleteEntities(entitiesForDeletion);
            }

            if ((cacheInfo.EnableUseCacheServer && ConfigHelper.GetConfigValue <bool>("IsCacheServer")) || !cacheInfo.EnableUseCacheServer)
            {
                if (!string.IsNullOrEmpty(cacheInfo.NameOfNavigationPropsForFetchingOnlyChangedDataFromDB) || (cacheInfo.EnableSaveCacheOnHDD && cacheInfo.NotYetGetCacheData))
                {
                    QueryableCacheDataProvider <object> .CalcAllTimeStampAndSet(newData as IList, cacheInfo, isQueryableCache);
                }
                else
                {
                    cacheInfo.MaxTimeStamp     = cacheInfo.MaxTimeStampCopy;
                    cacheInfo.MaxTimeStampUint = cacheInfo.MaxTimeStampUintCopy;
                }
            }

            if (nlst.Count > 0)
            {
                foreach (var en in nlst.Cast <ObjectBase>())
                {
                    (en as ObjectBase).EnableFillNavigationProperyByCache();
                }
            }

            // System.Diagnostics.Debug.WriteLine("after merg:" + (oldData as IList).Count);
            return(resultList);
        }
Esempio n. 4
0
        private static void RefreshCache_Force <T>(ICacheDataProvider <T> cacheExecution, CacheInfo cacheInfo, T oldCacheValue, out T refreshCacheValue)
        {
            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            var cacheKey     = cacheExecution.GenerateCacheKey();
            var cacheKeyFake = cacheKey + "_Fake";

            try
            {
                refreshCacheValue = cacheExecution.GetFreshData();
                List <ObjectBase> entitiesForDeletion = null;
                List <ObjectBase> entitiesForAddition = null;
                List <ObjectBase> entitiesForUpdates  = null;
                lock (cacheInfo.InfoAndEntityListForFillingNavigationPropertyDic)
                {
                    if (cacheInfo.EnableToFetchOnlyChangedDataFromDB)
                    {
                        refreshCacheValue = MergeFreshDataByOldCache <T>(oldCacheValue, refreshCacheValue, cacheInfo, true, out entitiesForDeletion, out entitiesForAddition, out entitiesForUpdates);
                    }

                    CacheService.SetCache <T>(cacheExecution.GenerateCacheKey(), refreshCacheValue, cacheInfo.AutoRefreshInterval * (double)100000);
                    cacheInfo.NotYetGetCacheData = false;
                }

                if (entitiesForUpdates != null && entitiesForUpdates.Count > 0)
                {
                    cacheInfo.CallAfterUpdateEntities(entitiesForUpdates);
                }

                if (entitiesForAddition != null && entitiesForAddition.Count > 0)
                {
                    cacheInfo.CallAfterAddEntities(entitiesForAddition);
                }

                if (entitiesForDeletion != null && entitiesForDeletion.Count > 0)
                {
                    cacheInfo.CallAfterDeleteEntities(entitiesForDeletion);
                }

                cacheInfo.FrequencyOfBuilding += 1;
                cacheInfo.LastBuildDateTime    = DateTime.Now;
                stopwatch.Stop();
                var time = new TimeSpan(stopwatch.ElapsedTicks);
                cacheInfo.BuildingTime += time;
            }
            catch (Exception ex)
            {
                cacheInfo.ErrorCount = cacheInfo.ErrorCount + 1;
                //System.Diagnostics.StackTrace st = new System.Diagnostics.StackTrace(ex, true);
                //System.Diagnostics.StackFrame[] frames = st.GetFrames();
                //string x = "";
                //// Iterate over the frames extracting the information you need
                //foreach (System.Diagnostics.StackFrame frame in frames)
                //{
                //    //   x = ""+ frame.GetFileName()+"";
                //    x += "filename:" + frame.GetFileName() + "--methodname:" + frame.GetMethod().Name + "--linenumber:" + frame.GetFileLineNumber() + "--columnnumber:" + frame.GetFileColumnNumber();
                //}
                CacheService.RemoveCache(cacheKeyFake);
                //var eLog = _logService.GetEventLogObj();
                //eLog.OccuredException = ex;
                //eLog.UserId = "dbContext Cache in Thread !";
                //eLog.CustomMessage = x;
                //_logService.Handle(eLog);

                refreshCacheValue = default(T);
                throw _logService.Handle(ex, "dbContext Cache in Thread !");
            }
        }
Esempio n. 5
0
 private static bool TryRefreshCache <T>(ICacheDataProvider <T> cacheExecution, CacheInfo cacheInfo, out T refreshCacheValue)
 {
     try
     {
         refreshCacheValue = RefreshCache <T>(cacheExecution, cacheInfo);
         return(true);
     }
     catch
     {
         refreshCacheValue = default(T);
         return(false);
     }
 }
Esempio n. 6
0
        private static void BuildCachesInAssembly(Type dBContext, Assembly repAssembly, bool isRepositoryAssembly)
        {
            IEnumerable <MethodInfo> types = null;

            try
            {
                types = repAssembly.GetTypes()
                        .SelectMany(type => type.GetMethods(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));
            }
            catch
            {
                //This exception is don't care.
                return;
            }

            foreach (var type in types)
            {
                var cacheInfoAtt = type.GetAttributeValue <CacheableAttribute, CacheableAttribute>(cAtt => cAtt);
                if (cacheInfoAtt != null)
                {
                    //if (string.IsNullOrEmpty(cacheInfo.Key))
                    //{
                    //    throw new ArgumentNullException("Cache Key can't be empty.");
                    //}

                    if ((type as MethodInfo).IsStatic)
                    {
                        if (!(type as MethodInfo).IsGenericMethod)
                        {
                            var  methodInfo   = type as MethodInfo;
                            var  parames      = methodInfo.GetParameters();
                            Type funcBaseType = null;
                            if (parames.Count() == 0)
                            {
                                funcBaseType = typeof(Func <>);
                            }
                            if (parames.Count() == 1)
                            {
                                funcBaseType = typeof(Func <,>);
                            }
                            if (parames.Count() == 2)
                            {
                                funcBaseType = typeof(Func <, ,>);
                            }
                            if (parames.Count() == 3)
                            {
                                funcBaseType = typeof(Func <, , ,>);
                            }
                            if (parames.Count() == 4)
                            {
                                funcBaseType = typeof(Func <, , , ,>);
                            }
                            if (parames.Count() == 5)
                            {
                                funcBaseType = typeof(Func <, , , , ,>);
                            }
                            List <Type> tArgs = methodInfo.GetParameters().Select(item => item.ParameterType).ToList();
                            tArgs.Add(methodInfo.ReturnType);
                            var       funcType         = funcBaseType.MakeGenericType(tArgs.ToArray());
                            var       funcInstanc      = methodInfo.CreateDelegate(funcType);
                            var       key              = funcInstanc.Method.GetHashCode().ToString();
                            CacheInfo currentCacheInfo = null;
                            if (!CacheInfoDic.TryGetValue(key, out currentCacheInfo))
                            {
                                // throw new ArgumentException("Duplicate cache key can't be used , please use an unique key for cache.");
                                currentCacheInfo = CreateCacheInfo(cacheInfoAtt, methodInfo, funcInstanc, key);
                            }
                            try
                            {
                                if (typeof(IQueryable).IsAssignableFrom(methodInfo.ReturnType) && parames.Length > 0 && typeof(IQueryable).IsAssignableFrom(parames[0].ParameterType))
                                {
                                    if (!isRepositoryAssembly)
                                    {
                                        throw new NotSupportedException("Queryable Cache just can use in Repository Layer.");
                                    }
                                    var repository = (IRepositoryCache)Activator.CreateInstance(methodInfo.DeclaringType, Activator.CreateInstance(dBContext));
                                    currentCacheInfo.Repository = repository;
                                    if (parames.Length == 1)
                                    {
                                        var    cacheDataProviderType = typeof(QueryableCacheDataProvider <>);
                                        Type[] typeArgs = methodInfo.ReturnType.GenericTypeArguments;
                                        var    cacheDataProviderGenericType = cacheDataProviderType.MakeGenericType(typeArgs);
                                        var    returnCacheType = typeof(List <>).MakeGenericType(methodInfo.ReturnType.GenericTypeArguments[0]);
                                        CacheWCFTypeHelper.typeList.Add(cacheDataProviderGenericType);
                                        CacheWCFTypeHelper.typeList.Add(methodInfo.ReturnType.GenericTypeArguments[0]);
                                        CacheWCFTypeHelper.typeList.Add(returnCacheType);
                                        // if (currentCacheInfo.EnableUseCacheServer)
                                        //      CacheWCFTypeHelper.typeList.Add(methodInfo.ReturnType);
                                        object queryableCacheExecution = Activator.CreateInstance(cacheDataProviderGenericType, new object[] { currentCacheInfo });

                                        if (currentCacheInfo.FrequencyOfBuilding == 0)
                                        {
                                            Stopwatch stopwatch = new Stopwatch();
                                            stopwatch.Start();
                                            if (!cacheInfoAtt.DisableCache)
                                            {
                                                (typeof(CacheBase)).GetMethod("RefreshCache").MakeGenericMethod(returnCacheType).Invoke(null, new object[] { queryableCacheExecution, currentCacheInfo });
                                            }
                                            stopwatch.Stop();
                                            currentCacheInfo.FrequencyOfBuilding += 1;
                                            currentCacheInfo.BuildingTime        += new TimeSpan(stopwatch.ElapsedTicks);
                                        }

                                        if (currentCacheInfo.CacheRefreshingKind == CacheRefreshingKind.Slide)
                                        {
                                            PeriodicTaskFactory p = new PeriodicTaskFactory((pt) =>
                                            {
                                                if (currentCacheInfo.CountOfWaitingThreads < 3)
                                                {
                                                    Stopwatch stopwatch = new Stopwatch();
                                                    stopwatch.Start();
                                                    ((IQueryableCacheDataProvider)queryableCacheExecution).DbContext = AppBase.DependencyInjectionFactory.CreateContextInstance();
                                                    (typeof(CacheBase)).GetMethod("RefreshCache").MakeGenericMethod(returnCacheType).Invoke(null, new object[] { queryableCacheExecution, currentCacheInfo });
                                                    stopwatch.Stop();
                                                    currentCacheInfo.FrequencyOfBuilding += 1;
                                                    currentCacheInfo.BuildingTime        += new TimeSpan(stopwatch.ElapsedTicks);
                                                }
                                            }, new TimeSpan(0, 0, currentCacheInfo.AutoRefreshInterval), new TimeSpan(0, 0, currentCacheInfo.AutoRefreshInterval));

                                            p.Start();
                                        }
                                        else
                                        {
                                            if (currentCacheInfo.CacheRefreshingKind == CacheRefreshingKind.SqlDependency)
                                            {
                                                if (currentCacheInfo.EnableSaveCacheOnHDD && currentCacheInfo.EnableToFetchOnlyChangedDataFromDB)
                                                {
                                                    Stopwatch stopwatch = new Stopwatch();
                                                    stopwatch.Start();
                                                    if (!cacheInfoAtt.DisableCache)
                                                    {
                                                        ((IQueryableCacheDataProvider)queryableCacheExecution).DbContext = AppBase.DependencyInjectionFactory.CreateContextInstance();
                                                        (typeof(CacheBase)).GetMethod("RefreshCache").MakeGenericMethod(returnCacheType).Invoke(null, new object[] { queryableCacheExecution, currentCacheInfo });
                                                    }
                                                    stopwatch.Stop();
                                                    currentCacheInfo.FrequencyOfBuilding += 1;
                                                    currentCacheInfo.BuildingTime        += new TimeSpan(stopwatch.ElapsedTicks);
                                                }

                                                var typeOfSqlNotifier = typeof(IImmediateSqlNotificationRegister <>)
                                                                        .MakeGenericType(currentCacheInfo.Repository.GetDomainModelType());
                                                IImmediateSqlNotificationRegisterBase immediateSqlNotificationRegister = (IImmediateSqlNotificationRegisterBase)
                                                                                                                         AppBase.DependencyInjectionManager.Resolve(typeOfSqlNotifier,
                                                                                                                                                                    new ParameterOverride("context", ((IQueryableCacheDataProvider)queryableCacheExecution).DbContext),
                                                                                                                                                                    new ParameterOverride("query", ((IQueryableCacheDataProvider)queryableCacheExecution).GetQuery()));

                                                using (var trace = new Trace.TraceDto())
                                                {
                                                    trace.TraceKey          = "CacheSqlDependency";
                                                    trace.Data["CacheName"] = currentCacheInfo.Name;
                                                    trace.Data["DateTime"]  = DateTime.Now.ToString();
                                                    trace.Message           = $"CacheSql Dependency {currentCacheInfo.Name} before configouration on startup at {DateTime.Now.ToString()} ...";
                                                    trace.Data["State"]     = "config";
                                                    Core.Cmn.AppBase.TraceWriter.SubmitData(trace);
                                                }

                                                immediateSqlNotificationRegister.OnChanged += (object sender, SqlNotificationEventArgs e) =>
                                                {
                                                    if (currentCacheInfo.CountOfWaitingThreads < 3)
                                                    {
                                                        using (var trace = new Trace.TraceDto())
                                                        {
                                                            trace.TraceKey          = "CacheSqlDependency";
                                                            trace.Data["CacheName"] = currentCacheInfo.Name;
                                                            trace.Data["DateTime"]  = DateTime.Now.ToString();
                                                            trace.Message           = $"CacheSql Dependency {currentCacheInfo.Name} before changing at {DateTime.Now.ToString()} ...";
                                                            trace.Data["State"]     = "changing";
                                                            Core.Cmn.AppBase.TraceWriter.SubmitData(trace);
                                                        }

                                                        Stopwatch stopwatch = new Stopwatch();
                                                        stopwatch.Start();
                                                        ((IQueryableCacheDataProvider)queryableCacheExecution).DbContext = AppBase.DependencyInjectionFactory.CreateContextInstance();
                                                        immediateSqlNotificationRegister.Init(((IQueryableCacheDataProvider)queryableCacheExecution).DbContext, ((IQueryableCacheDataProvider)queryableCacheExecution).GetQuery(), currentCacheInfo);
                                                        ExcecuteQueryForRefreshingSqlDependencyCache(currentCacheInfo, returnCacheType, queryableCacheExecution, 500);
                                                        stopwatch.Stop();
                                                        currentCacheInfo.FrequencyOfBuilding += 1;
                                                        currentCacheInfo.BuildingTime        += new TimeSpan(stopwatch.ElapsedTicks);
                                                        using (var trace = new Trace.TraceDto())
                                                        {
                                                            trace.TraceKey          = "CacheSqlDependency";
                                                            trace.Data["CacheName"] = currentCacheInfo.Name;
                                                            trace.Data["DateTime"]  = DateTime.Now.ToString();
                                                            trace.Message           = $"CacheSql Dependency {currentCacheInfo.Name} was changed at {DateTime.Now.ToString()} ...";
                                                            trace.Data["State"]     = "changing";
                                                            Core.Cmn.AppBase.TraceWriter.SubmitData(trace);
                                                        }
                                                    }
                                                };

                                                using (var trace = new Trace.TraceDto())
                                                {
                                                    trace.TraceKey          = "CacheSqlDependency";
                                                    trace.Data["CacheName"] = currentCacheInfo.Name;
                                                    trace.Data["DateTime"]  = DateTime.Now.ToString();
                                                    trace.Message           = $"CacheSql Dependency {currentCacheInfo.Name} was configured on startup at {DateTime.Now.ToString()} ...";
                                                    trace.Data["State"]     = "config";
                                                    Core.Cmn.AppBase.TraceWriter.SubmitData(trace);
                                                }
                                            }
                                        }
                                    }

                                    if (currentCacheInfo.EnableToFetchOnlyChangedDataFromDB && !currentCacheInfo.DisableToSyncDeletedRecord_JustIfEnableToFetchOnlyChangedDataFromDB)
                                    {
                                        CacheManagementRepository.CreateSqlTriggerForDetectingDeletedRecords(string.Format("{0}.{1}", repository.Schema, repository.TableName), repository.KeyName);
                                    }
                                }
                                else
                                {
                                    if (isRepositoryAssembly)
                                    {
                                        throw new NotSupportedException("Functional Cache just can use in Service Layer.");
                                    }

                                    var Service = (IServiceCache)Activator.CreateInstance(methodInfo.DeclaringType, Activator.CreateInstance(dBContext));
                                    Core.Cmn.AppBase.TraceWriter.SubmitData(new Trace.TraceDto {
                                        Message = $"{currentCacheInfo.Name} BuildCachesInAssembly start..."
                                    });
                                    currentCacheInfo.Service = Service;
                                    Type cacheDataProviderType = null;
                                    if (parames.Length == 0)
                                    {
                                        cacheDataProviderType = typeof(FunctionalCacheDataProvider <>);
                                        var    cacheDataProviderGenericType = AddAndGetCacheDataProviderTypeForSerialization(methodInfo, cacheDataProviderType);
                                        object functionalCacheExecution     = Activator.CreateInstance(cacheDataProviderGenericType, new object[] { currentCacheInfo });
                                        if (currentCacheInfo.FrequencyOfBuilding == 0)
                                        {
                                            Stopwatch stopwatch = new Stopwatch();
                                            stopwatch.Start();
                                            if (!cacheInfoAtt.DisableCache)
                                            {
                                                (typeof(CacheBase)).GetMethod("RefreshCache").MakeGenericMethod(methodInfo.ReturnType).Invoke(null, new object[] { functionalCacheExecution, currentCacheInfo });
                                            }
                                            stopwatch.Stop();
                                            currentCacheInfo.FrequencyOfBuilding += 1;
                                            currentCacheInfo.BuildingTime        += new TimeSpan(stopwatch.ElapsedTicks);
                                        }

                                        if (currentCacheInfo.CacheRefreshingKind == CacheRefreshingKind.Slide)
                                        {
                                            PeriodicTaskFactory p = new PeriodicTaskFactory((pt) =>
                                            {
                                                if (currentCacheInfo.CountOfWaitingThreads < 3)
                                                {
                                                    Stopwatch stopwatch = new Stopwatch();
                                                    stopwatch.Start();
                                                    (typeof(CacheBase)).GetMethod("RefreshCache").MakeGenericMethod(methodInfo.ReturnType).Invoke(null, new object[] { functionalCacheExecution, currentCacheInfo });
                                                    stopwatch.Stop();
                                                    currentCacheInfo.FrequencyOfBuilding += 1;
                                                    currentCacheInfo.BuildingTime        += new TimeSpan(stopwatch.ElapsedTicks);
                                                }
                                            }, new TimeSpan(0, 0, currentCacheInfo.AutoRefreshInterval), new TimeSpan(0, 0, currentCacheInfo.AutoRefreshInterval));

                                            p.Start();
                                        }
                                    }
                                    else
                                    {
                                        if (parames.Length == 1)
                                        {
                                            cacheDataProviderType = typeof(FunctionalCacheDataProvider <,>);
                                        }

                                        if (parames.Length == 2)
                                        {
                                            cacheDataProviderType = typeof(FunctionalCacheDataProvider <, ,>);
                                        }

                                        if (parames.Length == 3)
                                        {
                                            cacheDataProviderType = typeof(FunctionalCacheDataProvider <, , ,>);
                                        }

                                        if (parames.Length == 4)
                                        {
                                            cacheDataProviderType = typeof(FunctionalCacheDataProvider <, , , ,>);
                                        }

                                        if (parames.Length == 5)
                                        {
                                            cacheDataProviderType = typeof(FunctionalCacheDataProvider <, , , , ,>);
                                        }

                                        AddAndGetCacheDataProviderTypeForSerialization(methodInfo, cacheDataProviderType);
                                    }

                                    Core.Cmn.AppBase.TraceWriter.SubmitData(new Trace.TraceDto {
                                        Message = $"{currentCacheInfo.Name} BuildCachesInAssembly done."
                                    });
                                }
                            }
                            catch (Exception exception)
                            {
                                Core.Cmn.AppBase.LogService.Handle(exception, $"{exception.Message}. Cache name: {currentCacheInfo?.Name}");
                                throw;
                            }

                            currentCacheInfo.LastBuildDateTime = DateTime.Now;
                        }
                        else
                        {
                            if (cacheInfoAtt.EnableAutomaticallyAndPeriodicallyRefreshCache)
                            {
                                throw new NotSupportedException($"a generic method can't call automatically for cache.If you want to use generic method set '{nameof(cacheInfoAtt.CacheRefreshingKind)}' = {nameof(CacheRefreshingKind.Slide)} in CacheableAttribute");
                            }
                        }
                    }
                    else
                    {
                        throw new NotSupportedException("Cacheable Attribute can't use on Non static methods, because we can't work on nostatic method for caching.");
                    }
                }
            }
        }