public static Task <T> CachedQuery <T>(this DataSource datasource, OfflineCacheEnumeration type, TimeSpan?optionalTimeSpan = null)
        {
            var query   = datasource.Query();
            var manager = new OfflineCache(targetdirectory, datasource.dsname, DataSourceServiceName);

            if (optionalTimeSpan != null)
            {
                manager.Expiration = optionalTimeSpan.Value;
            }
            var task = manager.TaskManager(query, type);

            return(Task.Factory.StartNew <T>(() => {
                var result = JsonConvert.DeserializeObject <T>(task.Result);
                return result;
            }));
        }
Ejemplo n.º 2
0
        public Task <string> RequestQueueManager <T>(Task <string> apitask, T parameters, OfflineCacheEnumeration offlineType)
        {
            if (offlineType == OfflineCacheEnumeration.NetworkElseLocal)
            {
                return(apitask.ContinueWith(
                           task => {
                    if (task.IsFaulted)
                    {
                        var request = JsonConvert.SerializeObject(parameters);

                        return this.queueRequest(request);
                    }
                    else
                    {
                        Task.Factory.StartNew(() => {
                            processPending();
                        });
                        return task;
                    }
                }
                           ).Result);
            }
            else
            {
                throw new NotImplementedException();
            }
        }
Ejemplo n.º 3
0
        public Task <string> TaskManager(Task <string> apitask, OfflineCacheEnumeration offlineType)
        {
            if (offlineType == OfflineCacheEnumeration.NetworkElseLocal)
            {
                Console.WriteLine("OfflineCacheEnumeration.NetworkElseLocal");
                return(apitask.ContinueWith(
                           task => {
                    if (task.IsFaulted)
                    {
                        Console.WriteLine("Network fault, going to cache");
                        var result = this.getAsTask().Result;
                        if (result.Item1)                                   //expired
                        {
                            Console.WriteLine("Invalid, has expired");
                            System.IO.File.Delete(getFullFilePath());
                            throw new Exception("Cache data has expired.");
                        }
                        else
                        {
                            Console.WriteLine("Valid! return data from cache");
                            return result.Item2;
                        }
                    }
                    else
                    {
                        Console.WriteLine("Valid! return data from Network");
                        this.save(task.Result);

                        return task.Result;
                    }
                }
                           ));
            }
            else if (offlineType == OfflineCacheEnumeration.LocalElseNetwork)
            {
                Console.WriteLine("OfflineCacheEnumeration.LocalElseNetwork");
                return(this.getAsTask().ContinueWith(
                           task => {
                    if (task.IsFaulted)
                    {
                        Console.WriteLine("Cache fault, going to network");
                        this.save(apitask.Result);
                        return apitask.Result;
                    }
                    else
                    {
                        var result = task.Result;
                        if (result.Item1)                                   //expired
                        {
                            System.IO.File.Delete(getFullFilePath());
                            this.save(apitask.Result);
                            Console.WriteLine("Invalid, has expired");
                            Console.WriteLine("Going to network");
                            return apitask.Result;
                        }
                        else
                        {
                            return result.Item2;
                        }
                    }
                }
                           ));
            }
            else if (offlineType == OfflineCacheEnumeration.NetworkOnly)
            {
                return(apitask.ContinueWith(
                           task => {
                    if (task.IsFaulted)
                    {
                        throw task.Exception;
                    }
                    else
                    {
                        this.save(task.Result);                                 // updates local cache
                        return task;
                    }
                }
                           ).Result);
            }
            else
            {
                return(apitask);
            }
        }