Y at-il de toute façon à cache fonction / méthode en C #

Je me suis ennuyé avec l'écriture même de code encore et encore pour mettre en cache les objets dans la couche d'accès aux données.

Est de toute façon il cache c# fonction des résultats sans trop de changements de fonctions.

Est-il un framework prend en charge cette fonctionnalité à l'heure actuelle?

Puis-je archiver le même par écrit personnalisé "c# fonction des attributs"? si oui, envoyez-moi quelques points pour démarrer la mise en œuvre?

source d'informationauteur Veeru

  1. 7

    Vous pouvez créer de la mise en cache des attributs avec PostSharp. Ici en est un exemple.

  2. 20

    Possibilité 1: Utilisation de l'IL de Tissage

    Postsharp qui a été dit avant.

    Vous pouvez également essayer les MethodCache.Fody paquet.

    Possibilité 2: Utilisation d'un Proxy d'Interception /Cadre

    Exemple (Ninject & Ninject.Interception):

    public class CacheAttribute : InterceptAttribute
{
    public override IInterceptor CreateInterceptor(IProxyRequest request)
    {
        return request.Context.Kernel.Get<CachingInterceptor>();
    }
}

public class CachingInterceptor : IInterceptor
{
    private ICache Cache { get; set; }

    public CachingInterceptor(ICache cache)
    {
        Cache = cache;
    }

    public void Intercept(IInvocation invocation)
    {
        string className = invocation.Request.Target.GetType().FullName;
        string methodName = invocation.Request.Method.Name;

        object[] arguments = invocation.Request.Arguments;

        StringBuilder builder = new StringBuilder(100);
        builder.Append(className);
        builder.Append(".");
        builder.Append(methodName);

        arguments.ToList().ForEach(x =>
        {
            builder.Append("_");
            builder.Append(x);
        });

        string cacheKey = builder.ToString();

        object retrieve = Cache.Retrieve<object>(cacheKey);

        if (retrieve == null)
        {
            invocation.Proceed();
            retrieve = invocation.ReturnValue;
            Cache.Store(cacheKey, retrieve);
        }
        else
        {
            invocation.ReturnValue = retrieve;
        }
    }
}

    Ensuite, vous pouvez décorer des fonctions comme ceci:

    [Cache]
public virtual Customer GetCustomerByID(int customerID)
{
    return CustomerRepository.GetCustomerByID(customerID);
}

    Intercepté fonctions doivent être virtuel et des classes doit être créé par le noyau Ninject. Si vous comptez sur la performance, vous pourriez classes proxy directement via le Château.DynamicProxy (qui est utilisé en interne par Ninject.Extensions.L'Interception.DynamicProxy).

    Possibilité 3: Utiliser une Expression wrapper

    Vous pouvez passer à la fonction de l'expression, de générer un cache de clé contenant de la classe, la méthode et les paramètres de l'information et invoquer l'expression si elle ne trouve pas dans le Cache. Cela ajoute plus de gestion d'exécution de l'AOP /Proxy cadres, mais sera suffisant pour les solutions simples.

    private T CacheAction<T>(Expression<Func<T>> action, [CallerMemberName] string memberName = "") where T : class
{
    MethodCallExpression body = (MethodCallExpression)action.Body;

    ICollection<object> parameters = new List<object>();

    foreach (MemberExpression expression in body.Arguments)
    {
        parameters.Add(((FieldInfo)expression.Member).GetValue(((ConstantExpression)expression.Expression).Value));
    }

    StringBuilder builder = new StringBuilder(100);
    builder.Append(GetType().FullName);
    builder.Append(".");
    builder.Append(memberName);

    parameters.ToList().ForEach(x =>
    {
        builder.Append("_");
        builder.Append(x);
    });

    string cacheKey = builder.ToString();

    T retrieve = Cache.Retrieve<T>(cacheKey);

    if (retrieve == null)
    {
        retrieve = action.Compile().Invoke();
        Cache.Store(cacheKey, retrieve);
    }

    return retrieve;
}

public Customer GetCustomerByID(int customerID)
{
    return CacheAction(() => CustomerRepository.GetCustomerByID(customerID));
}
  3. 4

    Si je vous lis question correct, le terme correct pour ce que vous voulez est memoization. Wikipédia donne plus de détails sur ce sujets. Malheureusement, il n'existe pas de référence à un C# bibliothèque de la soutenir.

  4. 2

    La Cache de bloc d'Application est la réponse de Microsoft à construit dans la bibliothèque pour la mise en Cache .NET.

  5. 1

    Paresseux stocker de la valeur après la première exécution.
    Exemple: http://msdn.microsoft.com/en-us/vstudio/bb870976

  6. 0

    Je suggère Spring.Net AOP.
    Essentiellement, il crée un proxy et les appels peuvent être redirigés à partir de/vers la mémoire cache.
    http://www.springframework.net/doc/reference/html/aop-quickstart.html

    et puis vous pouvez avoir quelque chose comme ça pour vos conseils:

    public class CachingAroundAdvice : IMethodInterceptor
{
    #region Variable Declarations
    private Priority priority = Priority.Normal;
    #endregion

    public object Invoke(IMethodInvocation invocation)
    {
        //declare local variables
        string cacheKey = string.Empty;
        object dataObject = null;

        //build cache key with some algorithm
        cacheKey = CreateCacheKey(invocation.Method, invocation.Arguments);

        //retrieve item from cache
        dataObject = CacheManager.Cache.GetData(cacheKey);

        //if the dataobject is not in cache proceed to retrieve it
        if (null == dataObject)
        {
            dataObject = invocation.Proceed();

            //add item to cache
            CacheManager.Cache.Add(cacheKey, dataObject, CachePriority, null, Expiration);
        }

        //return data object
        return dataObject;
    }