Une classe d'aide au cache est-elle un candidat pour le modèle singleton ?

Question

J'ai récemment téléchargé quelques échantillons à utiliser avec la mise en cache d'AppFabric. J'ai remarqué que l'échantillon utilisait une classe avec des méthodes statiques au lieu d'un singleton.

Je pensais le transformer en singleton pour les raisons suivantes :

1. charge paresseuse
2. Un seul cas de cache... Je ne vois pas pourquoi il faudrait plus d'une instance.

Suis-je à côté de la plaque ou en plein dans le mille ?

Vous trouverez ci-dessous une classe qu'ils ont incluse :

public class CacheUtil
{
  private static DataCacheFactory _factory = null;
  private static DataCache _cache = null;
  public static DataCache GetCache()
  {
      if (_cache != null)
          return _cache;

      //-------------------------
      // Configure Cache Client 
      //-------------------------

      //Define Array for 1 Cache Host
      List<DataCacheServerEndpoint> servers = 
          new List<DataCacheServerEndpoint>(1);

      //Specify Cache Host Details 
      //  Parameter 1 = host name
      //  Parameter 2 = cache port number
      servers.Add(new DataCacheServerEndpoint("localhost", 22233));

      //Create cache configuration
      DataCacheFactoryConfiguration configuration = 
          new DataCacheFactoryConfiguration();

      //Set the cache host(s)
      configuration.Servers = servers;

      //Set default properties for local cache (local cache disabled)
      configuration.LocalCacheProperties = 
          new DataCacheLocalCacheProperties();

      //Disable tracing to avoid informational/verbose messages on the web page
      DataCacheClientLogManager.ChangeLogLevel(System.Diagnostics.TraceLevel.Off);

      //Pass configuration settings to cacheFactory constructor
      _factory = new DataCacheFactory(configuration);

      //Get reference to named cache called "default"
      _cache = _factory.GetCache("default");

    return _cache;
  }

Answer 1

Oui, il est facile à mettre en œuvre :

    public class CacheUtil
    {
        private static DataCacheFactory _factory = null;
        private static DataCache _cache = null;

        // This is the single instance of this class
        private static readonly CacheUtil instance = new CacheUtil();

        private CacheUtil()
        {
            _cache = GetCache();
        }        

        /// <summary>
        /// Provides the single reference point to access this class
        /// </summary>
        public static CacheUtil Instance
        {
            get { return instance; }
        }

        private static DataCache GetCache()
        {
            if (_cache != null)
                return _cache;

            //-------------------------
            // Configure Cache Client 
            //-------------------------

            //Define Array for 1 Cache Host
            List<DataCacheServerEndpoint> servers =
                new List<DataCacheServerEndpoint>(1);

            //Specify Cache Host Details 
            //  Parameter 1 = host name
            //  Parameter 2 = cache port number
            servers.Add(new DataCacheServerEndpoint("localhost", 22233));

            //Create cache configuration
            DataCacheFactoryConfiguration configuration = new DataCacheFactoryConfiguration { 
Servers = servers, 

LocalCacheProperties = new DataCacheLocalCacheProperties() };

            //Disable tracing to avoid informational/verbose messages on the web page
            DataCacheClientLogManager.ChangeLogLevel(System.Diagnostics.TraceLevel.Off);

            //Pass configuration settings to cacheFactory constructor
            _factory = new DataCacheFactory(configuration);

            //Get reference to named cache called "default"
            _cache = _factory.GetCache("default");

            return _cache;
        }
        /// <summary>
        /// Gets the cache
        /// </summary>
        public DataCache Cache { get; private set; }
    }

Answer 2

Je dirais que oui, j'utilise un modèle singleton pour le cache dans notre application web (par rapport à notre propre interface de cache).

Answer 3

Je ne vois pas pourquoi vous voulez changer la classe, qui semble être une fabrique statique, en un Singleton. Elle permet également un chargement paresseux, et il n'y aura pas plus d'une instance.

EDIT

L'approche de la fabrique est encore meilleure dans la mesure où elle renvoie une interface (du moins je le suppose), ce qui permet de modifier son implémentation dans les versions ultérieures sans casser le code du client.