HttpCache vs Singleton - Best practice per un'applicazione MVC

Question

Sono un po 'confuso nella comprensione degli approcci HttpCache e Singleton.

La mia applicazione utilizza ASP.net MVC e lo scenario è che, ho un elenco di dati che non cambieranno mai e alcuni dati che potrebbero cambiare raramente.

Ho sviluppato e distribuito l'applicazione utilizzando un repository Singleton per questo tipo di dati. Si comporta alla grande. L'unico problema è che quando si verifica un caso raro, devo riavviare IIS per avere effetto.

Qual è la soluzione migliore?

attuazione Singleton

public class SingletonRepository : ISingletonRepository 
    { 
     private static SingletonRepository singleInstance; 

     private readonly IStateRepository stateRepo; 
     private readonly ICountryRepository countryRepo; 
     private readonly ITDPaymentModeRepository paymentModeRepo; 
     private readonly ITDPlanRepository planRepo; 
     private readonly ITDOrderTypeRepository orderTypeRepo; 
     private readonly IKeywordRepository keywordRepo; 
     private readonly IAgencyRepository agencyRepo; 

     private readonly IList<AT_STATE> lstState; 
     private readonly IList<AT_COUNTRY> lstCountry; 
     private readonly IList<TDPaymentMode> lstPaymentMode; 
     private readonly IList<TDPlan> lstPlan; 
     private readonly IList<TDOrderType> lstOrderType; 
     private readonly IList<Keyword> lstKeyword; 
     private readonly IList<Agency_MST> lstAgency; 

     private SingletonRepository() 
     { 
      stateRepo = new StateRepository(); 
      countryRepo = new CountryRepository(); 
      paymentModeRepo = new TDPaymentModeRepository(); 
      planRepo = new TDPlanRepository(); 
      orderTypeRepo = new TDOrderTypeRepository(); 
      keywordRepo = new KeywordRepository(); 
      agencyRepo = new AgencyRepository(); 

      lstState = stateRepo.GetAll().Where(x => x.CountryId == 101).ToList(); 
      lstCountry = countryRepo.GetAll().ToList(); 
      lstPaymentMode = paymentModeRepo.GetAll().ToList(); 
      lstPlan = planRepo.GetAll().ToList(); 
      lstOrderType = orderTypeRepo.GetAll().ToList(); 
      lstKeyword = keywordRepo.GetAll().ToList(); 
      lstAgency = agencyRepo.GetAll().ToList(); 

      //lstState = stateRepo.GetAll().Take(20).ToList(); 
      //lstCountry = countryRepo.GetAll().Take(20).ToList(); 
      //lstPaymentMode = paymentModeRepo.GetAll().Take(20).ToList(); 
      //lstPlan = planRepo.GetAll().Take(20).ToList(); 
      //lstOrderType = orderTypeRepo.GetAll().Take(20).ToList(); 
      //lstKeyword = keywordRepo.GetAll().Take(20).ToList(); 
      //lstAgency = agencyRepo.GetAll().Take(20).ToList(); 
     } 

     public static SingletonRepository Instance() 
     { 
      return singleInstance ?? (singleInstance = new SingletonRepository()); 
     } 

     public IList<AT_STATE> GetState() 
     { 
      return this.lstState; 
     } 
     public IList<AT_COUNTRY> GetCountry() 
     { 
      return this.lstCountry; 
     } 

     public IList<TDPaymentMode> GetPaymentMode() 
     { 
      return this.lstPaymentMode; 
     } 

     public IList<TDPlan> GetPlan() 
     { 
      return this.lstPlan; 
     } 

     public IList<TDOrderType> GetOrderType() 
     { 
      return this.lstOrderType; 
     } 

     public IList<Keyword> GetKeyword() 
     { 
      return this.lstKeyword; 
     } 

     public IList<Agency_MST> GetAgency() 
     { 
      return this.lstAgency; 
     }  

    } 

}

Answer 1

Lo scopo di utilizzare il pattern Singleton generalmente non è per memorizzazione dati statici. È necessario utilizzare un singleton quando si desidera che una sola istanza di oggetto sia in grado di eseguire determinate azioni. Potrebbe essere veloce, ma come puoi vedere, quando i dati cambiano, è necessario ripristinare l'heap per ottenere i nuovi dati (come dici tu, riavviando IIS).

HttpCache (in particolare, l'ObjectCache utilizzato dalla memorizzazione nella cache di Http per impostazione predefinita), memorizza i dati nella stessa posizione dell'heap: in Random Access Memory. Quindi, è veloce quanto i dati statici memorizzati in una classe o istanza nello heap. La differenza è che è possibile impostare la cache per andare periodicamente in stallo, in modo da ottenere nuovi dati quando i dati cambiano. È anche possibile impostare SqlCacheDependencies in modo che la cache venga resa obsoleta ogni volta che lo stato del database cambia.

Un altro vantaggio della cache è che utilizza in modo più efficiente le risorse RAM del server. Con il tuo singleton, non importa cosa, questi dati occuperanno sempre la memoria, anche quando i dati non vengono utilizzati. Con la cache, il server memorizza solo i dati in memoria quando viene utilizzato. Gli svantaggi con la cache sono che occasionalmente, un utente qua e là otterrà una risposta più lenta quando richiedono i dati dopo che la cache è scaduta. Tuttavia, dopo averlo fatto, altri utenti trarranno beneficio dai dati che vengono memorizzati nella cache per un certo periodo di tempo.

Answer 2

Si può effettivamente ricaricare il Singleton con la creazione di un metodo di ricarica come questo:

public static void ReloadSingletonRepositoryInstance() 
{ 
    singleInstance = null; 
    SingletonRepository sr = SingletonRepository.Instance; 
} 

Speranza che aiuta.