Stocker les données en cache localement

Si vous êtes à l'aide de C# 2.0 et vous êtes prêt à expédier Système.Web comme une dépendance, alors vous pouvez utiliser l'ASP.NET cache:

using System.Web;
using System.Web.Caching;

Cache webCache;

webCache = HttpContext.Current.Cache;

//See if there's a cached item already
cachedObject = webCache.Get("MyCacheItem");

if (cachedObject == null)
{
    //If there's nothing in the cache, call the web service to get a new item
    webServiceResult = new Object();

    //Cache the web service result for five minutes
    webCache.Add("MyCacheItem", webServiceResult, null, DateTime.Now.AddMinutes(5), Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.Normal, null);
}
else
{
    //Item already in the cache - cast it to the right type
    webServiceResult = (object)cachedObject;
}

Si vous n'êtes pas prêt d'expédier Système.Web, alors vous voudrez peut-être jeter un oeil à la L'entreprise de la Bibliothèque de la mise en Cache de bloc.

Si vous êtes sur .NET 4.0, cependant, la mise en cache a été poussé dans le Système.Moment de l'exécution.La mise en cache de l'espace de noms. Pour l'utiliser, vous devez ajouter une référence à System.Moment de l'exécution.La mise en cache, puis votre code devrait ressembler à quelque chose comme ceci:

using System.Runtime.Caching;

MemoryCache cache;
object cachedObject;
object webServiceResult;

cache = new MemoryCache("StackOverflow");

cachedObject = cache.Get("MyCacheItem");

if (cachedObject == null)
{
    //Call the web service
    webServiceResult = new Object();

    cache.Add("MyCacheItem", webServiceResult, DateTime.Now.AddMinutes(5));
}
else
{
    webServiceResult = (object)cachedObject;
}

Tous ces caches exécuter en cours pour le client. Parce que vous êtes des données est à venir à partir d'un web service, comme le dit Adam, vous allez avoir de la difficulté à déterminer la fraîcheur des données, vous aurez à prendre une décision sur la façon dont souvent les changements de données et combien de temps vous mettre en cache les données.

OriginalL'auteur PhilPursglove

Identifier les objets à sérialiser, et le cache de stockage isolé. Spécifiez le niveau d'isolation des données que vous souhaitez (niveau de l'application, le niveau de l'utilisateur, etc).

Exemple:

Vous pouvez créer un générique sérialiseur, un exemple très simple devrait ressembler à ceci:

public class SampleDataSerializer
{
    public static void Deserialize<T>(out T data, Stream stm)
    {
        var xs = new XmlSerializer(typeof(T));
        data = (T)xs.Deserialize(stm);
    }

    public static void Serialize<T>(T data, Stream stm)
    {
        try
        {
            var xs = new XmlSerializer(typeof(T));
            xs.Serialize(stm, data);
        }
        catch (Exception e)
        {
            throw;
        }
    }
}

Notez que vous devriez probablement mettre dans certains des surcharges de la Sérialiser et Désérialiser les méthodes d'accueillir les lecteurs, ou de tout autre type, vous êtes réellement en utilisant votre application (par exemple, XmlDocuments, etc).

L'opération pour enregistrer à l'IsolatedStorage peuvent être manipulés par une classe utilitaire (exemple ci-dessous):

public class SampleIsolatedStorageManager : IDisposable
{
private string filename;
private string directoryname;
IsolatedStorageFile isf;
public SampleIsolatedStorageManager()
{
filename = string.Empty;
directoryname = string.Empty;
//create an ISF scoped to domain user...
isf = IsolatedStorageFile.GetStore(IsolatedStorageScope.User |
IsolatedStorageScope.Assembly | IsolatedStorageScope.Domain,
typeof(System.Security.Policy.Url), typeof(System.Security.Policy.Url));
}
public void Save<T>(T parm)
{
using (IsolatedStorageFileStream stm = GetStreamByStoredType<T>(FileMode.Create))
{
SampleDataSerializer.Serialize<T>(parm, stm);
}
}
public T Restore<T>() where T : new()
{
try
{
if (GetFileNameByType<T>().Length > 0)
{
T result = new T();
using (IsolatedStorageFileStream stm = GetStreamByStoredType<T>(FileMode.Open))
{
SampleDataSerializer.Deserialize<T>(out result, stm);
}
return result;
}
else
{
return default(T);
}
}
catch
{
try
{
Clear<T>();
}
catch
{
}
return default(T);
}
}
public void Clear<T>()
{
if (isf.GetFileNames(GetFileNameByType<T>()).Length > 0)
{
isf.DeleteFile(GetFileNameByType<T>());
}
}
private string GetFileNameByType<T>()
{
return typeof(T).Name + ".cache";
}
private IsolatedStorageFileStream GetStreamByStoredType<T>(FileMode mode)
{
var stm = new IsolatedStorageFileStream(GetFileNameByType<T>(), mode, isf);
return stm;
}
#region IDisposable Members
public void Dispose()
{
isf.Close();
}
}

Enfin, n'oubliez pas d'ajouter les éléments suivants à l'aide de clauses:

using System.IO;
using System.IO.IsolatedStorage;
using System.Xml.Serialization;

Le code à utiliser les classes ci-dessus pourrait ressembler à ceci:

var myClass = new MyClass();
myClass.name = "something";
using (var mgr = new SampleIsolatedStorageManager())
{
mgr.Save<MyClass>(myClass);
}

Cela permettra d'économiser de l'instance que vous spécifiez pour être sauvé pour le stockage isolé. Pour récupérer l'instance, il suffit d'appeler:

using (var mgr = new SampleIsolatedStorageManager())
{
mgr.Restore<MyClass>();
}

Remarque: l'exemple que j'ai fourni prend en charge un seul sérialisé instance par type. Je ne suis pas sûr si vous avez besoin de plus que cela. Faire toutes les modifications nécessaires pour prendre en charge davantage de fonctionnalités.

HTH!

OriginalL'auteur code4life

Dans notre mise en œuvre de chaque ligne dans la base de données a une dernière mise à jour le timestamp. À chaque fois que notre application client accède à un tableau, sélectionnez la dernière la dernière mise à jour le timestamp à partir du cache et de l'envoyer en valeur pour le serveur. Le serveur répond avec toutes les lignes qui ont nouveaux horodateurs.

OriginalL'auteur user356687