Autore: Iqbal Khan
NCache ti consente di memorizzare nella cache i dati più vicino alla tua applicazione nel livello intermedio in modo da poter ridurre costosi viaggi al database. Questo a sua volta velocizza notevolmente la tua applicazione. Lo rende inoltre più scalabile perché il carico sul database viene ridotto consentendogli di gestire un numero maggiore di client senza alcun aggiornamento hardware.
Tuttavia, quando memorizzi i dati nella cache, ne stai effettivamente creando una copia al di fuori del tuo database. Ciò introduce il rischio che i dati nel database vengano modificati ma la copia memorizzata nella cache rimanga invariata e diventi obsoleta. La buona notizia è che questa situazione si verifica solo quando più applicazioni modificano gli stessi dati nel database e quando non tutte stanno aggiornando la cache.
Quando si verifica la situazione in cui altre applicazioni modificano i dati nel database e non aggiornano la cache, è necessario un meccanismo affinché la cache sia in grado di sincronizzarsi direttamente con il database. Questo è possibile in diversi modi. Se il database è SQL Server 2008/2012, la cache può utilizzare le notifiche di eventi .NET per la sincronizzazione, il che è abbastanza efficiente. Tuttavia, se il database è SQL Server 2000, Oracle o qualsiasi altro database compatibile con OLEDB, l'unico modo per eseguire la sincronizzazione è eseguire il polling del database alla ricerca di eventuali aggiornamenti. Questo metodo ovviamente non è così efficiente perché la cache finisce per fare molti viaggi inutili nel database.
In questo articolo parlerò di come NCache sincronizza la cache con il database di SQL Server 2008/2012 utilizzando le notifiche degli eventi .NET.
Ecco cosa devi specificare nel codice dell'applicazione .NET per utilizzare questa funzionalità. NCache fornisce un'interfaccia molto simile a quella di Microsoft SqlCacheDependency interfaccia perché internamente NCache sta usando SqlCacheDependency oggetto da sincronizzare con SQL Server 2008/2012.
public class Program {
public static void Main(string[] args)
{
NCache.InitializeCache("myCache");
Customer cust = new Customer();
cust.CustomerID = "ALFKI";
LoadCustomer(cust);
List<Customer> custList = FindCustomers("San Francisco");
// Do your regular work here...
NCache.Cache.Dispose();
}
// A standard Load method that loads a single row from database
public Customer LoadCustomer(Customer cust)
{
String key = "Customer:CustomerID:" + cust.CustomerID;
Customer cust2 = (Customer)NCache.Cache.Get(key);
if (cust2 != null)
return cust2;
CustomerFactory custFactory = new CustomerFactory();
// Load a single customer from the database
// SELECT * FROM Customers WHERE CustomerID = 'ALFKI'
custFactory.Load(cust);
// Create a SqlCacheDependency for this item
CacheItem item = new CacheItem(cust);
item.Dependency = SqlDependencyFactory.CreateSqlYukonDependency(connectionString,
"SELECT CustomerID FROM Customers WHERE CustomerID = '" + cust.CustomerID + "'");
// Store item in the cache along with SqlCacheDependency
NCache.Cache.Insert(key, item);
return cust;
}
// A query method
public List<Customer> FindCustomers(String city)
{
String key = "List<Customer>:City:" + city;
List<Customer> custList = (List<Customer>)NCache.Cache.Get(key);
if (custList != null)
return custList;
CustomerFactory custFactory = new CustomerFactory();
// Load a list of customers from database based on a criteria
// SELECT * FROM Customers WHERE City = 'San Francisco'
custList = custFactory.FindByCity(city);
// Create a SqlCacheDependency for this list of customers
CacheItem item = new CacheItem(custList);
item.Dependency = SqlDependencyFactory.CreateSqlYukonDependency(connectionString,
"SELECT CustomerID FROM Customers WHERE City = '" + city + "'");
// Store list of customers in the cache along with SqlCacheDependency
NCache.Cache.Insert (key, item);
return custList;
}
}Il codice sopra mostra due diverse situazioni in cui è possibile specificare SqlCacheDependency. Il primo è quando carichi una singola riga dal database, la converti in un oggetto e la memorizzi nella cache. In questo caso, tieni presente che devi specificare un'istruzione SQL equivalente che hai utilizzato nel tuo codice per recuperare questa singola riga. Questa istruzione SQL viene quindi utilizzata da SqlCacheDependency oggetto per stabilire una connessione con il database e registrare le righe per le quali SQL Server 2008/2012 deve inviare notifiche di eventi .NET.
La seconda situazione è dove stai recuperando una raccolta di righe dal database come raccolta di oggetti e quindi archiviando l'intera raccolta come singolo oggetto nella cache. In questo caso, è necessario creare un SqlCacheDependency che utilizza la stessa istruzione SQL per recuperare le stesse righe che hai appena eseguito dal database. Per di qua, NCache notifica a SQL Server 2008/2012 che quando una di queste righe viene modificata, è necessario inviare una notifica di evento .NET a NCache.
L'esempio di codice precedente copre la maggior parte delle situazioni in cui è necessario specificare a SqlCacheDependency nel tuo codice Un'altra situazione è quando si tenta di recuperare una raccolta di oggetti correlati al Cliente (ad es. relazione 1-n). In quella situazione, farai esattamente quello che hai fatto per recuperare una raccolta di oggetti Cliente. L'unica cosa che cambierebbe è l'istruzione SQL utilizzata per recuperare oggetti correlati.
Si noti che l'istruzione SQL a cui si fornisce CreateSqlYukonDependency() metodo non deve essere utilizzato "SELECT * ..." formato. È necessario specificare uno o più nomi di colonna come parte di SELECT dichiarazione. Altrimenti, SqlCacheDependency non funzionerà
È necessario abilitare prima il broker di servizi in SQL Server 2008/2012 NCache possono usare SqlCacheDependency. Ciò consente a SQL Server 2008/2012 di inviare notifiche di eventi a NCache per fargli sapere che i dati sono cambiati nel database.
ALTER DATABASE Northwind SET ENABLE_BROKER;
GOTieni presente che NCache chiama automaticamente SqlCacheDependency.Start() metodo dall'interno del proprio codice. Non interagisci mai direttamente con SqlCacheDependency e quindi non è necessario chiamare "Start()" metodo su di esso.
Ora sei pronto per eseguire la tua applicazione che fa NCache chiamate per memorizzare nella cache i dati. Ora, ogni volta che memorizzi qualcosa nella cache NCache, NCache informa SQL Server 2008/2012 a riguardo e quindi quando questi dati cambiano in SQL Server 2008/2012, invia una notifica di evento .NET a NCache. NCache quindi rimuove questi dati dalla cache perché sono stati modificati nel database. In questo modo, la prossima volta che l'applicazione ha bisogno di questi dati, non li trova nella cache e va al database per recuperarli e quindi archiviarli nella cache.
Come hai visto NCache rende molto semplice sincronizzare la cache distribuita con il database di SQL Server 2008/2012. Ora puoi stare tranquillo sapendo che la tua cache non è mai fuori sincronia con il tuo database.
Autore: Iqbal Khan lavora per Alachisoft , azienda di software leader nella fornitura di soluzioni di caching distribuito .NET e Java, mappatura O/R e ottimizzazione dello storage di SharePoint. Puoi raggiungerlo a iqbal@alachisoft.com.