Conseils .NET Core2.0 : Comment résoudre les problèmes de MemoryCache (image)

Cet article vous présente principalement les informations pertinentes sur les conseils de migration de .NET Core 2.0 et la réparation et la solution des problèmes de cache mémoire. L'article le présente en détail à travers un exemple de code, qui a une certaine valeur d'apprentissage de référence pour les études ou le travail de chacun. qui en ont besoin, veuillez suivre l'éditeur pour apprendre ensemble.

Préface

Tout le monde doit savoir que pour les projets .NET Framework traditionnels, l'espace de noms System.Runtime.Caching est un outil couramment utilisé, parmi lesquels le La classe MemoryCache est souvent utilisée pour implémenter la mise en cache mémoire.

.NET Core 2.0 ne prend pas encore en charge la dll System.Runtime.Caching, ce qui signifie que le code lié à MemoryCache ne fonctionne plus.

Mais la bonne nouvelle est que nous pouvons utiliser la nouvelle API de .NET Core 2.0 pour implémenter la fonction de cache mémoire et simplement modifier le code pour résoudre le problème d'incompatibilité. Pas grand chose à dire ci-dessous, jetons un œil à l’introduction détaillée.

Solution

1. Importez l'ancien code dans le projet, comme suit :

using System;
using System.Runtime.Caching;

namespace TestWebApp.Service
{
 public class MemoryCacheService
 {
  static ObjectCache cache = MemoryCache.Default;
  /// <summary>
  /// 获取缓存值
  /// </summary>
  /// <param name="key"></param>
  /// <returns></returns>
  private object GetCacheValue(string key)
  {
   if (key != null && cache.Contains(key))
   {
    return cache[key];
   }
   return default(object);
  }
  /// <summary>
  /// 添加缓存内容
  /// </summary>
  /// <param name="key"></param>
  /// <param name="value"></param>
  public static void SetChacheValue(string key, object value)
  {
   if (key != null)
   {
    CacheItemPolicy policy = new CacheItemPolicy
    {
     SlidingExpiration = TimeSpan.FromHours(1)
     
    };
    cache.Set(key, value, policy);
   }
  }
 }
}

Après l'importation, vous constaterez que VS vous demandera que l'espace de noms System.Runtime.Caching est introuvable et que le code d'origine ne peut pas être compilé et utilisé directement.

2. Ajoutez une référence à l'espace de noms Microsoft.Extensions.Caching.Memory, qui fournit la classe MemoryCache implémentée par .NET Core par défaut, et la nouvelle API de cache mémoire

using Microsoft.Extensions.Caching.Memory;

3. Réécrivez le code et utilisez la nouvelle API pour implémenter la fonction de cache mémoire

Avant de réécrire la méthode de l'objet cache d'initialisation :

static ObjectCache cache = MemoryCache.Default;

Après la réécriture de la méthode d'initialisation de l'objet cache :

static MemoryCache cache = new MemoryCache(new MemoryCacheOptions());

La méthode de lecture de la valeur du cache mémoire a été modifié :

private object GetCacheValue(string key)
{
 if (key != null && cache.Contains(key))
 {
  return cache[key];
 }
 return default(object);
}

Après réécriture :

private object GetCacheValue(string key)
{
 object val = null;
 if (key != null && cache.TryGetValue(key, out val))
 {
  return val;
 }
 else
 {
  return default(object);
 }
}

Modifications dans la configuration du contenu du cache mémoire méthode :

public static void SetChacheValue(string key, object value)
{
 if (key != null)
 {
  CacheItemPolicy policy = new CacheItemPolicy
  {
   SlidingExpiration = TimeSpan.FromHours(1)
  };
  cache.Set(key, value, policy);
 }
}

Après modification :

public static void SetChacheValue(string key, object value)
{
 if (key != null)
 {
  cache.Set(key, value, new MemoryCacheEntryOptions
  {
   SlidingExpiration = TimeSpan.FromHours(1)
  });
 }
}

Conclusion

En cours d'utilisation Après avoir réécrit l'ancien code avec la nouvelle API sous Microsoft.Extensions.Caching.Memory, vous constaterez que toutes les stratégies d'expiration du cache mémoire d'origine ont de nouvelles API correspondantes, notamment AbsoluteExpiration, SlidingExpiration, etc.

Nous pouvons donc toujours facilement utiliser la nouvelle API .NET Core pour réutiliser la plupart de l'ancien code existant avec de simples modifications, et le migrer pour continuer à fonctionner.

Le code complet après migration est le suivant :

using Microsoft.Extensions.Caching.Memory;
using System;

namespace TestMemoryCacheWebApp.Services
{
 public class MemoryCacheService
 {
  static MemoryCache cache = new MemoryCache(new MemoryCacheOptions());
  /// <summary>
  /// 获取缓存值
  /// </summary>
  /// <param name="key"></param>
  /// <returns></returns>
  private object GetCacheValue(string key)
  {
   object val = null;
   if (key != null && cache.TryGetValue(key, out val))
   {

    return val;
   }
   else
   {
    return default(object);
   }
  }
  /// <summary>
  /// 添加缓存内容
  /// </summary>
  /// <param name="key"></param>
  /// <param name="value"></param>
  public static void SetChacheValue(string key, object value)
  {
   if (key != null)
   {
    cache.Set(key, value, new MemoryCacheEntryOptions
    {
     SlidingExpiration = TimeSpan.FromHours(1)
    });
   }
  }
 }
}

Résumé

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!