Пример #1
0
        private void StartBackgroundFetch <T>(string key, Func <Task <T> > func, TinyCachePolicy policy, Action <T> onUpdate)
        {
            if (policy.UpdateCacheTimeout > 0)
            {
                if (ShouldFetch(policy.UpdateCacheTimeout, key))
                {
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
                    Task.Delay((int)policy.UpdateCacheTimeout).ContinueWith(async(arg) =>
                    {
                        try
                        {
                            var newvalue = await TimeoutAfter <T>(func, policy.BackgroundFetchTimeout);
                            onUpdate?.Invoke(newvalue);
                            Store(key, newvalue, policy);
                        }
                        catch (Exception ex)
                        {
                            if (policy.ReportExceptionsOnBackgroundFetch)
                            {
                                OnError?.Invoke(policy, ex);
                                policy.ExceptionHandler?.Invoke(ex, true);
                            }
                        }
                    });
                }
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
            }
        }
Пример #2
0
        /// <summary>
        /// Fetch using policy
        /// </summary>
        /// <returns>The data from function or cache depending on policy.</returns>
        /// <param name="key">Cache key.</param>
        /// <param name="func">Function for populating cache</param>
        /// <param name="policy">Policy.</param>
        /// <param name="onUpdate">Method to call when data is updated in the background.</param>
        /// <typeparam name="T">Return type of function and cache object.</typeparam>
        public async Task <T> RunAsync <T>(string key, Func <Task <T> > func, TinyCachePolicy policy = null, Action <T> onUpdate = null)
        {
            var    genericType = typeof(T);
            object ret         = Storage.Get(key, genericType);

            if (ret == null && SecondaryStorage != null)
            {
                ret = SecondaryStorage.Get(key, genericType);
            }
            policy = policy ?? defaultPolicy;

            if (ret == null)
            {
                ret = await func();

                Store(key, ret, policy);
            }
            else if (policy.UseCacheFirstFunction == null || !policy.UseCacheFirstFunction())
            {
                if (policy.Mode == TinyCacheModeEnum.FetchFirst)
                {
                    try
                    {
                        var realFetch = await TimeoutAfter(func, policy.FetchTimeout);

                        if (!(realFetch is T))
                        {
                            ret = realFetch;
                            Store(key, realFetch, policy);
                        }
                    }
                    catch (Exception ex)
                    {
                        OnError?.Invoke(policy, ex);
                        policy.ExceptionHandler?.Invoke(ex, true);
                    }
                }
            }
            StartBackgroundFetch(key, func, policy, onUpdate);
            AddLastFetch(key);
            return((ret == null) ? default(T) : (T)ret);
        }
Пример #3
0
        private void Store(string key, object val, TinyCachePolicy policy)
        {
            if (val != null)
            {
                AddLastFetch(key);

                if (Storage.Store(key, val))
                {
                    policy?.UpdateHandler?.Invoke(key, val);
                    OnUpdate?.Invoke(val, new CacheUpdatedEvt(key, val));
                    if (SecondaryStorage != null)
                    {
                        Task.Delay(10).ContinueWith((a) =>
                        {
                            SecondaryStorage.Store(key, val, false);
                        });
                    }
                }
            }
        }
Пример #4
0
 /// <summary>
 /// Sets the base policy wich will be used if not specified in each request.
 /// </summary>
 /// <param name="tinyCachePolicy">Tiny cache policy.</param>
 public void SetBasePolicy(TinyCachePolicy tinyCachePolicy)
 {
     defaultPolicy = tinyCachePolicy;
 }